@needle-tools/three 0.162.12 → 0.169.2

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/core/VaryingNode.js

@@ -1,65 +0,0 @@
-import Node, { addNodeClass } from './Node.js';
-import { NodeShaderStage } from './constants.js';
-import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
-
-class VaryingNode extends Node {
-
-	constructor( node, name = null ) {
-
-		super();
-
-		this.node = node;
-		this.name = name;
-
-		this.isVaryingNode = true;
-
-	}
-
-	isGlobal() {
-
-		return true;
-
-	}
-
-	getHash( builder ) {
-
-		return this.name || super.getHash( builder );
-
-	}
-
-	getNodeType( builder ) {
-
-		// VaryingNode is auto type
-
-		return this.node.getNodeType( builder );
-
-	}
-
-	generate( builder ) {
-
-		const { name, node } = this;
-		const type = this.getNodeType( builder );
-
-		const nodeVarying = builder.getVaryingFromNode( this, name, type );
-
-		// this property can be used to check if the varying can be optimized for a var
-		nodeVarying.needsInterpolation || ( nodeVarying.needsInterpolation = ( builder.shaderStage === 'fragment' ) );
-
-		const propertyName = builder.getPropertyName( nodeVarying, NodeShaderStage.VERTEX );
-
-		// force node run in vertex stage
-		builder.flowNodeFromShaderStage( NodeShaderStage.VERTEX, node, type, propertyName );
-
-		return builder.getPropertyName( nodeVarying );
-
-	}
-
-}
-
-export default VaryingNode;
-
-export const varying = nodeProxy( VaryingNode );
-
-addNodeElement( 'varying', varying );
-
-addNodeClass( 'VaryingNode', VaryingNode );

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 );

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

@@ -1,108 +0,0 @@
-import TempNode from '../core/TempNode.js';
-import { mix } from '../math/MathNode.js';
-import { addNodeClass } from '../core/Node.js';
-import { addNodeElement, tslFn, nodeObject, nodeProxy, vec4 } from '../shadernode/ShaderNode.js';
-
-import { LinearSRGBColorSpace, SRGBColorSpace } from 'three';
-
-const sRGBToLinearShader = tslFn( ( inputs ) => {
-
-	const { value } = inputs;
-	const { rgb } = value;
-
-	const a = rgb.mul( 0.9478672986 ).add( 0.0521327014 ).pow( 2.4 );
-	const b = rgb.mul( 0.0773993808 );
-	const factor = rgb.lessThanEqual( 0.04045 );
-
-	const rgbResult = mix( a, b, factor );
-
-	return vec4( rgbResult, value.a );
-
-} );
-
-const LinearTosRGBShader = tslFn( ( inputs ) => {
-
-	const { value } = inputs;
-	const { rgb } = value;
-
-	const a = rgb.pow( 0.41666 ).mul( 1.055 ).sub( 0.055 );
-	const b = rgb.mul( 12.92 );
-	const factor = rgb.lessThanEqual( 0.0031308 );
-
-	const rgbResult = mix( a, b, factor );
-
-	return vec4( rgbResult, value.a );
-
-} );
-
-const getColorSpaceMethod = ( colorSpace ) => {
-
-	let method = null;
-
-	if ( colorSpace === LinearSRGBColorSpace ) {
-
-		method = 'Linear';
-
-	} else if ( colorSpace === SRGBColorSpace ) {
-
-		method = 'sRGB';
-
-	}
-
-	return method;
-
-};
-
-const getMethod = ( source, target ) => {
-
-	return getColorSpaceMethod( source ) + 'To' + getColorSpaceMethod( target );
-
-};
-
-class ColorSpaceNode extends TempNode {
-
-	constructor( method, node ) {
-
-		super( 'vec4' );
-
-		this.method = method;
-		this.node = node;
-
-	}
-
-	setup() {
-
-		const { method, node } = this;
-
-		if ( method === ColorSpaceNode.LINEAR_TO_LINEAR )
-			return node;
-
-		return Methods[ method ]( { value: node } );
-
-	}
-
-}
-
-ColorSpaceNode.LINEAR_TO_LINEAR = 'LinearToLinear';
-ColorSpaceNode.LINEAR_TO_sRGB = 'LinearTosRGB';
-ColorSpaceNode.sRGB_TO_LINEAR = 'sRGBToLinear';
-
-const Methods = {
-	[ ColorSpaceNode.LINEAR_TO_sRGB ]: LinearTosRGBShader,
-	[ ColorSpaceNode.sRGB_TO_LINEAR ]: sRGBToLinearShader
-};
-
-export default ColorSpaceNode;
-
-export const linearToColorSpace = ( node, colorSpace ) => nodeObject( new ColorSpaceNode( getMethod( LinearSRGBColorSpace, colorSpace ), nodeObject( node ) ) );
-export const colorSpaceToLinear = ( node, colorSpace ) => nodeObject( new ColorSpaceNode( getMethod( colorSpace, LinearSRGBColorSpace ), nodeObject( node ) ) );
-
-export const linearTosRGB = nodeProxy( ColorSpaceNode, ColorSpaceNode.LINEAR_TO_sRGB );
-export const sRGBToLinear = nodeProxy( ColorSpaceNode, ColorSpaceNode.sRGB_TO_LINEAR );
-
-addNodeElement( 'linearTosRGB', linearTosRGB );
-addNodeElement( 'sRGBToLinear', sRGBToLinear );
-addNodeElement( 'linearToColorSpace', linearToColorSpace );
-addNodeElement( 'colorSpaceToLinear', colorSpaceToLinear );
-
-addNodeClass( 'ColorSpaceNode', ColorSpaceNode );

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

@@ -1,27 +0,0 @@
-import Node, { addNodeClass } from '../core/Node.js';
-import { nodeImmutable, float } from '../shadernode/ShaderNode.js';
-
-class FrontFacingNode extends Node {
-
-	constructor() {
-
-		super( 'bool' );
-
-		this.isFrontFacingNode = true;
-
-	}
-
-	generate( builder ) {
-
-		return builder.getFrontFacing();
-
-	}
-
-}
-
-export default FrontFacingNode;
-
-export const frontFacing = nodeImmutable( FrontFacingNode );
-export const faceDirection = float( frontFacing ).mul( 2.0 ).sub( 1.0 );
-
-addNodeClass( 'FrontFacingNode', FrontFacingNode );

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

@@ -1,183 +0,0 @@
-import { addNodeClass } from '../core/Node.js';
-import TempNode from '../core/TempNode.js';
-import TextureNode from '../accessors/TextureNode.js';
-import { NodeUpdateType } from '../core/constants.js';
-import { nodeObject } from '../shadernode/ShaderNode.js';
-import { uniform } from '../core/UniformNode.js';
-import { viewZToOrthographicDepth, perspectiveDepthToViewZ } from './ViewportDepthNode.js';
-import { RenderTarget, Vector2, HalfFloatType, DepthTexture, NoToneMapping/*, FloatType*/ } from 'three';
-
-class PassTextureNode extends TextureNode {
-
-	constructor( passNode, texture ) {
-
-		super( texture );
-
-		this.passNode = passNode;
-
-		this.setUpdateMatrix( false );
-
-	}
-
-	setup( builder ) {
-
-		this.passNode.build( builder );
-
-		return super.setup( builder );
-
-	}
-
-	clone() {
-
-		return new this.constructor( this.passNode, this.value );
-
-	}
-
-}
-
-class PassNode extends TempNode {
-
-	constructor( scope, scene, camera ) {
-
-		super( 'vec4' );
-
-		this.scope = scope;
-		this.scene = scene;
-		this.camera = camera;
-
-		this._pixelRatio = 1;
-		this._width = 1;
-		this._height = 1;
-
-		const depthTexture = new DepthTexture();
-		depthTexture.isRenderTargetTexture = true;
-		//depthTexture.type = FloatType;
-		depthTexture.name = 'PostProcessingDepth';
-
-		const renderTarget = new RenderTarget( this._width * this._pixelRatio, this._height * this._pixelRatio, { type: HalfFloatType } );
-		renderTarget.texture.name = 'PostProcessing';
-		renderTarget.depthTexture = depthTexture;
-
-		this.renderTarget = renderTarget;
-
-		this.updateBeforeType = NodeUpdateType.FRAME;
-
-		this._textureNode = nodeObject( new PassTextureNode( this, renderTarget.texture ) );
-		this._depthTextureNode = nodeObject( new PassTextureNode( this, depthTexture ) );
-
-		this._depthNode = null;
-		this._cameraNear = uniform( 0 );
-		this._cameraFar = uniform( 0 );
-
-		this.isPassNode = true;
-
-	}
-
-	isGlobal() {
-
-		return true;
-
-	}
-
-	getTextureNode() {
-
-		return this._textureNode;
-
-	}
-
-	getTextureDepthNode() {
-
-		return this._depthTextureNode;
-
-	}
-
-	getDepthNode() {
-
-		if ( this._depthNode === null ) {
-
-			const cameraNear = this._cameraNear;
-			const cameraFar = this._cameraFar;
-
-			this._depthNode = viewZToOrthographicDepth( perspectiveDepthToViewZ( this._depthTextureNode, cameraNear, cameraFar ), cameraNear, cameraFar );
-
-		}
-
-		return this._depthNode;
-
-	}
-
-	setup() {
-
-		return this.scope === PassNode.COLOR ? this.getTextureNode() : this.getDepthNode();
-
-	}
-
-	updateBefore( frame ) {
-
-		const { renderer } = frame;
-		const { scene, camera } = this;
-
-		this._pixelRatio = renderer.getPixelRatio();
-
-		const size = renderer.getSize( new Vector2() );
-
-		this.setSize( size.width, size.height );
-
-		const currentToneMapping = renderer.toneMapping;
-		const currentToneMappingNode = renderer.toneMappingNode;
-		const currentRenderTarget = renderer.getRenderTarget();
-
-		this._cameraNear.value = camera.near;
-		this._cameraFar.value = camera.far;
-
-		renderer.toneMapping = NoToneMapping;
-		renderer.toneMappingNode = null;
-		renderer.setRenderTarget( this.renderTarget );
-
-		renderer.render( scene, camera );
-
-		renderer.toneMapping = currentToneMapping;
-		renderer.toneMappingNode = currentToneMappingNode;
-		renderer.setRenderTarget( currentRenderTarget );
-
-	}
-
-	setSize( width, height ) {
-
-		this._width = width;
-		this._height = height;
-
-		const effectiveWidth = this._width * this._pixelRatio;
-		const effectiveHeight = this._height * this._pixelRatio;
-
-		this.renderTarget.setSize( effectiveWidth, effectiveHeight );
-
-	}
-
-	setPixelRatio( pixelRatio ) {
-
-		this._pixelRatio = pixelRatio;
-
-		this.setSize( this._width, this._height );
-
-	}
-
-	dispose() {
-
-		this.renderTarget.dispose();
-
-	}
-
-
-}
-
-PassNode.COLOR = 'color';
-PassNode.DEPTH = 'depth';
-
-export default PassNode;
-
-export const pass = ( scene, camera ) => nodeObject( new PassNode( PassNode.COLOR, scene, camera ) );
-export const texturePass = ( pass, texture ) => nodeObject( new PassTextureNode( pass, texture ) );
-export const depthPass = ( scene, camera ) => nodeObject( new PassNode( PassNode.DEPTH, scene, camera ) );
-
-addNodeClass( 'PassNode', PassNode );