@needle-tools/three 0.162.12 → 0.169.2

package/src/materials/nodes/InstancedPointsNodeMaterial.js

@@ -0,0 +1,156 @@
+import NodeMaterial from './NodeMaterial.js';
+import { attribute } from '../../nodes/core/AttributeNode.js';
+import { cameraProjectionMatrix } from '../../nodes/accessors/Camera.js';
+import { materialColor, materialOpacity, materialPointWidth } from '../../nodes/accessors/MaterialNode.js'; // or should this be a property, instead?
+import { modelViewMatrix } from '../../nodes/accessors/ModelNode.js';
+import { positionGeometry } from '../../nodes/accessors/Position.js';
+import { smoothstep, lengthSq } from '../../nodes/math/MathNode.js';
+import { Fn, vec4, float } from '../../nodes/tsl/TSLBase.js';
+import { uv } from '../../nodes/accessors/UV.js';
+import { viewport } from '../../nodes/display/ScreenNode.js';
+
+import { PointsMaterial } from '../PointsMaterial.js';
+
+const _defaultValues = /*@__PURE__*/ new PointsMaterial();
+
+class InstancedPointsNodeMaterial extends NodeMaterial {
+
+	static get type() {
+
+		return 'InstancedPointsNodeMaterial';
+
+	}
+
+	constructor( params = {} ) {
+
+		super();
+
+		this.lights = false;
+
+		this.useAlphaToCoverage = true;
+
+		this.useColor = params.vertexColors;
+
+		this.pointWidth = 1;
+
+		this.pointColorNode = null;
+
+		this.pointWidthNode = null;
+
+		this.setDefaultValues( _defaultValues );
+
+		this.setValues( params );
+
+	}
+
+	setup( builder ) {
+
+		this.setupShaders( builder );
+
+		super.setup( builder );
+
+	}
+
+	setupShaders( { renderer } ) {
+
+		const useAlphaToCoverage = this.alphaToCoverage;
+		const useColor = this.useColor;
+
+		this.vertexNode = Fn( () => {
+
+			const instancePosition = attribute( 'instancePosition' ).xyz;
+
+			// camera space
+			const mvPos = vec4( modelViewMatrix.mul( vec4( instancePosition, 1.0 ) ) );
+
+			const aspect = viewport.z.div( viewport.w );
+
+			// clip space
+			const clipPos = cameraProjectionMatrix.mul( mvPos );
+
+			// offset in ndc space
+			const offset = positionGeometry.xy.toVar();
+
+			offset.mulAssign( this.pointWidthNode ? this.pointWidthNode : materialPointWidth );
+
+			offset.assign( offset.div( viewport.z ) );
+			offset.y.assign( offset.y.mul( aspect ) );
+
+			// back to clip space
+			offset.assign( offset.mul( clipPos.w ) );
+
+			//clipPos.xy += offset;
+			clipPos.addAssign( vec4( offset, 0, 0 ) );
+
+			return clipPos;
+
+		} )();
+
+		this.fragmentNode = Fn( () => {
+
+			const alpha = float( 1 ).toVar();
+
+			const len2 = lengthSq( uv().mul( 2 ).sub( 1 ) );
+
+			if ( useAlphaToCoverage && renderer.samples > 1 ) {
+
+				const dlen = float( len2.fwidth() ).toVar();
+
+				alpha.assign( smoothstep( dlen.oneMinus(), dlen.add( 1 ), len2 ).oneMinus() );
+
+			} else {
+
+				len2.greaterThan( 1.0 ).discard();
+
+			}
+
+			let pointColorNode;
+
+			if ( this.pointColorNode ) {
+
+				pointColorNode = this.pointColorNode;
+
+			} else {
+
+				if ( useColor ) {
+
+					const instanceColor = attribute( 'instanceColor' );
+
+					pointColorNode = instanceColor.mul( materialColor );
+
+				} else {
+
+					pointColorNode = materialColor;
+
+				}
+
+			}
+
+			alpha.mulAssign( materialOpacity );
+
+			return vec4( pointColorNode, alpha );
+
+		} )();
+
+	}
+
+	get alphaToCoverage() {
+
+		return this.useAlphaToCoverage;
+
+	}
+
+	set alphaToCoverage( value ) {
+
+		if ( this.useAlphaToCoverage !== value ) {
+
+			this.useAlphaToCoverage = value;
+			this.needsUpdate = true;
+
+		}
+
+	}
+
+}
+
+export default InstancedPointsNodeMaterial;

package/{examples/jsm/nodes/materials → src/materials/nodes}/Line2NodeMaterial.js

@@ -1,32 +1,35 @@
-import NodeMaterial, { addNodeMaterial } from './NodeMaterial.js';
-import { temp } from '../core/VarNode.js';
-import { varying } from '../core/VaryingNode.js';
-import { property, varyingProperty } from '../core/PropertyNode.js';
-import { attribute } from '../core/AttributeNode.js';
-import { cameraProjectionMatrix } from '../accessors/CameraNode.js';
-import { materialColor, materialLineScale, materialLineDashSize, materialLineGapSize, materialLineDashOffset, materialLineWidth } from '../accessors/MaterialNode.js';
-import { modelViewMatrix } from '../accessors/ModelNode.js';
-import { positionGeometry } from '../accessors/PositionNode.js';
-import { mix, smoothstep } from '../math/MathNode.js';
-import { tslFn, float, vec2, vec3, vec4, If } from '../shadernode/ShaderNode.js';
-import { uv } from '../accessors/UVNode.js';
-import { viewport } from '../display/ViewportNode.js';
-import { dashSize, gapSize } from '../core/PropertyNode.js';
-
-import { LineDashedMaterial } from 'three';
-
-const defaultValues = new LineDashedMaterial();
+import NodeMaterial from './NodeMaterial.js';
+import { varyingProperty } from '../../nodes/core/PropertyNode.js';
+import { attribute } from '../../nodes/core/AttributeNode.js';
+import { cameraProjectionMatrix } from '../../nodes/accessors/Camera.js';
+import { materialColor, materialLineScale, materialLineDashSize, materialLineGapSize, materialLineDashOffset, materialLineWidth } from '../../nodes/accessors/MaterialNode.js';
+import { modelViewMatrix } from '../../nodes/accessors/ModelNode.js';
+import { positionGeometry } from '../../nodes/accessors/Position.js';
+import { mix, smoothstep } from '../../nodes/math/MathNode.js';
+import { Fn, varying, float, vec2, vec3, vec4, If } from '../../nodes/tsl/TSLBase.js';
+import { uv } from '../../nodes/accessors/UV.js';
+import { viewport } from '../../nodes/display/ScreenNode.js';
+import { dashSize, gapSize } from '../../nodes/core/PropertyNode.js';
+
+import { LineDashedMaterial } from '../LineDashedMaterial.js';
+
+const _defaultValues = /*@__PURE__*/ new LineDashedMaterial();
 
 class Line2NodeMaterial extends NodeMaterial {
 
+	static get type() {
+
+		return 'Line2NodeMaterial';
+
+	}
+
 	constructor( params = {} ) {
 
 		super();
 
-		this.normals = false;
 		this.lights = false;
 
-		this.setDefaultValues( defaultValues );
+		this.setDefaultValues( _defaultValues );
 
 		this.useAlphaToCoverage = true;
 		this.useColor = params.vertexColors;
@@ -43,20 +46,26 @@ class Line2NodeMaterial extends NodeMaterial {
 		this.dashSizeNode = null;
 		this.gapSizeNode = null;
 
-		this.setupShaders();
-
 		this.setValues( params );
 
 	}
 
-	setupShaders() {
+	setup( builder ) {
+
+		this.setupShaders( builder );
+
+		super.setup( builder );
+
+	}
+
+	setupShaders( { renderer } ) {
 
 		const useAlphaToCoverage = this.alphaToCoverage;
 		const useColor = this.useColor;
 		const useDash = this.dashed;
 		const useWorldUnits = this.worldUnits;
 
-		const trimSegment = tslFn( ( { start, end } ) => {
+		const trimSegment = Fn( ( { start, end } ) => {
 
 			const a = cameraProjectionMatrix.element( 2 ).element( 2 ); // 3nd entry in 3th column
 			const b = cameraProjectionMatrix.element( 3 ).element( 2 ); // 3nd entry in 4th column
@@ -66,22 +75,24 @@ class Line2NodeMaterial extends NodeMaterial {
 
 			return vec4( mix( start.xyz, end.xyz, alpha ), end.w );
 
+		} ).setLayout( {
+			name: 'trimSegment',
+			type: 'vec4',
+			inputs: [
+				{ name: 'start', type: 'vec4' },
+				{ name: 'end', type: 'vec4' }
+			]
 		} );
 
-		this.vertexNode = tslFn( () => {
-
-			varyingProperty( 'vec2', 'vUv' ).assign( uv() );
+		this.vertexNode = Fn( () => {
 
 			const instanceStart = attribute( 'instanceStart' );
 			const instanceEnd = attribute( 'instanceEnd' );
 
 			// camera space
 
-			const start = property( 'vec4', 'start' );
-			const end = property( 'vec4', 'end' );
-
-			start.assign( modelViewMatrix.mul( vec4( instanceStart, 1.0 ) ) ); // force assignment into correct place in flow
-			end.assign( modelViewMatrix.mul( vec4( instanceEnd, 1.0 ) ) );
+			const start = vec4( modelViewMatrix.mul( vec4( instanceStart, 1.0 ) ) ).toVar( 'start' );
+			const end = vec4( modelViewMatrix.mul( vec4( instanceEnd, 1.0 ) ) ).toVar( 'end' );
 
 			if ( useWorldUnits ) {
 
@@ -105,7 +116,7 @@ class Line2NodeMaterial extends NodeMaterial {
 
 					end.assign( trimSegment( { start: start, end: end } ) );
 
-				} ).elseif( end.z.lessThan( 0.0 ).and( start.z.greaterThanEqual( 0.0 ) ), () => {
+				} ).ElseIf( end.z.lessThan( 0.0 ).and( start.z.greaterThanEqual( 0.0 ) ), () => {
 
 					start.assign( trimSegment( { start: end, end: start } ) );
 
@@ -122,13 +133,13 @@ class Line2NodeMaterial extends NodeMaterial {
 			const ndcEnd = clipEnd.xyz.div( clipEnd.w );
 
 			// direction
-			const dir = ndcEnd.xy.sub( ndcStart.xy ).temp();
+			const dir = ndcEnd.xy.sub( ndcStart.xy ).toVar();
 
 			// account for clip-space aspect ratio
 			dir.x.assign( dir.x.mul( aspect ) );
 			dir.assign( dir.normalize() );
 
-			const clip = temp( vec4() );
+			const clip = vec4().toVar();
 
 			if ( useWorldUnits ) {
 
@@ -141,18 +152,18 @@ class Line2NodeMaterial extends NodeMaterial {
 
 				const worldPos = varyingProperty( 'vec4', 'worldPos' );
 
-				worldPos.assign( positionGeometry.y.lessThan( 0.5 ).cond( start, end) );
+				worldPos.assign( positionGeometry.y.lessThan( 0.5 ).select( start, end ) );
 
 				// height offset
 				const hw = materialLineWidth.mul( 0.5 );
-				worldPos.addAssign( vec4( positionGeometry.x.lessThan( 0.0 ).cond( worldUp.mul( hw ), worldUp.mul( hw ).negate() ), 0 ) );
+				worldPos.addAssign( vec4( positionGeometry.x.lessThan( 0.0 ).select( worldUp.mul( hw ), worldUp.mul( hw ).negate() ), 0 ) );
 
 				// don't extend the line if we're rendering dashes because we
 				// won't be rendering the endcaps
 				if ( ! useDash ) {
 
 					// cap extension
-					worldPos.addAssign( vec4( positionGeometry.y.lessThan( 0.5 ).cond( worldDir.mul( hw ).negate(), worldDir.mul( hw ) ), 0 ) );
+					worldPos.addAssign( vec4( positionGeometry.y.lessThan( 0.5 ).select( worldDir.mul( hw ).negate(), worldDir.mul( hw ) ), 0 ) );
 
 					// add width to the box
 					worldPos.addAssign( vec4( worldFwd.mul( hw ), 0 ) );
@@ -171,30 +182,28 @@ class Line2NodeMaterial extends NodeMaterial {
 
 				// shift the depth of the projected points so the line
 				// segments overlap neatly
-				const clipPose = temp( vec3() );
+				const clipPose = vec3().toVar();
 
-				clipPose.assign( positionGeometry.y.lessThan( 0.5 ).cond( ndcStart, ndcEnd ) );
+				clipPose.assign( positionGeometry.y.lessThan( 0.5 ).select( ndcStart, ndcEnd ) );
 				clip.z.assign( clipPose.z.mul( clip.w ) );
 
 			} else {
 
-				const offset = property( 'vec2', 'offset' );
-
-				offset.assign( vec2( dir.y, dir.x.negate() ) );
+				const offset = vec2( dir.y, dir.x.negate() ).toVar( 'offset' );
 
 				// undo aspect ratio adjustment
 				dir.x.assign( dir.x.div( aspect ) );
 				offset.x.assign( offset.x.div( aspect ) );
 
 				// sign flip
-				offset.assign( positionGeometry.x.lessThan( 0.0 ).cond( offset.negate(), offset ) );
+				offset.assign( positionGeometry.x.lessThan( 0.0 ).select( offset.negate(), offset ) );
 
 				// endcaps
 				If( positionGeometry.y.lessThan( 0.0 ), () => {
 
 					offset.assign( offset.sub( dir ) );
 
-				} ).elseif( positionGeometry.y.greaterThan( 1.0 ), () => {
+				} ).ElseIf( positionGeometry.y.greaterThan( 1.0 ), () => {
 
 					offset.assign( offset.add( dir ) );
 
@@ -207,7 +216,7 @@ class Line2NodeMaterial extends NodeMaterial {
 				offset.assign( offset.div( viewport.w ) );
 
 				// select end
-				clip.assign( positionGeometry.y.lessThan( 0.5 ).cond( clipStart, clipEnd ) );
+				clip.assign( positionGeometry.y.lessThan( 0.5 ).select( clipStart, clipEnd ) );
 
 				// back to clip space
 				offset.assign( offset.mul( clip.w ) );
@@ -220,7 +229,7 @@ class Line2NodeMaterial extends NodeMaterial {
 
 		} )();
 
-		const closestLineToLine = tslFn( ( { p1, p2, p3, p4 } ) => {
+		const closestLineToLine = Fn( ( { p1, p2, p3, p4 } ) => {
 
 			const p13 = p1.sub( p3 );
 			const p43 = p4.sub( p3 );
@@ -243,9 +252,9 @@ class Line2NodeMaterial extends NodeMaterial {
 
 		} );
 
-		this.fragmentNode = tslFn( () => {
+		this.fragmentNode = Fn( () => {
 
-			const vUv = varyingProperty( 'vec2', 'vUv' );
+			const vUv = uv();
 
 			if ( useDash ) {
 
@@ -260,7 +269,7 @@ class Line2NodeMaterial extends NodeMaterial {
 				const instanceDistanceStart = attribute( 'instanceDistanceStart' );
 				const instanceDistanceEnd = attribute( 'instanceDistanceEnd' );
 
-				const lineDistance = positionGeometry.y.lessThan( 0.5 ).cond( dashScaleNode.mul( instanceDistanceStart ), materialLineScale.mul( instanceDistanceEnd ) );
+				const lineDistance = positionGeometry.y.lessThan( 0.5 ).select( dashScaleNode.mul( instanceDistanceStart ), materialLineScale.mul( instanceDistanceEnd ) );
 
 				const vLineDistance = varying( lineDistance.add( materialLineDashOffset ) );
 				const vLineDistanceOffset = offsetNode ? vLineDistance.add( offsetNode ) : vLineDistance;
@@ -270,9 +279,7 @@ class Line2NodeMaterial extends NodeMaterial {
 
 			}
 
-			 // force assignment into correct place in flow
-			const alpha = property( 'float', 'alpha' );
-			alpha.assign( 1 );
+			const alpha = float( 1 ).toVar( 'alpha' );
 
 			if ( useWorldUnits ) {
 
@@ -292,7 +299,7 @@ class Line2NodeMaterial extends NodeMaterial {
 
 				if ( ! useDash ) {
 
-					if ( useAlphaToCoverage ) {
+					if ( useAlphaToCoverage && renderer.samples > 1 ) {
 
 						const dnorm = norm.fwidth();
 						alpha.assign( smoothstep( dnorm.negate().add( 0.5 ), dnorm.add( 0.5 ), norm ).oneMinus() );
@@ -309,16 +316,14 @@ class Line2NodeMaterial extends NodeMaterial {
 
 				// round endcaps
 
-				if ( useAlphaToCoverage ) {
+				if ( useAlphaToCoverage && renderer.samples > 1 ) {
 
 					const a = vUv.x;
-					const b = vUv.y.greaterThan( 0.0 ).cond( vUv.y.sub( 1.0 ), vUv.y.add( 1.0 ) );
+					const b = vUv.y.greaterThan( 0.0 ).select( vUv.y.sub( 1.0 ), vUv.y.add( 1.0 ) );
 
 					const len2 = a.mul( a ).add( b.mul( b ) );
 
-					// force assignment out of following 'if' statement - to avoid uniform control flow errors
-					const dlen = property( 'float', 'dlen' );
-					dlen.assign( len2.fwidth() );
+					const dlen = float( len2.fwidth() ).toVar( 'dlen' );
 
 					If( vUv.y.abs().greaterThan( 1.0 ), () => {
 
@@ -331,7 +336,7 @@ class Line2NodeMaterial extends NodeMaterial {
 					If( vUv.y.abs().greaterThan( 1.0 ), () => {
 
 						const a = vUv.x;
-						const b = vUv.y.greaterThan( 0.0 ).cond( vUv.y.sub( 1.0 ), vUv.y.add( 1.0 ) );
+						const b = vUv.y.greaterThan( 0.0 ).select( vUv.y.sub( 1.0 ), vUv.y.add( 1.0 ) );
 						const len2 = a.mul( a ).add( b.mul( b ) );
 
 						len2.greaterThan( 1.0 ).discard();
@@ -355,7 +360,7 @@ class Line2NodeMaterial extends NodeMaterial {
 					const instanceColorStart = attribute( 'instanceColorStart' );
 					const instanceColorEnd = attribute( 'instanceColorEnd' );
 
-					const instanceColor = positionGeometry.y.lessThan( 0.5 ).cond( instanceColorStart, instanceColorEnd );
+					const instanceColor = positionGeometry.y.lessThan( 0.5 ).select( instanceColorStart, instanceColorEnd );
 
 					lineColorNode = instanceColor.mul( materialColor );
 
@@ -371,8 +376,6 @@ class Line2NodeMaterial extends NodeMaterial {
 
 		} )();
 
-		this.needsUpdate = true;
-
 	}
 
 
@@ -387,7 +390,7 @@ class Line2NodeMaterial extends NodeMaterial {
 		if ( this.useWorldUnits !== value ) {
 
 			this.useWorldUnits = value;
-			this.setupShaders();
+			this.needsUpdate = true;
 
 		}
 
@@ -405,7 +408,7 @@ class Line2NodeMaterial extends NodeMaterial {
 		if ( this.useDash !== value ) {
 
 			this.useDash = value;
-			this.setupShaders();
+			this.needsUpdate = true;
 
 		}
 
@@ -423,7 +426,7 @@ class Line2NodeMaterial extends NodeMaterial {
 		if ( this.useAlphaToCoverage !== value ) {
 
 			this.useAlphaToCoverage = value;
-			this.setupShaders();
+			this.needsUpdate = true;
 
 		}
 
@@ -432,5 +435,3 @@ class Line2NodeMaterial extends NodeMaterial {
 }
 
 export default Line2NodeMaterial;
-
-addNodeMaterial( 'Line2NodeMaterial', Line2NodeMaterial );

package/src/materials/nodes/LineBasicNodeMaterial.js

@@ -0,0 +1,31 @@
+import NodeMaterial from './NodeMaterial.js';
+
+import { LineBasicMaterial } from '../LineBasicMaterial.js';
+
+const _defaultValues = /*@__PURE__*/ new LineBasicMaterial();
+
+class LineBasicNodeMaterial extends NodeMaterial {
+
+	static get type() {
+
+		return 'LineBasicNodeMaterial';
+
+	}
+
+	constructor( parameters ) {
+
+		super();
+
+		this.isLineBasicNodeMaterial = true;
+
+		this.lights = false;
+
+		this.setDefaultValues( _defaultValues );
+
+		this.setValues( parameters );
+
+	}
+
+}
+
+export default LineBasicNodeMaterial;

package/{examples/jsm/nodes/materials → src/materials/nodes}/LineDashedNodeMaterial.js

@@ -1,15 +1,21 @@
-import NodeMaterial, { addNodeMaterial } from './NodeMaterial.js';
-import { attribute } from '../core/AttributeNode.js';
-import { varying } from '../core/VaryingNode.js';
-import { materialLineDashSize, materialLineGapSize, materialLineScale } from '../accessors/MaterialNode.js';
-import { dashSize, gapSize } from '../core/PropertyNode.js';
-import { float } from '../shadernode/ShaderNode.js';
-import { LineDashedMaterial } from 'three';
+import NodeMaterial from './NodeMaterial.js';
+import { attribute } from '../../nodes/core/AttributeNode.js';
+import { materialLineDashSize, materialLineGapSize, materialLineScale } from '../../nodes/accessors/MaterialNode.js';
+import { dashSize, gapSize } from '../../nodes/core/PropertyNode.js';
+import { varying, float } from '../../nodes/tsl/TSLBase.js';
 
-const defaultValues = new LineDashedMaterial();
+import { LineDashedMaterial } from '../LineDashedMaterial.js';
+
+const _defaultValues = /*@__PURE__*/ new LineDashedMaterial();
 
 class LineDashedNodeMaterial extends NodeMaterial {
 
+	static get type() {
+
+		return 'LineDashedNodeMaterial';
+
+	}
+
 	constructor( parameters ) {
 
 		super();
@@ -17,9 +23,8 @@ class LineDashedNodeMaterial extends NodeMaterial {
 		this.isLineDashedNodeMaterial = true;
 
 		this.lights = false;
-		this.normals = false;
 
-		this.setDefaultValues( defaultValues );
+		this.setDefaultValues( _defaultValues );
 
 		this.offsetNode = null;
 		this.dashScaleNode = null;
@@ -50,5 +55,3 @@ class LineDashedNodeMaterial extends NodeMaterial {
 }
 
 export default LineDashedNodeMaterial;
-
-addNodeMaterial( 'LineDashedNodeMaterial', LineDashedNodeMaterial );

package/src/materials/nodes/MeshBasicNodeMaterial.js

@@ -0,0 +1,77 @@
+import NodeMaterial from './NodeMaterial.js';
+import { materialLightMap } from '../../nodes/accessors/MaterialNode.js';
+import BasicEnvironmentNode from '../../nodes/lighting/BasicEnvironmentNode.js';
+import BasicLightMapNode from '../../nodes/lighting/BasicLightMapNode.js';
+import BasicLightingModel from '../../nodes/functions/BasicLightingModel.js';
+import { normalView } from '../../nodes/accessors/Normal.js';
+import { diffuseColor } from '../../nodes/core/PropertyNode.js';
+
+import { MeshBasicMaterial } from '../MeshBasicMaterial.js';
+
+const _defaultValues = /*@__PURE__*/ new MeshBasicMaterial();
+
+class MeshBasicNodeMaterial extends NodeMaterial {
+
+	static get type() {
+
+		return 'MeshBasicNodeMaterial';
+
+	}
+
+	constructor( parameters ) {
+
+		super();
+
+		this.isMeshBasicNodeMaterial = true;
+
+		this.lights = true;
+
+		this.setDefaultValues( _defaultValues );
+
+		this.setValues( parameters );
+
+	}
+
+	setupNormal() {
+
+		return normalView; // see #28839
+
+	}
+
+	setupEnvironment( builder ) {
+
+		const envNode = super.setupEnvironment( builder );
+
+		return envNode ? new BasicEnvironmentNode( envNode ) : null;
+
+	}
+
+	setupLightMap( builder ) {
+
+		let node = null;
+
+		if ( builder.material.lightMap ) {
+
+			node = new BasicLightMapNode( materialLightMap );
+
+		}
+
+		return node;
+
+	}
+
+	setupOutgoingLight() {
+
+		return diffuseColor.rgb;
+
+	}
+
+	setupLightingModel() {
+
+		return new BasicLightingModel();
+
+	}
+
+}
+
+export default MeshBasicNodeMaterial;

package/src/materials/nodes/MeshLambertNodeMaterial.js

@@ -0,0 +1,47 @@
+import NodeMaterial from './NodeMaterial.js';
+import BasicEnvironmentNode from '../../nodes/lighting/BasicEnvironmentNode.js';
+import PhongLightingModel from '../../nodes/functions/PhongLightingModel.js';
+
+import { MeshLambertMaterial } from '../MeshLambertMaterial.js';
+
+const _defaultValues = /*@__PURE__*/ new MeshLambertMaterial();
+
+class MeshLambertNodeMaterial extends NodeMaterial {
+
+	static get type() {
+
+		return 'MeshLambertNodeMaterial';
+
+	}
+
+	constructor( parameters ) {
+
+		super();
+
+		this.isMeshLambertNodeMaterial = true;
+
+		this.lights = true;
+
+		this.setDefaultValues( _defaultValues );
+
+		this.setValues( parameters );
+
+	}
+
+	setupEnvironment( builder ) {
+
+		const envNode = super.setupEnvironment( builder );
+
+		return envNode ? new BasicEnvironmentNode( envNode ) : null;
+
+	}
+
+	setupLightingModel( /*builder*/ ) {
+
+		return new PhongLightingModel( false ); // ( specular ) -> force lambert
+
+	}
+
+}
+
+export default MeshLambertNodeMaterial;