super-three 0.133.4 → 0.136.1

package/examples/jsm/renderers/nodes/ShaderNode.js

@@ -1,3 +1,7 @@
+// core
+import PropertyNode from './core/PropertyNode.js';
+import VarNode from './core/VarNode.js';
+
 // inputs
 import ColorNode from './inputs/ColorNode.js';
 import FloatNode from './inputs/FloatNode.js';
@@ -5,11 +9,18 @@ import Vector2Node from './inputs/Vector2Node.js';
 import Vector3Node from './inputs/Vector3Node.js';
 import Vector4Node from './inputs/Vector4Node.js';
 
+// accessors
+import PositionNode from './accessors/PositionNode.js';
+import NormalNode from './accessors/NormalNode.js';
+
 // math
-import MathNode from './math/MathNode.js';
 import OperatorNode from './math/OperatorNode.js';
+import CondNode from './math/CondNode.js';
+import MathNode from './math/MathNode.js';
 
 // utils
+import ArrayElementNode from './utils/ArrayElementNode.js';
+import ConvertNode from './utils/ConvertNode.js';
 import JoinNode from './utils/JoinNode.js';
 import SplitNode from './utils/SplitNode.js';
 
@@ -18,17 +29,35 @@ import { Vector2, Vector3, Vector4, Color } from 'three';
 
 const NodeHandler = {
 
-	get: function ( node, prop ) {
+	construct( NodeClosure, params ) {
+
+		const inputs = params.shift();
+
+		return NodeClosure( ShaderNodeObjects( inputs ), ...params );
 
-		// Split Properties Pass
+	},
+
+	get: function ( node, prop ) {
 
 		if ( typeof prop === 'string' && node[ prop ] === undefined ) {
 
-			const splitProps = prop.match( /^[xyzw]{1,4}$/ );
+			if ( /^[xyzwrgbastpq]{1,4}$/.test( prop ) === true ) {
 
-			if ( splitProps !== null ) {
+				// accessing properties ( swizzle )
 
-				return ShaderNodeObject( new SplitNode( node, splitProps[ 0 ] ) );
+				prop = prop
+					.replace( /r|s/g, 'x' )
+					.replace( /g|t/g, 'y' )
+					.replace( /b|p/g, 'z' )
+					.replace( /a|q/g, 'w' );
+
+				return ShaderNodeObject( new SplitNode( node, prop ) );
+
+			} else if ( /^\d+$/.test( prop ) === true ) {
+
+				// accessing array
+
+				return ShaderNodeObject( new ArrayElementNode( node, new FloatNode( Number( prop ) ).setConst( true ) ) );
 
 			}
 
@@ -40,7 +69,9 @@ const NodeHandler = {
 
 };
 
-export const ShaderNodeObject = ( obj ) => {
+const nodeObjects = new WeakMap();
+
+const ShaderNodeObject = ( obj ) => {
 
 	const type = typeof obj;
 
@@ -52,16 +83,17 @@ export const ShaderNodeObject = ( obj ) => {
 
 		if ( obj.isNode === true ) {
 
-			const node = obj;
+			let nodeObject = nodeObjects.get( obj );
 
-			if ( node.isProxyNode !== true ) {
+			if ( nodeObject === undefined ) {
 
-				node.isProxyNode = true;
-
-				return new Proxy( node, NodeHandler );
+				nodeObject = new Proxy( obj, NodeHandler );
+				nodeObjects.set( obj, nodeObject );
 
 			}
 
+			return nodeObject;
+
 		}
 
 	}
@@ -70,7 +102,19 @@ export const ShaderNodeObject = ( obj ) => {
 
 };
 
-export const ShaderNodeArray = ( array ) => {
+const ShaderNodeObjects = ( objects ) => {
+
+	for ( const name in objects ) {
+
+		objects[ name ] = ShaderNodeObject( objects[ name ] );
+
+	}
+
+	return objects;
+
+};
+
+const ShaderNodeArray = ( array ) => {
 
 	const len = array.length;
 
@@ -84,29 +128,57 @@ export const ShaderNodeArray = ( array ) => {
 
 };
 
-export const ShaderNodeScript = ( jsFunc ) => {
+const ShaderNodeProxy = ( NodeClass, scope = null, factor = null ) => {
 
-	return ( ...params ) => {
+	if ( scope === null ) {
 
-		ShaderNodeArray( params );
+		return ( ...params ) => {
 
-		return ShaderNodeObject( jsFunc( ...params ) );
+			return ShaderNodeObject( new NodeClass( ...ShaderNodeArray( params ) ) );
 
-	};
+		};
+
+	} else if ( factor === null ) {
+
+		return ( ...params ) => {
+
+			return ShaderNodeObject( new NodeClass( scope, ...ShaderNodeArray( params ) ) );
+
+		};
+
+	} else {
+
+		factor = ShaderNodeObject( factor );
+
+		return ( ...params ) => {
+
+			return ShaderNodeObject( new NodeClass( scope, ...ShaderNodeArray( params ), factor ) );
+
+		};
+
+	}
 
 };
 
-export const ShaderNode = ( obj ) => {
+const ShaderNodeScript = function ( jsFunc ) {
 
-	return ShaderNodeScript( obj );
+	return ( inputs, builder ) => {
+
+		ShaderNodeObjects( inputs );
+
+		return ShaderNodeObject( jsFunc( inputs, builder ) );
+
+	};
 
 };
 
+export const ShaderNode = new Proxy( ShaderNodeScript, NodeHandler );
+
 //
 // Node Material Shader Syntax
 //
 
-export const uniform = ShaderNodeScript( ( inputNode ) => {
+export const uniform = new ShaderNode( ( inputNode ) => {
 
 	inputNode.setConst( false );
 
@@ -114,80 +186,188 @@ export const uniform = ShaderNodeScript( ( inputNode ) => {
 
 } );
 
+export const nodeObject = ( val ) => {
+
+	return ShaderNodeObject( val );
+
+};
+
 export const float = ( val ) => {
 
-	return ShaderNodeObject( new FloatNode( val ).setConst( true ) );
+	return nodeObject( new FloatNode( val ).setConst( true ) );
 
 };
 
 export const color = ( ...params ) => {
 
-	return ShaderNodeObject( new ColorNode( new Color( ...params ) ).setConst( true ) );
+	return nodeObject( new ColorNode( new Color( ...params ) ).setConst( true ) );
 
 };
 
 export const join = ( ...params ) => {
 
-	return ShaderNodeObject( new JoinNode( ShaderNodeArray( params ) ) );
+	return nodeObject( new JoinNode( ShaderNodeArray( params ) ) );
 
 };
 
-export const vec2 = ( ...params ) => {
+export const cond = ( ...params ) => {
 
-	return ShaderNodeObject( new Vector2Node( new Vector2( ...params ) ).setConst( true ) );
+	return nodeObject( new CondNode( ...ShaderNodeArray( params ) ) );
 
 };
 
-export const vec3 = ( ...params ) => {
+export const vec2 = ( ...params ) => {
 
-	return ShaderNodeObject( new Vector3Node( new Vector3( ...params ) ).setConst( true ) );
+	if ( params[ 0 ]?.isNode === true ) {
 
-};
+		return nodeObject( new ConvertNode( params[ 0 ], 'vec2' ) );
 
-export const vec4 = ( ...params ) => {
+	} else {
 
-	return ShaderNodeObject( new Vector4Node( new Vector4( ...params ) ).setConst( true ) );
+		// Providing one scalar value: This value is used for all components
 
-};
+		if ( params.length === 1 ) {
 
-export const add = ( ...params ) => {
+			params[ 1 ] = params[ 0 ];
 
-	return ShaderNodeObject( new OperatorNode( '+', ...ShaderNodeArray( params ) ) );
+		}
+
+		return nodeObject( new Vector2Node( new Vector2( ...params ) ).setConst( true ) );
+
+	}
 
 };
 
-export const sub = ( ...params ) => {
+export const vec3 = ( ...params ) => {
 
-	return new OperatorNode( '-', ...ShaderNodeArray( params ) );
+	if ( params[ 0 ]?.isNode === true ) {
 
-};
+		return nodeObject( new ConvertNode( params[ 0 ], 'vec3' ) );
 
-export const mul = ( ...params ) => {
+	} else {
 
-	return ShaderNodeObject( new OperatorNode( '*', ...ShaderNodeArray( params ) ) );
+		// Providing one scalar value: This value is used for all components
 
-};
+		if ( params.length === 1 ) {
 
-export const div = ( ...params ) => {
+			params[ 1 ] = params[ 2 ] = params[ 0 ];
+
+		}
 
-	return ShaderNodeObject( new OperatorNode( '/', ...ShaderNodeArray( params ) ) );
+		return nodeObject( new Vector3Node( new Vector3( ...params ) ).setConst( true ) );
+
+	}
 
 };
 
-export const floor = ( ...params ) => {
+export const vec4 = ( ...params ) => {
 
-	return ShaderNodeObject( new MathNode( 'floor', ...ShaderNodeArray( params ) ) );
+	if ( params[ 0 ]?.isNode === true ) {
 
-};
+		return nodeObject( new ConvertNode( params[ 0 ], 'vec4' ) );
 
-export const mod = ( ...params ) => {
+	} else {
 
-	return ShaderNodeObject( new MathNode( 'mod', ...ShaderNodeArray( params ) ) );
+		// Providing one scalar value: This value is used for all components
+
+		if ( params.length === 1 ) {
+
+			params[ 1 ] = params[ 2 ] = params[ 3 ] = params[ 0 ];
+
+		}
+
+		return nodeObject( new Vector4Node( new Vector4( ...params ) ).setConst( true ) );
+
+	}
 
 };
 
-export const sign = ( ...params ) => {
+export const addTo = ( varNode, ...params ) => {
 
-	return ShaderNodeObject( new MathNode( 'sign', ...ShaderNodeArray( params ) ) );
+	varNode.node = add( varNode.node, ...ShaderNodeArray( params ) );
+
+	return nodeObject( varNode );
 
 };
+
+export const add = ShaderNodeProxy( OperatorNode, '+' );
+export const sub = ShaderNodeProxy( OperatorNode, '-' );
+export const mul = ShaderNodeProxy( OperatorNode, '*' );
+export const div = ShaderNodeProxy( OperatorNode, '/' );
+export const equal = ShaderNodeProxy( OperatorNode, '==' );
+export const assign = ShaderNodeProxy( OperatorNode, '=' );
+export const greaterThan = ShaderNodeProxy( OperatorNode, '>' );
+export const lessThanEqual = ShaderNodeProxy( OperatorNode, '<=' );
+export const and = ShaderNodeProxy( OperatorNode, '&&' );
+
+export const element = ShaderNodeProxy( ArrayElementNode );
+
+export const normalGeometry = new NormalNode( NormalNode.GEOMETRY );
+export const normalLocal = new NormalNode( NormalNode.LOCAL );
+export const normalWorld = new NormalNode( NormalNode.WORLD );
+export const normalView = new NormalNode( NormalNode.VIEW );
+export const transformedNormalView = new VarNode( new NormalNode( NormalNode.VIEW ), 'TransformedNormalView', 'vec3' );
+
+export const positionLocal = new PositionNode( PositionNode.LOCAL );
+export const positionWorld = new PositionNode( PositionNode.WORLD );
+export const positionView = new PositionNode( PositionNode.VIEW );
+export const positionViewDirection = new PositionNode( PositionNode.VIEW_DIRECTION );
+
+export const PI = float( 3.141592653589793 );
+export const PI2 = float( 6.283185307179586 );
+export const PI_HALF = float( 1.5707963267948966 );
+export const RECIPROCAL_PI = float( 0.3183098861837907 );
+export const RECIPROCAL_PI2 = float( 0.15915494309189535 );
+export const EPSILON = float( 1e-6 );
+
+export const diffuseColor = new PropertyNode( 'DiffuseColor', 'vec4' );
+export const roughness = new PropertyNode( 'Roughness', 'float' );
+export const metalness = new PropertyNode( 'Metalness', 'float' );
+export const alphaTest = new PropertyNode( 'AlphaTest', 'float' );
+export const specularColor = new PropertyNode( 'SpecularColor', 'color' );
+
+export const abs = ShaderNodeProxy( MathNode, 'abs' );
+export const acos = ShaderNodeProxy( MathNode, 'acos' );
+export const asin = ShaderNodeProxy( MathNode, 'asin' );
+export const atan = ShaderNodeProxy( MathNode, 'atan' );
+export const ceil = ShaderNodeProxy( MathNode, 'ceil' );
+export const clamp = ShaderNodeProxy( MathNode, 'clamp' );
+export const cos = ShaderNodeProxy( MathNode, 'cos' );
+export const cross = ShaderNodeProxy( MathNode, 'cross' );
+export const degrees = ShaderNodeProxy( MathNode, 'degrees' );
+export const dFdx = ShaderNodeProxy( MathNode, 'dFdx' );
+export const dFdy = ShaderNodeProxy( MathNode, 'dFdy' );
+export const distance = ShaderNodeProxy( MathNode, 'distance' );
+export const dot = ShaderNodeProxy( MathNode, 'dot' );
+export const exp = ShaderNodeProxy( MathNode, 'exp' );
+export const exp2 = ShaderNodeProxy( MathNode, 'exp2' );
+export const faceforward = ShaderNodeProxy( MathNode, 'faceforward' );
+export const floor = ShaderNodeProxy( MathNode, 'floor' );
+export const fract = ShaderNodeProxy( MathNode, 'fract' );
+export const invert = ShaderNodeProxy( MathNode, 'invert' );
+export const inversesqrt = ShaderNodeProxy( MathNode, 'inversesqrt' );
+export const length = ShaderNodeProxy( MathNode, 'length' );
+export const log = ShaderNodeProxy( MathNode, 'log' );
+export const log2 = ShaderNodeProxy( MathNode, 'log2' );
+export const max = ShaderNodeProxy( MathNode, 'max' );
+export const min = ShaderNodeProxy( MathNode, 'min' );
+export const mix = ShaderNodeProxy( MathNode, 'mix' );
+export const mod = ShaderNodeProxy( MathNode, 'mod' );
+export const negate = ShaderNodeProxy( MathNode, 'negate' );
+export const normalize = ShaderNodeProxy( MathNode, 'normalize' );
+export const pow = ShaderNodeProxy( MathNode, 'pow' );
+export const pow2 = ShaderNodeProxy( MathNode, 'pow', 2 );
+export const pow3 = ShaderNodeProxy( MathNode, 'pow', 3 );
+export const pow4 = ShaderNodeProxy( MathNode, 'pow', 4 );
+export const radians = ShaderNodeProxy( MathNode, 'radians' );
+export const reflect = ShaderNodeProxy( MathNode, 'reflect' );
+export const refract = ShaderNodeProxy( MathNode, 'refract' );
+export const round = ShaderNodeProxy( MathNode, 'round' );
+export const saturate = ShaderNodeProxy( MathNode, 'saturate' );
+export const sign = ShaderNodeProxy( MathNode, 'sign' );
+export const sin = ShaderNodeProxy( MathNode, 'sin' );
+export const smoothstep = ShaderNodeProxy( MathNode, 'smoothstep' );
+export const sqrt = ShaderNodeProxy( MathNode, 'sqrt' );
+export const step = ShaderNodeProxy( MathNode, 'step' );
+export const tan = ShaderNodeProxy( MathNode, 'tan' );
+export const transformDirection = ShaderNodeProxy( MathNode, 'transformDirection' );

package/examples/jsm/renderers/nodes/accessors/MaterialNode.js

@@ -22,7 +22,7 @@ class MaterialNode extends Node {
 	getNodeType( builder ) {
 
 		const scope = this.scope;
-		const material = builder.getContextValue( 'material' );
+		const material = builder.context.material;
 
 		if ( scope === MaterialNode.COLOR ) {
 
@@ -46,7 +46,7 @@ class MaterialNode extends Node {
 
 	generate( builder, output ) {
 
-		const material = builder.getContextValue( 'material' );
+		const material = builder.context.material;
 		const scope = this.scope;
 
 		let node = null;
@@ -85,15 +85,15 @@ class MaterialNode extends Node {
 
 		} else if ( scope === MaterialNode.SPECULAR ) {
 
-			const specularTintNode = new MaterialReferenceNode( 'specularTint', 'color' );
+			const specularColorNode = new MaterialReferenceNode( 'specularColor', 'color' );
 
-			if ( material.specularTintMap !== null && material.specularTintMap !== undefined && material.specularTintMap.isTexture === true ) {
+			if ( material.specularColorMap !== null && material.specularColorMap !== undefined && material.specularColorMap.isTexture === true ) {
 
-				node = new OperatorNode( '*', specularTintNode, new MaterialReferenceNode( 'specularTintMap', 'texture' ) );
+				node = new OperatorNode( '*', specularColorNode, new MaterialReferenceNode( 'specularColorMap', 'texture' ) );
 
 			} else {
 
-				node = specularTintNode;
+				node = specularColorNode;
 
 			}
 

package/examples/jsm/renderers/nodes/accessors/ModelViewProjectionNode.js

@@ -12,16 +12,16 @@ class ModelViewProjectionNode extends Node {
 
 		this.position = position;
 
-		this._mvpMatrix = new OperatorNode( '*', new CameraNode( CameraNode.PROJECTION_MATRIX ), new ModelNode( ModelNode.VIEW_MATRIX ) );
-
 	}
 
 	generate( builder ) {
 
-		const mvpSnipped = this._mvpMatrix.build( builder );
-		const positionSnipped = this.position.build( builder, 'vec3' );
+		const position = this.position;
+
+		const mvpMatrix = new OperatorNode( '*', new CameraNode( CameraNode.PROJECTION_MATRIX ), new ModelNode( ModelNode.VIEW_MATRIX ) );
+		const mvpNode = new OperatorNode( '*', mvpMatrix, position );
 
-		return `( ${mvpSnipped} * vec4( ${positionSnipped}, 1.0 ) )`;
+		return mvpNode.build( builder );
 
 	}
 

package/examples/jsm/renderers/nodes/accessors/NormalNode.js

@@ -5,10 +5,10 @@ import ModelNode from '../accessors/ModelNode.js';
 import CameraNode from '../accessors/CameraNode.js';
 import OperatorNode from '../math/OperatorNode.js';
 import MathNode from '../math/MathNode.js';
-import { inverseTransformDirection } from '../functions/MathFunctions.js';
 
 class NormalNode extends Node {
 
+	static GEOMETRY = 'geometry';
 	static LOCAL = 'local';
 	static WORLD = 'world';
 	static VIEW = 'view';
@@ -21,16 +21,26 @@ class NormalNode extends Node {
 
 	}
 
+	getHash( /*builder*/ ) {
+
+		return `normal-${this.scope}`;
+
+	}
+
 	generate( builder ) {
 
 		const scope = this.scope;
 
 		let outputNode = null;
 
-		if ( scope === NormalNode.LOCAL ) {
+		if ( scope === NormalNode.GEOMETRY ) {
 
 			outputNode = new AttributeNode( 'normal', 'vec3' );
 
+		} else if ( scope === NormalNode.LOCAL ) {
+
+			outputNode = new VaryNode( new NormalNode( NormalNode.GEOMETRY ) );
+
 		} else if ( scope === NormalNode.VIEW ) {
 
 			const vertexNormalNode = new OperatorNode( '*', new ModelNode( ModelNode.NORMAL_MATRIX ), new NormalNode( NormalNode.LOCAL ) );
@@ -38,7 +48,8 @@ class NormalNode extends Node {
 
 		} else if ( scope === NormalNode.WORLD ) {
 
-			const vertexNormalNode = inverseTransformDirection.call( { dir: new NormalNode( NormalNode.VIEW ), matrix: new CameraNode( CameraNode.VIEW_MATRIX ) } );
+			// To use INVERSE_TRANSFORM_DIRECTION only inverse the param order like this: MathNode( ..., Vector, Matrix );
+			const vertexNormalNode = new MathNode( MathNode.TRANSFORM_DIRECTION, new NormalNode( NormalNode.VIEW ), new CameraNode( CameraNode.VIEW_MATRIX ) );
 			outputNode = new MathNode( MathNode.NORMALIZE, new VaryNode( vertexNormalNode ) );
 
 		}

package/examples/jsm/renderers/nodes/accessors/PointUVNode.js

@@ -6,11 +6,9 @@ class PointUVNode extends Node {
 
 		super( 'vec2' );
 
-		Object.defineProperty( this, 'isPointUVNode', { value: true } );
-
 	}
 
-	generate( builder ) {
+	generate( /*builder*/ ) {
 
 		return 'vec2( gl_PointCoord.x, 1.0 - gl_PointCoord.y )';
 
@@ -18,4 +16,6 @@ class PointUVNode extends Node {
 
 }
 
+PointUVNode.prototype.isPointUVNode = true;
+
 export default PointUVNode;

package/examples/jsm/renderers/nodes/accessors/PositionNode.js

@@ -4,10 +4,10 @@ import VaryNode from '../core/VaryNode.js';
 import ModelNode from '../accessors/ModelNode.js';
 import MathNode from '../math/MathNode.js';
 import OperatorNode from '../math/OperatorNode.js';
-import { transformDirection } from '../functions/MathFunctions.js';
 
 class PositionNode extends Node {
 
+	static GEOMETRY = 'geometry';
 	static LOCAL = 'local';
 	static WORLD = 'world';
 	static VIEW = 'view';
@@ -21,19 +21,29 @@ class PositionNode extends Node {
 
 	}
 
+	getHash( /*builder*/ ) {
+
+		return `position-${this.scope}`;
+
+	}
+
 	generate( builder ) {
 
 		const scope = this.scope;
 
 		let outputNode = null;
 
-		if ( scope === PositionNode.LOCAL ) {
-			
+		if ( scope === PositionNode.GEOMETRY ) {
+
 			outputNode = new AttributeNode( 'position', 'vec3' );
-			
+
+		} else if ( scope === PositionNode.LOCAL ) {
+
+			outputNode = new VaryNode( new PositionNode( PositionNode.GEOMETRY ) );
+
 		} else if ( scope === PositionNode.WORLD ) {
 
-			const vertexPositionNode = transformDirection.call( { dir: new PositionNode( PositionNode.LOCAL ), matrix: new ModelNode( ModelNode.WORLD_MATRIX ) } );
+			const vertexPositionNode = new MathNode( MathNode.TRANSFORM_DIRECTION, new ModelNode( ModelNode.WORLD_MATRIX ), new PositionNode( PositionNode.LOCAL ) );
 			outputNode = new VaryNode( vertexPositionNode );
 
 		} else if ( scope === PositionNode.VIEW ) {

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

@@ -0,0 +1,107 @@
+import Node from '../core/Node.js';
+import AttributeNode from '../core/AttributeNode.js';
+import PositionNode from '../accessors/PositionNode.js';
+import NormalNode from '../accessors/NormalNode.js';
+import Matrix4Node from '../inputs/Matrix4Node.js';
+import BufferNode from '../inputs/BufferNode.js';
+
+import { ShaderNode, assign, element, add, mul, transformDirection } from '../ShaderNode.js';
+
+import { NodeUpdateType } from '../core/constants.js';
+
+const Skinning = new ShaderNode( ( inputs, builder ) => {
+
+	const { position, normal, index, weight, bindMatrix, bindMatrixInverse, boneMatrices } = inputs;
+
+	const boneMatX = element( boneMatrices, index.x );
+	const boneMatY = element( boneMatrices, index.y );
+	const boneMatZ = element( boneMatrices, index.z );
+	const boneMatW = element( boneMatrices, index.w );
+
+	// POSITION
+
+	const skinVertex = mul( bindMatrix, position );
+
+	const skinned = add(
+		mul( mul( boneMatX, skinVertex ), weight.x ),
+		mul( mul( boneMatY, skinVertex ), weight.y ),
+		mul( mul( boneMatZ, skinVertex ), weight.z ),
+		mul( mul( boneMatW, skinVertex ), weight.w )
+	);
+
+	const skinPosition = mul( bindMatrixInverse, skinned ).xyz;
+
+	// NORMAL
+
+	let skinMatrix = add(
+		mul( weight.x, boneMatX ),
+		mul( weight.y, boneMatY ),
+		mul( weight.z, boneMatZ ),
+		mul( weight.w, boneMatW )
+	);
+
+	skinMatrix = mul( mul( bindMatrixInverse, skinMatrix ), bindMatrix );
+
+	const skinNormal = transformDirection( skinMatrix, normal ).xyz;
+
+	// ASSIGNS
+
+	assign( position, skinPosition ).build( builder );
+	assign( normal, skinNormal ).build( builder );
+
+} );
+
+class SkinningNode extends Node {
+
+	constructor( skinnedMesh ) {
+
+		super( 'void' );
+
+		this.skinnedMesh = skinnedMesh;
+
+		this.updateType = NodeUpdateType.Object;
+
+		//
+
+		this.skinIndexNode = new AttributeNode( 'skinIndex', 'uvec4' );
+		this.skinWeightNode = new AttributeNode( 'skinWeight', 'vec4' );
+
+		this.bindMatrixNode = new Matrix4Node( skinnedMesh.bindMatrix );
+		this.bindMatrixInverseNode = new Matrix4Node( skinnedMesh.bindMatrixInverse );
+		this.boneMatricesNode = new BufferNode( skinnedMesh.skeleton.boneMatrices, 'mat4', skinnedMesh.skeleton.bones.length );
+
+	}
+
+	generate( builder ) {
+
+		// inout nodes
+		const position = new PositionNode( PositionNode.LOCAL );
+		const normal = new NormalNode( NormalNode.LOCAL );
+
+		const index = this.skinIndexNode;
+		const weight = this.skinWeightNode;
+		const bindMatrix = this.bindMatrixNode;
+		const bindMatrixInverse = this.bindMatrixInverseNode;
+		const boneMatrices = this.boneMatricesNode;
+
+		Skinning( {
+			position,
+			normal,
+			index,
+			weight,
+			bindMatrix,
+			bindMatrixInverse,
+			boneMatrices
+		}, builder );
+
+	}
+
+	update() {
+
+		this.skinnedMesh.skeleton.update();
+
+	}
+
+}
+
+export default SkinningNode;