super-three 0.165.0 → 0.168.0

package/examples/jsm/nodes/accessors/SkinningNode.js

@@ -1,124 +0,0 @@
-import Node, { addNodeClass } from '../core/Node.js';
-import { NodeUpdateType } from '../core/constants.js';
-import { nodeObject } from '../shadernode/ShaderNode.js';
-import { attribute } from '../core/AttributeNode.js';
-import { reference, referenceBuffer } from './ReferenceNode.js';
-import { add } from '../math/OperatorNode.js';
-import { normalLocal } from './NormalNode.js';
-import { positionLocal } from './PositionNode.js';
-import { tangentLocal } from './TangentNode.js';
-import { uniform } from '../core/UniformNode.js';
-import { buffer } from './BufferNode.js';
-
-class SkinningNode extends Node {
-
-	constructor( skinnedMesh, useReference = false ) {
-
-		super( 'void' );
-
-		this.skinnedMesh = skinnedMesh;
-		this.useReference = useReference;
-
-		this.updateType = NodeUpdateType.OBJECT;
-
-		//
-
-		this.skinIndexNode = attribute( 'skinIndex', 'uvec4' );
-		this.skinWeightNode = attribute( 'skinWeight', 'vec4' );
-
-		let bindMatrixNode, bindMatrixInverseNode, boneMatricesNode;
-
-		if ( useReference ) {
-
-			bindMatrixNode = reference( 'bindMatrix', 'mat4' );
-			bindMatrixInverseNode = reference( 'bindMatrixInverse', 'mat4' );
-			boneMatricesNode = referenceBuffer( 'skeleton.boneMatrices', 'mat4', skinnedMesh.skeleton.bones.length );
-
-		} else {
-
-			bindMatrixNode = uniform( skinnedMesh.bindMatrix, 'mat4' );
-			bindMatrixInverseNode = uniform( skinnedMesh.bindMatrixInverse, 'mat4' );
-			boneMatricesNode = buffer( skinnedMesh.skeleton.boneMatrices, 'mat4', skinnedMesh.skeleton.bones.length );
-
-		}
-
-		this.bindMatrixNode = bindMatrixNode;
-		this.bindMatrixInverseNode = bindMatrixInverseNode;
-		this.boneMatricesNode = boneMatricesNode;
-
-	}
-
-	setup( builder ) {
-
-		const { skinIndexNode, skinWeightNode, bindMatrixNode, bindMatrixInverseNode, boneMatricesNode } = this;
-
-		const boneMatX = boneMatricesNode.element( skinIndexNode.x );
-		const boneMatY = boneMatricesNode.element( skinIndexNode.y );
-		const boneMatZ = boneMatricesNode.element( skinIndexNode.z );
-		const boneMatW = boneMatricesNode.element( skinIndexNode.w );
-
-		// POSITION
-
-		const skinVertex = bindMatrixNode.mul( positionLocal );
-
-		const skinned = add(
-			boneMatX.mul( skinWeightNode.x ).mul( skinVertex ),
-			boneMatY.mul( skinWeightNode.y ).mul( skinVertex ),
-			boneMatZ.mul( skinWeightNode.z ).mul( skinVertex ),
-			boneMatW.mul( skinWeightNode.w ).mul( skinVertex )
-		);
-
-		const skinPosition = bindMatrixInverseNode.mul( skinned ).xyz;
-
-		// NORMAL
-
-		let skinMatrix = add(
-			skinWeightNode.x.mul( boneMatX ),
-			skinWeightNode.y.mul( boneMatY ),
-			skinWeightNode.z.mul( boneMatZ ),
-			skinWeightNode.w.mul( boneMatW )
-		);
-
-		skinMatrix = bindMatrixInverseNode.mul( skinMatrix ).mul( bindMatrixNode );
-
-		const skinNormal = skinMatrix.transformDirection( normalLocal ).xyz;
-
-		// ASSIGNS
-
-		positionLocal.assign( skinPosition );
-		normalLocal.assign( skinNormal );
-
-		if ( builder.hasGeometryAttribute( 'tangent' ) ) {
-
-			tangentLocal.assign( skinNormal );
-
-		}
-
-	}
-
-	generate( builder, output ) {
-
-		if ( output !== 'void' ) {
-
-			return positionLocal.build( builder, output );
-
-		}
-
-	}
-
-	update( frame ) {
-
-		const object = this.useReference ? frame.object : this.skinnedMesh;
-
-		object.skeleton.update();
-
-	}
-
-}
-
-export default SkinningNode;
-
-export const skinning = ( skinnedMesh ) => nodeObject( new SkinningNode( skinnedMesh ) );
-export const skinningReference = ( skinnedMesh ) => nodeObject( new SkinningNode( skinnedMesh, true ) );
-
-addNodeClass( 'SkinningNode', SkinningNode );

package/examples/jsm/nodes/accessors/TangentNode.js

@@ -1,23 +0,0 @@
-import { attribute } from '../core/AttributeNode.js';
-import { varying } from '../core/VaryingNode.js';
-import { cameraViewMatrix } from './CameraNode.js';
-import { modelViewMatrix } from './ModelNode.js';
-import { tslFn, vec4 } from '../shadernode/ShaderNode.js';
-
-export const tangentGeometry = /*#__PURE__*/ tslFn( ( stack, builder ) => {
-
-	if ( builder.geometry.hasAttribute( 'tangent' ) === false ) {
-
-		builder.geometry.computeTangents();
-
-	}
-
-	return attribute( 'tangent', 'vec4' );
-
-} )();
-
-export const tangentLocal = /*#__PURE__*/ tangentGeometry.xyz.toVar( 'tangentLocal' );
-export const tangentView = /*#__PURE__*/ varying( modelViewMatrix.mul( vec4( tangentLocal, 0 ) ).xyz, 'v_tangentView' ).normalize().toVar( 'tangentView' );
-export const tangentWorld = /*#__PURE__*/ varying( tangentView.transformDirection( cameraViewMatrix ), 'v_tangentWorld' ).normalize().toVar( 'tangentWorld' );
-export const transformedTangentView = /*#__PURE__*/ tangentView.toVar( 'transformedTangentView' );
-export const transformedTangentWorld = /*#__PURE__*/ transformedTangentView.transformDirection( cameraViewMatrix ).normalize().toVar( 'transformedTangentWorld' );

package/examples/jsm/nodes/core/CacheNode.js

@@ -1,49 +0,0 @@
-import Node, { addNodeClass } from './Node.js';
-import NodeCache from './NodeCache.js';
-import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
-
-class CacheNode extends Node {
-
-	constructor( node, cache = new NodeCache() ) {
-
-		super();
-
-		this.isCacheNode = true;
-
-		this.node = node;
-		this.cache = cache;
-
-	}
-
-	getNodeType( builder ) {
-
-		return this.node.getNodeType( builder );
-
-	}
-
-	build( builder, ...params ) {
-
-		const previousCache = builder.getCache();
-		const cache = this.cache || builder.globalCache;
-
-		builder.setCache( cache );
-
-		const data = this.node.build( builder, ...params );
-
-		builder.setCache( previousCache );
-
-		return data;
-
-	}
-
-}
-
-export default CacheNode;
-
-export const cache = nodeProxy( CacheNode );
-export const globalCache = ( node ) => cache( node, null );
-
-addNodeElement( 'cache', cache );
-addNodeElement( 'globalCache', globalCache );
-
-addNodeClass( 'CacheNode', CacheNode );

package/examples/jsm/nodes/core/NodeCache.js

@@ -1,26 +0,0 @@
-let id = 0;
-
-class NodeCache {
-
-	constructor() {
-
-		this.id = id ++;
-		this.nodesData = new WeakMap();
-
-	}
-
-	getNodeData( node ) {
-
-		return this.nodesData.get( node );
-
-	}
-
-	setNodeData( node, data ) {
-
-		this.nodesData.set( node, data );
-
-	}
-
-}
-
-export default NodeCache;

package/examples/jsm/nodes/core/NodeKeywords.js

@@ -1,80 +0,0 @@
-class NodeKeywords {
-
-	constructor() {
-
-		this.keywords = [];
-		this.nodes = {};
-		this.keywordsCallback = {};
-
-	}
-
-	getNode( name ) {
-
-		let node = this.nodes[ name ];
-
-		if ( node === undefined && this.keywordsCallback[ name ] !== undefined ) {
-
-			node = this.keywordsCallback[ name ]( name );
-
-			this.nodes[ name ] = node;
-
-		}
-
-		return node;
-
-	}
-
-	addKeyword( name, callback ) {
-
-		this.keywords.push( name );
-		this.keywordsCallback[ name ] = callback;
-
-		return this;
-
-	}
-
-	parse( code ) {
-
-		const keywordNames = this.keywords;
-
-		const regExp = new RegExp( `\\b${keywordNames.join( '\\b|\\b' )}\\b`, 'g' );
-
-		const codeKeywords = code.match( regExp );
-
-		const keywordNodes = [];
-
-		if ( codeKeywords !== null ) {
-
-			for ( const keyword of codeKeywords ) {
-
-				const node = this.getNode( keyword );
-
-				if ( node !== undefined && keywordNodes.indexOf( node ) === - 1 ) {
-
-					keywordNodes.push( node );
-
-				}
-
-			}
-
-		}
-
-		return keywordNodes;
-
-	}
-
-	include( builder, code ) {
-
-		const keywordNodes = this.parse( code );
-
-		for ( const keywordNode of keywordNodes ) {
-
-			keywordNode.build( builder );
-
-		}
-
-	}
-
-}
-
-export default NodeKeywords;

package/examples/jsm/nodes/core/PropertyNode.js

@@ -1,83 +0,0 @@
-import Node, { addNodeClass } from './Node.js';
-import { nodeImmutable, nodeObject } from '../shadernode/ShaderNode.js';
-
-class PropertyNode extends Node {
-
-	constructor( nodeType, name = null, varying = false ) {
-
-		super( nodeType );
-
-		this.name = name;
-		this.varying = varying;
-
-		this.isPropertyNode = true;
-
-	}
-
-	getHash( builder ) {
-
-		return this.name || super.getHash( builder );
-
-	}
-
-	isGlobal( /*builder*/ ) {
-
-		return true;
-
-	}
-
-	generate( builder ) {
-
-		let nodeVar;
-
-		if ( this.varying === true ) {
-
-			nodeVar = builder.getVaryingFromNode( this, this.name );
-			nodeVar.needsInterpolation = true;
-
-		} else {
-
-			nodeVar = builder.getVarFromNode( this, this.name );
-
-		}
-
-		return builder.getPropertyName( nodeVar );
-
-	}
-
-}
-
-export default PropertyNode;
-
-export const property = ( type, name ) => nodeObject( new PropertyNode( type, name ) );
-export const varyingProperty = ( type, name ) => nodeObject( new PropertyNode( type, name, true ) );
-
-export const diffuseColor = nodeImmutable( PropertyNode, 'vec4', 'DiffuseColor' );
-export const roughness = nodeImmutable( PropertyNode, 'float', 'Roughness' );
-export const metalness = nodeImmutable( PropertyNode, 'float', 'Metalness' );
-export const clearcoat = nodeImmutable( PropertyNode, 'float', 'Clearcoat' );
-export const clearcoatRoughness = nodeImmutable( PropertyNode, 'float', 'ClearcoatRoughness' );
-export const sheen = nodeImmutable( PropertyNode, 'vec3', 'Sheen' );
-export const sheenRoughness = nodeImmutable( PropertyNode, 'float', 'SheenRoughness' );
-export const iridescence = nodeImmutable( PropertyNode, 'float', 'Iridescence' );
-export const iridescenceIOR = nodeImmutable( PropertyNode, 'float', 'IridescenceIOR' );
-export const iridescenceThickness = nodeImmutable( PropertyNode, 'float', 'IridescenceThickness' );
-export const alphaT = nodeImmutable( PropertyNode, 'float', 'AlphaT' );
-export const anisotropy = nodeImmutable( PropertyNode, 'float', 'Anisotropy' );
-export const anisotropyT = nodeImmutable( PropertyNode, 'vec3', 'AnisotropyT' );
-export const anisotropyB = nodeImmutable( PropertyNode, 'vec3', 'AnisotropyB' );
-export const specularColor = nodeImmutable( PropertyNode, 'color', 'SpecularColor' );
-export const specularF90 = nodeImmutable( PropertyNode, 'float', 'SpecularF90' );
-export const shininess = nodeImmutable( PropertyNode, 'float', 'Shininess' );
-export const output = nodeImmutable( PropertyNode, 'vec4', 'Output' );
-export const dashSize = nodeImmutable( PropertyNode, 'float', 'dashSize' );
-export const gapSize = nodeImmutable( PropertyNode, 'float', 'gapSize' );
-export const pointWidth = nodeImmutable( PropertyNode, 'float', 'pointWidth' );
-export const ior = nodeImmutable( PropertyNode, 'float', 'IOR' );
-export const transmission = nodeImmutable( PropertyNode, 'float', 'Transmission' );
-export const thickness = nodeImmutable( PropertyNode, 'float', 'Thickness' );
-export const attenuationDistance = nodeImmutable( PropertyNode, 'float', 'AttenuationDistance' );
-export const attenuationColor = nodeImmutable( PropertyNode, 'color', 'AttenuationColor' );
-export const dispersion = nodeImmutable( PropertyNode, 'float', 'Dispersion' );
-
-addNodeClass( 'PropertyNode', PropertyNode );

package/examples/jsm/nodes/core/UniformGroupNode.js

@@ -1,36 +0,0 @@
-import Node from './Node.js';
-import { addNodeClass } from './Node.js';
-
-class UniformGroupNode extends Node {
-
-	constructor( name, shared = false ) {
-
-		super( 'string' );
-
-		this.name = name;
-		this.version = 0;
-
-		this.shared = shared;
-
-		this.isUniformGroup = true;
-
-	}
-
-	set needsUpdate( value ) {
-
-		if ( value === true ) this.version ++;
-
-	}
-
-}
-
-export const uniformGroup = ( name ) => new UniformGroupNode( name );
-export const sharedUniformGroup = ( name ) => new UniformGroupNode( name, true );
-
-export const frameGroup = sharedUniformGroup( 'frame' );
-export const renderGroup = sharedUniformGroup( 'render' );
-export const objectGroup = uniformGroup( 'object' );
-
-export default UniformGroupNode;
-
-addNodeClass( 'UniformGroupNode', UniformGroupNode );

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

@@ -1,128 +0,0 @@
-import TempNode from '../core/TempNode.js';
-import { /*mix, step,*/ EPSILON } from '../math/MathNode.js';
-import { addNodeClass } from '../core/Node.js';
-import { addNodeElement, tslFn, nodeProxy, vec3 } from '../shadernode/ShaderNode.js';
-
-export const BurnNode = tslFn( ( { base, blend } ) => {
-
-	const fn = ( c ) => blend[ c ].lessThan( EPSILON ).cond( blend[ c ], base[ c ].oneMinus().div( blend[ c ] ).oneMinus().max( 0 ) );
-
-	return vec3( fn( 'x' ), fn( 'y' ), fn( 'z' ) );
-
-} ).setLayout( {
-	name: 'burnColor',
-	type: 'vec3',
-	inputs: [
-		{ name: 'base', type: 'vec3' },
-		{ name: 'blend', type: 'vec3' }
-	]
-} );
-
-export const DodgeNode = tslFn( ( { base, blend } ) => {
-
-	const fn = ( c ) => blend[ c ].equal( 1.0 ).cond( blend[ c ], base[ c ].div( blend[ c ].oneMinus() ).max( 0 ) );
-
-	return vec3( fn( 'x' ), fn( 'y' ), fn( 'z' ) );
-
-} ).setLayout( {
-	name: 'dodgeColor',
-	type: 'vec3',
-	inputs: [
-		{ name: 'base', type: 'vec3' },
-		{ name: 'blend', type: 'vec3' }
-	]
-} );
-
-export const ScreenNode = tslFn( ( { base, blend } ) => {
-
-	const fn = ( c ) => base[ c ].oneMinus().mul( blend[ c ].oneMinus() ).oneMinus();
-
-	return vec3( fn( 'x' ), fn( 'y' ), fn( 'z' ) );
-
-} ).setLayout( {
-	name: 'screenColor',
-	type: 'vec3',
-	inputs: [
-		{ name: 'base', type: 'vec3' },
-		{ name: 'blend', type: 'vec3' }
-	]
-} );
-
-export const OverlayNode = tslFn( ( { base, blend } ) => {
-
-	const fn = ( c ) => base[ c ].lessThan( 0.5 ).cond( base[ c ].mul( blend[ c ], 2.0 ), base[ c ].oneMinus().mul( blend[ c ].oneMinus() ).oneMinus() );
-	//const fn = ( c ) => mix( base[ c ].oneMinus().mul( blend[ c ].oneMinus() ).oneMinus(), base[ c ].mul( blend[ c ], 2.0 ), step( base[ c ], 0.5 ) );
-
-	return vec3( fn( 'x' ), fn( 'y' ), fn( 'z' ) );
-
-} ).setLayout( {
-	name: 'overlayColor',
-	type: 'vec3',
-	inputs: [
-		{ name: 'base', type: 'vec3' },
-		{ name: 'blend', type: 'vec3' }
-	]
-} );
-
-class BlendModeNode extends TempNode {
-
-	constructor( blendMode, baseNode, blendNode ) {
-
-		super();
-
-		this.blendMode = blendMode;
-
-		this.baseNode = baseNode;
-		this.blendNode = blendNode;
-
-	}
-
-	setup() {
-
-		const { blendMode, baseNode, blendNode } = this;
-		const params = { base: baseNode, blend: blendNode };
-
-		let outputNode = null;
-
-		if ( blendMode === BlendModeNode.BURN ) {
-
-			outputNode = BurnNode( params );
-
-		} else if ( blendMode === BlendModeNode.DODGE ) {
-
-			outputNode = DodgeNode( params );
-
-		} else if ( blendMode === BlendModeNode.SCREEN ) {
-
-			outputNode = ScreenNode( params );
-
-		} else if ( blendMode === BlendModeNode.OVERLAY ) {
-
-			outputNode = OverlayNode( params );
-
-		}
-
-		return outputNode;
-
-	}
-
-}
-
-BlendModeNode.BURN = 'burn';
-BlendModeNode.DODGE = 'dodge';
-BlendModeNode.SCREEN = 'screen';
-BlendModeNode.OVERLAY = 'overlay';
-
-export default BlendModeNode;
-
-export const burn = nodeProxy( BlendModeNode, BlendModeNode.BURN );
-export const dodge = nodeProxy( BlendModeNode, BlendModeNode.DODGE );
-export const overlay = nodeProxy( BlendModeNode, BlendModeNode.OVERLAY );
-export const screen = nodeProxy( BlendModeNode, BlendModeNode.SCREEN );
-
-addNodeElement( 'burn', burn );
-addNodeElement( 'dodge', dodge );
-addNodeElement( 'overlay', overlay );
-addNodeElement( 'screen', screen );
-
-addNodeClass( 'BlendModeNode', BlendModeNode );

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

@@ -1,99 +0,0 @@
-import TempNode from '../core/TempNode.js';
-import { dot, mix } from '../math/MathNode.js';
-import { add } from '../math/OperatorNode.js';
-import { addNodeClass } from '../core/Node.js';
-import { addNodeElement, tslFn, nodeProxy, float, vec3 } from '../shadernode/ShaderNode.js';
-
-const saturationNode = tslFn( ( { color, adjustment } ) => {
-
-	return adjustment.mix( luminance( color.rgb ), color.rgb );
-
-} );
-
-const vibranceNode = tslFn( ( { color, adjustment } ) => {
-
-	const average = add( color.r, color.g, color.b ).div( 3.0 );
-
-	const mx = color.r.max( color.g.max( color.b ) );
-	const amt = mx.sub( average ).mul( adjustment ).mul( - 3.0 );
-
-	return mix( color.rgb, mx, amt );
-
-} );
-
-const hueNode = tslFn( ( { color, adjustment } ) => {
-
-	const k = vec3( 0.57735, 0.57735, 0.57735 );
-
-	const cosAngle = adjustment.cos();
-
-	return vec3( color.rgb.mul( cosAngle ).add( k.cross( color.rgb ).mul( adjustment.sin() ).add( k.mul( dot( k, color.rgb ).mul( cosAngle.oneMinus() ) ) ) ) );
-
-} );
-
-class ColorAdjustmentNode extends TempNode {
-
-	constructor( method, colorNode, adjustmentNode = float( 1 ) ) {
-
-		super( 'vec3' );
-
-		this.method = method;
-
-		this.colorNode = colorNode;
-		this.adjustmentNode = adjustmentNode;
-
-	}
-
-	setup() {
-
-		const { method, colorNode, adjustmentNode } = this;
-
-		const callParams = { color: colorNode, adjustment: adjustmentNode };
-
-		let outputNode = null;
-
-		if ( method === ColorAdjustmentNode.SATURATION ) {
-
-			outputNode = saturationNode( callParams );
-
-		} else if ( method === ColorAdjustmentNode.VIBRANCE ) {
-
-			outputNode = vibranceNode( callParams );
-
-		} else if ( method === ColorAdjustmentNode.HUE ) {
-
-			outputNode = hueNode( callParams );
-
-		} else {
-
-			console.error( `${ this.type }: Method "${ this.method }" not supported!` );
-
-		}
-
-		return outputNode;
-
-	}
-
-}
-
-ColorAdjustmentNode.SATURATION = 'saturation';
-ColorAdjustmentNode.VIBRANCE = 'vibrance';
-ColorAdjustmentNode.HUE = 'hue';
-
-export default ColorAdjustmentNode;
-
-export const saturation = nodeProxy( ColorAdjustmentNode, ColorAdjustmentNode.SATURATION );
-export const vibrance = nodeProxy( ColorAdjustmentNode, ColorAdjustmentNode.VIBRANCE );
-export const hue = nodeProxy( ColorAdjustmentNode, ColorAdjustmentNode.HUE );
-
-export const lumaCoeffs = vec3( 0.2125, 0.7154, 0.0721 );
-export const luminance = ( color, luma = lumaCoeffs ) => dot( color, luma );
-
-export const threshold = ( color, threshold ) => mix( vec3( 0.0 ), color, luminance( color ).sub( threshold ).max( 0 ) );
-
-addNodeElement( 'saturation', saturation );
-addNodeElement( 'vibrance', vibrance );
-addNodeElement( 'hue', hue );
-addNodeElement( 'threshold', threshold );
-
-addNodeClass( 'ColorAdjustmentNode', ColorAdjustmentNode );