@gnsx/three 0.185.16 → 0.186.0

package/examples/jsm/loaders/materialx/MaterialXHextile.js

@@ -0,0 +1,183 @@
+import {
+	abs,
+	add,
+	clamp,
+	cos,
+	dFdx,
+	dFdy,
+	div,
+	dot,
+	element,
+	floor,
+	fract,
+	max,
+	mix,
+	mul,
+	pow,
+	sin,
+	step,
+	sub,
+	vec2,
+	vec3,
+} from '@gnsx/three/tsl';
+
+const HEXTILE_SQRT3_2 = Math.sqrt( 3 ) * 2;
+const HEXTILE_EPSILON = 1e-6;
+const HEXTILE_PI_OVER_180 = Math.PI / 180;
+
+function toRadians( degrees ) {
+
+	return mul( degrees, HEXTILE_PI_OVER_180 );
+
+}
+
+function mxHextileHash( point ) {
+
+	const x = element( point, 0 );
+	const y = element( point, 1 );
+	const p3Base = vec3( x, y, x );
+	const p3Scaled = mul( p3Base, vec3( 0.1031, 0.103, 0.0973 ) );
+	const p3Fract = fract( p3Scaled );
+	const p3YZX = vec3( element( p3Fract, 1 ), element( p3Fract, 2 ), element( p3Fract, 0 ) );
+	const p3Offset = add( p3YZX, 33.33 );
+	const p3 = add( p3Fract, dot( p3Fract, p3Offset ) );
+	const lhs = add( vec2( element( p3, 0 ), element( p3, 0 ) ), vec2( element( p3, 1 ), element( p3, 2 ) ) );
+	const rhs = vec2( element( p3, 2 ), element( p3, 1 ) );
+	return fract( mul( lhs, rhs ) );
+
+}
+
+function mxSchlickGain( x, r ) {
+
+	const rr = clamp( r, 0.001, 0.999 );
+	const a = mul( sub( div( 1, rr ), 2 ), sub( 1, mul( 2, x ) ) );
+	const low = div( x, add( a, 1 ) );
+	const high = div( sub( a, x ), sub( a, 1 ) );
+	return mix( low, high, step( 0.5, x ) );
+
+}
+
+function normalizeBlendWeights( weights ) {
+
+	const wx = element( weights, 0 );
+	const wy = element( weights, 1 );
+	const wz = element( weights, 2 );
+	const sum = add( add( wx, wy ), wz );
+	return div( weights, sum );
+
+}
+
+function mxRotate2d( point, sine, cosine ) {
+
+	return vec2( sub( mul( cosine, element( point, 0 ) ), mul( sine, element( point, 1 ) ) ), add( mul( sine, element( point, 0 ) ), mul( cosine, element( point, 1 ) ) ) );
+
+}
+
+function toTileCenter( tileId ) {
+
+	const scaled = div( tileId, HEXTILE_SQRT3_2 );
+	const sx = element( scaled, 0 );
+	const sy = element( scaled, 1 );
+	return vec2( add( sx, mul( 0.5, sy ) ), mul( 0.8660254, sy ) );
+
+}
+
+export function mxHextileComputeBlendWeights( luminanceWeights, tileWeights, falloff ) {
+
+	const weighted = mul( luminanceWeights, pow( tileWeights, vec3( 7, 7, 7 ) ) );
+	const normalized = normalizeBlendWeights( weighted );
+	const gained = vec3(
+		mxSchlickGain( element( normalized, 0 ), falloff ),
+		mxSchlickGain( element( normalized, 1 ), falloff ),
+		mxSchlickGain( element( normalized, 2 ), falloff ),
+	);
+	const gainedNormalized = normalizeBlendWeights( gained );
+	const applyFalloff = step( HEXTILE_EPSILON, abs( sub( falloff, 0.5 ) ) );
+	return mix( normalized, gainedNormalized, applyFalloff );
+
+}
+
+export function mxHextileCoord( coord, rotation, rotationRange, scale, scaleRange, offset, offsetRange ) {
+
+	const st = mul( coord, HEXTILE_SQRT3_2 );
+	const stSkewed = vec2( add( element( st, 0 ), mul( - 0.57735027, element( st, 1 ) ) ), mul( 1.15470054, element( st, 1 ) ) );
+	const stFrac = fract( stSkewed );
+	const tx = element( stFrac, 0 );
+	const ty = element( stFrac, 1 );
+	const tz = sub( sub( 1, tx ), ty );
+	const s = step( 0, sub( 0, tz ) );
+	const s2 = sub( mul( 2, s ), 1 );
+	const w1 = mul( sub( 0, tz ), s2 );
+	const w2 = sub( s, mul( ty, s2 ) );
+	const w3 = sub( s, mul( tx, s2 ) );
+	const baseId = floor( stSkewed );
+	const oneMinusS = sub( 1, s );
+	const id1 = add( baseId, vec2( s, s ) );
+	const id2 = add( baseId, vec2( s, oneMinusS ) );
+	const id3 = add( baseId, vec2( oneMinusS, s ) );
+
+	const ctr1 = toTileCenter( id1 );
+	const ctr2 = toTileCenter( id2 );
+	const ctr3 = toTileCenter( id3 );
+
+	const seedOffset = vec2( 0.12345, 0.12345 );
+	const rand1 = mxHextileHash( add( id1, seedOffset ) );
+	const rand2 = mxHextileHash( add( id2, seedOffset ) );
+	const rand3 = mxHextileHash( add( id3, seedOffset ) );
+
+	const rr = vec2( toRadians( element( rotationRange, 0 ) ), toRadians( element( rotationRange, 1 ) ) );
+	const rrMin = element( rr, 0 );
+	const rrMax = element( rr, 1 );
+	const randX = vec3( element( rand1, 0 ), element( rand2, 0 ), element( rand3, 0 ) );
+	const rotations = mix( vec3( rrMin, rrMin, rrMin ), vec3( rrMax, rrMax, rrMax ), mul( randX, rotation ) );
+	const randY = vec3( element( rand1, 1 ), element( rand2, 1 ), element( rand3, 1 ) );
+	const scaleMin = element( scaleRange, 0 );
+	const scaleMax = element( scaleRange, 1 );
+	const randomScale = mix( vec3( scaleMin, scaleMin, scaleMin ), vec3( scaleMax, scaleMax, scaleMax ), randY );
+	const scales = mix( vec3( 1, 1, 1 ), randomScale, scale );
+	const offsetMin = element( offsetRange, 0 );
+	const offsetMax = element( offsetRange, 1 );
+	const offset1 = mix( vec2( offsetMin, offsetMin ), vec2( offsetMax, offsetMax ), mul( rand1, offset ) );
+	const offset2 = mix( vec2( offsetMin, offsetMin ), vec2( offsetMax, offsetMax ), mul( rand2, offset ) );
+	const offset3 = mix( vec2( offsetMin, offsetMin ), vec2( offsetMax, offsetMax ), mul( rand3, offset ) );
+
+	const sampleCoord = ( center, randomOffset, rotationValue, sampleScale ) => {
+
+		const delta = sub( coord, center );
+		const rotated = mxRotate2d( delta, sin( rotationValue ), cos( rotationValue ) );
+		const safeScale = max( sampleScale, HEXTILE_EPSILON );
+		return add( add( div( rotated, vec2( safeScale, safeScale ) ), center ), randomOffset );
+
+	};
+
+	const sampleDerivative = ( derivative, rotationValue, sampleScale ) => {
+
+		const rotated = mxRotate2d( derivative, sin( rotationValue ), cos( rotationValue ) );
+		const safeScale = max( sampleScale, HEXTILE_EPSILON );
+		return div( rotated, vec2( safeScale, safeScale ) );
+
+	};
+
+	const ddx = dFdx( coord );
+	const ddy = dFdy( coord );
+
+	return {
+		coords: [
+			sampleCoord( ctr1, offset1, element( rotations, 0 ), element( scales, 0 ) ),
+			sampleCoord( ctr2, offset2, element( rotations, 1 ), element( scales, 1 ) ),
+			sampleCoord( ctr3, offset3, element( rotations, 2 ), element( scales, 2 ) ),
+		],
+		ddx: [
+			sampleDerivative( ddx, element( rotations, 0 ), element( scales, 0 ) ),
+			sampleDerivative( ddx, element( rotations, 1 ), element( scales, 1 ) ),
+			sampleDerivative( ddx, element( rotations, 2 ), element( scales, 2 ) ),
+		],
+		ddy: [
+			sampleDerivative( ddy, element( rotations, 0 ), element( scales, 0 ) ),
+			sampleDerivative( ddy, element( rotations, 1 ), element( scales, 1 ) ),
+			sampleDerivative( ddy, element( rotations, 2 ), element( scales, 2 ) ),
+		],
+		weights: vec3( w1, w2, w3 ),
+	};
+
+}

package/examples/jsm/loaders/materialx/MaterialXInterfaceValidation.js

@@ -0,0 +1,376 @@
+import { MtlXLibrary } from './MaterialXNodeLibrary.js';
+import { MaterialXLogCodes } from './MaterialXLog.js';
+import registryData from './MaterialXNodeInterfaceRegistry.js';
+
+const SKIP_ELEMENTS = new Set( [ 'materialx', 'input', 'output' ] );
+const CONTAINER_ELEMENTS = new Set( [ 'nodegraph' ] );
+
+const LIBRARY_FALLBACK_OUTPUT = 'out';
+
+function formatInputElement( inputNodeX ) {
+
+	const attrs = [];
+	for ( const name of [ 'name', 'type', 'nodename', 'nodegraph', 'interfacename', 'output', 'value' ] ) {
+
+		const value = inputNodeX.getAttribute( name );
+		if ( value !== null && value !== '' ) {
+
+			attrs.push( `${name}="${value}"` );
+
+		}
+
+	}
+
+	return `<input ${attrs.join( ' ' )}>`;
+
+}
+
+function formatNodeElement( nodeX ) {
+
+	const attrs = [];
+	for ( const name of [ 'name', 'type', 'nodedef' ] ) {
+
+		const value = nodeX.getAttribute( name );
+		if ( value !== null && value !== '' ) {
+
+			attrs.push( `${name}="${value}"` );
+
+		}
+
+	}
+
+	return `<${nodeX.element} ${attrs.join( ' ' )}>`;
+
+}
+
+function scoreNodedefCandidate( candidateName, nodeX ) {
+
+	const candidate = registryData.resolved[ candidateName ];
+	if ( ! candidate ) return - 1;
+
+	let score = 0;
+	const nodeType = nodeX.type;
+	const outputType = candidate.outputs.out || Object.values( candidate.outputs )[ 0 ];
+	if ( nodeType && outputType === nodeType ) {
+
+		score += 4;
+
+	}
+
+	for ( const child of nodeX.children ) {
+
+		if ( child.element !== 'input' ) continue;
+		const expectedType = candidate.inputs[ child.name ];
+		if ( ! expectedType || ! child.type ) continue;
+		if ( expectedType === child.type ) {
+
+			score += 3;
+
+		} else if ( typesCompatible( expectedType, child.type ) ) {
+
+			score += 1;
+
+		} else {
+
+			score -= 2;
+
+		}
+
+	}
+
+	return score;
+
+}
+
+function resolveInterface( nodeX ) {
+
+	const nodedefName = nodeX.getAttribute( 'nodedef' );
+	if ( nodedefName && registryData.resolved[ nodedefName ] ) {
+
+		return { source: 'nodedef', name: nodedefName, ...registryData.resolved[ nodedefName ] };
+
+	}
+
+	const candidates = registryData.byNode[ nodeX.element ] || [];
+	if ( candidates.length > 0 ) {
+
+		let selected = candidates[ 0 ];
+		let bestScore = - Infinity;
+
+		for ( const candidateName of candidates ) {
+
+			const score = scoreNodedefCandidate( candidateName, nodeX );
+			if ( score > bestScore ) {
+
+				bestScore = score;
+				selected = candidateName;
+
+			}
+
+		}
+
+		const resolved = registryData.resolved[ selected ];
+		if ( resolved ) {
+
+			return { source: 'nodedef', name: selected, ...resolved };
+
+		}
+
+	}
+
+	const libraryEntry = MtlXLibrary[ nodeX.element ];
+	if ( libraryEntry ) {
+
+		const inputs = Object.fromEntries( libraryEntry.params.map( ( param ) => [ param, null ] ) );
+		const outputs = nodeX.type ? { [ LIBRARY_FALLBACK_OUTPUT ]: nodeX.type } : {};
+		return { source: 'library', name: nodeX.element, node: nodeX.element, inputs, outputs };
+
+	}
+
+	return null;
+
+}
+
+function resolveReferencedNode( inputNodeX ) {
+
+	const materialX = inputNodeX.materialX;
+	const referencePath = inputNodeX.referencePath;
+	if ( ! referencePath ) return null;
+
+	return materialX.getMaterialXNode( referencePath ) || null;
+
+}
+
+function resolveSourceOutputType( sourceNodeX, outputName ) {
+
+	if ( sourceNodeX.element === 'output' ) {
+
+		return {
+			interface: null,
+			outputType: sourceNodeX.type,
+			outputName: sourceNodeX.name || 'out',
+		};
+
+	}
+
+	const sourceInterface = resolveInterface( sourceNodeX );
+	if ( ! sourceInterface ) return { interface: null, outputType: null, outputName };
+
+	if ( outputName ) {
+
+		if ( sourceInterface.outputs[ outputName ] ) {
+
+			return {
+				interface: sourceInterface,
+				outputType: sourceInterface.outputs[ outputName ],
+				outputName,
+			};
+
+		}
+
+		return {
+			interface: sourceInterface,
+			outputType: null,
+			outputName,
+		};
+
+	}
+
+	if ( sourceNodeX.type && sourceNodeX.type !== 'multioutput' ) {
+
+		return {
+			interface: sourceInterface,
+			outputType: sourceNodeX.type,
+			outputName: 'out',
+		};
+
+	}
+
+	if ( sourceInterface.outputs.out ) {
+
+		return {
+			interface: sourceInterface,
+			outputType: sourceInterface.outputs.out,
+			outputName: 'out',
+		};
+
+	}
+
+	const declaredOutputs = Object.entries( sourceInterface.outputs );
+	if ( declaredOutputs.length === 1 ) {
+
+		const [ singleName, singleType ] = declaredOutputs[ 0 ];
+		return {
+			interface: sourceInterface,
+			outputType: singleType,
+			outputName: singleName,
+		};
+
+	}
+
+	if ( sourceNodeX.type ) {
+
+		return {
+			interface: sourceInterface,
+			outputType: sourceNodeX.type,
+			outputName: null,
+		};
+
+	}
+
+	return { interface: sourceInterface, outputType: null, outputName: null };
+
+}
+
+function typesCompatible( expectedType, actualType ) {
+
+	if ( ! expectedType || ! actualType ) return true;
+	if ( expectedType === actualType ) return true;
+	if ( ( expectedType === 'float' && actualType === 'integer' ) || ( expectedType === 'integer' && actualType === 'float' ) ) {
+
+		return true;
+
+	}
+
+	return false;
+
+}
+
+function validatePortConnection( inputNodeX, parentNodeX, log ) {
+
+	const sourceNodeX = resolveReferencedNode( inputNodeX );
+	if ( ! sourceNodeX ) return;
+
+	const { outputType } = resolveSourceOutputType( sourceNodeX, inputNodeX.output );
+	const inputSnippet = formatInputElement( inputNodeX );
+
+	if ( inputNodeX.output && outputType === null ) {
+
+		log.add(
+			MaterialXLogCodes.INVALID_OUTPUT_CONNECTION,
+			`No output found for port connection: ${inputSnippet}`,
+			parentNodeX.name,
+		);
+		return;
+
+	}
+
+	const inputType = inputNodeX.type;
+	if ( inputType && outputType && typesCompatible( inputType, outputType ) === false ) {
+
+		log.add(
+			MaterialXLogCodes.TYPE_MISMATCH,
+			`Mismatched types in port connection: ${inputSnippet}`,
+			parentNodeX.name,
+		);
+
+	}
+
+}
+
+function validateNodeInputs( nodeX, log ) {
+
+	if ( nodeX.element === 'materialx' ) {
+
+		for ( const child of nodeX.children ) {
+
+			validateNodeInputs( child, log );
+
+		}
+
+		return;
+
+	}
+
+	if ( SKIP_ELEMENTS.has( nodeX.element ) ) return;
+	if ( CONTAINER_ELEMENTS.has( nodeX.element ) ) {
+
+		for ( const child of nodeX.children ) {
+
+			validateNodeInputs( child, log );
+
+		}
+
+		return;
+
+	}
+
+	const nodeInterface = resolveInterface( nodeX );
+	if ( nodeInterface ) {
+
+		for ( const child of nodeX.children ) {
+
+			if ( child.element !== 'input' ) continue;
+
+			const inputName = child.name;
+			if ( ! inputName ) continue;
+
+			if ( nodeInterface.inputs[ inputName ] === undefined ) {
+
+				log.add(
+					MaterialXLogCodes.UNKNOWN_INPUT,
+					`Node interface error: Input '${inputName}' doesn't match declaration: ${formatNodeElement( nodeX )}`,
+					nodeX.name,
+				);
+
+			} else if (
+				child.type &&
+				nodeInterface.inputs[ inputName ] &&
+				child.hasReference === false &&
+				typesCompatible( nodeInterface.inputs[ inputName ], child.type ) === false
+			) {
+
+				log.add(
+					MaterialXLogCodes.TYPE_MISMATCH,
+					`Input '${inputName}' type '${child.type}' doesn't match nodedef type '${nodeInterface.inputs[ inputName ]}' on ${formatNodeElement( nodeX )}`,
+					nodeX.name,
+				);
+
+			}
+
+			if ( child.hasReference ) {
+
+				validatePortConnection( child, nodeX, log );
+
+			}
+
+		}
+
+	} else if ( MtlXLibrary[ nodeX.element ] === undefined && nodeX.element !== 'surfacematerial' ) {
+
+		// Defer unsupported-node warnings to compile-time behavior.
+		for ( const child of nodeX.children ) {
+
+			if ( child.element === 'input' && child.hasReference ) {
+
+				validatePortConnection( child, nodeX, log );
+
+			}
+
+		}
+
+	}
+
+	for ( const child of nodeX.children ) {
+
+		if ( child.element !== 'input' && child.element !== 'output' ) {
+
+			validateNodeInputs( child, log );
+
+		}
+
+	}
+
+}
+
+function createStrictInterfaceValidator() {
+
+	return function validateMaterialXInterfaces( rootNode, log ) {
+
+		validateNodeInputs( rootNode, log );
+
+	};
+
+}
+
+export { createStrictInterfaceValidator };

package/examples/jsm/loaders/materialx/MaterialXLog.js

@@ -0,0 +1,75 @@
+const MaterialXLogCodes = {
+	UNSUPPORTED_NODE: {
+		label: 'unsupported-node',
+		severity: 'error',
+	},
+	IGNORED_SURFACE_INPUT: {
+		label: 'ignored-surface-input',
+		severity: 'warning',
+	},
+	MISSING_REFERENCE: {
+		label: 'missing-reference',
+		severity: 'error',
+	},
+	MISSING_MATERIAL: {
+		label: 'missing-material',
+		severity: 'error',
+	},
+	INVALID_VALUE: {
+		label: 'invalid-value',
+		severity: 'error',
+	},
+	UNKNOWN_INPUT: {
+		label: 'unknown-input',
+		severity: 'error',
+	},
+	INVALID_OUTPUT_CONNECTION: {
+		label: 'invalid-output-connection',
+		severity: 'error',
+	},
+	TYPE_MISMATCH: {
+		label: 'type-mismatch',
+		severity: 'error',
+	},
+};
+
+class MaterialXLog {
+
+	constructor() {
+
+		this.entries = [];
+
+	}
+
+	get errors() {
+
+		return this.entries.filter( ( entry ) => entry.severity === 'error' );
+
+	}
+
+	get warnings() {
+
+		return this.entries.filter( ( entry ) => entry.severity === 'warning' );
+
+	}
+
+	add( code, message, nodeName ) {
+
+		const entry = {
+			code: code.label,
+			severity: code.severity,
+			message,
+		};
+		if ( nodeName !== undefined && nodeName !== null ) {
+
+			entry.nodeName = nodeName;
+
+		}
+
+		this.entries.push( entry );
+
+	}
+
+}
+
+export { MaterialXLogCodes, MaterialXLog };