materialxMaterials.physicallyBasedMaterialXCmd Namespace Reference

Command to convert Physically Based Materials to MaterialX Command Line Utility. More...

Functions
	physicallBasedMaterialXCmd ()
	Command to parse PhysicallyBased materials and create MaterialX materials.

Detailed Description

Command to convert Physically Based Materials to MaterialX Command Line Utility.

This script converts Physically Based Materials to MaterialX using the MaterialX Python API.

The script can be run from the command line with the following options:

–shadingModel: Shading models to use for conversion. If not specified then all will be used.

Options: standard_surface, gltf_pbr, open_pbr_surface

–outputDir: Output directory for MaterialX files

–writeJSON: Write materials JSON file. Default is True

–separateFiles: Convert individual MaterialX files per material. Default is false

Example usage:

• python physicallyBasedMaterialXCmd.py

• python physicallyBasedMaterialXCmd.py –outputDir=myfolder

• python physicallyBasedMaterialXCmd.py –writeJSON=False

• python physicallyBasedMaterialXCmd.py –shadingModel=gltf_pbr,open_pbr_surface

• python physicallyBasedMaterialXCmd.py –shadingModel=open_pbr_surface –separateFiles=True

Function Documentation

physicallBasedMaterialXCmd()

materialxMaterials.physicallyBasedMaterialXCmd.physicallBasedMaterialXCmd

(

)

Command to parse PhysicallyBased materials and create MaterialX materials.

Definition at line 26 of file physicallyBasedMaterialXCmd.py.

def physicallBasedMaterialXCmd():
    '''
    Command to parse PhysicallyBased materials and create MaterialX materials
    '''
    logger = logging.getLogger('PB_CMD')
    logging.basicConfig(level=logging.INFO)
 
    parser = argparse.ArgumentParser(description='Convert Physically Based Materials to MaterialX')
    parser.add_argument('-m', '--shadingModel', type=str, default='', help='Shading models to use for conversion. '
                        ' If not specified then all will be used. '
                        ' Options: standard_surface, gltf_pbr, open_pbr_surface')
    parser.add_argument('-o', '--outputDir', type=str, default='', 
                        help='Output directory for MaterialX files. Default location is PhysicallyBasedMaterialX')
    parser.add_argument('-j', '--writeJSON', type=bool, default=True, 
                        help='Write materials JSON file. Default is True')
    parser.add_argument('-s', '--separateFiles', type=bool, default=False, 
                        help='Convert individual MaterialX files per material. Default is false')
    parser.add_argument('-l', '--loadFromFile', type=str, default='', help='Load materials a specified file')
    parser.add_argument('-wr', '--writeRemapping', type=bool, default=False, help='Write remapping from PhysicallyBased to MaterialX. Default is False')
    parser.add_argument('-rr', '--readRemapping', type=str, default='', help='Read remapping from PhysicallyBased to MaterialX. Default is empty')
    parser.add_argument('-nd', '--createNodeDef', type=bool, default=False, help='Create NodeDef for Physically Based Material inputs. Default is False')
 
    # V2_TODO : Expose this argument when all materials support all colorspaces.
    support_colorspaces = False
    if support_colorspaces:
        parser.add_argument('-cs', '--colorspace', type=str, default='', help='Write colors using this color space. Default is to use srgb-linear = lin_rec709. Options incllude: srgb-linear, acescg')
    
    opts = parser.parse_args()
 
    outputDir = 'PhysicallyBasedMaterialX'
    if opts.outputDir:
        if not os.path.exists(opts.outputDir):
            logger.info(f'Error: Output directory does not exist: {opts.outputDir}')
            # Create the output directory
            try:
                os.makedirs(opts.outputDir)
                logger.info(f'> Created output directory: {opts.outputDir}')
                outputDir = opts.outputDir
            except Exception as e:
                logger.info(f'> Error: Could not create output directory: {opts.outputDir}')
                sys.exit(1)
        else:
            outputDir = opts.outputDir
 
    shadingModels = []
    if opts.shadingModel:
        shadingModels = opts.shadingModel.split(',')        
    shadingModePrefixMap = { 'standard_surface': 'SS', 'gltf_pbr': 'GLTF', 'open_pbr_surface': 'OPBR' }
    shadingModelPrefixes = []
    if len(shadingModels) == 0:
        shadingModels = ['standard_surface', 'gltf_pbr', 'open_pbr_surface']
        shadingModelPrefixes = ['SS', 'GLTF', 'OPBR']
    else:
        for shadingModel in shadingModels:
            shadingModelPrefixes.append(shadingModePrefixMap[shadingModel])
 
    writeJSON = opts.writeJSON
    separateFiles = opts.separateFiles
 
    material_file = opts.loadFromFile
    if material_file:
        if not os.path.exists(opts.loadFromFile):
            logger.info(f'> Error: File does not exist: {material_file}')
            sys.exit(1)
        logger.info(f'> Load materials from file: {material_file}')
 
    # Create loader and get PhysicallyBasedMaterials
    # Uses default remapping.
    loader = pbmx.PhysicallyBasedMaterialLoader(mx, None, material_file)
    if support_colorspaces and opts.colorspace:
        loader.set_desired_color_space(opts.colorspace)
 
    readRemapping = opts.readRemapping
    if readRemapping:
        if not os.path.exists(readRemapping):
            logger.info(f'> Error: Remapping file does not exist: {readRemapping}')
        logger.info(f'> Read remapping file: {readRemapping}')
        loader.readRemappingFile(readRemapping)
    else:
        writeRemapping = opts.writeRemapping
        if writeRemapping:
            outputFile = os.path.join(outputDir, 'PhysicallyBasedToMtlxMappings.json')
            logger.info(f'> Write remapping file: {outputFile}')
            loader.writeRemappingFile(outputFile)
 
    jsonMat = loader.getJSON()
    if jsonMat:
 
        # Create folder for MaterialX call PhysicallyBasedMaterialX
        os.makedirs(outputDir, exist_ok=True)
 
        create_nodedef = opts.createNodeDef
        if create_nodedef:
 
            # Write PhysicallyBased BSDF definition
            #
            logger.info('> Write definition for PhysicallyBased materials')
            definitions_doc = loader.get_physlib()
            if definitions_doc:
                nodedef_file_name = os.path.join(outputDir, 'physbased_pbr.mtlx')
                mx.writeToXmlFile(definitions_doc, nodedef_file_name)
                logger.info(f'> Write definition file: {nodedef_file_name}')
 
            # Get PhysicallyBased materials using the definition
            #
            doc_mat = loader.get_physlib_materials()
            if doc_mat:
                status, error = doc_mat.validate()
                if not status:
                    logger.error('> Error validating definition materials document:')
                    logger.error(error)
                else:
                    logger.info('> Definition materials document passed validation.')
 
                nodedef_mat_file_name = os.path.join(outputDir, 'physbased_pbr_materials.mtlx')
                mx.writeToXmlFile(doc_mat, mx.FilePath(nodedef_mat_file_name))
                logger.info(f'> Write materials file: {nodedef_mat_file_name}')
 
            # Write out translator definitions
            #
            translators_doc  = loader.get_translators()
            translators = translators_doc.getNodeDefs()
            print(f'Found  translator definitions: {len(translators)}')
 
            if translators_doc and translators:     
                output_file_name = 'physbased_pbr_translators.mtlx'
                output_path = os.path.join(outputDir, output_file_name)                
                logger.info('> Write translator file:' + output_path)
                mx.writeToXmlFile(translators_doc, mx.FilePath(output_path))
                logger.info(f'> Write translator file: {output_path}')
 
            # Get doc with all required definitions: stdlib, PhysicallyBased definition, and translator definitions
            stdlib = loader.get_definitions()
 
            # Export single file with all translated materials            
            if not separateFiles:
                translated_doc = loader.get_physlib_materials()
 
                # Copy over materials + reference libraries
                #translated_doc.copyContentFrom(doc_mat)
                #translated_doc.setDataLibrary(doc_mat.getDataLibrary())
 
                for shadingModel, prefix in zip(shadingModels, shadingModelPrefixes):
 
                    for node in translated_doc.getNodes():
                        if node.getCategory() == loader.get_physlib_category():
                            trans_result = loader.translate_node(translated_doc, loader.get_physlib_category(), shadingModel, node)
 
                    logger.info(f'> Generate MaterialX using nodedefs for shading model: {shadingModel}')
                    fileName = os.path.join(outputDir, f'PhysicallyBasedMaterialX_translated_{prefix}.mtlx')
                    loader.writeMaterialXToFile(fileName, translated_doc)
                    logger.info(f'> Write: {fileName}')
        
            # Export separate files per translated material            
            else:
                matDir = os.path.join(outputDir, 'Sep')
                os.makedirs(matDir, exist_ok=True)
                for shadingModel, prefix in zip(shadingModels, shadingModelPrefixes):
                    converted = []
                    for mat in loader.getJSONMaterialNames():
                        materialFilter = [mat]
                        
                        # Create doc with single material
                        matdoc = loader.create_definition_materials(None, materialFilter)
                        if matdoc is not None:
 
                            # Translate the material
                            mat_name = mx.createValidName(mat)  
                            node = matdoc.getNode(mat_name)
                            if node:
                                trans_result = loader.translate_node(matdoc, loader.get_physlib_category(), shadingModel, node)
                                if not trans_result:
                                    logger.warning(f'Failed to translate node: {mat_name} for shading model: {shadingModel}')
                                else:
                                    converted.append(trans_result['targetNode'].getName())
                                    valid, errors = loader.validateMaterialXDocument(matdoc)
                                    if valid:
                                        #logger.info(f'> Generate material {mat_name} for shading model: {shadingModel}')
                                        fileName = os.path.join(matDir, f'PB_{prefix}_{mat}.mtlx')
                                        loader.writeMaterialXToFile(fileName, matdoc)
                                        logger.info(f'> Write: {fileName}')
                                        
                    logger.info(f'> Converted {len(converted)} materials for shading model: {shadingModel}')
 
        if writeJSON:
            logger.info(f'> Write PB material file: {outputDir}/PhysicallyBasedMaterial.json')
            loader.writeJSONToFile(os.path.join(outputDir, 'PhysicallyBasedMaterial.json'))
 
        if create_nodedef:
            return
 
        # Direct translation from JSON to MaterialX path. Skip if using PhysicallyBased nodedefs
        if not separateFiles:
            for shadingModel, prefix in zip(shadingModels, shadingModelPrefixes):
                logger.info(f'> Generate MaterialX for shading model: {shadingModel}')
                matdoc = loader.convertToMaterialX([], shadingModel, {}, prefix)
                valid, errors = loader.validateMaterialXDocument(matdoc)
                if not valid:
                    logger.error(f'> Error validating MaterialX document for shading model: {shadingModel}')
                    logger.error(errors)
 
                if support_colorspaces and opts.colorspace:
                    prefix = prefix + '_' + opts.colorspace
                fileName = os.path.join(outputDir, f'PhysicallyBasedMaterialX_{prefix}.mtlx')
                loader.writeMaterialXToFile(fileName)
                logger.info(f'> Write: {fileName}')
    
        else:
            for shadingModel, prefix in zip(shadingModels, shadingModelPrefixes):
                logger.info(f'> Generate MaterialX for shading model: {shadingModel}')
                for mat in loader.getJSONMaterialNames():
                    materialFilter = [mat]
                    matdoc = loader.convertToMaterialX(materialFilter, shadingModel, {}, prefix)
                    if matdoc is not None:
                        valid, errors = loader.validateMaterialXDocument(matdoc)
                        if not valid:                            
                            logger.error(f'> Error validating MaterialX document for material: {mat} shading model: {shadingModel}')
                            logger.error(errors)
 
                        if support_colorspaces and opts.colorspace:
                            prefix = prefix + '_' + opts.colorspace
                        fileName = os.path.join(outputDir, f'PB_{prefix}_{mat}.mtlx')
                        loader.writeMaterialXToFile(fileName)
                        logger.info(f'> Write: {fileName}')
 
    else:
        logger.info('Could not retrieve PhysicallyBased Materials')