Javascript class for querying materials from the Physically Based database and creating MaterialX materials. More...

Public Member Functions
	constructor (mtlx_module=null, mtlx_stdlib=null)
	Constructor for the PhysicallyBasedMaterialLoader.
	getJSON ()
	Get the Physically Based Materials as JSON.
	getJSONMaterialNames ()
	Get list of the Physically Based Material names.
	getMaterialXDocument ()
	Get the MaterialX document.
	validateDocument ()
	Validate the MaterialX document.
	getInputRemapping (shadingModel)
	Get the remapping keys for a given shading model.
	getInputRemappingMap ()
	Get remmapping map.
	get_physlib ()
	get_physlib_definition ()
	get_physlib_category ()
	get_physlib_definition_name ()
	get_physlib_implementation_name ()
	get_physlib_materials ()
	get_definitions ()
	map_keys_to_definition (mat, ndef)
	find_all_bxdf (doc)
	derive_translator_name_from_targets (source, target)
	create_translator (doc, source, target, source_version="", target_version="", mappings=null, output_doc)
	create_all_translators (definitions, output_doc=null)
	add_copyright_comment (doc, shaderCategory, embedDate=false)
	create_definition (doc=null)
	create_definition_materials (doc_mat, filter_list=null)
	find_translator (doc, source, target)
	translate_node (doc, source_bxdf, target_bxdf, node)
	initialize_definitions_and_materials (shadingModel='standard_surface', materialNames=[], force=false)
	setDefaultRemapKeys ()
	Set the default remapping keys for different shading models : glTF, OpenPBR, and Autodesk Standard Surface.
	initializeInputRemapping ()
	Initialize the input remapping for different shading models.
	loadMaterialX ()
	Load the MaterialX module.
async	getPhysicallyBasedMaterials ()
	Get the Physically Based Materials from the API.
	loadStandardLibraries ()
	Load the MaterialX standard libraries.
	skipLibraryElement (element)
	Predicate to skip library elements.
	getMaterialXString ()
	Get the MaterialX document as a string.
	addComment (doc, commentString)
	Add a comment to the MaterialX document.
	getReferenceList ()
	Return a sorted list reference names mapped reference images.
	add_copyright_docstring (doc, shaderCategory='')
	Add copyright docstring to the MaterialX document.
	convertToMaterialX (shaderCategory, references, addAllInputs=false, materialNames=[], remapKeys={}, shaderPreFix='')
	Convert the Physically Based Materials to MaterialX.

Public Attributes
	url = ''
	URL to fetch the Physically Based Materials.
	headers = {}
	Headers for the fetch operation.
	materials = null
	List of Physically Based Materials.
	materialNames = []
	List of Physically Based Material names.
	mxMaterialNames = []
	List of MaterialX Material names.
	mx = null
	MaterialX module.
	doc = null
	Working MaterialX document.
	stdlib = null
	MaterialX standard libraries.
	remapMap = {}
	Remap keys for input values for different shading models.

Detailed Description

Javascript class for querying materials from the Physically Based database and creating MaterialX materials.

Definition at line 8 of file JsMaterialXPhysicallyBased.js.

Member Function Documentation

◆ add_copyright_comment()

JsPhysicallyBasedMaterialLoader::add_copyright_comment	(	doc,
		shaderCategory,
		embedDate = false )

Definition at line 462 of file JsMaterialXPhysicallyBased.js.

                                                                {
 
        // Add header comments
        this.addComment(doc, 'Physically Based Materials from https://api.physicallybased.info ');
        this.addComment(doc, '  Content Author: Anton Palmqvist, https://antonpalmqvist.com/ ');
        this.addComment(doc, `  Content processsed via REST API and mapped to MaterialX V${this.mx.getVersionString()} `);
        if (shaderCategory) {
            this.addComment(doc, `  Target Shading Model: ${shaderCategory} `);
        }
        this.addComment(doc, '  Utility Author: Bernard Kwok. kwokcb@gmail.com ');
        if (embedDate) {
            const now = new Date();
            const dt_string = now.getFullYear() + '-' + String(now.getMonth() + 1).padStart(2, '0') + '-' + String(now.getDate()).padStart(2, '0') + ' ' + String(now.getHours()).padStart(2, '0') + ':' + String(now.getMinutes()).padStart(2, '0') + ':' + String(now.getSeconds()).padStart(2, '0');
            this.addComment(doc, `  Generated on: ${dt_string} `);
        }
    }

◆ add_copyright_docstring()

JsPhysicallyBasedMaterialLoader::add_copyright_docstring	(		doc,
			shaderCategory = '' )

Add copyright docstring to the MaterialX document.

Parameters

doc	MaterialX document
shaderCategory	- MaterialX shader category (optional)

Definition at line 1033 of file JsMaterialXPhysicallyBased.js.

    {
        // Add document level accreditation
        let docString = 'Physically Based Materials from https://api.physicallybased.info.\n'
        docString += '  Content Author: Anton Palmqvist, https://antonpalmqvist.com/ \n'
        docString += `  Content processsed via REST API and mapped to MaterialX V${this.mx.getVersionString()} \n`
        if (shaderCategory.length > 0) {
            docString +=  `  Target Shading Model: ${shaderCategory} \n`
        }
        docString +=  '  Utility Author: Bernard Kwok. kwokcb@gmail.com '  
        doc.setDocString(docString);
    }

◆ addComment()

JsPhysicallyBasedMaterialLoader::addComment	(		doc,
			commentString )

Add a comment to the MaterialX document.

Parameters

doc	- MaterialX document
commentString	- Comment string to add

Definition at line 994 of file JsMaterialXPhysicallyBased.js.

    {
        let comment = doc.addChildOfCategory('comment')
        comment.setDocString(commentString)
    }

◆ constructor()

JsPhysicallyBasedMaterialLoader::constructor	(		mtlx_module = null,
			mtlx_stdlib = null )

Constructor for the PhysicallyBasedMaterialLoader.

Returns: {void}

Definition at line 60 of file JsMaterialXPhysicallyBased.js.

    {
        this.url = 'https://api.physicallybased.info/materials';
        this.headers = { 'Accept': 'application/json' };
 
        this.materials = null;
        this.materialNames = [];
 
        this.mxMaterialNames = [];
        this.mx = null;
        if (mtlx_module) {
            this.mx = mtlx_module;
        }
        this.stdlib = null;
        if (mtlx_stdlib) {
            this.stdlib = mtlx_stdlib;
        }
        this.doc = null;
 
        this.initializeInputRemapping();
 
        this.physlib = null;
        // PhysicallyBased MaterialX surface definition name
        this.physlib_definition_name = "ND_PhysicallyBasedMaterial";
        // PhysicallyBased MaterialX surface implementation (nodegraph) name
        this.physlib_implementation_name = "NG_PhysicallyBasedMaterial";
        // PhysicallyBased MaterialX surface category
        this.physlib_category = "physbased_pbr_surface"
        // Document containing PhysicallyBased materials using PhysicallyBasedMaterial definition
        this.physlib_materials = null
        // Document containing PhysicallyBased MaterialX translators
        this.physlib_translators = null
        // All MaterialX definitions (standard library + PhysicallyBased definition + translators)
        this.all_lib = null;
        // Translated materials keyed by shading model
        this.translated_materials = {};
    }

◆ convertToMaterialX()

JsPhysicallyBasedMaterialLoader::convertToMaterialX	(	shaderCategory,
		references,
		addAllInputs = false,
		materialNames = [],
		remapKeys = {},
		shaderPreFix = '' )

Convert the Physically Based Materials to MaterialX.

Parameters

shaderCategory	- MaterialX shader category
addAllInputs	- Add all inputs from node definitions
materialNames	- List of material names to convert. If empty all materials are converted
remapKeys	- Remap keys to MaterialX shader inputs. If not specified the default remap keys are used if any.
shaderPreFix	- Prefix for the shader name. Default is empty
references	- List of references found. (returned). Each reference is a object: { name: string, reference: string }

Returns: True if the conversion is successful. False otherwise

Definition at line 1056 of file JsMaterialXPhysicallyBased.js.

                                                                                                   {}, shaderPreFix = '') 
    {
        if (!this.mx) {
            console.error('MaterialX module is not loaded');
            return false;
        }
 
        if (!this.materials) {
            console.warn('No Physically Based Materials to convert');
            return false;
        }
 
        if (Object.keys(remapKeys).length === 0)
        {
            remapKeys = this.getInputRemapping(shaderCategory);
        }
        //console.log('Using remap keys for shading model:', shaderCategory, remapKeys);
 
        // Create a dummy doc with the surface shader with all inputs
        // as reference
        let refDoc = this.mx.createDocument();
        refDoc.importLibrary(this.stdlib);
        const refNode = refDoc.addNode(shaderCategory, 'refShader', this.mx.SURFACE_SHADER_TYPE_STRING);
        if (addAllInputs) {
            console.warn('MaterialX JS API missing addInputsFromNodeDef()');
            //refNode.addInputsFromNodeDef() -- This is missing from the JS API.
        }
        this.doc = this.mx.createDocument();
 
        // Add document level accreditation
        this.add_copyright_docstring(this.doc, shaderCategory);
 
        // Add properties to the material
        for (let i = 0; i < this.materials.length; i++) {
            const mat = this.materials[i];
            let matName = mat['name'];
 
            // Filter by material name(s)
            let skipGeneration = materialNames.length > 0 && !materialNames.includes(matName);
 
            let shaderNode = null;
            let docString = ''
            if (!skipGeneration) 
            {
                if (shaderPreFix.length > 0) {
                    matName = shaderPreFix + '_' + matName;
                }
 
                const shaderName = this.doc.createValidChildName(matName + '_' + shaderCategory + '_SPB');
                this.addComment(this.doc, ' Generated shader: ' + matName + ' ');
                shaderNode = this.doc.addNode(shaderCategory, shaderName, this.mx.SURFACE_SHADER_TYPE_STRING);
 
                const category = mat['category'];
                const group = mat['group'];
                let uifolder = '';
                if (category && category.length > 0) {
                    uifolder = category[0];
                }
                if (group && group.length > 0) {
                    if (uifolder.length > 0) {
                        uifolder += '/';
                    }
                    uifolder += group[0];
                }
                if (uifolder.length > 0) {
                    shaderNode.setAttribute('uifolder', uifolder);
                }
 
                if (mat['description'].length > 0) {
                    docString += 'Description: ' + mat['description'];
                }
            }
 
            // Always want to build the reference
            const refString = mat['reference'];
            if (refString.length > 0) {
                if (docString.length > 0) {
                    docString += '. ';
                }
                docString += 'Reference: ' + refString[0];
 
                let referenceItem = { name: matName, reference: refString[0] };
                //console.log('Add Reference:', referenceItem);
                references.push(referenceItem);
            }
            // Sort references by name
            references.sort((a, b) => a.name.localeCompare(b.name));
 
            if (!shaderNode) {
                continue;
            }
            if (docString.length > 0) {
                shaderNode.setDocString(docString);
            }
 
            // Create a new material
            const materialName = this.doc.createValidChildName(matName + '_' + shaderCategory + '_MPB');
            this.addComment(this.doc, ' Generated material: ' + matName + ' ');
            const materialNode = this.doc.addNode(this.mx.SURFACE_MATERIAL_NODE_STRING, materialName, this.mx.MATERIAL_TYPE_STRING);
            const shaderInput = materialNode.addInput(this.mx.SURFACE_SHADER_TYPE_STRING, this.mx.SURFACE_SHADER_TYPE_STRING);
            shaderInput.setAttribute(MTLX_NODE_NAME_ATTRIBUTE, shaderNode.getName());
 
            // Warning this is a bit bespoke for remapping keys
            // to Autodesk Standard Surface shader inputs
            const skipKeys = ['name', "density", "category", "description", "sources", "tags", "reference"];
 
            let metallness = null;
            let roughness = null;
            let transmission_color = null;
            let transmission = null;
            Object.entries(mat).forEach(([key, value]) => {
 
                if (!skipKeys.includes(key)) {
 
                    //console.log(`-- Processing key: "${key}" with value:`, value);
 
                    if (key == 'metalness') {
                        metallness = value;
                        //console.log('Metalness:', metallness);
                    }
                    if (key == 'roughness') {
                        roughness = value;
                        //console.log('Roughness:', roughness);
                    }
                    if (key == 'transmission') {
                        transmission = value;
                        //console.log('Transmission:', transmission);
                    }
                    if (key == 'color') {
                        transmission_color = value;
                        //console.log('Color:', color);
                    }    
 
                    //console.log(`-- Remapping key "${key}" to "${remapKeys[key]}"`);
                    if (remapKeys[key]) {
                        key = remapKeys[key];
                    }
 
                    let refInput = refNode.getInput(key);
                    if (!refInput)
                        refInput = refNode.addInputFromNodeDef(key);
                    if (refInput) {
                        const input = shaderNode.addInput(key);
                        input.copyContentFrom(refInput);
                        if (input) {
                            // Convert number vector to string
                            if (Array.isArray(value)) {
                                value = value.join(',');
                            }
                            // Convert number to string
                            else if (typeof value === 'number') {
                                value = value.toString();
                            }
                            // Note: This API has side-effects as the
                            // type is set to "string" when the value is set. Thus
                            // we must explicitly set the type here.
                            input.setValueString(value, refInput.getType());
                        }
                    }
                    else {
                        //console.log('>> Could not map input:', key, 'to node definition')
                    }
                }
            });
 
            if (transmission !== null && metallness !== null && roughness !== null && transmission_color !== null) 
            {
                if (metallness == 0 && roughness == 0) 
                {
                    if (remapKeys['transmission_color']) {
                        let inputName = remapKeys['transmission_color'];
                        let input = shaderNode.addInput(inputName);
                        if (input) {
                            let value = transmission_color.join(',');
                            //console.log(`Add "${inputName}": "${value}"`);
                            input.setValueString(value, 'color3');
                        }
                    }
                }
            };                
        }
        return true;
    }

◆ create_all_translators()

JsPhysicallyBasedMaterialLoader::create_all_translators	(		definitions,
			output_doc = null )

Create translators for all supported shading models.

Parameters

{object}	definitions - The source document containing Physically Based MaterialX definitions.
{object}	output_doc - The document to add the translators to. If null, use the source doc.

Returns: {object[]} A list of created translator definitions.

Definition at line 418 of file JsMaterialXPhysicallyBased.js.

                                                         {
        let trans_nodedefs = [];
        // Create temporary doc with all standard library definitions
        //let result = this.create_working_document();
        let trans_doc = this.mx.createDocument();
        let stdlib_defs = this.stdlib.getNodeDefs();
        console.log('> --------------------->>>>>>>>>> Use stdlib', stdlib_defs.length, 'definitions');
        trans_doc.setDataLibrary(this.stdlib);
 
        // Add Physically Based Material definitions to the temporary document
        trans_doc.copyContentFrom(definitions);
        this.add_copyright_docstring(output_doc, '');
        if (!output_doc) {
            console.log('No output document specified for translators');
            return trans_nodedefs;
        }
        // Source BSDF is always physbased_pbr_surface
        let source_bsdf = this.physlib_category;
        // Iterate over all target BSDFs
        let bsdfs = this.find_all_bxdf(trans_doc);
        for (let bsdf of bsdfs) {
            let bsdf_name = bsdf.getNodeString();
            if (bsdf_name === this.physlib_category) {
                continue;
            }
            let target_bsdf = bsdf.getNodeString();
            let remapping = this.getInputRemapping(target_bsdf);
            if (remapping && Object.keys(remapping).length > 0) {
                let trans_nodedef = this.create_translator(trans_doc, source_bsdf, target_bsdf, "", "", remapping, output_doc);
                if (trans_nodedef) {
                    console.log(`> Created translator to BSDF: ${bsdf_name}`);
                    trans_nodedefs.push(trans_nodedef);
                }
            }
        }
        return trans_nodedefs;
    }

◆ create_definition()

JsPhysicallyBasedMaterialLoader::create_definition ( doc = null )

Create a NodeDef for the Physically Based Material inputs

Parameters

{object|null} doc - The MaterialX document to add the NodeDef to. If null, a new document will be created.

Returns: {object} The MaterialX document with the created definition.

Definition at line 479 of file JsMaterialXPhysicallyBased.js.

                                {
        if (!doc) {
            doc = this.mx.createDocument();
            this.add_copyright_docstring(doc, '');
        }
        
        // Create placeholder nodegraph
        let graph = doc.addNodeGraph(this.get_physlib_implementation_name());
        graph.setNodeDefString(this.get_physlib_definition_name());
        let node = graph.addNode('oren_nayar_diffuse_bsdf', 'oren_nayar_diffuse_bsdf', 'BSDF');
        let node_in = node.addInput('color', 'color3');
        node_in.setInterfaceName('color');
        let node_in_rough = node.addInput('roughness', 'float');
        node_in_rough.setInterfaceName('roughness');
        node.addOutput('out', 'BSDF');
        node = graph.addNode('surface', 'surface', 'surfaceshader');
        node_in = node.addInput('bsdf', 'BSDF');
        node_in.setAttribute('out', 'out');
        node_in.setNodeName('oren_nayar_diffuse_bsdf');
        let node_out = graph.addOutput('out', 'surfaceshader');
        node_out.setNodeName('surface');
        
        // Create definition template
        let ndef = doc.addNodeDef(this.get_physlib_definition_name(), 'surfaceshader');
        ndef.setNodeString(this.physlib_category);
        ndef.setNodeGroup("pbr");
        ndef.setDocString("Node definitions for PhysicallyBased Material");
        ndef.setVersionString("1.0");
        ndef.setAttribute("isdefaultversion", "true");
 
        if (this.materials) {
            console.log('> Map keys to definition for materials:', this.materials.length);
            for (let mat of this.materials) {
                this.map_keys_to_definition(mat, ndef);
            }
        }
        else {
            console.log('>  No materials to map keys to definition');
        }
        return doc;
    }

◆ create_definition_materials()

JsPhysicallyBasedMaterialLoader::create_definition_materials	(		doc_mat,
			filter_list = null )

Create a MaterialX document containing Physically Based MaterialX materials

Parameters

{object\|null}	doc_mat - The MaterialX document to add the materials to
{string[]\|null}	filter_list - A list of material names to filter. If null, all materials will be processed.

Returns: {object} The MaterialX document containing the materials

Definition at line 526 of file JsMaterialXPhysicallyBased.js.

                                                           {
        let definitions = this.get_definitions();
        if (!doc_mat) {
            doc_mat = this.mx.createDocument();
            this.add_copyright_docstring(doc_mat, '');
        }
        // Reference the library definitions into the material document
        doc_mat.setDataLibrary(definitions);
        for (let mat of this.materials) {
 
            let matName = mat['name'];
            if (filter_list && !filter_list.includes(matName)) {
                continue;
            }
 
            let shaderName = doc_mat.createValidChildName(matName + '_SHD_PBM');
            //console.log('************* Create material for:', mat['name'], '-> shader name:', shaderName, filter_list);
 
            let shaderNode = doc_mat.addNode(this.physlib_category, shaderName, this.mx.SURFACE_SHADER_TYPE_STRING);
            for (let [key, value] of Object.entries(mat)) {
                if (!value){
                    continue;
                }
 
                if (key === 'name') {
                    let new_name = doc_mat.createValidChildName(String(value));
                    shaderNode.setName(new_name);
                }
                let input = shaderNode.addInputFromNodeDef(key);
                if (input) {
                    //console.log('> Add input for key:', key, 'value:', value, 'input:', input.getName());
                    if (Array.isArray(value)) {
                        value = value.map(x => String(x)).join(', ');
                    }
                    input.setValueString(String(value), input.getType());
                    // Add doc string
                    let doc_string = '';
                    if (key === 'description') {
                        doc_string = String(value);
                    }
                    if (doc_string.length > 0) {
                        shaderNode.setDocString(doc_string);
                    }
                }
            }
            shaderNode.setAttribute('uiname', matName);
 
            // Create a new material
            let materialName = doc_mat.createValidChildName(matName + '_MAT_PBM');
            let materialNode = doc_mat.addNode(this.mx.SURFACE_MATERIAL_NODE_STRING, materialName, this.mx.MATERIAL_TYPE_STRING);
            let shaderInput = materialNode.addInput(this.mx.SURFACE_SHADER_TYPE_STRING, this.mx.SURFACE_SHADER_TYPE_STRING);
            shaderInput.setAttribute(MTLX_NODE_NAME_ATTRIBUTE, shaderNode.getName());
        }
        return doc_mat;
    }

◆ create_translator()

JsPhysicallyBasedMaterialLoader::create_translator	(	doc,
		source,
		target,
		source_version = "",
		target_version = "",
		mappings = null,
		output_doc )

Create a translator nodedef and nodegraph from source to target definitions.

Parameters

{object}	doc - The source document containing the definition.
{string}	source - The source definition category.
{string}	target - The target definition category.
{string}	source_version - The source version string. If empty, use the first source definition version found.
{string}	target_version - The target version string. If empty, use the first target definition version found.
{object}	mappings - A dictionary mapping source input names to target input names.
{object}	output_doc - The document to add the translator to. If null, use the source doc.

Returns: {object|null} The created translator definition.

Definition at line 297 of file JsMaterialXPhysicallyBased.js.

                                                                                                            {
        if (!output_doc) {
            return null;
        }
        // Get source and target nodedefs
        let nodedefs = this.find_all_bxdf(doc);
        let source_nodedef = null;
        let target_nodedef = null;
        for (let nodedef of nodedefs) {
            if (nodedef.getNodeString() === source) {
                if (source_version === "" || nodedef.getVersionString() === source_version) {
                    source_nodedef = nodedef;
                }
            }
            if (nodedef.getNodeString() === target) {
                if (target_version === "" || nodedef.getVersionString() === target_version) {
                    target_nodedef = nodedef;
                }
            }
        }
        if (!source_nodedef || !target_nodedef) {
            if (!source_nodedef) {
                console.warn(`Source nodedef not found for '${source}' with version '${source_version}'`);
            }
            if (!target_nodedef) {
                console.warn(`Target nodedef not found for '${target}' with version '${target_version}'`);
            }
            return null;
        }
        //console.log('******* Source nodedef:\n', this.mx.prettyPrint(source_nodedef));
 
        // 1. Add a new nodedef for the translator
        let derived_name = this.derive_translator_name_from_targets(source, target);
        let nodename = derived_name.startsWith("ND_") ? derived_name.substring(3) : derived_name;
        let translator_nodedef = output_doc.getNodeDef(derived_name);
        if (translator_nodedef) {
            console.log(`> Translator NodeDef already exists: ${target_nodedef.getName()}`);
            return translator_nodedef;
        }
        else {
            console.log(`> Creating Translator NodeDef: ${nodename} from '${source}' to '${target}'`);
        }
 
        translator_nodedef = output_doc.addNodeDef(derived_name);
        translator_nodedef.removeOutput("out");
        translator_nodedef.setNodeString(nodename);
        translator_nodedef.setNodeGroup("translation");
        translator_nodedef.setDocString(`Translator from '${source}' to '${target}'`);
        let version1 = source_nodedef.getVersionString();
        if (!version1) version1 = "1.0";
        translator_nodedef.setAttribute('source_version', version1);
        translator_nodedef.setAttribute('source', source);
        let version2 = target_nodedef.getVersionString();
        if (!version2) version2 = "1.0";
        translator_nodedef.setAttribute('target_version', version2);
        translator_nodedef.setAttribute('target', target);
        
        // Add inputs from source as inputs to the translator
        let comment = translator_nodedef.addChildOfCategory("comment");
        comment.setDocString(`Inputs (inputs from source '${source}')`);
        let inputs = source_nodedef.getActiveInputs();
        //console.log('>>>>>>>>>>>>>> ADD Inputs from source nodedef:', inputs.length);
        for (let input of inputs) {
            //console.log('-------------------------- Input:', input.getName(), input.getType());
            let nodedef_input = translator_nodedef.addInput(input.getName(), input.getType());
            if (input.hasValueString()) {
                nodedef_input.setValueString(input.getValueString(), input.getType());
            }
        }
        
        // Add inputs from target as outputs to the translator
        comment = translator_nodedef.addChildOfCategory("comment");
        comment.setDocString(`Outputs (inputs from target '${target}' with '_out' suffix)`);
        for (let input of target_nodedef.getActiveInputs()) {
            let output_name = input.getName() + "_out";
            translator_nodedef.addOutput(output_name, input.getType());
        }
        // 2. Create a new functional nodegraph
        comment = output_doc.addChildOfCategory("comment");
        comment.setDocString(`NodeGraph implementation for translator '${nodename}'`);
        let nodegraph_id = 'NG_' + nodename;
        let nodegraph = output_doc.addNodeGraph(nodegraph_id);
        nodegraph.setNodeDefString(derived_name);
        nodegraph.setDocString(`NodeGraph implementation of translator from '${source}' to '${target}'`);
        nodegraph.setAttribute('source_version', version1);
        nodegraph.setAttribute('source', source);
        nodegraph.setAttribute('target_version', version2);
        nodegraph.setAttribute('target', target);
        for (let output of translator_nodedef.getActiveOutputs()) {
            nodegraph.addOutput(output.getName(), output.getType());
        }
        if (mappings) {
            for (let [source_input_name, target_input_name] of Object.entries(mappings)) {
                let source_input = translator_nodedef.getInput(source_input_name);
                let output_name = target_input_name + "_out";
                let target_output = nodegraph.getOutput(output_name);
                if (source_input && target_output) {
                    let dot_name = nodegraph.createValidChildName(target_input_name);
                    let comment = nodegraph.addChildOfCategory("comment");
                    comment.setDocString(`Routing source input: '${source_input_name}' to target input: '${target_input_name}'`);
                    let dot_node = nodegraph.addNode('dot', dot_name);
                    let dot_input = dot_node.addInput('in', source_input.getType());
                    dot_input.setInterfaceName(source_input.getName());
                    target_output.setNodeName(dot_node.getName());
                }
            }
        }
        return translator_nodedef;
    }

◆ derive_translator_name_from_targets()

JsPhysicallyBasedMaterialLoader::derive_translator_name_from_targets	(		source,
			target )

Definition at line 292 of file JsMaterialXPhysicallyBased.js.

    {
        return `ND_${source}_to_${target}`;
    }

◆ find_all_bxdf()

JsPhysicallyBasedMaterialLoader::find_all_bxdf ( doc )

Definition at line 279 of file JsMaterialXPhysicallyBased.js.

                       {
        // Scan all nodedefs with output type of "surfaceshader"
        let bxdfs = [];
        for (let nodedef of doc.getNodeDefs()) {
            if (nodedef.getType() === "surfaceshader") {
                if (nodedef.getNodeString() !== "convert" && nodedef.getNodeString() !== "surface" && nodedef.getNodeGroup() === "pbr") {
                    bxdfs.push(nodedef);
                }
            }
        }
        return bxdfs;
    }

◆ find_translator()

JsPhysicallyBasedMaterialLoader::find_translator	(	doc,
		source,
		target )

Find a translator nodedef from source to target in the document.

Parameters

{object}	doc - The MaterialX document to search.
{string}	source - The source definition category.
{string}	target - The target definition category.

Returns: {object|null} The translator nodedef if found, otherwise null.

Definition at line 588 of file JsMaterialXPhysicallyBased.js.

                                         {
        let derived_name = this.derive_translator_name_from_targets(source, target);
        let translator_nodedef = doc.getNodeDef(derived_name);
        return translator_nodedef;
    }

◆ get_definitions()

JsPhysicallyBasedMaterialLoader::get_definitions ( )

Definition at line 200 of file JsMaterialXPhysicallyBased.js.

                      {
        // Get a combined MaterialX document containing the standard library and Physically Based MaterialX definition and translators.
        if (!this.all_lib) {
            this.all_lib = this.mx.createDocument();
            this.all_lib.copyContentFrom(this.stdlib);
            if (this.physlib) {
                this.all_lib.copyContentFrom(this.physlib);
            }
            if (this.physlib_translators) {
                this.all_lib.copyContentFrom(this.physlib_translators);
            }
        }
        return this.all_lib;
    }

◆ get_physlib()

JsPhysicallyBasedMaterialLoader::get_physlib ( )

Definition at line 167 of file JsMaterialXPhysicallyBased.js.

                  {
        // Get the Physically Based MaterialX definition library.
        return this.physlib;
    }

◆ get_physlib_category()

JsPhysicallyBasedMaterialLoader::get_physlib_category ( )

Definition at line 180 of file JsMaterialXPhysicallyBased.js.

                           {
        // Get the Physically Based MaterialX surface category.
        return this.physlib_category;
    }

◆ get_physlib_definition()

JsPhysicallyBasedMaterialLoader::get_physlib_definition ( )

Definition at line 172 of file JsMaterialXPhysicallyBased.js.

                             {
        // Get the Physically Based MaterialX definition NodeDef.
        if (this.physlib) {
            return this.physlib.getNodeDef(this.get_physlib_definition_name());
        }
        return null;
    }

◆ get_physlib_definition_name()

JsPhysicallyBasedMaterialLoader::get_physlib_definition_name ( )

Definition at line 185 of file JsMaterialXPhysicallyBased.js.

                                  {
        // Get the Physically Based MaterialX definition name.
        return this.physlib_definition_name;
    }

◆ get_physlib_implementation_name()

JsPhysicallyBasedMaterialLoader::get_physlib_implementation_name ( )

Definition at line 190 of file JsMaterialXPhysicallyBased.js.

                                      {
        // Get the Physically Based MaterialX implementation (nodegraph) name.
        return this.physlib_implementation_name;
    }

◆ get_physlib_materials()

JsPhysicallyBasedMaterialLoader::get_physlib_materials ( )

Definition at line 195 of file JsMaterialXPhysicallyBased.js.

                            {
        // Get the Physically Based MaterialX materials document.
        return this.physlib_materials;
    }

◆ getInputRemapping()

JsPhysicallyBasedMaterialLoader::getInputRemapping ( shadingModel )

Get the remapping keys for a given shading model.

Parameters

shadingModel - Shading model to get the remapping keys

Returns: Remapping keys for the shading model. Empty object if not found

Definition at line 146 of file JsMaterialXPhysicallyBased.js.

    {
        if (shadingModel in this.remapMap) {
            return this.remapMap[shadingModel];
        }
        else
        {
            console.log('>> No remap keys for shading model:', shadingModel);
        }
        return {};
    }

◆ getInputRemappingMap()

JsPhysicallyBasedMaterialLoader::getInputRemappingMap ( )

Get remmapping map.

Returns: {object} - Remapping map

Definition at line 162 of file JsMaterialXPhysicallyBased.js.

    {
        return this.remapMap;
    }

◆ getJSON()

JsPhysicallyBasedMaterialLoader::getJSON ( )

Get the Physically Based Materials as JSON.

Returns: {object[]} - List of Physically Based Materials

Definition at line 102 of file JsMaterialXPhysicallyBased.js.

    {
        return this.materials
    }

◆ getJSONMaterialNames()

JsPhysicallyBasedMaterialLoader::getJSONMaterialNames ( )

Get list of the Physically Based Material names.

Definition at line 110 of file JsMaterialXPhysicallyBased.js.

    {
        return this.materialNames
    }

◆ getMaterialXDocument()

JsPhysicallyBasedMaterialLoader::getMaterialXDocument ( )

Get the MaterialX document.

Definition at line 118 of file JsMaterialXPhysicallyBased.js.

    {
        return this.doc;
    }

◆ getMaterialXString()

JsPhysicallyBasedMaterialLoader::getMaterialXString ( )

Get the MaterialX document as a string.

Returns: {string} - MaterialX document as a string. Empty string if no document

Definition at line 971 of file JsMaterialXPhysicallyBased.js.

    {
        if (!this.doc) {
            console.error('No MaterialX document to convert');
            return '';
        }
 
        // Create write options
        const writeOptions = new this.mx.XmlWriteOptions();
        writeOptions.writeXIncludeEnable = false;
        //writeOptions.writeXIncludes = false;
        writeOptions.elementPredicate = this.skipLibraryElement;
 
        // Convert the MaterialX document to a string
        const mtlx = this.mx.writeToXmlString(this.doc, writeOptions);
        return mtlx;
    }

◆ getPhysicallyBasedMaterials()

async JsPhysicallyBasedMaterialLoader::getPhysicallyBasedMaterials ( )

Get the Physically Based Materials from the API.

Returns: {object[]} - List of Physically Based Materials in JSON format

Definition at line 898 of file JsMaterialXPhysicallyBased.js.

    {
        try {
            // Re-initialize cached information
            this.materials = null
            this.materialNames = [];
            this.physlib = null;
            this.physlib_materials = null;
            this.physlib_translators = null;
            this.translated_materials = {};
 
            const response = await fetch(this.url, {
                method: 'GET',
                headers: this.headers
            });
 
            if (!response.ok) {
                throw new Error('Network response was not ok ' + response.statusText);
            }
 
            this.materials = await response.json();
            for (let i = 0; i < this.materials.length; i++) {
                this.materialNames.push(this.materials[i]['name']);
            }
            return this.materials;
        } catch (error) {
            console.error('There has been a problem with your fetch operation:', error);
        }
 
        return null;
    }

◆ getReferenceList()

JsPhysicallyBasedMaterialLoader::getReferenceList ( )

Return a sorted list reference names mapped reference images.

Returns: {object[]} - List of references.

Definition at line 1005 of file JsMaterialXPhysicallyBased.js.

    {
        let references = [];
        if (this.materials) {
            for (let i = 0; i < this.materials.length; i++) {
                const mat = this.materials[i];
                const matName = mat['name'];
                const refString = mat['reference']; 
                const tags = mat['tags'];
                const category = mat['category'];
                if (refString.length > 0)
                {
                    let referenceItem = { name: matName, reference: refString[0], tags: tags, category: category };
                    //console.log('Add Reference:', referenceItem);
                    references.push(referenceItem);
                }
            }
            // Sort references by name
            references.sort((a, b) => a.name.localeCompare(b.name));
        }
        return references;
    }

◆ initialize_definitions_and_materials()

JsPhysicallyBasedMaterialLoader::initialize_definitions_and_materials	(	shadingModel = 'standard_surface',
		materialNames = [],
		force = false )

Initialize Physically Based MaterialX definitions, materials, remappings, and translators.

Returns: {void}

Definition at line 697 of file JsMaterialXPhysicallyBased.js.

                                                                                                       {
 
        console.log('> Generate for shading model:', shadingModel, 'materials filer:', materialNames);
        
        if (!this.physlib || force) {
 
            // Create Physically Based MaterialX definition library
            this.physlib = this.create_definition(null);
            console.log('> Created Physically Based MaterialX definition library...');
        }
 
        let translated_doc = null;
        let untranslated_doc = null;
        if (!this.physlib_materials || !this.physlib_translators || force) {
            // Create all translators
            this.physlib_translators = this.mx.createDocument();
            this.create_all_translators(this.physlib, this.physlib_translators);
 
            // Create Physically Based MaterialX materials library
            let filter_list = null;
            this.physlib_materials = this.create_definition_materials(null, filter_list);
        }
 
        untranslated_doc = this.physlib_materials;
 
        if (materialNames.length > 0) {
 
            // Translate specified materials
            //
            untranslated_doc = this.create_definition_materials(null, materialNames);
            translated_doc = this.mx.createDocument();
            translated_doc.copyContentFrom(untranslated_doc);
            translated_doc.setDataLibrary(this.get_definitions());
            const category = this.get_physlib_category()
            for (const node of translated_doc.getNodes()) {
                if (materialNames.length > 0 && !materialNames.includes(node.getName())) {
                    continue;
                }
                if (node.getCategory() == 'physbased_pbr_surface')
                {
                    console.log('> Translate specified material:', node.getName());
                    let result = this.translate_node(translated_doc, 'physbased_pbr_surface', shadingModel, node)
                }
            }
 
        }
        else 
        {
            // Translate all material
            //
            if (!(shadingModel in this.translated_materials) || force) {        
 
                const category = this.get_physlib_category()
                console.log('> Translating all materials from', category, 'to', shadingModel);
 
                // Create translated materials for specified shader model
                translated_doc = this.mx.createDocument();
                translated_doc.copyContentFrom(this.physlib_materials);
                translated_doc.setDataLibrary(this.get_definitions());
                for (const node of translated_doc.getNodes()) {
                    if (node.getCategory() == 'physbased_pbr_surface')
                    {
                        let result = this.translate_node(translated_doc, 'physbased_pbr_surface', shadingModel, node)
                    }
                }
                this.translated_materials[shadingModel] = translated_doc;
            }
            else {
                translated_doc = this.translated_materials[shadingModel];
            }
        }
 
        let def_string = this.mx.writeToXmlString(this.physlib);
        //console.log('> Physically Based MaterialX Definition Library:\n', def_string);
        let trans_string = this.mx.writeToXmlString(this.physlib_translators);
        //console.log('> Physically Based MaterialX Translators Library:\n', trans_string);   
        let mat_string = this.mx.writeToXmlString(untranslated_doc);
        //console.log('> Physically Based MaterialX Materials Library:\n', mat_string);        
        let mat_trans_string = this.mx.writeToXmlString(translated_doc);
        
        return { 'bsdf': def_string, 
            'bsdf_trans': trans_string, 
            'bsdf_materials': mat_string,
            'bsdf_trans_materials': mat_trans_string };
    }

◆ initializeInputRemapping()

JsPhysicallyBasedMaterialLoader::initializeInputRemapping ( )

Initialize the input remapping for different shading models.

Returns: {void}

Definition at line 846 of file JsMaterialXPhysicallyBased.js.

    {
        console.log('Initializing input remapping for Physically Based Materials...');
        this.remapMap = null;
 
        const remapKeyURL = 'https://raw.githubusercontent.com/kwokcb/materialxMaterials/refs/heads/main/src/materialxMaterials/data/PhysicallyBasedMaterialX/PhysicallyBasedToMtlxMappings.json';
 
        fetch(remapKeyURL)
            .then((response) => 
            {
                if (!response.ok) {
                    console.warn(`HTTP error! Status: ${response.status}`);
                    return null;
                }
                return response.json();
            })
            .then((data) => {
                if (data) {
                    this.remapMap = data;
                    console.log('- Remap keys loaded from repo:', this.remapMap);
                } else {
                    console.log('- No remap keys from repo. Using default remap keys.');
                    this.setDefaultRemapKeys();
                }
            })
            .catch((error) => {
                console.log('- Error loading remap keys:', error);
                this.setDefaultRemapKeys();
                console.warn('- Using default remap keys.', this.remapMap);
            });
    }

◆ loadMaterialX()

JsPhysicallyBasedMaterialLoader::loadMaterialX ( )

Load the MaterialX module.

Returns: {Promise} - Promise to load the MaterialX module

Definition at line 882 of file JsMaterialXPhysicallyBased.js.

    {
        return new Promise((resolve, reject) => {
            MaterialX().then((mtlx) => {
                this.mx = mtlx;
                resolve();
            }).catch((error) => {
                reject(error);
            });
        });
    }

◆ loadStandardLibraries()

JsPhysicallyBasedMaterialLoader::loadStandardLibraries ( )

Load the MaterialX standard libraries.

Returns: {void}

Definition at line 934 of file JsMaterialXPhysicallyBased.js.

    {
        if (!this.mx) {
            // Call the asynchronous function and then perform additional logic
            this.loadMaterialX().then(() => {
 
                this.esslgenerator = new this.mx.EsslShaderGenerator.create();
                this.esslgenContext = new this.mx.GenContext(this.esslgenerator);
                this.stdlib = this.mx.loadStandardLibraries(this.esslgenContext);
                let children = this.stdlib.getChildren();
                for (let i = 0; i < children.length; i++) {
                    let child = children[i];
                    child.setSourceUri('STDLIB_ELEMENT');
                }
 
                let nodedefs = this.stdlib.getNodeDefs();                
                console.log("MaterialX is loaded. With ", nodedefs.length, "definitions.");
            }).catch((error) => {
                console.error("Error loading MaterialX:", error);
            });
        }
    }

◆ map_keys_to_definition()

JsPhysicallyBasedMaterialLoader::map_keys_to_definition	(		mat,
			ndef )

Definition at line 215 of file JsMaterialXPhysicallyBased.js.

                                      {
        // Map a key to a NodeDef input
        for (let [key, value] of Object.entries(mat)) {
            let uifolder = null;
            if (!ndef.getInput(key)) {
                //if (key === 'name') {
                    // Skip as these will be node instance names
                //    continue;
                //}
 
                let input_type = "string";
                if (key.toLowerCase().includes('color')) {
                    input_type = "color3";
                    value = "1,1,1";
                } else if (typeof value === 'number' && !Number.isInteger(value)) {
                    input_type = "float";
                    value = "0.0";
                } else if (typeof value === 'number' && Number.isInteger(value)) {
                    input_type = "float";
                    value = "0.0";
                } else if (key === 'category') {
                    // category handling (optional)
                } else if (["sources", "reference", "tags", "group"].includes(key)) {
                    value = '';
                }
                //console.log(`> Add key as input: ${key}. Type: ${typeof value}. input_type: ${input_type}, value: ${value}`);
                let input = ndef.addInput(key, input_type);
                if (input) {
                    if (value !== undefined && value !== null) {
                        if (Array.isArray(value)) {
                            let value_list = value.map(x => String(x));
                            let is_number_list = value.every(x => typeof x === 'number');
                            if (is_number_list) {
                                if (value_list.length > 4) {
                                    input_type = 'string'; // floatarray will cause errors in shader generation!
                                } else if (value_list.length > 3) {
                                    input_type = 'vector4';
                                } else if (value_list.length > 2) {
                                    input_type = 'vector3';
                                } else if (value_list.length > 1) {
                                    input_type = 'vector2';
                                } else {
                                    input_type = 'float';
                                }
                                value_list = value_list.map(() => '0.0');
                            }
                            value = value_list.join(', ');
                        }
                        input.setValueString(String(value));
                        input.setType(input_type);
                    }
                    // Split camel case names and separate by space, e.g. specularColor -> Specular Color
                    let uiname = key.replace(/([A-Z])/g, ' $1').replace(/^./, str => str.toUpperCase()).trim();
                    input.setAttribute("uiname", uiname);
                    uifolder = 'Base';
                    if (["description", "sources", "reference", "tags"].includes(key)) {
                        uifolder = 'Metadata';
                    }
                    input.setAttribute("uifolder", uifolder);
                }
            }
        }
    }

◆ setDefaultRemapKeys()

JsPhysicallyBasedMaterialLoader::setDefaultRemapKeys ( )

Set the default remapping keys for different shading models : glTF, OpenPBR, and Autodesk Standard Surface.

Returns: {void}

Definition at line 792 of file JsMaterialXPhysicallyBased.js.

    {
        const standard_surface_remapKeys = {
            "color": "base_color",
            "specularColor": "specular_color",
            "roughness": "specular_roughness",
            "metalness": "metalness",
            "ior": "specular_IOR",
            "subsurfaceRadius": "subsurface_radius",
            "transmission": "transmission",
            "transmission_color": "transmission_color",
            "transmissionDispersion": "transmission_dispersion",
            "thinFilmThickness": "thin_film_thickness",
            "thinFilmIor": "thin_film_IOR"
        };
 
        const openpbr_remapKeys = {
            "color": "base_color",
            "specularColor": "specular_color",
            "roughness": "specular_roughness",
            "metalness": "base_metalness",
            "ior": "specular_ior",
            "subsurfaceRadius": "subsurface_radius",
            "transmission": "transmission_weight",
            "transmission_color": "transmission_color",
            "transmissionDispersion": "transmission_dispersion_abbe_number",
            "thinFilmThickness": "thin_film_thickness",
            "thinFilmIor": "thin_film_ior"
        };
 
        const gltf_remapKeys = {
            "color": "base_color",
            "specularColor": "specular_color",
            "roughness": "roughness",
            "metalness": "metallic",
            "ior": "ior",
            "transmission": "transmission",
            "transmission_color": "attenuation_color",
            "thinFilmThickness": "iridescence_thickness",
            "thinFilmIor": "iridescence_ior"
        };
 
        this.remapMap = {
            'standard_surface': standard_surface_remapKeys,
            'gltf_pbr': gltf_remapKeys,
            'open_pbr_surface': openpbr_remapKeys
        };
    }

◆ skipLibraryElement()

JsPhysicallyBasedMaterialLoader::skipLibraryElement ( element )

Predicate to skip library elements.

Parameters

element - MaterialX element

Returns: True if the element is a library element. False otherwise

Definition at line 962 of file JsMaterialXPhysicallyBased.js.

    {
        return !elem.hasSourceUri()
    }

◆ translate_node()

JsPhysicallyBasedMaterialLoader::translate_node	(	doc,
		source_bxdf,
		target_bxdf,
		node )

Translate a shader node of source_bxdf to target_bxdf using ungrouped nodes. This function creates a target node and a translation node based on the translator nodedef, then makes upstream and downstream connections.

Parameters

{object}	doc - The document to operate on.
{string}	source_bxdf - The source BXDF shading model name.
{string}	target_bxdf - The target BXDF shading model name.
{object}	node - The source shader node to translate.

Returns: {object|null} An object with 'translationNode' and 'targetNode' if successful, null otherwise.

Definition at line 601 of file JsMaterialXPhysicallyBased.js.

                                                        {
        let nodedef = this.find_translator(doc, source_bxdf, target_bxdf);
        if (!nodedef) {
            console.warn(`- No translator found from '${source_bxdf}' to '${target_bxdf}' for node '${node.getName()}'`);
            return null;
        }
        // Create a target node of the target_bxdf category.
        let replace_name = node.getName();
        let target_node_name = doc.createValidChildName(`${replace_name}_${target_bxdf}_SPB`); 
 
        // Cleanup dowstream connections
        let downstream_ports = node.getDownstreamPorts()
        for (let port of downstream_ports) {
            //console.log('Scan downstream port:', port.getName(), 'of node:', port.getParent().getName());
            let downstream_node = port.getParent();
            let downstream_input = downstream_node.getInput(port.getName());
            if (downstream_input) {
                //console.log(` - Reconnecting downstream node '${downstream_node.getName()}' input '${downstream_input.getName()}' from '${node.getName()}' to target node '${target_node_name}'`);
                downstream_input.setNodeName(target_node_name);
            }
        }
 
        let targetNode = doc.addChildOfCategory(target_bxdf, target_node_name);
        if (!targetNode) {
            console.warn(`- Failed to create target node of category '${target_bxdf}' for node '${node.getName()}'`);
            return null;
        }
        targetNode.setType("surfaceshader");
        // WARNING: addInputsFromNodeDef() is missing from MaterialX JS API as of 1.39.5 !
        //targetNode.addInputsFromNodeDef();
        //const targetNodeDef = targetNode.getNodeDef();
        //for (let input of targetNodeDef.getActiveInputs()) {
        //    let targetInput = targetNode.addInputFromNodeDef(input.getName());
        //}
 
        // Create a translation node based on the translator nodedef.
        let translationNode = doc.addNodeInstance(nodedef, 
                            targetNode.getName() + "_translator");
 
        // Copy over inputs from the source node to the translation node.
        let num_overrides = 0;
        for (let input of node.getActiveInputs()) {
            let translationInput = translationNode.addInputFromNodeDef(input.getName());
            if (translationInput) {
                translationInput.copyContentFrom(input);
                num_overrides += 1;
            }
        }
 
        // Connect translation outputs to target inputs.
        const impl = nodedef.getImplementation();
        for (let output of nodedef.getActiveOutputs()) {
 
            // Avoid adding ports which do not route an input data
            const impl_output = impl.getOutput(output.getName());
            if (!impl_output.getConnectedNode()) {
                continue;
            }
 
            let target_input_name = output.getName();
            // Remove trailing '_out' from name
            if (target_input_name.endsWith('_out')) {
                target_input_name = target_input_name.slice(0, -4);
            }
 
            let translationOutput = translationNode.addOutput(output.getName(), output.getType());
            translationOutput.copyContentFrom(output);
 
            let target_input = targetNode.addInputFromNodeDef(target_input_name);
            if (!target_input) {
                console.info(` - Warning: Target node '${targetNode.getName()}' has no input named '${target_input_name}' for output '${output.getName()}'`);
                continue;
            } else {
                target_input.setNodeName(translationNode.getName());
                target_input.setOutputString(translationOutput.getName());
                target_input.removeAttribute('value');
            }
        }
     
 
        // Remove original node
        doc.removeNode(replace_name);
 
        return { 'translationNode': translationNode, 'targetNode': targetNode };
    }

◆ validateDocument()

JsPhysicallyBasedMaterialLoader::validateDocument ( )

Validate the MaterialX document.

Returns: {[boolean, errors]} - True if the document is valid. False otherwise

Definition at line 127 of file JsMaterialXPhysicallyBased.js.

    {
        if (this.doc) {
            let errors = {}
            let errorString = ''
            var valid = this.doc.validate(errors);
            if (!valid) {
                errorString = errors.message;
            }
            return [valid, errorString]
        }
        return [false, 'No MaterialX document'];
    }

Member Data Documentation

◆ doc

JsPhysicallyBasedMaterialLoader::doc = null

Working MaterialX document.

Definition at line 43 of file JsMaterialXPhysicallyBased.js.

◆ headers

JsPhysicallyBasedMaterialLoader::headers = {}

Headers for the fetch operation.

Definition at line 18 of file JsMaterialXPhysicallyBased.js.

18{};

◆ materialNames

JsPhysicallyBasedMaterialLoader::materialNames = []

List of Physically Based Material names.

Definition at line 28 of file JsMaterialXPhysicallyBased.js.

◆ materials

JsPhysicallyBasedMaterialLoader::materials = null

List of Physically Based Materials.

Definition at line 23 of file JsMaterialXPhysicallyBased.js.

◆ mx

JsPhysicallyBasedMaterialLoader::mx = null

MaterialX module.

Definition at line 38 of file JsMaterialXPhysicallyBased.js.

◆ mxMaterialNames

JsPhysicallyBasedMaterialLoader::mxMaterialNames = []

List of MaterialX Material names.

Definition at line 33 of file JsMaterialXPhysicallyBased.js.

◆ remapMap

JsPhysicallyBasedMaterialLoader::remapMap = {}

Remap keys for input values for different shading models.

Definition at line 53 of file JsMaterialXPhysicallyBased.js.

53{};

◆ stdlib

JsPhysicallyBasedMaterialLoader::stdlib = null

MaterialX standard libraries.

Definition at line 48 of file JsMaterialXPhysicallyBased.js.

◆ url

JsPhysicallyBasedMaterialLoader::url = ''

URL to fetch the Physically Based Materials.

Definition at line 13 of file JsMaterialXPhysicallyBased.js.

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

JsMaterialXPhysicallyBased.js

Public Member Functions

Public Attributes

Detailed Description

Member Function Documentation

◆ add_copyright_comment()

◆ add_copyright_docstring()

◆ addComment()

◆ constructor()

◆ convertToMaterialX()

◆ create_all_translators()

◆ create_definition()

◆ create_definition_materials()

◆ create_translator()

◆ derive_translator_name_from_targets()

◆ find_all_bxdf()

◆ find_translator()

◆ get_definitions()

◆ get_physlib()

◆ get_physlib_category()

◆ get_physlib_definition()

◆ get_physlib_definition_name()

◆ get_physlib_implementation_name()

◆ get_physlib_materials()

◆ getInputRemapping()

◆ getInputRemappingMap()

◆ getJSON()

◆ getJSONMaterialNames()

◆ getMaterialXDocument()

◆ getMaterialXString()

◆ getPhysicallyBasedMaterials()

◆ getReferenceList()

◆ initialize_definitions_and_materials()

◆ initializeInputRemapping()

◆ loadMaterialX()

◆ loadStandardLibraries()

◆ map_keys_to_definition()

◆ setDefaultRemapKeys()

◆ skipLibraryElement()

◆ translate_node()

◆ validateDocument()

Member Data Documentation

◆ doc

◆ headers

◆ materialNames

◆ materials

◆ mx

◆ mxMaterialNames

◆ remapMap

◆ stdlib

◆ url