super-three 0.167.0 → 0.169.0

package/examples/jsm/utils/PackedPhongMaterial.js

@@ -1,178 +0,0 @@
-
-/**
- * `PackedPhongMaterial` inherited from THREE.MeshPhongMaterial
- *
- * @param {Object} parameters
- */
-import {
-	MeshPhongMaterial,
-	ShaderChunk,
-	ShaderLib,
-	UniformsUtils,
-} from 'three';
-
-class PackedPhongMaterial extends MeshPhongMaterial {
-
-	constructor( parameters ) {
-
-		super();
-
-		this.defines = {};
-		this.type = 'PackedPhongMaterial';
-		this.uniforms = UniformsUtils.merge( [
-
-			ShaderLib.phong.uniforms,
-
-			{
-				quantizeMatPos: { value: null },
-				quantizeMatUV: { value: null }
-			}
-
-		] );
-
-		this.vertexShader = [
-			'#define PHONG',
-
-			'varying vec3 vViewPosition;',
-
-			ShaderChunk.common,
-			ShaderChunk.uv_pars_vertex,
-			ShaderChunk.displacementmap_pars_vertex,
-			ShaderChunk.envmap_pars_vertex,
-			ShaderChunk.color_pars_vertex,
-			ShaderChunk.fog_pars_vertex,
-			ShaderChunk.normal_pars_vertex,
-			ShaderChunk.morphtarget_pars_vertex,
-			ShaderChunk.skinning_pars_vertex,
-			ShaderChunk.shadowmap_pars_vertex,
-			ShaderChunk.logdepthbuf_pars_vertex,
-			ShaderChunk.clipping_planes_pars_vertex,
-
-			`#ifdef USE_PACKED_NORMAL
-					#if USE_PACKED_NORMAL == 0
-						vec3 decodeNormal(vec3 packedNormal)
-						{
-							float x = packedNormal.x * 2.0 - 1.0;
-							float y = packedNormal.y * 2.0 - 1.0;
-							vec2 scth = vec2(sin(x * PI), cos(x * PI));
-							vec2 scphi = vec2(sqrt(1.0 - y * y), y);
-							return normalize( vec3(scth.y * scphi.x, scth.x * scphi.x, scphi.y) );
-						}
-					#endif
-
-					#if USE_PACKED_NORMAL == 1
-						vec3 decodeNormal(vec3 packedNormal)
-						{
-							vec3 v = vec3(packedNormal.xy, 1.0 - abs(packedNormal.x) - abs(packedNormal.y));
-							if (v.z < 0.0)
-							{
-								v.xy = (1.0 - abs(v.yx)) * vec2((v.x >= 0.0) ? +1.0 : -1.0, (v.y >= 0.0) ? +1.0 : -1.0);
-							}
-							return normalize(v);
-						}
-					#endif
-
-					#if USE_PACKED_NORMAL == 2
-						vec3 decodeNormal(vec3 packedNormal)
-						{
-							vec3 v = (packedNormal * 2.0) - 1.0;
-							return normalize(v);
-						}
-					#endif
-				#endif`,
-
-			`#ifdef USE_PACKED_POSITION
-					#if USE_PACKED_POSITION == 0
-						uniform mat4 quantizeMatPos;
-					#endif
-				#endif`,
-
-			`#ifdef USE_PACKED_UV
-					#if USE_PACKED_UV == 1
-						uniform mat3 quantizeMatUV;
-					#endif
-				#endif`,
-
-			`#ifdef USE_PACKED_UV
-					#if USE_PACKED_UV == 0
-						vec2 decodeUV(vec2 packedUV)
-						{
-							vec2 uv = (packedUV * 2.0) - 1.0;
-							return uv;
-						}
-					#endif
-
-					#if USE_PACKED_UV == 1
-						vec2 decodeUV(vec2 packedUV)
-						{
-							vec2 uv = ( vec3(packedUV, 1.0) * quantizeMatUV ).xy;
-							return uv;
-						}
-					#endif
-				#endif`,
-
-			'void main() {',
-
-			ShaderChunk.uv_vertex,
-
-			`#ifdef USE_MAP
-					#ifdef USE_PACKED_UV
-						vMapUv = decodeUV(vMapUv);
-					#endif
-				#endif`,
-
-			ShaderChunk.color_vertex,
-			ShaderChunk.morphcolor_vertex,
-
-			ShaderChunk.beginnormal_vertex,
-
-			`#ifdef USE_PACKED_NORMAL
-					objectNormal = decodeNormal(objectNormal);
-				#endif
-
-				#ifdef USE_TANGENT
-					vec3 objectTangent = vec3( tangent.xyz );
-				#endif
-				`,
-
-			ShaderChunk.morphnormal_vertex,
-			ShaderChunk.skinbase_vertex,
-			ShaderChunk.skinnormal_vertex,
-			ShaderChunk.defaultnormal_vertex,
-			ShaderChunk.normal_vertex,
-
-			ShaderChunk.begin_vertex,
-
-			`#ifdef USE_PACKED_POSITION
-					#if USE_PACKED_POSITION == 0
-						transformed = ( vec4(transformed, 1.0) * quantizeMatPos ).xyz;
-					#endif
-				#endif`,
-
-			ShaderChunk.morphtarget_vertex,
-			ShaderChunk.skinning_vertex,
-			ShaderChunk.displacementmap_vertex,
-			ShaderChunk.project_vertex,
-			ShaderChunk.logdepthbuf_vertex,
-			ShaderChunk.clipping_planes_vertex,
-
-			'vViewPosition = - mvPosition.xyz;',
-
-			ShaderChunk.worldpos_vertex,
-			ShaderChunk.envmap_vertex,
-			ShaderChunk.shadowmap_vertex,
-			ShaderChunk.fog_vertex,
-
-			'}',
-		].join( '\n' );
-
-		// Use the original MeshPhongMaterial's fragmentShader.
-		this.fragmentShader = ShaderLib.phong.fragmentShader;
-
-		this.setValues( parameters );
-
-	}
-
-}
-
-export { PackedPhongMaterial };

package/src/nodes/accessors/CameraNode.js

@@ -1,19 +0,0 @@
-import { uniform } from '../core/UniformNode.js';
-import { sharedUniformGroup } from '../core/UniformGroupNode.js';
-import { Vector3 } from '../../math/Vector3.js';
-
-const cameraGroup = /*#__PURE__*/ sharedUniformGroup( 'camera' ).onRenderUpdate( () => {
-
-	cameraGroup.needsUpdate = true;
-
-} );
-
-export const cameraNear = /*#__PURE__*/ uniform( 'float' ).label( 'cameraNear' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => camera.near );
-export const cameraFar = /*#__PURE__*/ uniform( 'float' ).label( 'cameraFar' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => camera.far );
-export const cameraLogDepth = /*#__PURE__*/ uniform( 'float' ).label( 'cameraLogDepth' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => 2.0 / ( Math.log( camera.far + 1.0 ) / Math.LN2 ) );
-export const cameraProjectionMatrix = /*#__PURE__*/ uniform( 'mat4' ).label( 'cameraProjectionMatrix' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => camera.projectionMatrix );
-export const cameraProjectionMatrixInverse = /*#__PURE__*/ uniform( 'mat4' ).label( 'cameraProjectionMatrixInverse' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => camera.projectionMatrixInverse );
-export const cameraViewMatrix = /*#__PURE__*/ uniform( 'mat4' ).label( 'cameraViewMatrix' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => camera.matrixWorldInverse );
-export const cameraWorldMatrix = /*#__PURE__*/ uniform( 'mat4' ).label( 'cameraWorldMatrix' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => camera.matrixWorld );
-export const cameraNormalMatrix = /*#__PURE__*/ uniform( 'mat3' ).label( 'cameraNormalMatrix' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera } ) => camera.normalMatrix );
-export const cameraPosition = /*#__PURE__*/ uniform( new Vector3() ).label( 'cameraPosition' ).setGroup( cameraGroup ).onRenderUpdate( ( { camera }, self ) => self.value.setFromMatrixPosition( camera.matrixWorld ) );

package/src/nodes/accessors/NormalNode.js

@@ -1,14 +0,0 @@
-import { attribute } from '../core/AttributeNode.js';
-import { varying } from '../core/VaryingNode.js';
-import { property } from '../core/PropertyNode.js';
-import { cameraViewMatrix } from './CameraNode.js';
-import { modelNormalMatrix } from './ModelNode.js';
-import { vec3 } from '../shadernode/ShaderNode.js';
-
-export const normalGeometry = /*#__PURE__*/ attribute( 'normal', 'vec3', vec3( 0, 1, 0 ) );
-export const normalLocal = /*#__PURE__*/ normalGeometry.toVar( 'normalLocal' );
-export const normalView = /*#__PURE__*/ varying( modelNormalMatrix.mul( normalLocal ), 'v_normalView' ).normalize().toVar( 'normalView' );
-export const normalWorld = /*#__PURE__*/ varying( normalView.transformDirection( cameraViewMatrix ), 'v_normalWorld' ).normalize().toVar( 'normalWorld' );
-export const transformedNormalView = /*#__PURE__*/ property( 'vec3', 'transformedNormalView' );
-export const transformedNormalWorld = /*#__PURE__*/ transformedNormalView.transformDirection( cameraViewMatrix ).normalize().toVar( 'transformedNormalWorld' );
-export const transformedClearcoatNormalView = /*#__PURE__*/ property( 'vec3', 'transformedClearcoatNormalView' );

package/src/nodes/accessors/PositionNode.js

@@ -1,10 +0,0 @@
-import { attribute } from '../core/AttributeNode.js';
-import { varying } from '../core/VaryingNode.js';
-import { modelWorldMatrix, modelViewMatrix } from './ModelNode.js';
-
-export const positionGeometry = /*#__PURE__*/ attribute( 'position', 'vec3' );
-export const positionLocal = /*#__PURE__*/ positionGeometry.toVar( 'positionLocal' );
-export const positionWorld = /*#__PURE__*/ varying( modelWorldMatrix.mul( positionLocal ).xyz, 'v_positionWorld' );
-export const positionWorldDirection = /*#__PURE__*/ varying( positionLocal.transformDirection( modelWorldMatrix ), 'v_positionWorldDirection' ).normalize().toVar( 'positionWorldDirection' );
-export const positionView = /*#__PURE__*/ varying( modelViewMatrix.mul( positionLocal ).xyz, 'v_positionView' );
-export const positionViewDirection = /*#__PURE__*/ varying( positionView.negate(), 'v_positionViewDirection' ).normalize().toVar( 'positionViewDirection' );

package/src/nodes/accessors/ReflectVectorNode.js

@@ -1,10 +0,0 @@
-import { cameraViewMatrix } from './CameraNode.js';
-import { transformedNormalView } from './NormalNode.js';
-import { positionViewDirection } from './PositionNode.js';
-import { materialRefractionRatio } from './MaterialNode.js';
-
-export const reflectView = /*#__PURE__*/ positionViewDirection.negate().reflect( transformedNormalView );
-export const refractView = /*#__PURE__*/ positionViewDirection.negate().refract( transformedNormalView, materialRefractionRatio );
-
-export const reflectVector = /*#__PURE__*/ reflectView.transformDirection( cameraViewMatrix ).toVar( 'reflectVector' );
-export const refractVector = /*#__PURE__*/ refractView.transformDirection( cameraViewMatrix ).toVar( 'reflectVector' );

package/src/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/src/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/src/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/src/nodes/display/ColorAdjustmentNode.js

@@ -1,104 +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';
-import { ColorManagement } from '../../math/ColorManagement.js';
-import { Vector3 } from '../../math/Vector3.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 );
-
-const _luminanceCoefficients = /*#__PURE__*/ new Vector3();
-export const luminance = (
-	color,
-	luminanceCoefficients = vec3( ... ColorManagement.getLuminanceCoefficients( _luminanceCoefficients ) )
-) => dot( color, luminanceCoefficients );
-
-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 );