MxMaterialXHandler Class Reference

This class extends the MxGraphHandler class to provide MaterialX-specific functionality for handling MaterialX graphs within the editor. More...

Inheritance diagram for MxMaterialXHandler:

Public Member Functions
	constructor (id, extension)
	Constructor for the MxMaterialXHandler class.
	loadMaterialX ()
	Load in the MaterialX library.
	loadLibraryDocument (editor, materialFilename)
	Load the MaterialX document from library into the editor.
	initialize (editor, materialFilename)
	Initialize the MaterialX handler for the given editor.
	findRenderableItems (graph)
	Find all MaterialX renderable items in a graph.
	findRenderableItemsInDoc (mdoc)
	Find all renderable items in the MaterialX document.
	buildMetaData (colorSpace, unit, unitType, uiname, uimin, uimax, uifolder, _type)
	Builds and returns metadata for a node based on the provided parameters.
	createLiteGraphDefinitions (doc, debug, addInputOutputs, definitionsList, libraryPrefix='mtlx', editor, icon='')
	Creates LiteGraph node definitions based on the MaterialX document.
	validateDocument (doc)
	Validates the provided MaterialX document.
	saveGraphToDocument (graph, graphWriteOptions)
	Saves the graph to a MaterialX document.
	saveGraphToString (extension, graph, graphWriteOptions)
	Saves the graph to a string in the specified format.
	saveGraphToFile (extension, graph, graphWriteOptions)
	Saves the graph to a file with the specified extension.
	writeGraphToDocument (mltxgraph, graph, graphWriteOptions)
	Writes the graph to the specified MaterialX document.
	isArray (_type)
	Determines if the specified type is an array type.
	isURI (s)
	buildConnections (editor, node, lg_node, explicitInputs, graph, parentGraph)
	Builds the connections between MaterialX nodes.
	loadInputMetaData (node, input, property_info)
	Set the meta-data for the specified input based on LiteGraph node property info.
	buildGraphFromDoc (doc, editor, auto_arrange)
	Builds the LiteGraph graph from the specified MaterialX document.
	getAllFilesRecursive (dir)
	Recursively collects all file paths in a folder.
async	loadFolderToDocument (folderPath)
	loadDefinitionsFromFile ()
	Load MaterialX document containing node definitions from a file.
	loadFromString (extension, fileContents, fileName, auto_arrange, rerender=false)
	Load graph editor from a string.
	loadFromFile (extension, file, fileName, editor, auto_arrange)
	Load graph editor from a file.
	loadFromZip (extension, file, fileName, editor, auto_arrange, rerender=false)
	loadMaterialXLibraries (stdlib)
	Load MaterialX definition libraries.
	createValidName (name, msg=null)
	Create a valid MaterialX name within the context of the current graph.
Public Member Functions inherited from MxGraphHandler
	constructor (id, extension)
	addConverter (converter)
	Add a converter to the handler.
	setMonitor (monitor)
	Set the monitor for the handler.
	canExport (extension)
	Return if the handler can export to the given extension / format.
	getExporter (extension='')
	Find the first exporter that can export to the given extension / format.
	canImport (extension)
	Return if the handler can import the given extension / format.
	getImporter (extension='')
	Find the first importer that can import the given extension / format.
	setColorSpaces (colorSpaces)
	Set the color spaces used by the handler.
	getColorSpaces ()
	Get the color spaces used by the handler.
	setUnits (units)
	Set the units used by the handler.
	getUnits ()
	Get the units used by the handler.
	setSourceColorSpace (colorSpace)
	Set the source color space for the handler.
	setTargetDistanceUnit (unit)
	Set the target distance unit for the handler.
	getSourceColorSpace ()
	Get the source color space for the handler.
	getTargetDistanceUnit ()
	Get the target distance unit for the handler.
	getExtension ()
	Get the extension /format for the handler.
	initialize (editor)
	Initialize the handler for the given editor.
	createValidName (name)
	Create a valid name for the given name.
	getDefaultValue (value, _type)
	Get default value as a string for the given value and type.

Public Attributes
return	userlib

Detailed Description

This class extends the MxGraphHandler class to provide MaterialX-specific functionality for handling MaterialX graphs within the editor.

Definition at line 932 of file JsMaterialXNodeEditor.js.

Member Function Documentation

buildConnections()

MxMaterialXHandler::buildConnections	(		editor,
			node,
			lg_node,
			explicitInputs,
			graph,
			parentGraph )

Builds the connections between MaterialX nodes.

Parameters

editor	- The graph editor.
node	- The MaterialXnode to build connections for.
lg_node	- The LiteGraph node
explicitInputs	- The explicit inputs to the node.
graph	- The LiteGraph parent.
parentGraph	- The parent MaterialX graph.

Definition at line 2268 of file JsMaterialXNodeEditor.js.

                                                                                {
 
        var nodeInputs = [];
        var isOutput = (node.getCategory() == 'output');
        var isInput = (node.getCategory() == 'input');
        if (isOutput || isInput) {
            nodeInputs = [node];
        }
        else {
            nodeInputs = node.getInputs();
        }
        for (var input of nodeInputs) {
 
            var _name = ''
 
            if (!isOutput && !isInput) {
                _name = input.getName();
                explicitInputs.push(_name);
            }
 
            var nodeName = input.getNodeName();
            var nodeGraphName = input.getNodeGraphString();
            var inputInterfaceName = input.getInterfaceName();
            var outputName = input.getOutputString();
 
            if (nodeName.length ||
                nodeGraphName.length ||
                inputInterfaceName.length ||
                outputName.length) {
 
                //console.log('Test connection on input:', input.getNamePath(), 'nodeName:[ ', nodeName, 
                //    '] nodeGraphName:[', nodeGraphName, 
                //    '] inputInterfaceName:[', inputInterfaceName, 
                //    ']outputName:[', outputName, ']');
 
                var target_node = lg_node;
                var target_slot = null;
                if (!isOutput && !isInput)
                    target_slot = target_node.findInputSlot(_name);
                else
                    target_slot = 0;
                var source_node = null;
                var source_slot = 0;
                var source_name = nodeName;
                if (nodeGraphName.length) {
                    source_name = nodeGraphName;
                }
                if (inputInterfaceName.length) {
                    source_name = inputInterfaceName;
                }
 
                var graphToCheck = graph;
                if (isInput && graph._subgraph_node) {
                    target_node = graph._subgraph_node;
                    target_slot = target_node.findInputSlot(lg_node.title);
                    // Go up to parent graph
                    graphToCheck = parentGraph;
                    //console.log(' go up to parent graph:', graphToCheck,
                    //    'from:', graph, 'subgraph:', graph._subgraph_node,
                    //'target_node:', target_node.title, 'target_slot:', target_slot);
                }
                source_node = graphToCheck.findNodeByTitle(source_name);
                if (source_node) {
                    if (outputName) {
                        var outputSlot = source_node.findOutputSlot(outputName);
                        if (outputSlot >= 0) {
                            source_slot = outputSlot;
                        }
                        else {
                            editor.debugOutput('Failed to find output slot:' + outputName, 1);
                        }
                        var linkInfo = source_node.connect(source_slot, target_node, target_slot);
                        if (!linkInfo) {
                            editor.debugOutput('Failed to connect:' + source_node.title + '.' + outputName, '->', target_node.title + '.' + _name), 1, false;
                        }
                    }
                    //console.log('CONNECT START: source[', source_node.title, '.', source_slot,
                    //    '] --> target[:', target_node.title, ".", target_slot);
                    var linkInfo = null;
                    if (source_slot == null || target_slot == null || target_node == null) {
                        console.warning('Cannot connect!')
                    }
                    else {
                        linkInfo = source_node.connect(source_slot, target_node, target_slot);
                    }
                    if (!linkInfo) {
                        editor.debugOutput('Failed to connect:' + source_node.title + '.' + outputName, '->', target_node.title + '.' + _name, 1);
                    }
                    //console.log('CONNECT END: source[', source_node.title, '.', source_slot,
                    //    '] --> target[:', target_node.title, ".", target_slot);
                }
                else {
                    console.log('Failed to find node ', source_name, 'in graph:', graphToCheck);
                    this.editor.debugOutput('Failed to find source node: ' + source_node + "." +
                        source_name, '->', lg_node.title + "." + _name, 2);
                }
            }
            else {
                const inputType = input.getAttribute(ne_mx.TypedElement.TYPE_ATTRIBUTE);
                let valueString = input.getValueString();
                if (valueString.length > 0) {
                    let _value = '';
 
                    if (inputType === ne_mx.FILENAME_TYPE_STRING) {
                        // If the string is a http or blob url then call input.getValuesString()
                        // else call input.getResolvedValueString()
                        if (this.isURI(valueString)) {
                            this.editor.debugOutput('Filename is a url:' + valueString + '. Cannot use resolved path value.');
                            _value = input.getValueString();
                        }
                        else {
                            _value = input.getResolvedValueString();
                        }
                    }
                    else 
                    {
                        _value = input.getResolvedValueString(); // input.getValueString();
 
                        if (this.isArray(input.getType())) {
                            let valueArray = "[" + _value + "]"
                            valueArray = JSON.parse(valueArray);                        
                            //valueArray = _value.split(/[\s,]+/); - This does not parse all  configs properly.
                            //console.log('>>> Read array value:', _value, 'as:', valueArray);
                            _value = valueArray;
                        }
                    }
 
                    //console.log('-- Value Input:', 
                    //lg_node.title + "." + _name, 'value:', _value);
                    lg_node.setProperty(_name, _value);
                }
            }
 
            var property_info = lg_node.getPropertyInfo(_name);
            this.loadInputMetaData(node, input, property_info);
        }
    }

buildGraphFromDoc()

MxMaterialXHandler::buildGraphFromDoc	(		doc,
			editor,
			auto_arrange )

Builds the LiteGraph graph from the specified MaterialX document.

Parameters

doc	- The MaterialX document to build the graph from.
editor	- The graph editor.
auto_arrange	- True to auto-arrange the graph, false otherwise.

Returns

{void}

Definition at line 2488 of file JsMaterialXNodeEditor.js.

                                                 {
        let debug = false;
        let loadNodePositions = false; // TODO: Some issues with UI update when setting xpos, ypos. To address.
 
        //console.log('Build graph from doc. auto_arrange: ', auto_arrange);
        if (!ne_mx) {
            editor.debugOutput("MaterialX is not initialized", 2);
            return;
        }
 
        editor.clearGraph();
 
        // Don't try and update the graph while building it
        editor.monitor.monitorGraph(graph, false);
 
        // Index here is index into litegraph nodes
        var mtlxNodes = [];
        var mtlxNodeDefs = [];
 
        for (var interfaceInput of doc.getInputs()) {
            var _type = interfaceInput.getType();
            var id = 'mtlx/input/input_' + _type;
 
            var lg_node = LiteGraph.createNode(id);
            if (lg_node) {
                lg_node.title = interfaceInput.getName();
                if (debug)
                    console.log('Add top level input:', lg_node.title, 'to graph', graph);
 
                var _value = interfaceInput.getValueString();
                if (_value && _value.length > 0) {
                    if (this.isArray(interfaceInput.getType())) {
                        _value = "[" + _value + "]"
                        _value = JSON.parse(_value);
                    }
                    lg_node.setProperty('in', _value);
                }
 
                if (loadNodePositions) {
                    var xpos = interfaceInput.getAttribute('xpos');
                    var ypos = interfaceInput.getAttribute('ypos');
                    if (xpos.length > 0 && ypos.length > 0) {
                        lg_node.pos[0] = xpos;
                        lg_node.pos[1] = ypos;
                        //lg_node.flags.collapsed = false;
                    }
                }
 
                // Make sure size is updated
                lg_node.setSize(lg_node.computeSize());
 
                graph.add(lg_node);
 
                //mtlxNodes.push([interfaceInput, lg_node, graph]);                        
            }
        }
 
        for (var interfaceOutput of doc.getOutputs()) {
            var _type = interfaceOutput.getType()
            var id = 'mtlx/output/output_' + _type;
 
            var lg_node = LiteGraph.createNode(id);
            if (lg_node) {
                lg_node.title = interfaceOutput.getName();
                graph.add(lg_node);
                if (debug) {
                    console.log('Add graph output:', lg_node.title);
                }
 
                // Make sure size is updated
                lg_node.setSize(lg_node.computeSize());
 
                if (loadNodePositions) {
                    var xpos = interfaceOutput.getAttribute('xpos');
                    var ypos = interfaceOutput.getAttribute('ypos');
                    if (xpos.length > 0 && ypos.length > 0)
                        lg_node.pos = [xpos, ypos];
                }
 
                mtlxNodes.push([interfaceOutput, lg_node, graph]);
            }
        }
 
        for (var node of doc.getNodes()) {
            var nodeDef = node.getNodeDef();
            if (!nodeDef) {
                editor.debugOutput('Skip node w/o nodedef:' + node.getName(), 1)
                continue;
            }
 
            // mtlx/pbr/gltf_pbr_surfaceshader                    
            var id = 'mtlx/' + nodeDef.getNodeGroup() + '/' + nodeDef.getName();
            id = id.replace('ND_', '');
            if (debug)
                console.log('Load node:', node.getName(), ' -> ', id);
 
            var lg_node = LiteGraph.createNode(id);
            if (lg_node) {
                //console.log('LiteGraph node:', lg_node);
                lg_node.title = node.getName();
 
                graph.add(lg_node);
 
                // Make sure size is updated
                lg_node.setSize(lg_node.computeSize());
 
                if (loadNodePositions) {
                    var xpos = node.getAttribute('xpos');
                    var ypos = node.getAttribute('ypos');
                    if (xpos.length > 0 && ypos.length > 0)
                        lg_node.pos = [xpos, ypos];
                }
 
                mtlxNodes.push([node, lg_node, graph]);
                mtlxNodeDefs.push(nodeDef);
            }
            else {
                editor.debugOutput('Failed to create node:' + node.getName(), 2);
            }
        }
 
        for (var nodegraph of doc.getNodeGraphs()) {
            if (nodegraph.hasSourceUri()) {
                continue;
            }
            var nodedefAttrib = nodegraph.getAttribute('nodedef');
            if (nodedefAttrib && nodedefAttrib.length > 0) {
                console.log('Skip loading in functional graph:', nodegraph.getName(), 'nodedef:', nodedefAttrib);
                continue;
            }
            if (debug)
                console.log('Create nodegraph:', nodegraph.getName());
 
            var title = nodegraph.getName();
            var subgraphNode = LiteGraph.createNode("graph/subgraph", title);
            //var subgraph = new LiteGraph.LGraph();
            //subgraphNode._subgraph_node = subgraph;
            //subgraphNode.bgcolor = "#112";
            subgraphNode.bgImageUrl = "./Icons/nodegraph.png";
 
            var mtlxSubGraphNodes = [];
            for (var interfaceInput of nodegraph.getInputs()) {
                var _type = interfaceInput.getType();
                var id = 'mtlx/input/input_' + _type;
 
                var lg_node = LiteGraph.createNode(id);
                if (lg_node) {
                    lg_node.title = interfaceInput.getName();
                    this.loadInputMetaData(null, interfaceInput, lg_node.properties_info[0]);
                    subgraphNode.subgraph.add(lg_node);
 
                    if (debug)
                        console.log('-------- Add subgraph input:', lg_node.title, lg_node);
 
                    subgraphNode.addInput(interfaceInput.getName(), _type);
                    subgraphNode.subgraph.addInput(interfaceInput.getName(), _type);
 
                    var _value = interfaceInput.getValueString();
                    if (_value && _value.length > 0) {
                        if (this.isArray(interfaceInput.getType())) {
                            _value = "[" + _value + "]"
                            _value = JSON.parse(_value);
                        }
                        lg_node.setProperty('in', _value);
                    }
 
                    // Make sure size is updated
                    lg_node.setSize(lg_node.computeSize());
 
                    if (loadNodePositions) {
                        var xpos = nodegraph.getAttribute('xpos');
                        var ypos = nodegraph.getAttribute('ypos');
                        if (xpos.length > 0 && ypos.length > 0)
                            lg_node.pos = [xpos, ypos];
                    }
 
                    mtlxSubGraphNodes.push([interfaceInput, lg_node, graph]);
                }
            }
 
            for (var interfaceOutput of nodegraph.getOutputs()) {
                var _type = interfaceOutput.getType()
                var id = 'mtlx/output/output_' + _type;
 
                var lg_node = LiteGraph.createNode(id);
                if (lg_node) {
                    lg_node.title = interfaceOutput.getName();
                    subgraphNode.subgraph.add(lg_node);
                    if (debug)
                        console.log('Add subgraph output:', lg_node.title);
 
                    subgraphNode.addOutput(interfaceOutput.getName(), _type);
                    subgraphNode.subgraph.addOutput(interfaceOutput.getName(), _type);
 
                    // Make sure size is updated
                    lg_node.setSize(lg_node.computeSize());
 
                    if (loadNodePositions) {
                        var xpos = interfaceOutput.getAttribute('xpos');
                        var ypos = interfaceOutput.getAttribute('ypos');
                        if (xpos.length > 0 && ypos.length > 0)
                            lg_node.pos = [xpos, ypos];
                    }
 
                    mtlxSubGraphNodes.push([interfaceOutput, lg_node, graph]);
                }
            }
 
 
            for (var node of nodegraph.getNodes()) {
                var nodeDef = node.getNodeDef();
                if (!nodeDef) {
                    editor.debugOutput('Skip node w/o nodedef:' + node.getName(), 1)
                    continue;
                }
 
                // mtlx/pbr/gltf_pbr_surfaceshader                    
                var id = 'mtlx/' + nodeDef.getNodeGroup() + '/' + nodeDef.getName();
                id = id.replace('ND_', '');
 
                var lg_node = LiteGraph.createNode(id);
                lg_node.title = node.getName();
                subgraphNode.subgraph.add(lg_node);
                if (debug)
                    console.log('Add subgraph node:', lg_node.title);
 
                // Make sure size is updated
                lg_node.setSize(lg_node.computeSize());
 
                if (loadNodePositions) {
                    var xpos = node.getAttribute('xpos');
                    var ypos = node.getAttribute('ypos');
                    if (xpos.length > 0 && ypos.length > 0)
                        lg_node.pos = [xpos, ypos];
                }
 
                mtlxSubGraphNodes.push([node, lg_node, graph]);
            }
 
            for (var item of mtlxSubGraphNodes) {
                var node = item[0];
                var lg_node = item[1];
                var parentGraph = item[2];
                var explicitInputs = [];
 
                // Make sure size is updated
                lg_node.setSize(lg_node.computeSize());
 
                //console.log('Build connections for subgraog node:', lg_node.title);
                this.buildConnections(editor, node, lg_node, explicitInputs, subgraphNode.subgraph, parentGraph);
            }
 
            if (debug)
                console.log('Add subgraph:', subgraphNode.title);
 
            if (auto_arrange > 0) {
                subgraphNode.subgraph.arrange(auto_arrange);
            }
 
            graph.add(subgraphNode);
 
        }
 
        // Build top level connections last after top level nodes
        // and nodegraph have been added.
        var itemCount = 0;
        for (var item of mtlxNodes) {
            var node = item[0];
            var lg_node = item[1];
 
            // Keep track of explicit inputs
            var explicitInputs = [];
            //console.log('Build connections for:', lg_node.title);
            this.buildConnections(editor, node, lg_node, explicitInputs, graph, null);
 
            if (lg_node.nodedef_node == 'input' || lg_node.nodedef_node == 'output') {
                continue;
            }
 
            /* 
            var removeInputs = [];
            var nodeDef = mtlxNodeDefs[itemCount];
            if (nodeDef) {
                for (var nodeDefInput of nodeDef.getActiveInputs()) {
                    var _name = nodeDefInput.getName();
                    if (!explicitInputs.includes(_name)) {
                        removeInputs.push(_name);
                    }
                }
                for (var _name of removeInputs) {
                    var slot = lg_node.findInputSlot(_name);
                    lg_node.inputs[slot].hidden = true; 
                    console.log('Hide input:', _name, '. ', slot, ' on: ', lg_node);
                    //lg_node.removeInput(slot);
                }
 
                // Make sure size is updated
                lg_node.setSize(lg_node.computeSize());
            }
            */
            itemCount++;
        }
 
        editor.monitor.monitorGraph(graph, true);
 
        if (auto_arrange > 0) {
            graph.arrange(auto_arrange);
        }
 
        graph.setDirtyCanvas(true, true);
        graphcanvas.setDirty(true, true);
    }

buildMetaData()

MxMaterialXHandler::buildMetaData	(		colorSpace,
			unit,
			unitType,
			uiname,
			uimin,
			uimax,
			uifolder,
			_type )

Builds and returns metadata for a node based on the provided parameters.

This metadata can be used to enhance the node's representation and interaction within the UI, specifying details like color space, unit, and UI properties.

Parameters

colorSpace	- The color space of the node (e.g., 'sRGB', 'linear').
unit	- The unit of measurement for the node's value (e.g., 'meters', 'seconds').
unitType	- The type of unit measurement (e.g., 'distance', 'time').
uiname	- The name to display in the UI for this node.
uimin	- The minimum value allowed for this node in the UI.
uimax	- The maximum value allowed for this node in the UI.
uifolder	- The folder/group in the UI where this node should be placed.
_type	- The data type of the node (e.g., 'float', 'vector3').

Returns

An object containing the constructed metadata based on the input parameters.

Definition at line 1187 of file JsMaterialXNodeEditor.js.

                                                                                     {
        // Create a struct with the metadata names as key and value
        var metaData = {};
        metaData['colorspace'] = colorSpace;
        metaData['unit'] = unit;
        metaData['unittype'] = unitType;
        metaData['uiname'] = uiname;
        if (_type == 'vector2' || _type == 'vector3' || _type == 'vector4' || _type == 'matrix33' || _type == 'matrix44') {
            if (uimin) {
                uimin = uimin.split(',').map(Number);
            }
            if (uimax) {
                uimax = uimax.split(',').map(Number);
            }
        }
        metaData['uimin'] = uimin;
        metaData['uimax'] = uimax;
        metaData['uifolder'] = uifolder;
 
        // Return struct in an array
        return metaData;
    }

constructor()

MxMaterialXHandler::constructor	(		id,
			extension )

Constructor for the MxMaterialXHandler class.

Parameters

id	- The identifier for the handler.
extension	- The associated extension for the handler.

Definition at line 940 of file JsMaterialXNodeEditor.js.

                               {
        super(id, extension);
    }

createLiteGraphDefinitions()

MxMaterialXHandler::createLiteGraphDefinitions	(		doc,
			debug,
			addInputOutputs,
			definitionsList,
			libraryPrefix = 'mtlx',
			editor,
			icon = '' )

Creates LiteGraph node definitions based on the MaterialX document.

This function parses the MaterialX document to extract node definitions and generates Javascript code for corresponding LiteGraph nodes that can be used within the editor.

Parameters

doc	- The MaterialX document to parse.
debug	- Flag to enable debug logging.
addInputOutputs	- Flag to determine whether to add inputs and outputs to the LiteGraph nodes.
definitionsList	- List to store the generated LiteGraph node definitions.
libraryPrefix	- Prefix to use for the LiteGraph nodes, default is 'mtlx'.
editor	- The instance of the editor where the nodes will be used.
icon	- Icon to use for the LiteGraph nodes, default is an empty string.

Returns

{void}

Definition at line 1224 of file JsMaterialXNodeEditor.js.

    {
        var definition_code = ""
 
        console.log('Creating LiteGraph definitions from MaterialX document:', doc);
 
        // Get the node definitions from the MaterialX document
        var nodeDefs = doc.getNodeDefs();
 
        if (debug)
            definition_code += "console.log('Loading MaterialX Definitions...');\n";
 
        definition_code += "// MaterialX LiteGraph Functional Definitions\n"
        definition_code += "//\n";
        definition_code += "// MaterialX Version: " + ne_mx.getVersionString() + "\n";
        const date = new Date();
        definition_code += "// Generated on: " + date.toString() + "\n"; 
        definition_code += "//\n";
 
        var TMAP = {}
        TMAP['float'] = 'float';
        TMAP['color3'] = 'color3';
        TMAP['color4'] = 'color4';
        TMAP['vector2'] = 'vector2';
        TMAP['vector3'] = 'vector3';
        TMAP['vector4'] = 'vector4';
        TMAP['matrix33'] = 'matrix33';
        TMAP['matrix44'] = 'matrix44';
        TMAP['integer'] = 'integer';
        TMAP['string'] = 'string';
        TMAP['boolean'] = 'boolean';
        TMAP['filename'] = 'filename';
        TMAP['BSDF'] = 'BSDF';
        TMAP['EDF'] = 'EDF';
        TMAP['VDF'] = 'VDF';
        TMAP['surfaceshader'] = 'surfaceshader';
        TMAP['volumeshader'] = 'volumeshader';
        TMAP['displacementshader'] = 'displacementshader';
        TMAP['lightshader'] = 'lightshader';
        TMAP['material'] = 'material';
        TMAP['vector2array'] = 'vector2array';
 
        var CMAP = {}
        CMAP['integer'] = "#A32";
        CMAP['float'] = "#161";
        CMAP['vector2'] = "#265";
        CMAP['vector3'] = "#465";
        CMAP['vector4'] = "#275";
        CMAP['color3'] = "#37A";
        CMAP['color4'] = "#69A";
        CMAP['matrix33'] = "#333";
        CMAP['matrix44'] = "#444";
        CMAP['string'] = "#395";
        CMAP['filename'] = "#888";
        CMAP['boolean'] = "#060";
 
        var inputTypes = ['float', 'color3', 'color4', 'vector2', 'vector3', 'vector4', 'matrix33', 'matrix44', 'integer', 'string', 'boolean', 'filename', 'BSDF', 'EDF', 'VDF', 'surfaceshader', 'volumeshader', 'displacementshader', 'lightshader', 'material', 'vector2array'];
        var outputTypes = ['float', 'color3', 'color4', 'vector2', 'vector3', 'vector4', 'matrix33', 'matrix44', 'integer', 'string', 'boolean', 'filename', 'BSDF', 'EDF', 'VDF', 'surfaceshader', 'volumeshader', 'displacementshader', 'lightshader', 'material', 'vector2array'];
 
        // TODO: Support tokens
        var supporTokens = false;
        if (supporTokens) {
            inputTypes.push('token');
            TMAP['token'] = 'string';
        }
 
        const INPUT_ND = 'ND_input_';
        const OUTPUT_ND = 'ND_output_';
        const INPUT_NODE_STRING = 'input';
        const OUTPUT_NODE_STRING = 'output';
        const LIBRARY_ICON = '';
 
        // Register inputs (which have no nodedef)
        if (addInputOutputs) {
            for (var _type of inputTypes) {
                var id = libraryPrefix + '/input/input_' + _type;
                var functionName = ne_mx.createValidName(id);
                var titleName = 'input_' + _type;
                definition_code += "\n/**\n"; 
                definition_code += "  * @function "+ functionName + "\n";
                definition_code += "  * @description Library: " + libraryPrefix + ". Category: input. Type: " + _type + "\n";
                definition_code += "  *   LiteGraph id: " + id + "\n"; 
                definition_code += "  */\n";
                definition_code += "function " + functionName + "() {\n";
                {
                    definition_code += "  this.nodedef_icon = '" + LIBRARY_ICON + "';\n";
                    definition_code += "  this.nodedef_name = '" + INPUT_ND + _type + "';\n";
                    definition_code += "  this.nodedef_node = '" + INPUT_NODE_STRING + "';\n";
                    definition_code += "  this.nodedef_type = '" + _type + "';\n";
                    definition_code += "  this.nodedef_group = '" + INPUT_NODE_STRING + "';\n";
                    if (_type == 'token')
                        _type = 'string';
                    definition_code += "  this.addInput('in', '" + TMAP[_type] + "');\n";
                    var value = this.getDefaultValue('', _type);
                    var metaData = this.buildMetaData('', '', '', '', null, null, '', null);
                    metaData = JSON.stringify(metaData);
 
                    // TODO: It's not possible to add a default colorspace since you 
                    // don't know what node type it will feed into. i.e. the specification
                    // is underdefined at this time (1.39)
                    if (_type == 'filename')
                    {
                        ; // Nothing for now.
                    }
 
                    definition_code += "  this.addProperty('in', " + value + ", '" + _type + "'," + metaData + ");\n";
                    definition_code += "  this.addOutput('out', '" + TMAP[_type] + "');\n";
 
                    definition_code += "  this.title = '" + titleName + "';\n"
                    var desc = '"MaterialX:' + id + '"';
                    definition_code += "  this.desc = " + desc + ";\n";
 
                    var onNodeCreated = "function() {\n";
                    onNodeCreated += "    //console.log('Node created:', this);\n";
                    onNodeCreated += "  }";
                    definition_code += "  this.onNodeCreated = " + onNodeCreated + "\n";
                    var onRemoved = "function() {\n";
                    onRemoved += "    //console.log('Node removed:', this);\n";
                    onRemoved += "  }";
                    definition_code += "  this.onRemoved = " + onRemoved + "\n";
 
                    // Property changed callback
                    let monitor = editor.monitor;
                    var onPropertyChanged = "function(name, value, prev_value) {\n";
                    if (monitor)
                    {
                        onPropertyChanged += " MxShadingGraphEditor.theEditor.monitor.onPropertyChanged(this.title, name, value, prev_value, this);\n";
                    }
                    else
                    {
                        onPropertyChanged += "    console.log('+ Internal property changed:', this.title, name, value, prev_value, this);\n";
                    }
                    onPropertyChanged += "  }";
                    definition_code += "  this.onPropertyChanged = " + onPropertyChanged + "\n";
 
                    // Property info / attribute changed callback
                    var onPropertyInfoChanged = "function(name, info, value, prev_value) {\n";
                    if (monitor)
                    {
                        onPropertyInfoChanged += " MxShadingGraphEditor.theEditor.monitor.onPropertyInfoChanged(this.title, name, info, value, prev_value, this);\n";
                    }
                    else
                    {
                        onPropertyInfoChanged += "    console.log('+ Internal property info changed:', this.title, name, info, value, prev_value, this);\n";
                    }
                    onPropertyInfoChanged += "  }"                    
                    definition_code += "  this.onPropertyInfoChanged = " + onPropertyInfoChanged + "\n";
 
                    // Output connection callback 
                    var onConnectOutput = "function(slot, input_type, input, target_node, target_slot) {\n";
                    if (monitor)
                    {
                        onConnectOutput += " MxShadingGraphEditor.theEditor.monitor.onConnectOutput(slot, input_type, input, target_node, target_slot, this);\n";
                    }
                    else
                    {
                        onConnectOutput += "    console.log('+ Output connection changed:', this.title, slot, input_type, input, target_node, target_slot);\n";
                    }
                    onConnectOutput += "  }"                    
                    definition_code += "  this.onConnectOutput = " + onConnectOutput + "\n";    
    
                    // Input connection callback 
                    var onConnectInput = "function(target_slot, output_type, output, source, slot) {\n";
                    if (monitor)
                    {
                        onConnectInput += " MxShadingGraphEditor.theEditor.monitor.onConnectInput(target_slot, output_type, output, source, slot, this);\n";
                    }
                    else
                    {
                        onConnectInput += "    console.log('+ Input connection changed:', this.title, target_slot, output_type, output, source, slot);\n";
                    }
                    onConnectInput += "  }"                    
                    definition_code += "  this.onConnectInput = " + onConnectInput + "\n";
 
                    definition_code += "  this.color = '#004C94';\n";
                    definition_code += "  this.bgcolor = '#000';\n";
                    if (_type in CMAP) {
                        definition_code += "  this.boxcolor = '" + CMAP[_type] + "';\n";
                    }
                    definition_code += "  this.shape = LiteGraph.ROUND_SHAPE;\n";
 
                    definition_code += "  this.onExecute = function() {\n";
                    definition_code += "    console.log('Executing node: ', this);\n";
                    definition_code += "  }\n";
                }
                definition_code += "}\n"
                definition_code += "LiteGraph.registerNodeType('" + id + "', " + functionName + ");\n";
            }
 
            // Register outputs (which have no nodedef)
            for (var _type of outputTypes) {
                var id = libraryPrefix + '/output/output_' + _type;
                var functionName = ne_mx.createValidName(id);
                var titleName = 'output_' + _type;
 
                definition_code += "\n/**\n"; 
                definition_code += "  * @function "+ functionName + "\n";
                definition_code += "  * @description Library: " + libraryPrefix + ". Category: output. Type: " + _type + "\n";
                definition_code += "  *   LiteGraph id: " + id + "\n"; 
                definition_code += "  */\n";
 
                definition_code += "function " + functionName + "() {\n";
                {
                    definition_code += "  this.title = '" + titleName + "';\n"
                    var desc = '"MaterialX Node :' + id + '"';
                    definition_code += "  this.desc = " + desc + ";\n";
 
                    definition_code += "  this.nodedef_icon = '" + LIBRARY_ICON + "';\n";
                    definition_code += "  this.nodedef_name = '" + OUTPUT_ND + + _type + "';\n";
                    definition_code += "  this.nodedef_node = '" + OUTPUT_NODE_STRING + "';\n";
                    definition_code += "  this.nodedef_type = '" + _type + "';\n";
                    definition_code += "  this.nodedef_group = '" + OUTPUT_NODE_STRING + "';\n";
                    definition_code += "  this.addInput('in', '" + TMAP[_type] + "');\n";
                    var value = this.getDefaultValue('', _type);
                    definition_code += "  this.addProperty('in', " + value + ", '" + _type + "');\n";
                    definition_code += "  this.addOutput('out', '" + TMAP[_type] + "');\n";
 
                    var onNodeCreated = "function() {\n";
                    onNodeCreated += "  //console.log('Node created:', this);\n";
                    onNodeCreated += "  }";
                    definition_code += "  this.onNodeCreated = " + onNodeCreated + "\n";
                    var onRemoved = "function() {\n";
                    onRemoved += "  //console.log('Node removed:', this);\n";
                    onRemoved += "  }";
                    definition_code += "  this.onRemoved = " + onRemoved + "\n";
 
                    let monitor = editor.monitor;
                    var onPropertyChanged = "function(name, value, prev_value) {\n";
                    if (monitor)
                    {
                        onPropertyChanged += " MxShadingGraphEditor.theEditor.monitor.onPropertyChanged(this.title, name, value, prev_value, this);\n";
                    }
                    else
                    {
                        onPropertyChanged += "    console.log('+ Internal property changed:', this.title, name, value, prev_value, this);\n";
                    }
                    onPropertyChanged += "  }";
                    definition_code += "  this.onPropertyChanged = " + onPropertyChanged + "\n";    
 
                    var onPropertyInfoChanged = "function(name, info, value, prev_value) {\n";
                    if (monitor)
                    {
                        onPropertyInfoChanged += " MxShadingGraphEditor.theEditor.monitor.onPropertyInfoChanged(this.title, name, info, value, prev_value, this);\n";
                    }
                    else
                    {
                        onPropertyInfoChanged += "    console.log('+ Internal property info changed:', this.title, name, info, value, prev_value, this);\n";
                    }
                    onPropertyInfoChanged += "  }"                    
                    definition_code += "  this.onPropertyInfoChanged = " + onPropertyInfoChanged + "\n";
 
 
                    // Output connection callback 
                    var onConnectOutput = "function(slot, input_type, input, target_node, target_slot) {\n";
                    if (monitor)
                    {
                        onConnectOutput += " MxShadingGraphEditor.theEditor.monitor.onConnectOutput(slot, input_type, input, target_node, target_slot, this);\n";
                    }
                    else
                    {
                        onConnectOutput += "    console.log('+ Output connection changed:', this.title, slot, input_type, input, target_node, target_slot);\n";
                    }
                    onConnectOutput += "  }"                    
                    definition_code += "  this.onConnectOutput = " + onConnectOutput + "\n";    
    
                    // Input connection callback 
                    var onConnectInput = "function(target_slot, output_type, output, source, slot) {\n";
                    if (monitor)
                    {
                        onConnectInput += " MxShadingGraphEditor.theEditor.monitor.onConnectInput(target_slot, output_type, output, source, slot, this);\n";
                    }
                    else
                    {
                        onConnectInput += "    console.log('+ Input connection changed:', this.title, target_slot, output_type, output, source, slot);\n";
                    }
                    onConnectInput += "  }"                    
                    definition_code += "  this.onConnectInput = " + onConnectInput + "\n";
 
                    definition_code += "  this.color = '#013514';\n";
                    definition_code += "  this.bgcolor = '#000';\n";
                    if (_type in CMAP) {
                        definition_code += "  this.boxcolor = '" + CMAP[_type] + "';\n";
                    }
                    definition_code += "  this.shape = LiteGraph.ROUND_SHAPE;\n";
 
                    definition_code += "  this.onExecute = function() {\n";
                    definition_code += "  console.log('Executing node:', this);\n";
                    definition_code += "  }\n";
                }
                definition_code += "}\n"
                definition_code += "LiteGraph.registerNodeType('" + id + "', " + functionName + ");\n";
                definitionsList.push(id);
            }
        }
 
        // Iterate over all node definitions
        for (var nodeDef of nodeDefs) {
 
            var nodeDefName = nodeDef.getName();
            var id = libraryPrefix + '/' + nodeDef.getNodeGroup() + '/' + nodeDefName;
            id = id.replace('ND_', '');
            var functionName = ne_mx.createValidName(id);
            var nodeType = nodeDef.getType();
            var titleName = nodeDef.getNodeString() + "_" + nodeType;
            var swatchLocation = 'https://kwokcb.github.io/MaterialX_Learn/resources/mtlx/nodedef_materials/';
            var outputs = nodeDef.getActiveOutputs();
            var outputName = outputs[0].getName(); // TODO: Handle swatch for multiple outputs
            var swatchId = swatchLocation + 'material_' + nodeDefName + '_' + outputName + '_genglsl.png';
            swatchId = swatchId.replace('ND_', '');
            if (debug)
                console.log('\n--- Registering node type:', id, '----');
 
 
            definition_code += "\n/**\n"; 
            definition_code += "  * @function "+ functionName + "\n";
            definition_code += "  * @description Library: " + libraryPrefix + ". Category: " + nodeString + ". Type: " + nodeType + "\n";
            definition_code += "  *   LiteGraph id: " + id + "\n"; 
            definition_code += "  */\n";
 
            definition_code += "function " + functionName + "() {\n";
            {
                var nodeGroup = nodeDef.getNodeGroup();
                var nodeString = nodeDef.getNodeString();
                var theIcon = icon;
                if (theIcon.length == 0) {
                    for (var key in editor.ui.icon_map) {
                        if (nodeString.toLowerCase().startsWith(key.toLowerCase())) {
                            if (key in editor.ui.icon_map)
                                theIcon = editor.ui.icon_map[key];
                            //console.log('set icon:', theIcon, 'for:', key, nodeString);
                            break;
                        }
                        else if (nodeGroup.toLowerCase().startsWith(key.toLowerCase())) {
                            if (key in editor.ui.icon_map)
                                theIcon = editor.ui.icon_map[key];
                            //console.log('set icon:', theIcon, 'for:', key, nodeGroup);
                            break;
                        }
                    }
                }
 
                definition_code += "  this.nodedef_icon = '" + theIcon + "';\n";
                definition_code += "  this.nodedef_name = '" + nodeDefName + "';\n";
                definition_code += "  this.nodedef_type = '" + nodeType + "';\n";
                definition_code += "  this.nodedef_node = '" + nodeString + "';\n";
                definition_code += "  this.nodedef_href = 'https://kwokcb.github.io/MaterialX_Learn/documents/definitions/" + nodeString + ".html';\n";
                definition_code += "  this.nodedef_swatch = '" + swatchId + "';\n";
                definition_code += "  this.nodedef_group = '" + nodeGroup + "';\n";
 
                for (var input of nodeDef.getActiveInputs()) {
                    var _name = input.getName();
                    var _type = input.getType();
                    if (_type in TMAP)
                        _type = TMAP[_type];
                    else
                        console.log('Unmappable type:', _type)
                    definition_code += "  this.addInput('" + _name + "','" + _type + "');\n";
 
                    let value = input.getValueString();
                    value = this.getDefaultValue(value, _type);
                    let uiname = input.getAttribute('uiname');
 
                    let uimin = input.getAttribute('uimin');
                    if (uimin.length == 0) {
                        uimin = null;
                    }
                    let uimax = input.getAttribute('uimax');
                    if (uimax.length == 0) {
                        uimax = null;
                    }
                    let uisoftmin = input.getAttribute('uisoftmin');
                    if (uisoftmin.length > 0) {
                        uimin = uisoftmin;
                    }
                    let uisoftmax = input.getAttribute('uisoftmax');
                    if (uisoftmax.length > 0) {
                        uimax = uisoftmax;
                    }
                    var uifolder = input.getAttribute('uifolder');
                    var metaData = this.buildMetaData('', '', '', uiname, uimin, uimax, uifolder, _type);
 
                    // Add colorspace on nodedefs
                    let colorspace = input.getAttribute('colorspace');     
                    let nodeDefType = nodeDef.getType();               
                    if (_type == 'filename' && (nodeDefType == 'color3' || nodeDefType == 'color4'))
                    {
                        if (colorspace.length == 0)
                        {
                            colorspace = 'none';
                        }
                    }
                    if (colorspace.length > 0)
                        metaData['colorspace'] = colorspace;
 
                    // TODO: Add units, unitype on nodedefs. There is no
                    // default unittype or units.
                    let unitAttributes = ['unit', 'unittype'];
                    for (let unitAttribute of unitAttributes)
                    {
                        let value = input.getAttribute(unitAttribute);
                        if (value.length > 0)
                        {
                            metaData[unitAttribute] = value;
                        }
                    }
 
                    // Add in defaultgeomprop to denote geometric inputs.
                    let defaultgeomprop = input.getAttribute('defaultgeomprop')
                    metaData['defaultgeomprop'] = defaultgeomprop;
 
                    // Add enumerations
                    let enums = input.getAttribute('enum');
                    if (enums.length > 0)
                    {                        
                        metaData['enum'] = enums.split(',');
                        metaData['enum'].map(function(x) { return x.trim(); });                
                    }
                    let enumvalues = input.getAttribute('enumvalues');
                    if (enumvalues.length > 0)
                    {                        
                        metaData['enumvalues'] = enumvalues.split(',');
                        metaData['enumvalues'].map(function(x) { return x.trim(); });                
                    }
 
                    metaData = JSON.stringify(metaData);
                    definition_code += "  this.addProperty('" + _name + "', " + value + ", '" + _type + "'," + metaData + ");\n";
                }
                for (var output of nodeDef.getActiveOutputs()) {
                    var _name = output.getName();
                    var _type = output.getType();
                    if (_type in TMAP)
                        _type = TMAP[_type];
                    else
                        console.log('Unmappable type:', _type)
                    //if(_type && _type.constructor === String)
                    //   _type = '"'+_type+'"';
                    definition_code += "  this.addOutput('" + _name + "','" + _type + "');\n";
                }
 
                definition_code += "  this.title = '" + titleName + "';\n"
                var desc = '"MaterialX:' + id + '"';
                definition_code += "  this.desc = " + desc + ";\n";
 
                //definition_code += "  /**\n";
                //definition_code += "   * @function " + "onNodeCreated" + "\n"; 
                //definition_code += "   */";
 
                var onNodeCreated = "function() {\n";
                onNodeCreated += "  //console.log('Node created:', this);\n";
                onNodeCreated += "}";
                definition_code += "  this.onNodeCreated = " + onNodeCreated + "\n";
                var onRemoved = "function() {\n";
                onRemoved += "  //console.log('Node removed:', this);\n";
                onRemoved += "  }";
                definition_code += "  this.onRemoved = " + onRemoved + "\n";
 
                let monitor = editor.monitor;
                var onPropertyChanged = "function(name, value, prev_value) {\n";
                if (monitor)
                {
                    onPropertyChanged += " MxShadingGraphEditor.theEditor.monitor.onPropertyChanged(this.title, name, value, prev_value, this);\n";
                }
                else
                {
                    onPropertyChanged += "    console.log('+ Internal property changed:', this.title, name, value, prev_value, this);\n";
                }
                onPropertyChanged += "  }";
                definition_code += "  this.onPropertyChanged = " + onPropertyChanged + "\n";
 
                var onPropertyInfoChanged = "function(name, info, value, prev_value) {\n";
                if (monitor)
                {
                    onPropertyInfoChanged += " MxShadingGraphEditor.theEditor.monitor.onPropertyInfoChanged(this.title, name, info, value, prev_value, this);\n";
                }
                else
                {
                    onPropertyInfoChanged += "    console.log('+ Internal property info changed:', this.title, name, info, value, prev_value, this);\n";
                }
                onPropertyInfoChanged += "  }"                    
                definition_code += "  this.onPropertyInfoChanged = " + onPropertyInfoChanged + "\n";
 
                // Output connection callback 
                var onConnectOutput = "function(slot, input_type, input, target_node, target_slot) {\n";
                if (monitor)
                {
                    onConnectOutput += " MxShadingGraphEditor.theEditor.monitor.onConnectOutput(slot, input_type, input, target_node, target_slot, this);\n";
                }
                else
                {
                    onConnectOutput += "    console.log('+ Output connection changed:', this.title, slot, input_type, input, target_node, target_slot);\n";
                }
                onConnectOutput += "  }"                    
                definition_code += "  this.onConnectOutput = " + onConnectOutput + "\n";    
 
                // Input connection callback 
                var onConnectInput = "function(target_slot, output_type, output, source, slot) {\n";
                if (monitor)
                {
                    onConnectInput += " MxShadingGraphEditor.theEditor.monitor.onConnectInput(target_slot, output_type, output, source, slot, this);\n";
                }
                else
                {
                    onConnectInput += "    console.log('+ Input connection changed:', this.title, target_slot, output_type, output, source, slot);\n";
                }
                onConnectInput += "  }"                    
                definition_code += "  this.onConnectInput = " + onConnectInput + "\n";
 
                // Set the background color to slate grey
                definition_code += "  this.bgcolor = '#111';\n";
                //console.log('Node group:', nodeGroup, nodeDefName);
                if (nodeGroup == 'conditional') {
                    //console.log('Cond Node group:', nodeGroup)
                    definition_code += "  this.color = '#532200';\n";
                    definition_code += "  this.title_text_color = '#000';\n";
                    definition_code += "  this.shape = LiteGraph.CARD_SHAPE;\n";
                }
 
                else if (nodeString != 'convert' &&
                    (nodeGroup == 'shader' || nodeType == 'surfaceshader' || nodeType == 'volumshader' || nodeType == 'displacementshader')) {
                    definition_code += "  this.color = '#232';\n";
                    definition_code += "  this.shape = LiteGraph.ROUND_SHAPE;\n";
                }
                else if (nodeGroup == 'material') {
                    definition_code += "  this.color = '#151';\n";
                    definition_code += "  this.shape = LiteGraph.BOX_SHAPE;\n";
                }
                else {
                    definition_code += "  this.color = '#222';\n";
                    definition_code += "  this.shape = LiteGraph.ROUND_SHAPE;\n";
                }
                if (nodeType in CMAP) {
                    definition_code += "  this.boxcolor = '" + CMAP[nodeType] + "';\n";
                }
            }
            definition_code += "}\n"
 
            // Register the node type
            definition_code += functionName + ".nodedef_name = '" + nodeDefName + "';\n";
            definition_code += functionName + ".nodedef_node = '" + nodeString + "';\n";
            definition_code += functionName + ".nodedef_href = 'https://kwokcb.github.io/MaterialX_Learn/documents/definitions/" + nodeString + ".html';\n";
 
            definition_code += "LiteGraph.registerNodeType(" + "'" + id + "'," + functionName + ");\n";
            definitionsList.push(id);
            if (debug)
                definition_code += "console.log('Registered node type:', '" + id + "');\n";
        }
 
        //definition_code += "}\n";
        return definition_code;
    }

createValidName()

MxMaterialXHandler::createValidName	(		name,
			msg = null )

Create a valid MaterialX name within the context of the current graph.

Parameters

name	- The name to validate.
msg	- The message to display if the name is invalid.

Returns

The valid name.

Definition at line 3245 of file JsMaterialXNodeEditor.js.

                                      {
        if (name.length == 0) {
            if (msg) {
                msg = 'Setting empty name as "blank"';
            }
            name = "blank";
        }
 
        // Get list of all names in graph.
        var graph = graphcanvas.graph;
        var nodes = graph._nodes;
        var nodenames = [];
        for (var node of nodes) {
            nodenames.push(node.title);
        }
        //console.log('Current graph nodes:', nodenames);
 
        name = ne_mx.createValidName(name);
 
        if (!nodenames.includes(name)) {
            return name;
        }
 
        // Get starting number and root name
        var rootName = name;
        var i = 1;
        var number = name.match(/\d+$/);
        if (number) {
            i = (parseInt(number) + 1)
            rootName = name.slice(0, -number[0].length);
        }
 
        var valid_name = rootName + i.toString();
        while (nodenames.includes(valid_name)) {
            i++;
            valid_name = rootName + i.toString();
        }
        return valid_name;
    }

findRenderableItems()

MxMaterialXHandler::findRenderableItems

(

graph

)

Find all MaterialX renderable items in a graph.

Parameters

graph

- The graph to scan.

Returns

An array of MaterialX renderable items found in the graph.

Definition at line 1103 of file JsMaterialXNodeEditor.js.

                               {
 
        let graphWriteOptions = { writeCustomLibs : false, saveNodePositions: false, writeOutputs : true };
        let mdoc = this.saveGraphToDocument(graph, graphWriteOptions);
        if (!mdoc) {
            console.log('Failed to save graph to document');
            return;
        }
        return this.findRenderableItemsInDoc(mdoc);
    }

findRenderableItemsInDoc()

MxMaterialXHandler::findRenderableItemsInDoc

(

mdoc

)

Find all renderable items in the MaterialX document.

Parameters

mdoc	- The MaterialX document to scan.

Returns

An array of renderable items found in the document.

Definition at line 1120 of file JsMaterialXNodeEditor.js.

                                   {
 
        const materialNodes = mdoc.getMaterialNodes();
        let shaderList = [];
        let renderableItems = [];
 
        for (let i = 0; i < materialNodes.length; ++i) {
            let materialNode = materialNodes[i];
            if (materialNode) {
                //console.log('Scan material: ', materialNode.getNamePath());
                let shaderNodes = ne_mx.getShaderNodes(materialNode)
                if (shaderNodes.length > 0) {
                    let shaderNodePath = shaderNodes[0].getNamePath()
                    if (!shaderList.includes(shaderNodePath)) {
                        //console.log('-- add shader: ', shaderNodePath);
                        shaderList.push(shaderNodePath);
                        renderableItems.push(shaderNodePath);
                    }
                }
            }
        }
        const nodeGraphs = mdoc.getNodeGraphs();
        for (let i = 0; i < nodeGraphs.length; ++i) {
            let nodeGraph = nodeGraphs[i];
            if (nodeGraph) {
                if (nodeGraph.hasAttribute('nodedef') || nodeGraph.hasSourceUri()) {
                    continue;
                }
                // Skip any nodegraph that is connected to something downstream
                if (nodeGraph.getDownstreamPorts().length > 0) {
                    continue
                }
                let outputs = nodeGraph.getOutputs();
                for (let j = 0; j < outputs.length; ++j) {
                    let output = outputs[j];
                    {
                        renderableItems.push(output.getNamePath());
                    }
                }
            }
        }
        const outputs = mdoc.getOutputs();
        for (let i = 0; i < outputs.length; ++i) {
            let output = outputs[i];
            if (output) {
                renderableItems.push(output.getNamePath());
            }
        }
 
        return renderableItems;
    }

getAllFilesRecursive()

MxMaterialXHandler::getAllFilesRecursive

(

dir

)

Recursively collects all file paths in a folder.

Parameters

{string}

dir - Folder path

Returns

{string[]} Array of file paths

Definition at line 2806 of file JsMaterialXNodeEditor.js.

                              {
        // Prefer build-time manifest injection when available to avoid
        // relying on directory index HTML. HtmlWebpackPlugin injects
        // `adsklibFiles` into the page as `window.ADSKLIB_FILES`.
        const webPath = String(dir).replace(/^\/+/, '');
        return (async () => {
            try {
                // If a global manifest was injected, and it contains entries
                // for this folder, use it.
                if (window && Array.isArray(window.ADSKLIB_FILES) && window.ADSKLIB_FILES.length > 0) {
                    const prefix = webPath.replace(/\/+$|^\/+/, '');
                    const matched = window.ADSKLIB_FILES.filter(p => p.startsWith(prefix) || p.startsWith('/' + prefix));
                    if (matched.length > 0) {
                        // Ensure absolute paths
                        return matched.map(p => p.startsWith('/') ? p : '/' + p);
                    }
                }
 
                // Fallback: fetch directory index and parse anchor links.
                const res = await fetch(`/${webPath}/`);
                if (!res.ok) {
                    console.warn('getAllFilesRecursive: directory fetch failed', `/${webPath}/`, res.status);
                    return [];
                }
                const html = await res.text();
                const parser = new DOMParser();
                const doc = parser.parseFromString(html, 'text/html');
                const anchors = Array.from(doc.querySelectorAll('a')).map(a => a.getAttribute('href'));
                const files = anchors
                    .filter(h => h && h.toLowerCase().endsWith('.mtlx'))
                    .map(h => (h.startsWith('/') ? h : `/${webPath}/${h}`));
                // Normalize and deduplicate
                const uniq = Array.from(new Set(files));
                return uniq;
            } catch (e) {
                console.warn('getAllFilesRecursive: error parsing directory', dir, e);
                return [];
            }
        })();
    }

initialize()

MxMaterialXHandler::initialize	(		editor,
			materialFilename )

Initialize the MaterialX handler for the given editor.

Initializes MaterialX and sets up the MaterialX document and standard libraries. If a default MaterialX document is provided, it will be loaded into the editor. The standard libraries are scanned for colorspaces and units, which are cached for later usage.

Parameters

editor	- The editor instance
materialFilename	- The filename of the default MaterialX document to graph

Definition at line 1009 of file JsMaterialXNodeEditor.js.

                                         {
        super.initialize(editor);
 
        if (!ne_mx) {
 
            this.loadMaterialX().then(() => {
 
                // Additional logic after MaterialX is loaded
                editor.debugOutput("Loaded MaterialX version:" + ne_mx.getVersionString(), 0, true);
                doc = ne_mx.createDocument();
 
                var generator = new ne_mx.EsslShaderGenerator.create();
                var genContext = new ne_mx.GenContext(generator);
                stdlib = ne_mx.loadStandardLibraries(genContext);
                editor.debugOutput('Loaded standard libraries definitions:' + stdlib.getNodeDefs().length, 0, false);
 
                // Find units, unittype pairs available. Keep in unique list.
                let units = new Map();
                for (let ud of stdlib.getUnitDefs()) {
                    let unittype = ud.getAttribute('unittype')
                    for (let unit of ud.getChildren()) {
                        units.set(unit.getName(), unittype);
                    }
                }
                // Sort units
                this.setUnits(Array.from(units).sort());
                console.log('> Setup real-world units: ', this.getUnits());
 
                // Find the colorspaces available. Keep in unique list. Hack as there
                // is no way to find a list of colorspaces.
                let colorSpaces = new Set();
                let docNodeDefs = stdlib.getNodeDefs();
                for (let i = 0; i < docNodeDefs.length; i++) {
                    let cmnode = docNodeDefs[i];
                    if (cmnode.getNodeGroup() === 'colortransform') {
                        let name = cmnode.getName();
                        name = name.replace('ND_', '');
                        let namesplit = name.split('_to_');
                        let type = 'color3';
                        if (namesplit[1].includes('color4')) {
                            namesplit[1] = namesplit[1].replace('_color4', '');
                            type = 'color4';
                        } else {
                            namesplit[1] = namesplit[1].replace('_color3', '');
                        }
                        colorSpaces.add(namesplit[0]);
                        colorSpaces.add(namesplit[1]);
                    }
                }
                // Sort the colorspaces
                this.setColorSpaces(Array.from(colorSpaces).sort())
                console.log('Set up colorspaces: ', this.getColorSpaces());
 
                var definitionsList = [];
                var result = this.createLiteGraphDefinitions(stdlib, false, true, definitionsList, 'mtlx', MxShadingGraphEditor.theEditor);
                var definitionsDisplayUpdater = editor.ui.definitionsDisplayUpdater;
                if (definitionsDisplayUpdater) {
                    definitionsDisplayUpdater(result);
                }
 
                editor.clearNodeTypes();
                try {
                    eval(result);
                } catch (e) {
                    editor.debugOutput('Error evaluating source: ' + e, 2, false);
                }
 
                var nodeTypes = LiteGraph.registered_node_types;
                var i = 0;
                for (var typeName in nodeTypes) {
                    i++;
                }
                editor.debugOutput("Registered node types:" + definitionsList.length, 0, false);
 
                editor.displayNodeTypes();
 
                if (materialFilename.length > 0) {
                    this.loadLibraryDocument(editor, materialFilename);
                }
 
                editor.updatePropertyPanel(null);
 
            }).catch((error) => {
                editor.debugOutput("Error on initialization:" + error, 2);
            });
        }
    }

isArray()

MxMaterialXHandler::isArray

(

_type

)

Determines if the specified type is an array type.

Parameters

_type

- The type to check.

Returns

True if the type is an array type, false otherwise.

Definition at line 2240 of file JsMaterialXNodeEditor.js.

                   {
        var ARRAY_TYPES = ['color3', 'color4', 'vector2', 'vector3', 'vector4', 'matrix33', 'matrix44'];
        if (ARRAY_TYPES.includes(_type)) {
            return true;
        }
        return false;
    }

isURI()

MxMaterialXHandler::isURI

(

s

)

Definition at line 2252 of file JsMaterialXNodeEditor.js.

             {
        // Check if the string starts with common URI schemes
        const uriSchemes = ['http://', 'https://', 'ftp://', 'blob:', 'file://', 'data:'];
        return uriSchemes.some(scheme => s.startsWith(scheme));
    }    

loadDefinitionsFromFile()

MxMaterialXHandler::loadDefinitionsFromFile

(

)

Load MaterialX document containing node definitions from a file.

Returns

{void}

Definition at line 2890 of file JsMaterialXNodeEditor.js.

                              {
        var that = this;
 
        // Load mtlx document from disk
        var input = document.createElement("input");
        input.style = this.fontSizeStyle;
        input.type = "file";
        input.accept = ".mtlx";
        input.onchange = function (e) {
            var file = e.target.files[0];
            console.log('Loading definitions from file: ' + file.name);
 
            if (ne_mx) {
                // Load the content from the specified file (replace this with actual loading logic)
 
                const reader = new FileReader();
                reader.readAsText(file, 'UTF-8');
 
                reader.onload = function (e) {
                    // Display the contents of the file in the output div
                    let fileContents = e.target.result;
                    //console.log(fileContents);
 
                    (async () => {
                        try {
                            const readOptions = new ne_mx.XmlReadOptions();
                            readOptions.readXIncludes = false;
                            var customLib = ne_mx.createDocument();
 
                            await ne_mx.readFromXmlString(customLib, fileContents, '', readOptions);
 
                            // Create JS from custom library
                            try {
                                console.log('Create custom library definitions', ne_mx.prettyPrint(customLib));
                                var iconName = '';
                                var scanForIcon = false;
                                if (scanForIcon) {
                                    // Icon name is filename with webp as extension 
                                    var iconName = file.name.replace(/\.[^/.]+$/, ".webp");
                                    // Check if iconName file exists
                                    var iconExists = await that.editor.uriExists(iconName);
                                    if (!iconExists) {
                                        iconName = '';
                                    }
                                }
                                var definitionsList = [];
                                var result = that.createLiteGraphDefinitions(customLib, false, false, definitionsList, 'mtlx', that.editor, iconName);
                                if (result) {
                                    eval(result);
                                    var definitionsListString = definitionsList.join(', ');
                                    that.editor.debugOutput("Registered custom node types: [" + definitionsListString + "]", 0, false);
                                    that.editor.displayNodeTypes();
                                }
                            } catch (e) {
                                console.log('Error evaluating source:', e);
                            }
 
 
                            // Keep track of libraries loaded by filename.
                            customlibs.push([file.name, customLib]);
 
                        } catch (error) {
                            that.editor.debugOutput('Error reading definitions:' + error, 2, false);
                        }
                    })();
 
                };
 
            } else {
                that.editor.debugOutput("MaterialX is not initialized", 2);
            }
 
            //customlibs
        };
        input.click();
    }

loadFolderToDocument()

async MxMaterialXHandler::loadFolderToDocument

(

folderPath

)

Definition at line 2847 of file JsMaterialXNodeEditor.js.

                                           {
        // Browser-only: use getAllFilesRecursive to obtain file URLs and fetch
        // them. Assumes files are served under '/<folderPath>/'.
        let files = [];
        try {
            files = await this.getAllFilesRecursive(folderPath);
            console.log('===================== FOund files, count:', files.length);
        } catch (e) {
            console.error('Error listing files for', folderPath, e);
            return null;
        }
 
        const userlib = ne_mx.createDocument();
        for (const fileUrl of files) {
            try {
                // Ensure URL is absolute-path style
                let fetchUrl = fileUrl;
                if (!fetchUrl.startsWith('/') && !fetchUrl.match(/^https?:\/\//)) {
                    const base = String(folderPath).replace(/^\/+/, '');
                    fetchUrl = `/${base}/${fetchUrl}`;
                }
                console.log('----------- FETCH: ', fetchUrl);
                const res = await fetch(fetchUrl);
                if (!res.ok) {
                    console.error('Failed to fetch', fetchUrl, res.statusText);
                    continue;
                }
                const mtlxString = await res.text();
                const readOptions = new ne_mx.XmlReadOptions();
                await ne_mx.readFromXmlString(userlib, mtlxString, '', readOptions);
 
            } catch (err) {
                console.error('Error loading file', fileUrl, err);
            }
        }

loadFromFile()

MxMaterialXHandler::loadFromFile	(		extension,
			file,
			fileName,
			editor,
			auto_arrange )

Load graph editor from a file.

Parameters

extension	- The extension indicating the format of the file.
file	- The file to load the graph from.
fileName	- The identifier for the source file, or a arbitrary name.
editor	- The graph editor.
auto_arrange	- True to auto-arrange the graph, false otherwise.

Returns

{void}

Definition at line 3134 of file JsMaterialXNodeEditor.js.

                                                                  {
        var debug = false;
 
        if (ne_mx) {
            if (!this.loadMaterialXLibraries(stdlib))
                return;
 
            // Load the content from the specified file (replace this with actual loading logic)
 
            const reader = new FileReader();
            reader.readAsText(file, 'UTF-8');
            reader.accept = '.mtlx';
 
            var that = this;
            console.log('loadFromFile:', file, fileName);
            try {
                reader.onload = function (e) {
                    // Display the contents of the file in the output div
                    let fileContents = e.target.result;
                    console.log("read file: ", file.name, " with extension: ", extension, " and length: ", fileContents.length);
 
                    that.loadFromString('mtlx', fileContents, fileName, auto_arrange, true);
                };
            } catch (error) {
                MxShadingGraphEditor.theEditor.debugOutput('Error reading document: ' + fileName + '. Error: ' + error, 2, false);
            }
 
        } else {
            editor.debugOutput("MaterialX is not initialized", 2, false);
        }
    }

loadFromString()

MxMaterialXHandler::loadFromString	(		extension,
			fileContents,
			fileName,
			auto_arrange,
			rerender = false )

Load graph editor from a string.

Parameters

extension	- The extension indicating the format of the string.
fileContents	- The document string.
fileName	- The identifier for the source file, or a arbitrary name.
auto_arrange	- True to auto-arrange the graph, false otherwise.
rerender	- True to re-render the scene after loading, false otherwise.

Returns

{void}

Definition at line 2977 of file JsMaterialXNodeEditor.js.

                                                                                    {
        if (!ne_mx) {
            console.log('MaterialX is not initialized');
            return;
        }
 
        // Check if we need to pre-convert from extension type to mtlx
        if (extension != 'mtlx')
        {
            let converter = this.getImporter(extension);
            if (converter) {
                let result = converter.import(ne_mx, fileContents, stdlib);
                if (result) {
                    fileContents = result[0];
                } 
                else {
                    console.log('Failed to convert from:', extension, 'to mtlx. Errors:', result[1]);
                    return;
                }
            }    
            else
            {
                console.log('Failed to find converter from:', extension, 'to mtlx.');
                return;
            }
        }    
 
        (async () => {
            try {
                const readOptions = new ne_mx.XmlReadOptions();
                readOptions.readXIncludes = false;
 
                doc.clearContent();
 
                doc.importLibrary(stdlib);
                for (var item of customlibs) {
                    console.log('Import custom library:', item[0]);
                    doc.importLibrary(item[1]);
                }
                var loadDoc = ne_mx.createDocument();
                await ne_mx.readFromXmlString(loadDoc, fileContents, '', readOptions);
 
                // Check if nodedef is not in existingDefs
                //
                var customLib = ne_mx.createDocument();
                customLib.copyContentFrom(loadDoc);
                var keepChildren = [];
                var existingDefs = []
                var saveCustomLib = false;
                doc.getNodeDefs().forEach(def => { existingDefs.push(def.getName()); });
                for (var nodedef of loadDoc.getNodeDefs()) {
                    var nodedefName = nodedef.getName();
                    if (!existingDefs.includes(nodedefName)) {
                        keepChildren.push(nodedef.getName());
                        saveCustomLib = true;
                    }
                }
                for (var ng of loadDoc.getNodeGraphs()) {
                    if (ng.getAttribute('nodedef') && ng.getAttribute('nodedef').length > 0) {
                        saveCustomLib = true;
                        keepChildren.push(ng.getName());
                    }
                }
 
                if (saveCustomLib) {
 
                    for (var child of customLib.getChildren()) {
                        if (!keepChildren.includes(child.getName())) {
                            //console.log('Remove child:', child.getName());
                            customLib.removeChild(child.getName());
                        }
                    }
 
                    var additionDefs = [];
                    console.log('Create custom library definitions from addtionDefs:', 
                        ne_mx.prettyPrint(customLib));
 
                    var result = this.createLiteGraphDefinitions(customLib, true, false, additionDefs, 'mtlx', MxShadingGraphEditor.theEditor);
                    try {
                        eval(result);
                        console.log('Loaded local definitions: ', additionDefs);
                    } catch (e) {
                        console.log('Error evaluating source:', e);
                    }
                }
 
                doc.copyContentFrom(loadDoc);
 
                this.validateDocument(doc);
                
                this.buildGraphFromDoc(doc, MxShadingGraphEditor.theEditor, auto_arrange);
 
                // Must do this after build as build will clear customDocLibs array
                if (saveCustomLib) {
                    customDocLibs.push([fileName, customLib]);
                }
 
                // Get the document's colorspace and set it as the active colorspace
                var documentColorSpace = doc.getColorSpace();
                this.setSourceColorSpace(documentColorSpace);
                documentColorSpace = this.getSourceColorSpace();
                MxShadingGraphEditor.theEditor.updatePropertyPanel(null);
 
                // Cleanup document, and get up-to-date contents after any possible upgrade.
                loadDoc.removeAttribute('fileprefix');
                fileContents = ne_mx.writeToXmlString(loadDoc);
 
                this.validateDocument(loadDoc);
 
                MxShadingGraphEditor.theEditor.debugOutput('Loaded document: "' + fileName + '"', 0, false);
 
                // Update mtlx text area
                let documentDisplayUpdater = MxShadingGraphEditor.theEditor.ui.documentDisplayUpdater;
                if (documentDisplayUpdater) {
                    documentDisplayUpdater(fileContents);
                }
                else {
                    console.log('No docDisplayUpdater!!!');
                }
 
                // Update render items in UI
                let renderableItemUpdater = MxShadingGraphEditor.theEditor.ui.renderableItemUpdater;
                if (renderableItemUpdater) {
                    let renderableItems = this.findRenderableItemsInDoc(doc);
                    if (!renderableItems || renderableItems.length == 0) {
                        MxShadingGraphEditor.theEditor.debugOutput('No renderable items found in graph: ' + fileName, 1, false);
                    }
                    renderableItemUpdater(renderableItems);
                }
 
                // 
                
                if (rerender)
                {
                    console.log('> Update rendering from document');
                    let theRenderer = this.editor.monitor.renderer; 
                    //console.log(this.editor.monitor, this.editor.monitor.renderer)
                    if (theRenderer)
                        theRenderer.updateMaterialFromText(fileContents);
                }
 
            } catch (error) {
                MxShadingGraphEditor.theEditor.debugOutput('Error reading document: ' + fileName + '. Error: ' + error, 2, false);
            }
        })();
    }

loadFromZip()

MxMaterialXHandler::loadFromZip	(		extension,
			file,
			fileName,
			editor,
			auto_arrange,
			rerender = false )

Definition at line 3166 of file JsMaterialXNodeEditor.js.

    {
        if (ne_mx) {
            // Load the content from the specified file (replace this with actual loading logic)
            console.log("Loading content from zip:", file.name);
 
            const reader = new FileReader();
 
            var that = this;
            reader.onload = async function (e) {
                try {
                    const zipData = new Uint8Array(e.target.result); // Convert to Uint8Array
                    const result = await MxZipUtils.unzipMaterialXData(zipData);
                    let documents = result[0];
                    let docText = documents[0].content;
                    let docFile = documents[0].name;
                    console.log('Documents:', docText);
 
                    let textures = result[1];
                    for (let i = 0; i < textures.length; i++) {
                        const url = textures[i].url;
                        const textureName = textures[i].name;
                        // Replace fileName with url in docText.
                        // Do not care about case sensitivity since some examples
                        // from GPUOpen have the incorrect case.
                        docText = docText.replace(new RegExp(textureName, 'i'), url);
                        console.log('Replace reference:' + textureName + ' with blob: ' + url);
 
                    }
                    that.loadFromString('mtlx', docText, docFile, auto_arrange, rerender);
 
                } catch (error) {
                    //editor.debugOutput("MaterialX is not initialized", 2, false);
                    console.error('Error loading ZIP file:', error);
                }
            };
 
            reader.readAsArrayBuffer(file);
 
        } else {
            console.error("MaterialX is not initialized");
        }
    }    

loadInputMetaData()

MxMaterialXHandler::loadInputMetaData	(		node,
			input,
			property_info )

Set the meta-data for the specified input based on LiteGraph node property info.

Parameters

node	- The MaterialX node parent of the input. If parent is a nodegraph then null is passed in.
input	- The input to load the meta-data for.
property_info	- The property info object to load the meta-data into.

Returns

{void}

Definition at line 2414 of file JsMaterialXNodeEditor.js.

                                                  {
        if (input && property_info) {
 
            // Load in basic meta-data
            var colorspace = input.getColorSpace();
            if (colorspace.length > 0)
                property_info['colorspace'] = colorspace;
 
            var unit = input.getUnit();
            if (unit.length > 0)
                property_info['unit'] = unit;
 
            var uiname = input.getAttribute('uiname');
            if (uiname.length > 0)
                property_info['uiname'] = uiname;
 
            var uimin = input.getAttribute('uimin');
            if (uimin.length > 0)
                property_info['uimin'] = uimin;
 
            var uimax = input.getAttribute('uimax');
            if (uimax.length > 0)
                property_info['uimax'] = uimax;
            var uisoftmin = input.getAttribute('uisoftmin');
            if (uisoftmin.length > 0)
                property_info['uimin'] = uisoftmin;
 
            var uisoftmax = input.getAttribute('uisoftmax');
            if (uisoftmax.length > 0)
                property_info['uimax'] = uisoftmax;
 
            var uifolder = input.getAttribute('uifolder');
            if (uifolder.length > 0)
                property_info['uifolder'] = uifolder;
 
            var basicMetaData = ['colorspace', 'unit', 'uiname', 'uimin', 'uimax', 'uifolder', 'name', 'type', 'output', 'nodename', 'nodegraph'];
            for (var attrName of input.getAttributeNames()) {
                if (!basicMetaData.includes(attrName)) {
                    property_info[attrName] = input.getAttribute(attrName);
                }
            }
            
            if (node && input.getType() == 'filename') 
            {
                let nodeType = node.getType();
                let colorTypes = ['color3', 'color4'];
                //console.log('Load input metadata for:', input.getName(), input.getType(), property_info, nodeType);
                if (colorTypes.includes(nodeType))
                {
                    if (!property_info['colorspace']) {
                        console.log('Auto create "none" colorspace for input:', input.getName());
                        let doc = node.getDocument();
                        let defaultColorSpace = 'none';
                        // For now don't use the document color space as 'none' is more flexible.
                        //let docColorSpace = doc.getAttribute('colorspace');
                        //if (docColorSpace.length > 0)
                        //    defaultColorSpace = docColorSpace;
                        property_info['colorspace'] = defaultColorSpace;
                    }
                }
            } 
 
            //console.log('load input metadata for:', input.getNamePath(), property_info);
        }
    }

loadLibraryDocument()

MxMaterialXHandler::loadLibraryDocument	(		editor,
			materialFilename )

Load the MaterialX document from library into the editor.

Parameters

editor	- The editor instance.
materialFilename	- The filename of the library MaterialX document to graph.

Definition at line 977 of file JsMaterialXNodeEditor.js.

                                                  {
 
        function loadInitialText(filePath, handler) {
            try {
                fetch(filePath)
                    .then(response => response.blob())
                    .then(blob => {
                        const reader = new FileReader();
                        reader.onload = function (e) {
                            console.log('Loaded document:', filePath);
                            editor.loadGraphFromString('mtlx', e.target.result, filePath, 80, true);
                        }
                        reader.readAsText(blob);
                    })
            } catch (error) {
                console.error('Error loading file %s:' % filePath, error);
            }
        }
 
        loadInitialText(materialFilename, this);
    }

loadMaterialX()

MxMaterialXHandler::loadMaterialX

(

)

Load in the MaterialX library.

Sets the global ne_mx variable to the MaterialX instance.

Returns

{Promise} A promise that resolves when the MaterialX library is loaded.

Definition at line 950 of file JsMaterialXNodeEditor.js.

                    {
        return new Promise((resolve, reject) => {
            MaterialX().then((ne_mtlx) => {
                // Save the MaterialX instance to the global variable
                ne_mx = ne_mtlx;
                console.log('>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Loaded MaterialX version: ' + ne_mx.getVersionString());
                // Only attempt to auto-load the adsklib if a build-time manifest
                // is available (window.ADSKLIB_FILES). This avoids fetching the
                // directory index (which often returns 404 on static servers).
                if (typeof window !== 'undefined' && Array.isArray(window.ADSKLIB_FILES) && window.ADSKLIB_FILES.length > 0) {
                    let adsklib = this.loadFolderToDocument('Libraries/adsklib');
                } else {
                    console.log('Skipping auto-load of Libraries/adsklib (no manifest available)');
                }
                resolve();
            }).catch((error) => {
                reject(error);
            });
        });
    }

loadMaterialXLibraries()

MxMaterialXHandler::loadMaterialXLibraries

(

stdlib

)

Load MaterialX definition libraries.

Returns

The MaterialX document containing the standard libraries.

Definition at line 3215 of file JsMaterialXNodeEditor.js.

    {
        console.log('------------------------------- LOAD MTLX LIBRARIES -------------------------------');
        if (stdlib)
            return stdlib;
 
        if (!ne_mx) {
            MxShadingGraphEditor.theEditor.debugOutput("MaterialX is not initialized", 2);
            return null;
        }
 
        var generator = new ne_mx.EsslShaderGenerator.create();
        var genContext = new ne_mx.GenContext(generator);
        {
            stdlib = ne_mx.loadStandardLibraries(genContext);
            console.log('Loaded standard libraries:', stdlib.getNodeDefs().length);
        }
 
        let adsklib = this.loadFolderToDocument('./Libraries/adsklib');
 
        return stdlib;
    }

saveGraphToDocument()

MxMaterialXHandler::saveGraphToDocument	(		graph,
			graphWriteOptions )

Saves the graph to a MaterialX document.

Parameters

graph	- The graph to save.
graphWriteOptions	- Options to use when writing the graph.

Returns

The MaterialX document containing the graph.

Definition at line 1808 of file JsMaterialXNodeEditor.js.

                                                  {
 
        if (!ne_mx) {
            this.editor.debugOutput("MaterialX is not initialized", 2);
            return;
        }
        
        let writeCustomLibs = graphWriteOptions.writeCustomLibs;
        if (writeCustomLibs == undefined)
        {
            console.error('Graph output option: writeCustomLibs is undefined.')
            writeCustomLibs = true;
        }
 
        var outputDoc = ne_mx.createDocument();
 
        if (!stdlib) {
            var generator = new ne_mx.EsslShaderGenerator.create();
            var genContext = new ne_mx.GenContext(generator);
            stdlib = ne_mx.loadStandardLibraries(genContext);
        }
 
        // Handle top level
        this.writeGraphToDocument(outputDoc, graph, graphWriteOptions);
 
        let doc_string = ne_mx.writeToXmlString(outputDoc);
        //console.log(doc_string);
        //console.log('-----------------------------------------------')
 
        if (writeCustomLibs) {
            console.log('Write custom libraries:', customlibs.length);
            for (var customlib of customlibs) {
                outputDoc.copyContentFrom(customlib[1]);
            }
            console.log('Write document custom definitions:', customDocLibs.length);
            for (var customDocLib of customDocLibs) {
                outputDoc.copyContentFrom(customDocLib[1]);
            }
        }
 
        // TODO: Add in other globals
        outputDoc.setColorSpace(this.getSourceColorSpace());
        outputDoc.removeAttribute('fileprefix');
 
        this.validateDocument(outputDoc);
 
        return outputDoc;
    }

saveGraphToFile()

MxMaterialXHandler::saveGraphToFile	(		extension,
			graph,
			graphWriteOptions )

Saves the graph to a file with the specified extension.

Parameters

extension	- The file extension to save the graph as.
graph	- The graph to save.
graphWriteOptions	- Options to use when writing the graph.

Returns

{void}

Definition at line 1918 of file JsMaterialXNodeEditor.js.

    {
        var data = this.saveGraphToString(extension, graph, graphWriteOptions);
        if (!data[0]) {
            return;
        }
 
        var blob = new Blob([data[0]], { type: "text/plain" });
        var url = URL.createObjectURL(blob);
        var a = document.createElement("a");
        a.href = url;
        a.download = "output_graph.mtlx";
        a.click();
    }

saveGraphToString()

MxMaterialXHandler::saveGraphToString	(		extension,
			graph,
			graphWriteOptions )

Saves the graph to a string in the specified format.

Parameters

extension	- The file extension to save the graph as.
graph	- The graph to save.
graphWriteOptions	- Options to use when writing the graph.

Returns

An array containing the data string and any error messages.

Definition at line 1865 of file JsMaterialXNodeEditor.js.

                                                           {
 
        if (!ne_mx) {
            this.editor.debugOutput("MaterialX is not initialized", 2);
            return ['', 'MaterialX is not initialized'];
        }
 
        var outputDoc = this.saveGraphToDocument(graph, graphWriteOptions);
        if (!outputDoc) {
            this.editor.debugOutput("Failed to save graph to document", 2);
            return ['', 'Failed to save graph to document'];
        }
 
        if (extension == 'mtlx')
        {
            const writeOptions = new ne_mx.XmlWriteOptions();
            writeOptions.writeXIncludeEnable = false;
            var data = '';
            try {
                data = ne_mx.writeToXmlString(outputDoc, writeOptions);
            } catch (e) {
                this.editor.debugOutput("Failed to write graph:" + e, 2);
            }
            return [data, ''];                
        }
 
        // Look for a registered exporter
        else
        {            
            let exporter = this.getExporter(extension);
            if (!exporter) {
                this.editor.debugOutput('Failed to find ' + extension + ' exporter', 2);
            }
            else { 
                let exportDoc = ne_mx.createDocument();
                exportDoc.copyContentFrom(outputDoc);
                exportDoc.importLibrary(stdlib);
 
                let result = exporter.export(ne_mx, exportDoc);
                return result;
            }
        }
        return ['', 'Failed to export graph to ' + extension];
    }

validateDocument()

MxMaterialXHandler::validateDocument

(

doc

)

Validates the provided MaterialX document.

Parameters

doc	- The MaterialX document to validate.

Returns

True if the document is valid, false otherwise.

Definition at line 1782 of file JsMaterialXNodeEditor.js.

    {
        if (!doc || !stdlib)
        {
            return true;
        }
 
        // Need to create a dummy "validation" doc
        let validationDocument = ne_mx.createDocument();
        validationDocument.copyContentFrom(doc);
        validationDocument.importLibrary(stdlib);
 
        var errors = {};
        var valid = validationDocument.validate(errors);
        if (!valid) {
            this.editor.debugOutput('Failed to validate document:\n' + errors.message, 2);
        }
    }

writeGraphToDocument()

MxMaterialXHandler::writeGraphToDocument	(		mltxgraph,
			graph,
			graphWriteOptions )

Writes the graph to the specified MaterialX document.

Parameters

mltxgraph	- The MaterialX document to write the graph to.
graph	- The graph to write.
graphWriteOptions	- Options to use when writing the graph.

Returns

{void}

Definition at line 1941 of file JsMaterialXNodeEditor.js.

                                                              {
 
        var debug = false;
 
        if (debug)
            console.log('***** START Scan Graph:', graph.title);
        for (var node of graph._nodes) {
            if (node.type == 'graph/subgraph') {
                var subgraph = node.subgraph;
                //var subgraphNode = mltxgraph.addNodeGraph(node.title);
                var subgraphNode = mltxgraph.addChildOfCategory('nodegraph', node.title);
                if (debug)
                    console.log('---->>> Scan NodeGraph:', node.title);
                this.writeGraphToDocument(subgraphNode, subgraph, graphWriteOptions);
                continue;
            }
 
            if (debug)
                console.log('---->>> Scan Node:', node.title);
 
            var nodeDefName = node.nodedef_name;
            /* if (!nodeDefName)
            {
                this.editor.debugOutput('Failed to find nodeDef for:' + node.title, 1);
                continue;
            } */
 
            //var nodeTypes = LiteGraph.registered_node_types;
            //var nodeType = nodeTypes[node.type];
            var nodedefName = node.nodedef_name;
            var nodedef = null;
            var nodeElement = null;
            //if (nodeType) {
            //    nodedefName = nodeType.nodedef_name;
            //    nodedef = stdlib.getNodeDef(nodedefName);
            //}
 
            //if (nodedef) {
            //    nodeElement = mltxgraph.addNodeInstance(nodedef, name)
            //    nodeElement.setName(node.title);
            //}
            //else 
            {
                if (nodedefName) {
                    nodeElement = mltxgraph.addChildOfCategory(node.nodedef_node, node.nodedef_type);
                    nodeElement.setType(node.nodedef_type);                               
 
                    if (graphWriteOptions.saveNodePositions) {
                        // TODO: Get properly remapping for xpos, ypos.
                        nodeElement.setAttribute('xpos', JSON.stringify(node.pos[0]));
                        nodeElement.setAttribute('ypos', JSON.stringify(node.pos[1]));
                    }
                    if (debug)
                        console.log('** Create node:', nodeElement.getNamePath(), nodeElement.getType());
                    nodeElement.setName(node.title);
                }
            }
 
            if (nodeElement) {
                if (debug)
                    console.log('-> Write Node:', graph.title + '/' + node.title, ' --> ', nodeElement.getNamePath());
            }
            else {
                console.log('Skip writing :', node.title);
                //this.editor.debugOutput('No nodedef for:' + node.title + 'Nodetype: ' + node.type, 0);
                continue;
            }
 
            var properties = node.properties;
 
            var node_inputs = node.inputs;
            var isInputNode = false;
            var isOutputNode = false;
            if (nodeElement.getCategory() == 'input') {
                isInputNode = true;
                node_inputs = [node];
            }
            else if (nodeElement.getCategory() == 'output') {
                isOutputNode = true;
                node_inputs = [node];
            }
 
            // Add all outputs if the type is multioutput, or user option set
            if (!isInputNode && !isOutputNode)
            {
                if (node.nodedef_type == "multioutput")
                {                        
                    console.log('Write outputs for:', node, '. type: ', node.nodedef_type);
                    for (var output of node.outputs) {
                        var outputName = output.name;
                        var outputType = output.type;
                        var outputElement = nodeElement.addOutput(outputName, outputType);
                        if (debug) {
                            console.log('> Read: node.nodedef_type: ', node.nodedef_type);
                            console.log('> Write: output:', outputElement.getNamePath(), outputElement.getType());
                        }
                    }
                }                     
            }
 
            // Add inputs
            if (node_inputs) {
 
                var inputs = node_inputs;
                for (var i in inputs) {
                    let input = inputs[i];
                    if (debug)
                        console.log('---- Write port:', input);
 
                    let inputName = input.name;
                    let inputType = input.type;
                    if (nodeElement.getCategory() == 'input' ||
                        nodeElement.getCategory() == 'output') {
                        inputName = 'in';
                        inputType = node.nodedef_type;
                    }
 
                    //var inputType = input.type;
                    var inputElement = null;
                    var nodeToCheck = node;
                    var inputNode = null;
                    var inputLink = null;
                    if (isInputNode && node.graph._subgraph_node) {
                        nodeToCheck = node.graph._subgraph_node;
                        for (var i = 0; i < nodeToCheck.inputs.length; i++) {
                            var nci = nodeToCheck.inputs[i];
                            if (nci.name == node.title) {
                                inputNode = nodeToCheck.getInputNode(i);
                                inputLink = nodeToCheck.getInputLink(i);
                                //console.log('--- Found parent input:', nci.name, 'inputNode:', inputNode, 'inputLink:', inputLink);
                                break;
                            }
                        }
                    }
                    else {
                        inputNode = node.getInputNode(i);
                        inputLink = node.getInputLink(i);
                    }
                    var inputLinkOutput = '';
                    var numInputOutputs = 0;
                    if (inputLink) {
                        numInputOutputs = inputNode.outputs.length;
                        inputLinkOutput = inputNode.outputs[inputLink.origin_slot];
                    }
                    if (inputNode) {
                        //console.log('inputNode', inputNode, 'inputLink:', inputLink, '. --- upsteream Output:', inputLinkOutput);
                        if (nodeElement.getCategory() != 'input' &&
                            nodeElement.getCategory() != 'output') {
                            inputElement = nodeElement.getInput(inputName);
                            //console.log('Call add input on elem', nodeElement, inputName);
                            inputElement = nodeElement.addInput(inputName, inputType);
                        }
                        else {
                            inputElement = nodeElement;
                        }
 
                        if (debug) {
                            console.log('Write connection');
                            console.log('  - TO:', inputElement.getName() + "." + inputName);
                            console.log('  - FROM link:', inputNode.id + "." + inputLinkOutput.name);
                        }
                        if (inputNode.type == 'graph/subgraph') {
                            inputElement.setNodeGraphString(inputNode.title);
                            // Set output string if there was an output link.
                            if (numInputOutputs > 1 && inputLinkOutput) {
                                inputElement.setOutputString(inputLinkOutput.name);
                            }
                        }
                        else {
                            //var upstream_nodeType = nodeTypes[inputNode.type];
                            //if (upstream_nodeType) 
                            //console.log('Write connection: ', inputNode.title)
                            {
                                if (inputNode.nodedef_node == 'input') {
                                    //console.log('Set interface name:', inputNode.title, ' on ', inputElement.getNamePath());
                                    //console.log(inputNode)
                                    inputElement.setInterfaceName(inputNode.title);
                                    //console.log('---------- Get interface name:', inputElement.getInterfaceName());
                                }
                                else {
                                    inputElement.setNodeName(inputNode.title);
                                    // Need to check that upstream has > 1 output.
                                    // TODO: Log issue that this is annoying to disallow an explicit output in validation. 
                                    if (numInputOutputs > 1 && inputNode.nodedef_node != 'output') {
                                        // Set output string if there was an output link.
                                        if (inputLinkOutput) {
                                            inputElement.setOutputString(inputLinkOutput.name);
                                        }
                                    }
                                }
                            }
                        }
                    }
                    else {
 
                        var inputValue = node.properties[inputName];
                        if (inputValue == null) {
                            console.log('Cannot find property value for input:', inputName);
                        }
                        else {
                            var origValue = inputValue;
                            //var inputType = propInfo.type;                            
                            if (['float', 'integer'].includes(inputType)) {
                                inputValue = inputValue.toString();
                            }
                            else if (['vector2', 'vector3', 'vector4', 'matrix33', 'matrix44', 'color3', 'color4'].includes(inputType)) {
                                inputValue = inputValue.toString();
                                inputValue = inputValue.split(',').map(Number).join(', ');
                            }
                            else if (inputType === 'boolean') {
                                if (inputValue === 'true')
                                    inputValue = 'true';
                                else
                                    inputValue = 'false';
                            }
                            else {
                                inputValue = inputValue.toString();
                            }
                            //console.log('Write input:', inputElement, node, inputName, origValue, inputValue, inputType);
                            
                            if (nodeElement.getCategory() != 'input' &&
                                nodeElement.getCategory() != 'output') {
                                inputElement = nodeElement.getInput(inputName);
                                if (!inputElement)
                                    inputElement = nodeElement.addInput(inputName, inputType);
                                else {
                                    // TODO: LiteGraph seems that copy+paste adds same input > once.
                                    console.log('Error> Trying add input more than once:', inputName, ' to node: ', nodeElement.getNamePath());
                                }
                            }
                            else {
                                inputElement = nodeElement;
                            }
 
                            try {
                                inputElement.setValueString(inputValue, inputType);
                            }
                            catch (e) {
                                console.warn("Set value error: ", e);
                            }
                        }
                    }
 
                    if (inputElement) {
 
                        var propInfo = null;
                        var skip_attributes = [];
                        if (isInputNode || isOutputNode) {
                            if (input.properties_info) {
                                // Make sure not to clobber connections like interfacename
                                skip_attributes = ['interfacename', 'nodegraph', 'nodename', 'name', 'type', 'value', 'default_value'];
                                propInfo = input.properties_info[0];
                            }
                        }
                        else {
                            if (node.properties_info) {
                                // Make sure not to clobber connections like interfacename
                                skip_attributes = ['interfacename', 'nodegraph', 'nodename', 'name', 'type', 'value', 'default_value', 'uimin', 'uimax', 'uiname', 'uifolder'];
                                propInfo = node.properties_info[i];
                            }
                        }
                        if (propInfo) {
                            //console.log('Scan propinfo:', propInfo, 'for input:', inputElement.getNamePath(), 'prop_info:', propInfo);
 
                            // Write node_properties metadata to input
                            skip_attributes = skip_attributes.concat(['defaultgeomprop', 'enum', 'enumvalues']);
                            //console.log('SKIP ATTRIBUTES:', skip_attributes);
                            for (var propAttribute in propInfo) {
                                if (skip_attributes.includes(propAttribute))
                                    continue;
 
                                //console.log('-- scan attrib:', propAttribute, 'value:', propInfo[propAttribute]);
                                var propAttributeValue = propInfo[propAttribute];
                                if (propAttributeValue && propAttributeValue.length > 0) {
                                    inputElement.setAttribute(propAttribute, propAttributeValue);
                                }
                            }
                        }
                    }
                }
 
                if (debug)
                    console.log('---- END Write inputs:', node.inputs);
            }
 
            if (debug)
                console.log('---> End write node', node.title);
        }
 
        if (debug)
            console.log('***** END Scan Graph:', graph.title);
    }

Member Data Documentation

userlib

return MxMaterialXHandler::userlib

Definition at line 2882 of file JsMaterialXNodeEditor.js.

---

The documentation for this class was generated from the following file:

• JsMaterialXNodeEditor.js