glTF serializer for MaterialX More...

Public Member Functions
None	__init__ (self, editor, root)
	Initialize the plugin.

	handle_file_loaded (self, data)

	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

	handle_file_loaded

str	current_mx_file = ""

int	temp_file_counter = 1

	web_view = QWebEngineView()

str	viewer_options = '?hideSave=true'

str	viewer_address = 'https://kwokcb.github.io/MaterialXLab/documents/gltfViewer_simple.html'

	page = glTFEnginePage(self.web_view)

	web_dock_widget = glTFWidget(self.editor)

Detailed Description

glTF serializer for MaterialX

Definition at line 162 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 167 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)   
 
        # Catch when file is loaded.
        self.editor.qx_node_graph.mx_file_loaded.connect(self.handle_file_loaded)
        self.current_mx_file = ""
        self.temp_file_counter = 1
 

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 525 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 446 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 247 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 459 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, f"_tmp_quiltix{self.temp_file_counter}.gltf")
            self.temp_file_counter += 1
        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)
   

◆ handle_file_loaded()

plugin.QuiltiX_glTF_serializer.handle_file_loaded	(		self,
			data )

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

    def handle_file_loaded(self, data):
        # Slot to handle the emitted data
        logger.info(f"Watch file loaded: {data}")
        self.current_mx_file = data
 

◆ import_gltf_triggered()

None plugin.QuiltiX_glTF_serializer.import_gltf_triggered ( self )

Import a glTF file into the current graph.

Definition at line 342 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 254 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 398 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.
            #data_path = pkg_files(__package__) / 'data' / 'shaderBall.gltf'
            #with open(data_path, 'rb') as f:
            #    gltfGeometryFile = f.read() 
            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())
        searchPath.append(mx.FilePath(self.current_mx_file).getParentPath())
        if embed_geometry:
            searchPath.append(mx.FilePath(gltfGeometryFile).getParentPath())
        options['searchPath'] = searchPath
        logger.info(f'Export Search path: {searchPath.asString()}')
 
        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 260 of file materialxgltf/plugin.py.

    def setup_gltf_viewer_doc(self) -> None:
        '''
        Set up the glTF viewer dock widget.
        '''
        class glTFWidget(QDockWidget):
            '''
            @brief glTF Viewer widget    
            '''
            def __init__(self, parent=None):
                '''
                @brief Sets up a web view and loads in a sample glTF viewer page.
                '''
                super(glTFWidget, self).__init__(parent)
                
                self.setWindowTitle("glTF Viewer")
 
                self.setFloating(False)
                
                # Create a web view. 
                self.web_view = QWebEngineView()        
                self.viewer_options = '?hideSave=true'
                self.viewer_options += '&env=https://kwokcb.github.io/MaterialXLab/documents/resources/Lights/rural_crossroads_1k.hdr'
                self.viewer_address = 'https://kwokcb.github.io/MaterialXLab/documents/gltfViewer_simple.html' 
                # e.g. For debugging can set to local host if you want to run a local page
                #self.viewer_address = 'http://localhost:8000/documents/gltfViewer_simple.html' 
                self.viewer_address += self.viewer_options
                #self.logger.debug('glTF Viewer address: ' + self.viewer_address)
 
                # Create a custom page and set it to the web view
                self.page = glTFEnginePage(self.web_view)
                self.web_view.setPage(self.page)
 
                self.web_view.setUrl(QtCore.QUrl(self.viewer_address))
                
                # Apply the request interceptor
                #interceptor = MyRequestInterceptor()
                #QWebEngineProfile.defaultProfile().setUrlRequestInterceptor(interceptor)
 
                #settings = self.web_view.settings()
                # Disable features that might trigger the error (general approach)
                #settings.setAttribute(QWebEngineSettings.WebAttribute.LocalStorageEnabled, False)
                #settings.setAttribute(QWebEngineSettings.WebAttribute.LocalContentCanAccessFileUrls, False)
                #settings.setAttribute(QWebEngineSettings.WebAttribute.XSSAuditingEnabled, False)
                                
                # Set up the layout
                layout = QVBoxLayout()
                layout.addWidget(self.web_view)
                
                # Create a central widget to hold the layout
                central_widget = QWidget()
                central_widget.setLayout(layout)
 
                # Inject JavaScript after the page is loaded
                #self.web_view.loadFinished.connect(self.page.injectJavaScript)        
                
                # Set the central widget of the dock widget
                self.setWidget(central_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 588 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 322 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 228 of file materialxgltf/plugin.py.

◆ bake_textures_option

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

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

◆ current_mx_file

plugin.QuiltiX_glTF_serializer.current_mx_file = ""

Definition at line 239 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 235 of file materialxgltf/plugin.py.

◆ editor

plugin.QuiltiX_glTF_serializer.editor = editor

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

◆ handle_file_loaded

plugin.QuiltiX_glTF_serializer.handle_file_loaded

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

◆ import_gltf_triggered

plugin.QuiltiX_glTF_serializer.import_gltf_triggered

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

◆ on_gltf_viewer_toggled

plugin.QuiltiX_glTF_serializer.on_gltf_viewer_toggled

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

◆ page

plugin.QuiltiX_glTF_serializer.page = glTFEnginePage(self.web_view)

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

◆ root

plugin.QuiltiX_glTF_serializer.root = root

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

◆ show_gltf_text_triggered

plugin.QuiltiX_glTF_serializer.show_gltf_text_triggered

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

◆ temp_file_counter

int plugin.QuiltiX_glTF_serializer.temp_file_counter = 1

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

◆ viewer_address

plugin.QuiltiX_glTF_serializer.viewer_address = 'https://kwokcb.github.io/MaterialXLab/documents/gltfViewer_simple.html'

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

◆ viewer_options

str plugin.QuiltiX_glTF_serializer.viewer_options = '?hideSave=true'

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

◆ web_dock_widget

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

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

◆ web_view

plugin.QuiltiX_glTF_serializer.web_view = QWebEngineView()

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

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

materialxgltf/plugin.py

Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ convert_graph_to_gltf()

◆ create_baked_path()

◆ custom_on_view_menu_about_to_show()

◆ export_gltf_triggered()

◆ handle_file_loaded()

◆ import_gltf_triggered()

◆ on_gltf_viewer_toggled()

◆ setup_default_export_options()

◆ setup_gltf_viewer_doc()

◆ show_gltf_text_triggered()

◆ show_text_box()

Member Data Documentation

◆ act_gltf_viewer

◆ bake_textures_option

◆ current_mx_file

◆ custom_on_view_menu_about_to_show

◆ editor

◆ handle_file_loaded

◆ import_gltf_triggered

◆ on_gltf_viewer_toggled

◆ page

◆ root

◆ show_gltf_text_triggered

◆ temp_file_counter

◆ viewer_address

◆ viewer_options

◆ web_dock_widget

◆ web_view

◆ init()