Accueil / npm / three@0.186.1 / examples / jsm / loaders / materialx / MaterialXNodeLibrary.js
MaterialXNodeLibrary.js
import {
abs,
add,
clamp,
floor,
ceil,
round,
sign,
sin,
cos,
tan,
asin,
acos,
sqrt,
log,
exp,
min,
max,
normalize,
length,
dot,
cross,
mul,
div,
pow,
distance,
remap,
luminance,
mx_rgbtohsv,
mx_hsvtorgb,
mix,
saturation as mx_saturation,
transpose,
determinant,
inverse,
mat3,
mx_ramp4,
mx_ramplr,
mx_ramptb,
mx_splitlr,
mx_splittb,
mx_fractal_noise_float,
mx_fractal_noise_vec3,
mx_noise_float,
mx_noise_vec3,
mx_cell_noise_float,
mx_cell_noise_vec3,
mx_smoothstep,
mx_worley_noise_float_2d,
mx_worley_noise_float_3d,
mx_worley_noise_vec3_style,
mx_unifiednoise2d,
mx_unifiednoise3d,
mx_modulo,
mx_invert,
mx_place2d,
mx_rotate2d,
mx_rotate3d,
mx_safepower,
mx_contrast,
element,
reflect,
refract,
mx_timer,
mx_frame,
mx_ifgreater,
mx_ifgreatereq,
mx_ifequal,
mx_atan2,
positionLocal,
positionWorld,
normalWorld,
tangentWorld,
bitangentWorld,
cameraPosition,
mx_heighttonormal,
float,
int,
bool,
color,
modelNormalMatrix,
modelWorldMatrix,
modelWorldMatrixInverse,
vec2,
vec3,
vec4,
fract,
sub,
step,
and as tslAnd,
or as tslOr,
xor as tslXor,
not as tslNot,
Fn,
Loop,
} from 'three/tsl';
import { normalizeSpaceName, toBooleanNode, toVec3Channels } from './MaterialXUtils.js';
const createMXElement = ( name, nodeFunc, params = [], defaults = {}, usesNode = false ) => ( { name, nodeFunc, params, defaults, usesNode } );
const mx_range = ( inNode, inLow, inHigh, outLow, outHigh, gamma = 1 ) => {
const inSpan = max( sub( inHigh, inLow ), 1e-6 );
const normalized = div( sub( inNode, inLow ), inSpan );
const reciprocalGamma = div( 1, gamma );
const gammaApplied = mul( pow( abs( normalized ), reciprocalGamma ), sign( normalized ) );
return add( outLow, mul( gammaApplied, sub( outHigh, outLow ) ) );
};
const mx_open_pbr_anisotropy = ( roughness = 0, anisotropy = 0 ) => {
const anisoInvert = sub( float( 1 ), anisotropy );
const anisoInvertSq = mul( anisoInvert, anisoInvert );
const denom = add( anisoInvertSq, float( 1 ) );
const fraction = div( float( 2 ), denom );
const sqrtFraction = sqrt( fraction );
const roughSq = mul( roughness, roughness );
const alphaX = mul( roughSq, sqrtFraction );
const alphaY = mul( anisoInvert, alphaX );
return vec2( alphaX, alphaY );
};
const mx_boolean = ( inNode ) => toBooleanNode( inNode );
const mx_and = ( in1, in2 ) => tslAnd( mx_boolean( in1 ), mx_boolean( in2 ) );
const mx_or = ( in1, in2 ) => tslOr( mx_boolean( in1 ), mx_boolean( in2 ) );
const mx_xor = ( in1, in2 ) => tslXor( mx_boolean( in1 ), mx_boolean( in2 ) );
const mx_not = ( inNode ) => tslNot( mx_boolean( inNode ) );
const mx_checkerboard = ( color1, color2, uvtiling, uvoffset, texcoord ) => {
const tiledUv = sub( mul( texcoord, uvtiling ), uvoffset );
const checkerMix = mx_modulo( dot( floor( tiledUv ), vec2( 1, 1 ) ), float( 2 ) );
return mix( color2, color1, checkerMix );
};
const mx_circle = ( texcoord, center, radius ) => {
const delta = sub( texcoord, center );
const distanceSquared = dot( delta, delta );
const radiusSquared = mul( radius, radius );
return mx_ifgreater( distanceSquared, radiusSquared, 0, 1 );
};
const mx_normalmap = (
value = vec3( 0.5, 0.5, 1.0 ),
scale = 1.0,
normal = vec3( 0.0, 0.0, 1.0 ),
tangent = vec3( 1.0, 0.0, 0.0 ),
bitangent = vec3( 0.0, 1.0, 0.0 ),
) => {
const mapValue = toVec3Channels( value );
const decoded = sub( mul( mapValue, 2.0 ), vec3( 1.0, 1.0, 1.0 ) );
const safeValue = dot( mapValue, mapValue ).equal( 0 ).mix( decoded, vec3( 0.0, 0.0, 1.0 ) );
const normalScale = vec2( scale );
const blended =
add(
add(
mul( tangent, mul( element( safeValue, 0 ), element( normalScale, 0 ) ) ),
mul( bitangent, mul( element( safeValue, 1 ), element( normalScale, 1 ) ) ),
),
mul( normal, element( safeValue, 2 ) ),
);
return normalize( blended );
};
const mx_bump = (
height,
scale = 1,
normal = vec3( 0.0, 0.0, 1.0 ),
tangent = vec3( 1.0, 0.0, 0.0 ),
bitangent = vec3( 0.0, 1.0, 0.0 ),
) => mx_normalmap( mx_heighttonormal( height, 1 ), scale, normal, tangent, bitangent );
const mx_dot = ( inNode ) => inNode;
const mx_viewdirection = ( space = 'world' ) => {
const outputSpace = normalizeSpaceName( space, 'world' );
const worldDirection = normalize( sub( positionWorld, cameraPosition ) );
if ( outputSpace === 'world' ) {
return worldDirection;
}
return mx_transformnormal( worldDirection, 'world', outputSpace );
};
const mx_blackbody = ( temperature = 5000 ) => {
const temperatureKelvin = clamp( temperature, float( 800 ), float( 25000 ) );
const t = div( float( 1000 ), temperatureKelvin );
const t2 = mul( t, t );
const t3 = mul( t2, t );
const lowX = add( add( mul( float( - 0.2661239 ), t3 ), mul( float( - 0.234358 ), t2 ) ), add( mul( float( 0.8776956 ), t ), float( 0.17991 ) ) );
const highX = add(
add( mul( float( - 3.0258469 ), t3 ), mul( float( 2.1070379 ), t2 ) ),
add( mul( float( 0.2226347 ), t ), float( 0.24039 ) ),
);
const xc = mx_ifgreatereq( temperatureKelvin, float( 4000 ), highX, lowX );
const xc2 = mul( xc, xc );
const xc3 = mul( xc2, xc );
const ycLow = add(
add( mul( float( - 1.1063814 ), xc3 ), mul( float( - 1.3481102 ), xc2 ) ),
add( mul( float( 2.18555832 ), xc ), float( - 0.20219683 ) ),
);
const ycMid = add(
add( mul( float( - 0.9549476 ), xc3 ), mul( float( - 1.37418593 ), xc2 ) ),
add( mul( float( 2.09137015 ), xc ), float( - 0.16748867 ) ),
);
const ycHigh = add(
add( mul( float( 3.081758 ), xc3 ), mul( float( - 5.8733867 ), xc2 ) ),
add( mul( float( 3.75112997 ), xc ), float( - 0.37001483 ) ),
);
const ycLowMid = mx_ifgreatereq( temperatureKelvin, float( 2222 ), ycMid, ycLow );
const yc = mx_ifgreatereq( temperatureKelvin, float( 4000 ), ycHigh, ycLowMid );
const safeYc = max( yc, float( 1e-6 ) );
const xyz = vec3( div( xc, safeYc ), float( 1 ), div( sub( sub( float( 1 ), xc ), yc ), safeYc ) );
const rgb = vec3(
add( add( mul( float( 3.2406 ), element( xyz, 0 ) ), mul( float( - 1.5372 ), element( xyz, 1 ) ) ), mul( float( - 0.4986 ), element( xyz, 2 ) ) ),
add( add( mul( float( - 0.9689 ), element( xyz, 0 ) ), mul( float( 1.8758 ), element( xyz, 1 ) ) ), mul( float( 0.0415 ), element( xyz, 2 ) ) ),
add( add( mul( float( 0.0557 ), element( xyz, 0 ) ), mul( float( - 0.204 ), element( xyz, 1 ) ) ), mul( float( 1.057 ), element( xyz, 2 ) ) ),
);
const clampedRgb = max( rgb, vec3( 0, 0, 0 ) );
const validYcMask = step( float( 1e-6 ), yc );
return mix( vec3( 1, 1, 1 ), clampedRgb, validYcMask );
};
const mx_unpremult = ( input ) => {
const alpha = element( input, 3 );
const rgb = toVec3Channels( input );
const unpremultiplied = alpha.equal( 0 ).mix( rgb, div( rgb, alpha ) );
return vec4( unpremultiplied, alpha );
};
const mx_colorcorrect = (
input,
hue = 0,
saturationAmount = 1,
gamma = 1,
lift = 0,
gain = 1,
contrast = 1,
contrastPivot = 0.5,
exposure = 0,
) => {
const rgbInput = toVec3Channels( input );
const hsv = mx_rgbtohsv( rgbInput );
const hueAdjusted = mx_hsvtorgb( add( hsv, vec3( hue, 0, 0 ) ) );
const saturationAdjusted = mx_saturation( hueAdjusted, saturationAmount );
const gammaAdjusted = mx_range( saturationAdjusted, 0, 1, 0, 1, gamma );
const liftApplied = add( mul( gammaAdjusted, sub( 1, lift ) ), lift );
const gainApplied = mul( liftApplied, gain );
const contrastApplied = mx_contrast( gainApplied, contrast, contrastPivot );
const exposureApplied = mul( contrastApplied, pow( 2, exposure ) );
const preserveAlpha = input && ( input.nodeType === 'vec4' || input.nodeType === 'color4' );
return preserveAlpha ? vec4( exposureApplied, element( input, 3 ) ) : exposureApplied;
};
const mx_minus = ( fg, bg, mixval = 1 ) => add( mul( mixval, sub( bg, fg ) ), mul( sub( 1, mixval ), bg ) );
const mx_difference = ( fg, bg, mixval = 1 ) => add( mul( mixval, abs( sub( bg, fg ) ) ), mul( sub( 1, mixval ), bg ) );
const mx_screen = ( fg, bg, mixval = 1 ) => {
const screened = sub( 1, mul( sub( 1, fg ), sub( 1, bg ) ) );
return mix( bg, screened, mixval );
};
const mx_overlay = ( fg, bg, mixval = 1 ) => {
const lowBranch = mul( mul( 2, fg ), bg );
const highBranch = sub( 1, mul( mul( 2, sub( 1, fg ) ), sub( 1, bg ) ) );
const overlayed = mix( lowBranch, highBranch, step( 0.5, bg ) );
return mix( bg, overlayed, mixval );
};
const mx_transformnormal = ( inNode = vec3( 0, 0, 1 ), fromspace = 'world', tospace = 'world' ) => {
const from = normalizeSpaceName( fromspace, 'world' );
const to = normalizeSpaceName( tospace, 'world' );
const inNormal = vec3( inNode );
if ( from === to ) {
return normalize( inNormal );
}
if ( from === 'object' && to === 'world' ) {
return normalize( mul( inNormal, modelNormalMatrix ) );
}
return normalize( mul( inNormal, mat3( modelWorldMatrix ) ) );
};
const mx_transformvector = ( inNode = vec3( 0, 0, 0 ), fromspace = 'world', tospace = 'world' ) => {
const from = normalizeSpaceName( fromspace, 'world' );
const to = normalizeSpaceName( tospace, 'world' );
const inVector = vec3( inNode );
if ( from === to ) {
return inVector;
}
if ( from === 'object' && to === 'world' ) {
return mul( inVector, mat3( modelWorldMatrix ) );
}
return mul( inVector, mat3( modelWorldMatrixInverse ) );
};
const mx_transformpoint = ( inNode = vec3( 0, 0, 0 ), fromspace = 'world', tospace = 'world' ) => {
const from = normalizeSpaceName( fromspace, 'world' );
const to = normalizeSpaceName( tospace, 'world' );
const inPoint = vec3( inNode );
if ( from === to ) {
return inPoint;
}
const point4 = vec4( inPoint, 1 );
const matrix = from === 'object' && to === 'world' ? modelWorldMatrix : modelWorldMatrixInverse;
const transformed4 = mul( matrix, point4 );
return vec3( element( transformed4, 0 ), element( transformed4, 1 ), element( transformed4, 2 ) );
};
const mx_burn_channel = ( fg, bg, mixval = 1 ) => {
const composed = add( mul( mixval, sub( 1, div( sub( 1, bg ), fg ) ) ), mul( sub( 1, mixval ), bg ) );
return mul( composed, step( float( 1e-6 ), abs( fg ) ) );
};
const mx_dodge_channel = ( fg, bg, mixval = 1 ) => {
const composed = add( mul( mixval, div( bg, sub( 1, fg ) ) ), mul( sub( 1, mixval ), bg ) );
return mul( composed, step( float( 1e-6 ), abs( sub( 1, fg ) ) ) );
};
const isVec3Like = ( node ) =>
node && ( node.nodeType === 'vec3' || node.nodeType === 'color' || node.nodeType === 'color3' );
const isVec4Like = ( node ) => node && ( node.nodeType === 'vec4' || node.nodeType === 'color4' );
const applyBlendByChannel = ( channelFunc, fg, bg, mixval = 1 ) => {
if ( isVec4Like( fg ) || isVec4Like( bg ) ) {
return vec4(
channelFunc( element( fg, 0 ), element( bg, 0 ), mixval ),
channelFunc( element( fg, 1 ), element( bg, 1 ), mixval ),
channelFunc( element( fg, 2 ), element( bg, 2 ), mixval ),
channelFunc( element( fg, 3 ), element( bg, 3 ), mixval ),
);
}
if ( isVec3Like( fg ) || isVec3Like( bg ) ) {
return vec3(
channelFunc( element( fg, 0 ), element( bg, 0 ), mixval ),
channelFunc( element( fg, 1 ), element( bg, 1 ), mixval ),
channelFunc( element( fg, 2 ), element( bg, 2 ), mixval ),
);
}
return channelFunc( fg, bg, mixval );
};
const mx_burn = ( fg, bg, mixval = 1 ) => applyBlendByChannel( mx_burn_channel, fg, bg, mixval );
const mx_dodge = ( fg, bg, mixval = 1 ) => applyBlendByChannel( mx_dodge_channel, fg, bg, mixval );
const mixColor4 = ( bg, fg, factor ) =>
vec4(
mix( element( bg, 0 ), element( fg, 0 ), factor ),
mix( element( bg, 1 ), element( fg, 1 ), factor ),
mix( element( bg, 2 ), element( fg, 2 ), factor ),
mix( element( bg, 3 ), element( fg, 3 ), factor ),
);
const mxRampSegment = ( x, color1, color2, interval1, interval2, interpolation ) => {
const linearClamped = clamp( x, interval1, interval2 );
const rangeSize = sub( interval2, interval1 );
const safeRange = max( rangeSize, float( 1e-6 ) );
const linearRemap = div( sub( linearClamped, interval1 ), safeRange );
const smoothVal = mx_smoothstep( x, interval1, interval2 );
const interpolationDistanceToLinear = abs( sub( interpolation, float( 0 ) ) );
const useLinear = sub( float( 1 ), step( float( 0.5 ), interpolationDistanceToLinear ) );
const interpFactor = mix( smoothVal, linearRemap, useLinear );
const mixedColor = mixColor4( color1, color2, interpFactor );
const stepColor = mixColor4( color1, color2, step( interval2, x ) );
const interpolationDistanceToStep = abs( sub( interpolation, float( 2 ) ) );
const useStep = sub( float( 1 ), step( float( 0.5 ), interpolationDistanceToStep ) );
return mixColor4( mixedColor, stepColor, useStep );
};
const mx_ramp_gradient = (
x = 0,
interval1 = 0,
interval2 = 1,
color1 = vec4( 0, 0, 0, 1 ),
color2 = vec4( 1, 1, 1, 1 ),
interpolation = 1,
prevColor = vec4( 0, 0, 0, 1 ),
intervalNum = 1,
numIntervals = 2,
) => {
const xFloat = float( x );
const interval1Float = float( interval1 );
const interval2Float = float( interval2 );
const interpolationFloat = float( interpolation );
const intervalNumFloat = float( intervalNum );
const numIntervalsFloat = float( numIntervals );
const interpolated = mxRampSegment( xFloat, color1, color2, interval1Float, interval2Float, interpolationFloat );
const withinInterval = mixColor4( prevColor, interpolated, step( add( interval1Float, float( 1e-6 ) ), xFloat ) );
return mixColor4( withinInterval, prevColor, step( numIntervalsFloat, intervalNumFloat ) );
};
const mx_ramp = ( texcoord = vec2( 0, 0 ), type = 0, interpolation = 1, numIntervals = 2, ...rest ) => {
const rampTypeFloat = float( type );
const interpolationFloat = float( interpolation );
const numIntervalsFloat = float( numIntervals );
const clamped = clamp( texcoord, vec2( 0, 0 ), vec2( 1, 1 ) );
const s = element( clamped, 0 );
const t = element( clamped, 1 );
const centeredS = sub( s, float( 0.5 ) );
const centeredT = sub( t, float( 0.5 ) );
const radialDist = sqrt( add( mul( centeredS, centeredS ), mul( centeredT, centeredT ) ) );
const radialVal = clamp( mul( radialDist, float( 2 ) ), float( 0 ), float( 1 ) );
const circularAngle = add( div( mx_atan2( centeredT, centeredS ), float( Math.PI * 2 ) ), float( 0.5 ) );
const boxVal = clamp( mul( max( abs( centeredS ), abs( centeredT ) ), float( 2 ) ), float( 0 ), float( 1 ) );
const typeDistanceToRadial = abs( sub( rampTypeFloat, float( 1 ) ) );
const typeDistanceToCircular = abs( sub( rampTypeFloat, float( 2 ) ) );
const typeDistanceToBox = abs( sub( rampTypeFloat, float( 3 ) ) );
const useRadial = sub( float( 1 ), step( float( 0.5 ), typeDistanceToRadial ) );
const useCircular = sub( float( 1 ), step( float( 0.5 ), typeDistanceToCircular ) );
const useBox = sub( float( 1 ), step( float( 0.5 ), typeDistanceToBox ) );
const afterRadial = mix( s, radialVal, useRadial );
const afterCircular = mix( afterRadial, circularAngle, useCircular );
const rampX = mix( afterCircular, boxVal, useBox );
const intervals = [];
const colors = [];
for ( let i = 0; i < 10; i += 1 ) {
const intervalInput = rest[ i * 2 ];
const colorInput = rest[ i * 2 + 1 ];
intervals.push( intervalInput ?? float( i <= 1 ? i : 1 ) );
colors.push( colorInput ?? vec4( i === 0 ? 0 : 1, i === 0 ? 0 : 1, i === 0 ? 0 : 1, 1 ) );
}
let result = colors[ 0 ];
for ( let i = 0; i < 9; i += 1 ) {
const iv1 = intervals[ i ];
const iv2 = intervals[ i + 1 ];
const c1 = colors[ i ];
const c2 = colors[ i + 1 ];
const intNum = float( i + 1 );
const interpolated = mxRampSegment( rampX, c1, c2, iv1, iv2, interpolationFloat );
const withinInterval = mixColor4( result, interpolated, step( add( iv1, float( 1e-6 ) ), rampX ) );
result = mixColor4( withinInterval, result, step( numIntervalsFloat, intNum ) );
}
return result;
};
const defaultFloat = ( value ) => () => float( value );
const defaultInt = ( value ) => () => int( value );
const defaultBool = ( value ) => () => bool( value );
const defaultColor = ( r, g, b ) => () => color( r, g, b );
const defaultVec2 = ( x, y ) => () => vec2( x, y );
const defaultVec3 = ( x, y, z ) => () => vec3( x, y, z );
const defaultVec4 = ( x, y, z, w ) => () => vec4( x, y, z, w );
const usesVec2Noise = ( nodeX ) => nodeX && nodeX.type === 'vector2';
const usesVec3Noise = ( nodeX ) => nodeX && ( nodeX.type === 'vector3' || nodeX.type === 'color3' );
const mx_noise_materialx = ( texcoord, amplitude, pivot, nodeX ) =>
usesVec3Noise( nodeX ) ? mx_noise_vec3( texcoord, vec3( amplitude ), pivot ) : mx_noise_float( texcoord, amplitude, pivot );
const mx_fractal_noise_materialx_2d = ( texcoord, octaves, lacunarity, diminish, amplitude, nodeX ) =>
usesVec3Noise( nodeX ) ? mx_fractal_noise_vec3_materialx_2d( texcoord, octaves, lacunarity, diminish, amplitude ) : mx_fractal_noise_float_materialx_2d( texcoord, octaves, lacunarity, diminish, amplitude );
const mx_fractal_noise_materialx_3d = ( position, octaves, lacunarity, diminish, amplitude, nodeX ) =>
usesVec3Noise( nodeX ) ? mx_fractal_noise_vec3( position, octaves, lacunarity, diminish, vec3( amplitude ) ) : mx_fractal_noise_float( position, octaves, lacunarity, diminish, amplitude );
const mx_cell_noise_materialx = ( position, nodeX ) =>
usesVec3Noise( nodeX ) ? mx_cell_noise_vec3( position ) : mx_cell_noise_float( position );
const mx_worley_noise_vec2_style = ( position, jitter, style ) => {
const result = mx_worley_noise_vec3_style( position, jitter, style, 0 );
return vec2( element( result, 0 ), element( result, 1 ) );
};
const mx_worley_noise_materialx_2d = ( texcoord, jitter, style, nodeX ) =>
usesVec3Noise( nodeX ) ? mx_worley_noise_vec3_style( texcoord, jitter, style, 0 ) : usesVec2Noise( nodeX ) ? mx_worley_noise_vec2_style( texcoord, jitter, style ) : mx_worley_noise_float_2d( texcoord, jitter, style );
const mx_worley_noise_materialx_3d = ( position, jitter, style, nodeX ) =>
usesVec3Noise( nodeX ) ? mx_worley_noise_vec3_style( position, jitter, style, 0 ) : usesVec2Noise( nodeX ) ? mx_worley_noise_vec2_style( position, jitter, style ) : mx_worley_noise_float_3d( position, jitter, style );
const mx_fractal_noise_float_materialx_2d = Fn( ( [ texcoordInput, octavesInput, lacunarityInput, diminishInput, amplitudeInput ] ) => {
const texcoord = vec2( texcoordInput ).toVar();
const octaves = int( octavesInput ).toVar();
const lacunarity = float( lacunarityInput ).toVar();
const diminish = float( diminishInput ).toVar();
const amplitude = float( amplitudeInput ).toVar();
const result = float( 0 ).toVar();
const octaveAmplitude = float( 1 ).toVar();
Loop( octaves, () => {
result.addAssign( mul( octaveAmplitude, mx_noise_float( texcoord, float( 1 ), float( 0 ) ) ) );
octaveAmplitude.mulAssign( diminish );
texcoord.mulAssign( lacunarity );
} );
return mul( result, amplitude );
} );
const mx_fractal_noise_vec3_materialx_2d = Fn( ( [ texcoordInput, octavesInput, lacunarityInput, diminishInput, amplitudeInput ] ) => {
const texcoord = vec2( texcoordInput ).toVar();
const octaves = int( octavesInput ).toVar();
const lacunarity = float( lacunarityInput ).toVar();
const diminish = float( diminishInput ).toVar();
const amplitude = vec3( amplitudeInput ).toVar();
const result = vec3( 0 ).toVar();
const octaveAmplitude = float( 1 ).toVar();
Loop( octaves, () => {
result.addAssign( mul( octaveAmplitude, mx_noise_vec3( texcoord, vec3( 1 ), float( 0 ) ) ) );
octaveAmplitude.mulAssign( diminish );
texcoord.mulAssign( lacunarity );
} );
return mul( result, amplitude );
} );
const MXElements = [
createMXElement( 'add', add, [ 'in1', 'in2' ], { in1: defaultFloat( 0 ), in2: defaultFloat( 0 ) } ),
createMXElement( 'subtract', sub, [ 'in1', 'in2' ], { in1: defaultFloat( 0 ), in2: defaultFloat( 0 ) } ),
createMXElement( 'multiply', mul, [ 'in1', 'in2' ], { in1: defaultFloat( 0 ), in2: defaultFloat( 1 ) } ),
createMXElement( 'divide', div, [ 'in1', 'in2' ], { in1: defaultFloat( 0 ), in2: defaultFloat( 1 ) } ),
createMXElement( 'modulo', mx_modulo, [ 'in1', 'in2' ], { in1: defaultFloat( 0 ), in2: defaultFloat( 1 ) } ),
createMXElement( 'absval', abs, [ 'in' ], { in: defaultFloat( 0 ) } ),
createMXElement( 'sign', sign, [ 'in' ], { in: defaultFloat( 0 ) } ),
createMXElement( 'floor', floor, [ 'in' ], { in: defaultFloat( 0 ) } ),
createMXElement( 'ceil', ceil, [ 'in' ], { in: defaultFloat( 0 ) } ),
createMXElement( 'round', round, [ 'in' ], { in: defaultFloat( 0 ) } ),
createMXElement( 'power', pow, [ 'in1', 'in2' ], { in1: defaultFloat( 0 ), in2: defaultFloat( 1 ) } ),
createMXElement( 'sin', sin, [ 'in' ], { in: defaultFloat( 0 ) } ),
createMXElement( 'cos', cos, [ 'in' ], { in: defaultFloat( 0 ) } ),
createMXElement( 'tan', tan, [ 'in' ], { in: defaultFloat( 0 ) } ),
createMXElement( 'asin', asin, [ 'in' ], { in: defaultFloat( 0 ) } ),
createMXElement( 'acos', acos, [ 'in' ], { in: defaultFloat( 0 ) } ),
createMXElement( 'atan2', mx_atan2, [ 'iny', 'inx' ], { iny: defaultFloat( 0 ), inx: defaultFloat( 1 ) } ),
createMXElement( 'sqrt', sqrt, [ 'in' ], { in: defaultFloat( 0 ) } ),
createMXElement( 'ln', log, [ 'in' ], { in: defaultFloat( 1 ) } ),
createMXElement( 'exp', exp, [ 'in' ], { in: defaultFloat( 0 ) } ),
createMXElement( 'fract', fract, [ 'in' ], { in: defaultFloat( 0 ) } ),
createMXElement( 'clamp', clamp, [ 'in', 'low', 'high' ], {
in: defaultFloat( 0 ),
low: defaultFloat( 0 ),
high: defaultFloat( 1 ),
} ),
createMXElement( 'min', min, [ 'in1', 'in2' ], { in1: defaultFloat( 0 ), in2: defaultFloat( 0 ) } ),
createMXElement( 'max', max, [ 'in1', 'in2' ], { in1: defaultFloat( 0 ), in2: defaultFloat( 0 ) } ),
createMXElement( 'normalize', normalize, [ 'in' ], { in: defaultFloat( 0 ) } ),
createMXElement( 'magnitude', length, [ 'in' ], { in: defaultFloat( 0 ) } ),
createMXElement( 'length', length, [ 'in' ], { in: defaultFloat( 0 ) } ),
createMXElement( 'dot', mx_dot, [ 'in' ], { in: defaultFloat( 0 ) } ),
createMXElement( 'dotproduct', dot, [ 'in1', 'in2' ], { in1: defaultFloat( 0 ), in2: defaultFloat( 0 ) } ),
createMXElement( 'viewdirection', mx_viewdirection, [ 'space' ], { space: () => 'world' } ),
createMXElement( 'crossproduct', cross, [ 'in1', 'in2' ], { in1: defaultVec3( 0, 0, 0 ), in2: defaultVec3( 0, 0, 0 ) } ),
createMXElement( 'distance', distance, [ 'in1', 'in2' ], { in1: defaultFloat( 0 ), in2: defaultFloat( 0 ) } ),
createMXElement( 'invert', mx_invert, [ 'in', 'amount' ], { in: defaultFloat( 0 ), amount: defaultFloat( 1 ) } ),
createMXElement( 'transformmatrix', mul, [ 'in', 'mat' ], { in: defaultFloat( 0 ) } ),
createMXElement( 'transformnormal', mx_transformnormal, [ 'in', 'fromspace', 'tospace' ], {
in: defaultVec3( 0, 0, 1 ),
fromspace: () => 'world',
tospace: () => 'world',
} ),
createMXElement( 'transformpoint', mx_transformpoint, [ 'in', 'fromspace', 'tospace' ], {
in: defaultVec3( 0, 0, 0 ),
fromspace: () => 'world',
tospace: () => 'world',
} ),
createMXElement( 'transformvector', mx_transformvector, [ 'in', 'fromspace', 'tospace' ], {
in: defaultVec3( 0, 0, 0 ),
fromspace: () => 'world',
tospace: () => 'world',
} ),
createMXElement( 'normalmap', mx_normalmap, [ 'in', 'scale', 'normal', 'tangent', 'bitangent' ], {
in: defaultVec3( 0.5, 0.5, 1.0 ),
scale: defaultFloat( 1 ),
normal: () => normalWorld,
tangent: () => tangentWorld,
bitangent: () => bitangentWorld,
} ),
createMXElement( 'transpose', transpose, [ 'in' ] ),
createMXElement( 'determinant', determinant, [ 'in' ] ),
createMXElement( 'invertmatrix', inverse, [ 'in' ] ),
createMXElement( 'creatematrix', mat3, [ 'in1', 'in2', 'in3' ], {
in1: defaultVec3( 1, 0, 0 ),
in2: defaultVec3( 0, 1, 0 ),
in3: defaultVec3( 0, 0, 1 ),
} ),
createMXElement( 'remap', remap, [ 'in', 'inlow', 'inhigh', 'outlow', 'outhigh' ], {
in: defaultFloat( 0 ),
inlow: defaultFloat( 0 ),
inhigh: defaultFloat( 1 ),
outlow: defaultFloat( 0 ),
outhigh: defaultFloat( 1 ),
} ),
createMXElement( 'range', mx_range, [ 'in', 'inlow', 'inhigh', 'outlow', 'outhigh', 'gamma' ], {
in: defaultFloat( 0 ),
inlow: defaultFloat( 0 ),
inhigh: defaultFloat( 1 ),
outlow: defaultFloat( 0 ),
outhigh: defaultFloat( 1 ),
gamma: defaultFloat( 1 ),
} ),
createMXElement( 'open_pbr_anisotropy', mx_open_pbr_anisotropy, [ 'roughness', 'anisotropy' ], {
roughness: defaultFloat( 0 ),
anisotropy: defaultFloat( 0 ),
} ),
createMXElement( 'smoothstep', mx_smoothstep, [ 'in', 'low', 'high' ], {
in: defaultFloat( 0 ),
low: defaultFloat( 0 ),
high: defaultFloat( 1 ),
} ),
createMXElement( 'luminance', luminance, [ 'in', 'lumacoeffs' ], {
in: defaultColor( 0, 0, 0 ),
lumacoeffs: defaultColor( 0.2722287, 0.6740818, 0.0536895 ),
} ),
createMXElement( 'rgbtohsv', mx_rgbtohsv, [ 'in' ], { in: defaultColor( 0, 0, 0 ) } ),
createMXElement( 'hsvtorgb', mx_hsvtorgb, [ 'in' ], { in: defaultColor( 0, 0, 0 ) } ),
createMXElement( 'mix', mix, [ 'bg', 'fg', 'mix' ], { bg: defaultFloat( 0 ), fg: defaultFloat( 0 ), mix: defaultFloat( 0 ) } ),
createMXElement( 'minus', mx_minus, [ 'fg', 'bg', 'mix' ], {
fg: defaultFloat( 0 ),
bg: defaultFloat( 0 ),
mix: defaultFloat( 1 ),
} ),
createMXElement( 'difference', mx_difference, [ 'fg', 'bg', 'mix' ], {
fg: defaultFloat( 0 ),
bg: defaultFloat( 0 ),
mix: defaultFloat( 1 ),
} ),
createMXElement( 'screen', mx_screen, [ 'fg', 'bg', 'mix' ], {
fg: defaultFloat( 0 ),
bg: defaultFloat( 0 ),
mix: defaultFloat( 1 ),
} ),
createMXElement( 'overlay', mx_overlay, [ 'fg', 'bg', 'mix' ], {
fg: defaultFloat( 0 ),
bg: defaultFloat( 0 ),
mix: defaultFloat( 1 ),
} ),
createMXElement( 'burn', mx_burn, [ 'fg', 'bg', 'mix' ], {
fg: defaultFloat( 0 ),
bg: defaultFloat( 0 ),
mix: defaultFloat( 1 ),
} ),
createMXElement( 'dodge', mx_dodge, [ 'fg', 'bg', 'mix' ], {
fg: defaultFloat( 0 ),
bg: defaultFloat( 0 ),
mix: defaultFloat( 1 ),
} ),
createMXElement(
'colorcorrect',
mx_colorcorrect,
[ 'in', 'hue', 'saturation', 'gamma', 'lift', 'gain', 'contrast', 'contrastpivot', 'exposure' ],
{
in: defaultColor( 1, 1, 1 ),
hue: defaultFloat( 0 ),
saturation: defaultFloat( 1 ),
gamma: defaultFloat( 1 ),
lift: defaultFloat( 0 ),
gain: defaultFloat( 1 ),
contrast: defaultFloat( 1 ),
contrastpivot: defaultFloat( 0.5 ),
exposure: defaultFloat( 0 ),
},
),
createMXElement( 'unpremult', mx_unpremult, [ 'in' ], { in: defaultVec4( 0, 0, 0, 1 ) } ),
createMXElement( 'combine2', vec2, [ 'in1', 'in2' ], { in1: defaultFloat( 0 ), in2: defaultFloat( 0 ) } ),
createMXElement( 'combine3', vec3, [ 'in1', 'in2', 'in3' ], {
in1: defaultFloat( 0 ),
in2: defaultFloat( 0 ),
in3: defaultFloat( 0 ),
} ),
createMXElement( 'combine4', vec4, [ 'in1', 'in2', 'in3', 'in4' ], {
in1: defaultFloat( 0 ),
in2: defaultFloat( 0 ),
in3: defaultFloat( 0 ),
in4: defaultFloat( 0 ),
} ),
createMXElement( 'ramplr', mx_ramplr, [ 'valuel', 'valuer', 'texcoord' ], {
valuel: defaultFloat( 0 ),
valuer: defaultFloat( 0 ),
} ),
createMXElement( 'ramptb', mx_ramptb, [ 'valueb', 'valuet', 'texcoord' ], {
valueb: defaultFloat( 0 ),
valuet: defaultFloat( 0 ),
} ),
createMXElement( 'ramp4', mx_ramp4, [ 'valuetl', 'valuetr', 'valuebl', 'valuebr', 'texcoord' ], {
valuetl: defaultColor( 0, 0, 0 ),
valuetr: defaultColor( 0, 0, 0 ),
valuebl: defaultColor( 0, 0, 0 ),
valuebr: defaultColor( 0, 0, 0 ),
texcoord: defaultVec2( 0, 0 ),
} ),
createMXElement(
'ramp_gradient',
mx_ramp_gradient,
[ 'x', 'interval1', 'interval2', 'color1', 'color2', 'interpolation', 'prev_color', 'interval_num', 'num_intervals' ],
{
x: defaultFloat( 0 ),
interval1: defaultFloat( 0 ),
interval2: defaultFloat( 1 ),
color1: defaultVec4( 0, 0, 0, 1 ),
color2: defaultVec4( 1, 1, 1, 1 ),
interpolation: defaultFloat( 1 ),
prev_color: defaultVec4( 0, 0, 0, 1 ),
interval_num: defaultFloat( 1 ),
num_intervals: defaultFloat( 2 ),
},
),
createMXElement(
'ramp',
mx_ramp,
[
'texcoord',
'type',
'interpolation',
'num_intervals',
'interval1',
'color1',
'interval2',
'color2',
'interval3',
'color3',
'interval4',
'color4',
'interval5',
'color5',
'interval6',
'color6',
'interval7',
'color7',
'interval8',
'color8',
'interval9',
'color9',
'interval10',
'color10',
],
{
texcoord: defaultVec2( 0, 0 ),
type: defaultFloat( 0 ),
interpolation: defaultFloat( 1 ),
num_intervals: defaultFloat( 2 ),
interval1: defaultFloat( 0 ),
color1: defaultVec4( 0, 0, 0, 1 ),
interval2: defaultFloat( 1 ),
color2: defaultVec4( 1, 1, 1, 1 ),
interval3: defaultFloat( 1 ),
color3: defaultVec4( 1, 1, 1, 1 ),
interval4: defaultFloat( 1 ),
color4: defaultVec4( 1, 1, 1, 1 ),
interval5: defaultFloat( 1 ),
color5: defaultVec4( 1, 1, 1, 1 ),
interval6: defaultFloat( 1 ),
color6: defaultVec4( 1, 1, 1, 1 ),
interval7: defaultFloat( 1 ),
color7: defaultVec4( 1, 1, 1, 1 ),
interval8: defaultFloat( 1 ),
color8: defaultVec4( 1, 1, 1, 1 ),
interval9: defaultFloat( 1 ),
color9: defaultVec4( 1, 1, 1, 1 ),
interval10: defaultFloat( 1 ),
color10: defaultVec4( 1, 1, 1, 1 ),
},
),
createMXElement( 'splitlr', mx_splitlr, [ 'valuel', 'valuer', 'center', 'texcoord' ], {
valuel: defaultFloat( 0 ),
valuer: defaultFloat( 0 ),
center: defaultFloat( 0.5 ),
} ),
createMXElement( 'splittb', mx_splittb, [ 'valueb', 'valuet', 'center', 'texcoord' ], {
valueb: defaultFloat( 0 ),
valuet: defaultFloat( 0 ),
center: defaultFloat( 0.5 ),
} ),
createMXElement( 'noise2d', mx_noise_materialx, [ 'texcoord', 'amplitude', 'pivot' ], {
texcoord: defaultVec2( 0, 0 ),
amplitude: defaultFloat( 1 ),
pivot: defaultFloat( 0 ),
}, true ),
createMXElement( 'noise3d', mx_noise_materialx, [ 'position', 'amplitude', 'pivot' ], {
position: () => positionLocal,
amplitude: defaultFloat( 1 ),
pivot: defaultFloat( 0 ),
}, true ),
createMXElement( 'fractal2d', mx_fractal_noise_materialx_2d, [ 'texcoord', 'octaves', 'lacunarity', 'diminish', 'amplitude' ], {
texcoord: defaultVec2( 0, 0 ),
octaves: defaultInt( 3 ),
lacunarity: defaultFloat( 2.0 ),
diminish: defaultFloat( 0.5 ),
amplitude: defaultFloat( 1.0 ),
}, true ),
createMXElement( 'fractal3d', mx_fractal_noise_materialx_3d, [ 'position', 'octaves', 'lacunarity', 'diminish', 'amplitude' ], {
position: () => positionLocal,
octaves: defaultInt( 3 ),
lacunarity: defaultFloat( 2.0 ),
diminish: defaultFloat( 0.5 ),
amplitude: defaultFloat( 1.0 ),
}, true ),
createMXElement( 'cellnoise2d', mx_cell_noise_materialx, [ 'texcoord' ], { texcoord: defaultVec2( 0, 0 ) }, true ),
createMXElement( 'cellnoise3d', mx_cell_noise_materialx, [ 'position' ], { position: () => positionLocal }, true ),
createMXElement( 'worleynoise2d', mx_worley_noise_materialx_2d, [ 'texcoord', 'jitter', 'style' ], {
texcoord: defaultVec2( 0, 0 ),
jitter: defaultFloat( 1 ),
style: defaultInt( 0 ),
}, true ),
createMXElement( 'worleynoise3d', mx_worley_noise_materialx_3d, [ 'position', 'jitter', 'style' ], {
position: () => positionLocal,
jitter: defaultFloat( 1 ),
style: defaultInt( 0 ),
}, true ),
createMXElement(
'unifiednoise2d',
mx_unifiednoise2d,
[
'type',
'texcoord',
'freq',
'offset',
'jitter',
'outmin',
'outmax',
'clampoutput',
'octaves',
'lacunarity',
'diminish',
'style',
],
{
type: defaultInt( 0 ),
texcoord: defaultVec2( 0, 0 ),
freq: defaultVec2( 1, 1 ),
offset: defaultVec2( 0, 0 ),
jitter: defaultFloat( 1 ),
outmin: defaultFloat( 0 ),
outmax: defaultFloat( 1 ),
clampoutput: defaultBool( true ),
octaves: defaultInt( 3 ),
lacunarity: defaultFloat( 2 ),
diminish: defaultFloat( 0.5 ),
style: defaultInt( 0 ),
},
),
createMXElement(
'unifiednoise3d',
mx_unifiednoise3d,
[
'type',
'position',
'freq',
'offset',
'jitter',
'outmin',
'outmax',
'clampoutput',
'octaves',
'lacunarity',
'diminish',
'style',
],
{
type: defaultInt( 0 ),
position: () => positionLocal,
freq: defaultVec3( 1, 1, 1 ),
offset: defaultVec3( 0, 0, 0 ),
jitter: defaultFloat( 1 ),
outmin: defaultFloat( 0 ),
outmax: defaultFloat( 1 ),
clampoutput: defaultBool( true ),
octaves: defaultInt( 3 ),
lacunarity: defaultFloat( 2 ),
diminish: defaultFloat( 0.5 ),
style: defaultInt( 0 ),
},
),
createMXElement( 'place2d', mx_place2d, [ 'texcoord', 'pivot', 'scale', 'rotate', 'offset', 'operationorder' ], {
texcoord: defaultVec2( 0, 0 ),
pivot: defaultVec2( 0, 0 ),
scale: defaultVec2( 1, 1 ),
rotate: defaultFloat( 0 ),
offset: defaultVec2( 0, 0 ),
operationorder: defaultInt( 0 ),
} ),
createMXElement( 'safepower', mx_safepower, [ 'in1', 'in2' ], { in1: defaultFloat( 0 ), in2: defaultFloat( 1 ) } ),
createMXElement( 'contrast', mx_contrast, [ 'in', 'amount', 'pivot' ], {
in: defaultFloat( 0 ),
amount: defaultFloat( 1 ),
pivot: defaultFloat( 0.5 ),
} ),
createMXElement( 'saturate', mx_saturation, [ 'in', 'amount' ], { in: defaultColor( 0, 0, 0 ), amount: defaultFloat( 1 ) } ),
createMXElement( 'extract', element, [ 'in', 'index' ], { in: defaultFloat( 0 ), index: defaultInt( 0 ) } ),
createMXElement( 'separate2', element, [ 'in' ], { in: defaultVec2( 0, 0 ) } ),
createMXElement( 'separate3', element, [ 'in' ], { in: defaultVec3( 0, 0, 0 ) } ),
createMXElement( 'separate4', element, [ 'in' ], { in: defaultVec4( 0, 0, 0, 0 ) } ),
createMXElement( 'reflect', reflect, [ 'in', 'normal' ], { in: defaultVec3( 1, 0, 0 ) } ),
createMXElement( 'refract', refract, [ 'in', 'normal', 'ior' ], { in: defaultVec3( 1, 0, 0 ), ior: defaultFloat( 1 ) } ),
createMXElement( 'time', mx_timer ),
createMXElement( 'frame', mx_frame ),
createMXElement( 'ifgreater', mx_ifgreater, [ 'value1', 'value2', 'in1', 'in2' ], {
value1: defaultFloat( 1 ),
value2: defaultFloat( 0 ),
in1: defaultFloat( 0 ),
in2: defaultFloat( 0 ),
} ),
createMXElement( 'ifgreatereq', mx_ifgreatereq, [ 'value1', 'value2', 'in1', 'in2' ], {
value1: defaultFloat( 1 ),
value2: defaultFloat( 0 ),
in1: defaultFloat( 0 ),
in2: defaultFloat( 0 ),
} ),
createMXElement( 'ifequal', mx_ifequal, [ 'value1', 'value2', 'in1', 'in2' ], {
value1: defaultFloat( 0 ),
value2: defaultFloat( 0 ),
in1: defaultFloat( 0 ),
in2: defaultFloat( 0 ),
} ),
createMXElement( 'rotate2d', mx_rotate2d, [ 'in', 'amount' ], { in: defaultVec2( 0, 0 ), amount: defaultFloat( 0 ) } ),
createMXElement( 'rotate3d', mx_rotate3d, [ 'in', 'amount', 'axis' ], {
in: defaultVec3( 0, 0, 0 ),
amount: defaultFloat( 0 ),
axis: defaultVec3( 0, 1, 0 ),
} ),
createMXElement( 'heighttonormal', mx_heighttonormal, [ 'in', 'scale', 'texcoord' ], {
in: defaultFloat( 0 ),
scale: defaultFloat( 1 ),
} ),
createMXElement( 'and', mx_and, [ 'in1', 'in2' ], { in1: defaultBool( false ), in2: defaultBool( false ) } ),
createMXElement( 'or', mx_or, [ 'in1', 'in2' ], { in1: defaultBool( false ), in2: defaultBool( false ) } ),
createMXElement( 'xor', mx_xor, [ 'in1', 'in2' ], { in1: defaultBool( false ), in2: defaultBool( false ) } ),
createMXElement( 'not', mx_not, [ 'in' ], { in: defaultBool( false ) } ),
createMXElement( 'checkerboard', mx_checkerboard, [ 'color1', 'color2', 'uvtiling', 'uvoffset', 'texcoord' ], {
color1: defaultColor( 1, 1, 1 ),
color2: defaultColor( 0, 0, 0 ),
uvtiling: defaultVec2( 8, 8 ),
uvoffset: defaultVec2( 0, 0 ),
texcoord: defaultVec2( 0, 0 ),
} ),
createMXElement( 'circle', mx_circle, [ 'texcoord', 'center', 'radius' ], {
center: defaultVec2( 0, 0 ),
radius: defaultFloat( 0.5 ),
} ),
createMXElement( 'bump', mx_bump, [ 'height', 'scale', 'normal', 'tangent', 'bitangent' ], {
height: defaultFloat( 0 ),
scale: defaultFloat( 1 ),
normal: () => normalWorld,
tangent: () => tangentWorld,
bitangent: () => bitangentWorld,
} ),
createMXElement( 'blackbody', mx_blackbody, [ 'temperature' ], { temperature: defaultFloat( 5000 ) } ),
];
const MtlXLibrary = Object.fromEntries( MXElements.map( ( entry ) => [ entry.name, entry ] ) );
export { MtlXLibrary };