plugin.QuiltiX_glTF_serializer Class Reference

glTF serializer for MaterialX More...

Public Member Functions
None	__init__ (self, editor, root)
	Initialize the plugin.
	custom_on_view_menu_about_to_show (self)
	Custom about to show event for the view menu.
None	on_gltf_viewer_toggled (self, checked)
	Toggle the glTF viewer dock widget.
None	setup_gltf_viewer_doc (self)
	Set up the glTF viewer dock widget.
None	show_text_box (self, text, title="")
	Core utilities.
None	import_gltf_triggered (self)
	Import a glTF file into the current graph.
dict	setup_default_export_options (self, path, bakeFileName, bakeResolution=1024, embed_geometry=False)
	Set up the default export options for gltf output.
	create_baked_path (self, path)
	Create a baked path name from an original path.
None	export_gltf_triggered (self, writeToTemp=False)
	Export the current graph to a glTF file in binary format (glb)
str	convert_graph_to_gltf (self, options)
	Convert the current graph to a glTF document string.
	show_gltf_text_triggered (self)
	Show the current graph as glTF text popup.

Public Attributes
	editor = editor
	root = root
	import_gltf_triggered
	show_gltf_text_triggered
	bake_textures_option = QAction("Always Bake Textures", editor)
	act_gltf_viewer = QAction("glTF Viewer", editor)
	Add viewer toggle.
	on_gltf_viewer_toggled
	custom_on_view_menu_about_to_show
	web_dock_widget = glTFWidget(self.editor)

Detailed Description

glTF serializer for MaterialX

Definition at line 211 of file materialxgltf/plugin.py.

Constructor & Destructor Documentation

__init__()

None plugin.QuiltiX_glTF_serializer.__init__	(		self,
			editor,
			root )

Initialize the plugin.

Adds in:

• Menu items for loading and saving glTF files
• Menu items for setting options for glTF export
• Menu item for showing the current graph as glTF text

Parameters

editor	The QuiltiX editor
root	The root path of QuitiX

Definition at line 216 of file materialxgltf/plugin.py.

    def __init__(self, editor, root) -> None:
        '''
        Initialize the plugin. Adds in:
        - Menu items for loading and saving glTF files
        - Menu items for setting options for glTF export
        - Menu item for showing the current graph as glTF text
 
        @param editor: The QuiltiX editor
        @param root: The root path of QuitiX        
        '''
        self.editor = editor
        self.root = root
        
        # glTF menu items
        # ----------------------------------------
        # Update 'File' menu
        
        editor.file_menu.addSeparator()
        gltfMenu1 = self.editor.file_menu.addMenu("glTF")
 
        # Load menu item
        import_gltf_item = QAction("Load glTF...", editor)
        import_gltf_item.triggered.connect(self.import_gltf_triggered)
        gltfMenu1.addAction(import_gltf_item)
 
        # Save menu item
        export_gltf_item = QAction("Save glTF...", editor)
        export_gltf_item.triggered.connect(lambda: self.export_gltf_triggered(False))
        gltfMenu1.addAction(export_gltf_item)
 
        # Export to Viewer menu item
        export_view_gltf_item = QAction("Export to Viewer...", editor)
        export_view_gltf_item.triggered.connect(lambda: self.export_gltf_triggered(True))
        gltfMenu1.addAction(export_view_gltf_item)
 
        # Show glTF text. Does most of export, except does not write to file
        show_gltf_text = QAction("Show glTF as text...", editor)
        show_gltf_text.triggered.connect(self.show_gltf_text_triggered)
        gltfMenu1.addAction(show_gltf_text)
 
        # Update 'Options' menu
        
        editor.options_menu.addSeparator()
        gltfMenu2 = editor.options_menu.addMenu("glTF Options")
 
        self.bake_textures_option = QAction("Always Bake Textures", editor)
        self.bake_textures_option.setCheckable(True)
        self.bake_textures_option.setChecked(False)
        gltfMenu2.addAction(self.bake_textures_option)
 
        #version = 'materialxgltf version: ' + materialxgltf.__version__
        #version_action = QAction(version, self.editor)
        #version_action.setEnabled(False)
        #gltfMenu.addAction(version_action)
 
        # Add glTF Viewer
        self.setup_gltf_viewer_doc()
 
        # Update 'View' menu
        
        self.act_gltf_viewer = QAction("glTF Viewer", editor)
        self.act_gltf_viewer.setCheckable(True)
        self.act_gltf_viewer.toggled.connect(self.on_gltf_viewer_toggled)
        editor.view_menu.addSeparator()
        editor.view_menu.addAction(self.act_gltf_viewer)
 
        # Override about to show event to update the gltf viewer toggle
        editor.view_menu.aboutToShow.connect(self.custom_on_view_menu_about_to_show)   
 

Member Function Documentation

convert_graph_to_gltf()

str plugin.QuiltiX_glTF_serializer.convert_graph_to_gltf	(		self,
			options )

Convert the current graph to a glTF document string.

Will perform:

• Shader translation if needed (not that only standard surface is supported)
• Baking if needed. Note that this writes local files.
• Uses the materialgltf package to perform conversion

Parameters

options

(dict): Dictionary of options for the conversion

Returns

The glTF string.

Definition at line 504 of file materialxgltf/plugin.py.

    def convert_graph_to_gltf(self, options) -> str:
        '''
        Convert the current graph to a glTF document string.
        Will perform:
        - Shader translation if needed (not that only standard surface is supported)
        - Baking if needed. Note that this writes local files.
        - Uses the materialgltf package to perform conversion
 
        @param options (dict): Dictionary of options for the conversion            
        @return The glTF string.
        '''
        # Disable auto nodegraph creation during
        ng_abstraction = self.editor.act_ng_abstraction.isChecked()
        self.editor.act_ng_abstraction.setChecked(False)  
 
        doc = self.editor.qx_node_graph.get_current_mx_graph_doc()
        
        self.editor.act_ng_abstraction.setChecked(ng_abstraction)
 
        mtlx2glTFWriter = core.MTLX2GLTFWriter()
        mtlx2glTFWriter.setOptions(options)
 
        # Need to load in definition libraries to get translation graphs
        stdlib = mx.createDocument()
        searchPath = mx.getDefaultDataSearchPath()
        libraryFolders = []
        libraryFolders.extend(mx.getDefaultDataLibraryFolders())
        mx.loadLibraries(libraryFolders, searchPath, stdlib)
        doc.importLibrary(stdlib)     
 
        # Perform shader translation if needed
        translatedCount = 0
        if options['translateShaders']:
            translatedCount = mtlx2glTFWriter.translateShaders(doc)
            logger.debug('- Translated shaders: ' + str(translatedCount))
 
        forceBake = False
        if self.bake_textures_option.isChecked():
            logger.debug('--- Forcing baking of textures')
            forceBake = True
 
        # Perform baking if needed
        if forceBake or (translatedCount > 0 and options['bakeTextures']):
            bakedFileName = options['bakeFileName']
            bakeResolution = 1024
            if options['bakeResolution']:
                bakeResolution = options['bakeResolution']
            logger.debug(f'- START baking to {bakedFileName}. Resolution: {bakeResolution} ...')
            mtlx2glTFWriter.bakeTextures(doc, False, bakeResolution, bakeResolution, True, 
                                        False, False, bakedFileName)
            if os.path.exists(bakedFileName):
                logger.debug('  - Baked textures to: ' + bakedFileName)
                doc, libFiles = core.Util.createMaterialXDoc()
                mx.readFromXmlFile(doc, bakedFileName, options['searchPath'])
                remappedUris = core.Util.makeFilePathsRelative(doc, bakedFileName)
                for uri in remappedUris:
                    logger.debug('  - Remapped URI: ' + uri[0] + ' to ' + uri[1])
                    core.Util.writeMaterialXDoc(doc, bakedFileName)
            logger.debug('- ... END baking.')
 
        gltfString = mtlx2glTFWriter.convert(doc)
        return gltfString
 

create_baked_path()

plugin.QuiltiX_glTF_serializer.create_baked_path	(		self,
			path )

Create a baked path name from an original path.

Parameters

path	(str): The original path

Returns

: The baked path

Definition at line 426 of file materialxgltf/plugin.py.

    def create_baked_path(self, path):
        '''
        Create a baked path name from an original path
        @param path (str): The original path
        @return: The baked path
        '''
        # If is a directory, add a file name
        if os.path.isdir(path):
            path = os.path.join(path, 'temp_baked.mtlx')
        else:
            path = path.replace('.mtlx', '_baked.mtlx')
        return path
 

custom_on_view_menu_about_to_show()

plugin.QuiltiX_glTF_serializer.custom_on_view_menu_about_to_show

(

self

)

Custom about to show event for the view menu.

Updates the glTF viewer toggle.

Definition at line 286 of file materialxgltf/plugin.py.

    def custom_on_view_menu_about_to_show(self):
        '''
        Custom about to show event for the view menu. Updates the glTF viewer toggle.
        '''
        self.editor.on_view_menu_showing()
        self.act_gltf_viewer.setChecked(self.web_dock_widget.isVisible())
 

export_gltf_triggered()

None plugin.QuiltiX_glTF_serializer.export_gltf_triggered	(		self,
			writeToTemp = False )

Export the current graph to a glTF file in binary format (glb)

• Will perform shader translation if needed to glTF
• Will perform baking if needed
• Will package to a binary file

  Parameters

  writeToTemp

  (bool): Whether to write to a temporary file

  Returns

  : None

Definition at line 439 of file materialxgltf/plugin.py.

    def export_gltf_triggered(self, writeToTemp=False) -> None:
        '''
        Export the current graph to a glTF file in binary format (glb)
        - Will perform shader translation if needed to glTF
        - Will perform baking if needed
        - Will package to a binary file
        @param writeToTemp (bool): Whether to write to a temporary file
        @return: None
        '''
        if writeToTemp:
            start_path = os.environ["TEMP"]
            if not start_path:
                start_path = os.path.join(ROOT, "resources", "materials")
            path = os.path.join(start_path, "_tmp_quiltix.gltf")
        else:
            start_path = self.editor.mx_selection_path
            if not start_path:
                start_path = self.editor.geometry_selection_path
 
            if not start_path:
                start_path = os.path.join(ROOT, "resources", "materials")
 
            path = self.editor.request_filepath(
                title="Save glTF file", start_path=start_path, file_filter="glTF files (*.gltf)", mode="save",
            )
        
        # Set up export options
        bakeFileName = self.create_baked_path(start_path)
        options = self.setup_default_export_options(path, bakeFileName, bakeResolution=1024, embed_geometry=True)
        gltf_string = self.convert_graph_to_gltf(options)
 
        if gltf_string == '{}':
            return
 
        #self.editor.set_current_filepath("")
 
        # To be able to view the exported file in the glTF viewer, we need to package to a  binary file
        options['packageBinary'] = True
        try:
            with open(path, "w") as f:
                f.write(gltf_string)
                logger.info(f"Wrote .gltf file to {path}")
 
            # Package binary file
            binaryFileName = str(path)
            binaryFileName = binaryFileName.replace('.gltf', '.glb')            
            logger.debug('- Packaging GLB file...')
            mtlx2glTFWriter = core.MTLX2GLTFWriter()
            mtlx2glTFWriter.setOptions(options)
            saved, images, buffers = mtlx2glTFWriter.packageGLTF(path, binaryFileName)
            logger.info('- Save GLB file:' + binaryFileName + '. Status:' + str(saved))
            for image in images:
                logger.debug('  - Embedded image: ' + image)
            for buffer in buffers:
                logger.debug('  - Embedded buffer: ' + buffer)  
            logger.debug('- Packaging GLB file... finished.')
 
            # Load the glb file into the glTF viewer
            logger.debug(f'Loading GLB file into glTF viewer: {binaryFileName}')
            if self.web_dock_widget.page:                
                self.web_dock_widget.page.load_glb(binaryFileName)
 
        except Exception as e:
            logger.error(e)
   

import_gltf_triggered()

None plugin.QuiltiX_glTF_serializer.import_gltf_triggered

(

self

)

Import a glTF file into the current graph.

Definition at line 327 of file materialxgltf/plugin.py.

    def import_gltf_triggered(self) -> None:
        '''
        Import a glTF file into the current graph.
        '''
        start_path = self.editor.mx_selection_path
        if not start_path:
            start_path = self.editor.geometry_selection_path
 
        if not start_path:
            start_path = os.path.join(ROOT, "resources", "materials")
 
        path = self.editor.request_filepath(
            title="Load glTF file", start_path=start_path, file_filter="glTF files (*.gltf)", mode="open",
        )
 
        if not os.path.exists(path):
            logger.error('Cannot find input file: ' + path)
            return
 
        # Setup defaults for glTF import and create the MaterialX document
        # - Do not create assignments
        # - Do not add all inputs
        # - Add extract nodes. Only required for pre 1.39 MaterialX
        options = core.GLTF2MtlxOptions()
        options['createAssignments'] = False   
        options['addAllInputs'] = False
        options['addExtractNodes'] = True
        gltf2MtlxReader = core.GLTF2MtlxReader()
        gltf2MtlxReader.setOptions(options)
        doc = gltf2MtlxReader.convert(path)
 
        success = True
        if not doc:
            success  = False
            logger.error('Error converting glTF file to MaterialX file')
        else:
            success , err = doc.validate()
            if not success:
                logger.error(err)
            else:
                # Extract out the appropriate data from the original MaterialX document
                docString = core.Util.writeMaterialXDocString(doc)
                doc = mx.createDocument()
                mx.readFromXmlString(doc, docString)
 
                # Auto ng creation can cause issues for nodes with multiple outputs. Turn off on import
                ng_abstraction = self.editor.act_ng_abstraction.isChecked()
                self.editor.act_ng_abstraction.setChecked(False)  
 
                self.editor.mx_selection_path = path
                self.editor.qx_node_graph.load_graph_from_mx_doc(doc)  
                # Blank out as there is no MaterialX file this was read from              
                self.editor.qx_node_graph.mx_file_loaded.emit("")
 
                self.editor.act_ng_abstraction.setChecked(ng_abstraction)
    

on_gltf_viewer_toggled()

None plugin.QuiltiX_glTF_serializer.on_gltf_viewer_toggled	(		self,
			checked )

Toggle the glTF viewer dock widget.

Definition at line 293 of file materialxgltf/plugin.py.

    def on_gltf_viewer_toggled(self, checked) -> None:
        '''
        Toggle the glTF viewer dock widget.
        '''
        self.web_dock_widget.setVisible(checked)
        

setup_default_export_options()

dict plugin.QuiltiX_glTF_serializer.setup_default_export_options	(		self,
			path,
			bakeFileName,
			bakeResolution = 1024,
			embed_geometry = False )

Set up the default export options for gltf output.

Parameters

path	(str): path to the gltf file
bakeFileName	(str): path to the baked file
bakeResolution	(int): resolution of the baked textures. Default is 1024.
embed_geometry	(bool): whether to embed the geometry in the gltf file. Default is False.

Returns

options (dict): Dictionary of options for the conversion

Definition at line 383 of file materialxgltf/plugin.py.

    def setup_default_export_options(self, path, bakeFileName, bakeResolution=1024, embed_geometry=False) -> dict:
        '''
        Set up the default export options for gltf output.
        @param path (str): path to the gltf file
        @param bakeFileName (str): path to the baked file
        @param bakeResolution (int): resolution of the baked textures. Default is 1024.
        @param embed_geometry (bool): whether to embed the geometry in the gltf file. Default is False.
        @return options (dict): Dictionary of options for the conversion
        '''
        options = core.MTLX2GLTFOptions()
 
        options['debugOutput'] = False
        options['bakeFileName'] = bakeFileName
        # Clamp to a minimum power-of-2 resolution
        bakeResolution = max(bakeResolution, 16)
        options['bakeResolution'] = bakeResolution
 
        # TODO: Expose these options to the user
        if embed_geometry:
            # By default uses the "MaterialX" shader ball provided as part of
            # the materialxgltf package for binary export. 
            gltfGeometryFile = pkg_resources.resource_filename('materialxgltf', 'data/shaderBall.gltf')
            msg = '> Load default geometry: %s' % mx.FilePath(gltfGeometryFile).getBaseName()
            logger.info(msg)        
            options['geometryFile'] = gltfGeometryFile        
        options['primsPerMaterial'] = True
        options['writeDefaultInputs'] = False
        options['translateShaders'] = True
        options['bakeTextures'] = True
        # Always should be set
        options['addExtractNodes'] = True
 
        searchPath = mx.getDefaultDataSearchPath()
        if not mx.FilePath(path).isAbsolute():
            path = os.path.abspath(path)
        searchPath.append(mx.FilePath(path).getParentPath())
        searchPath.append(mx.FilePath.getCurrentPath())
        if embed_geometry:
            searchPath.append(mx.FilePath(gltfGeometryFile).getParentPath())
        options['searchPath'] = searchPath
 
        return options
    

setup_gltf_viewer_doc()

None plugin.QuiltiX_glTF_serializer.setup_gltf_viewer_doc

(

self

)

Set up the glTF viewer dock widget.

Definition at line 299 of file materialxgltf/plugin.py.

    def setup_gltf_viewer_doc(self) -> None:
        '''
        Set up the glTF viewer dock widget.
        '''
        self.web_dock_widget = glTFWidget(self.editor)
        self.editor.addDockWidget(QtCore.Qt.RightDockWidgetArea, self.web_dock_widget)        
 

show_gltf_text_triggered()

plugin.QuiltiX_glTF_serializer.show_gltf_text_triggered

(

self

)

Show the current graph as glTF text popup.

Definition at line 567 of file materialxgltf/plugin.py.

    def show_gltf_text_triggered(self):
        '''
        Show the current graph as glTF text popup.
        '''
        path = self.editor.mx_selection_path
        if not path:
            path = self.editor.geometry_selection_path
        if not path:
            path = os.path.join(ROOT, "resources", "materials")
 
        # Setup export options
        bakeFileName = self.create_baked_path(path)
        options = self.setup_default_export_options(path, bakeFileName, bakeResolution=64, embed_geometry=False)
 
        logger.debug('Show glTF text triggered. Path:' + path + '. bakeFileName: ' + bakeFileName)
 
        # Convert and display the text                
        text = self.convert_graph_to_gltf(options)
        self.show_text_box(text, 'glTF Representation')
                    
@qx_plugin.hookimpl

show_text_box()

None plugin.QuiltiX_glTF_serializer.show_text_box	(		self,
			text,
			title = "" )

Core utilities.

Show a text box with the given text.

Parameters

text	The text to show
title	The title of the text box. Default is empty string.

Definition at line 307 of file materialxgltf/plugin.py.

    def show_text_box(self, text, title="") -> None:
        '''
        Show a text box with the given text.
        @param text: The text to show
        @param title: The title of the text box. Default is empty string.        
        '''
        te_text = QTextEdit()
 
        if have_highliting:
            jsonHighlighter = GLTFHighlighter()
            highlighted_html = jsonHighlighter.highlight(text)
            te_text.setHtml(highlighted_html)
        else:
            te_text.setText(text)
        te_text.setReadOnly(True)
        te_text.setParent(self.editor, QtCore.Qt.Window)
        te_text.setWindowTitle(title)
        te_text.resize(1000, 800)
        te_text.show()
 

Member Data Documentation

act_gltf_viewer

plugin.QuiltiX_glTF_serializer.act_gltf_viewer = QAction("glTF Viewer", editor)

Add viewer toggle.

Definition at line 277 of file materialxgltf/plugin.py.

bake_textures_option

plugin.QuiltiX_glTF_serializer.bake_textures_option = QAction("Always Bake Textures", editor)

Definition at line 261 of file materialxgltf/plugin.py.

custom_on_view_menu_about_to_show

plugin.QuiltiX_glTF_serializer.custom_on_view_menu_about_to_show

Definition at line 284 of file materialxgltf/plugin.py.

editor

plugin.QuiltiX_glTF_serializer.editor = editor

Definition at line 226 of file materialxgltf/plugin.py.

import_gltf_triggered

plugin.QuiltiX_glTF_serializer.import_gltf_triggered

Definition at line 238 of file materialxgltf/plugin.py.

on_gltf_viewer_toggled

plugin.QuiltiX_glTF_serializer.on_gltf_viewer_toggled

Definition at line 279 of file materialxgltf/plugin.py.

root

plugin.QuiltiX_glTF_serializer.root = root

Definition at line 227 of file materialxgltf/plugin.py.

show_gltf_text_triggered

plugin.QuiltiX_glTF_serializer.show_gltf_text_triggered

Definition at line 253 of file materialxgltf/plugin.py.

web_dock_widget

plugin.QuiltiX_glTF_serializer.web_dock_widget = glTFWidget(self.editor)

Definition at line 303 of file materialxgltf/plugin.py.

---

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

• materialxgltf/plugin.py