Merge branch 'develop' into feature/OP-2795_maya-to-unreal-skeletal-meshes

openpype/hosts/maya/api/lib.py

@@ -1511,7 +1511,7 @@ def get_container_members(container):
 
     members = cmds.sets(container, query=True) or []
     members = cmds.ls(members, long=True, objectsOnly=True) or []
-    members = set(members)
+    all_members = set(members)
 
     # Include any referenced nodes from any reference in the container
     # This is required since we've removed adding ALL nodes of a reference
@@ -1530,9 +1530,9 @@ def get_container_members(container):
         reference_members = cmds.ls(reference_members,
                                     long=True,
                                     objectsOnly=True)
-        members.update(reference_members)
+        all_members.update(reference_members)
 
-    return members
+    return list(all_members)
 
 
 # region LOOKDEV

openpype/hosts/maya/api/pipeline.py

@@ -10,7 +10,6 @@ import pyblish.api
 import avalon.api
 
 from avalon.lib import find_submodule
-from avalon.pipeline import AVALON_CONTAINER_ID
 
 import openpype.hosts.maya
 from openpype.tools.utils import host_tools
@@ -23,7 +22,10 @@ from openpype.lib.path_tools import HostDirmap
 from openpype.pipeline import (
     LegacyCreator,
     register_loader_plugin_path,
+    register_inventory_action_path,
     deregister_loader_plugin_path,
+    deregister_inventory_action_path,
+    AVALON_CONTAINER_ID,
 )
 from openpype.hosts.maya.lib import copy_workspace_mel
 from . import menu, lib
@@ -59,7 +61,7 @@ def install():
 
     register_loader_plugin_path(LOAD_PATH)
     avalon.api.register_plugin_path(LegacyCreator, CREATE_PATH)
-    avalon.api.register_plugin_path(avalon.api.InventoryAction, INVENTORY_PATH)
+    register_inventory_action_path(INVENTORY_PATH)
     log.info(PUBLISH_PATH)
 
     log.info("Installing callbacks ... ")
@@ -188,9 +190,7 @@ def uninstall():
 
     deregister_loader_plugin_path(LOAD_PATH)
     avalon.api.deregister_plugin_path(LegacyCreator, CREATE_PATH)
-    avalon.api.deregister_plugin_path(
-        avalon.api.InventoryAction, INVENTORY_PATH
-    )
+    deregister_inventory_action_path(INVENTORY_PATH)
 
     menu.uninstall()
 

openpype/hosts/maya/api/plugin.py

@@ -4,11 +4,11 @@ from maya import cmds
 
 import qargparse
 
-from avalon.pipeline import AVALON_CONTAINER_ID
 from openpype.pipeline import (
     LegacyCreator,
     LoaderPlugin,
     get_representation_path,
+    AVALON_CONTAINER_ID,
 )
 
 from .pipeline import containerise

openpype/hosts/maya/api/setdress.py

@@ -6,6 +6,8 @@ import contextlib
 import copy
 
 import six
+from bson.objectid import ObjectId
+
 from maya import cmds
 
 from avalon import io
@@ -282,7 +284,7 @@ def update_package_version(container, version):
 
     # Versioning (from `core.maya.pipeline`)
     current_representation = io.find_one({
-        "_id": io.ObjectId(container["representation"])
+        "_id": ObjectId(container["representation"])
     })
 
     assert current_representation is not None, "This is a bug"
@@ -327,7 +329,7 @@ def update_package(set_container, representation):
 
     # Load the original package data
     current_representation = io.find_one({
-        "_id": io.ObjectId(set_container['representation']),
+        "_id": ObjectId(set_container['representation']),
         "type": "representation"
     })
 
@@ -478,10 +480,10 @@ def update_scene(set_container, containers, current_data, new_data, new_file):
                 # They *must* use the same asset, subset and Loader for
                 # `update_container` to make sense.
                 old = io.find_one({
-                    "_id": io.ObjectId(representation_current)
+                    "_id": ObjectId(representation_current)
                 })
                 new = io.find_one({
-                    "_id": io.ObjectId(representation_new)
+                    "_id": ObjectId(representation_new)
                 })
                 is_valid = compare_representations(old=old, new=new)
                 if not is_valid:

openpype/hosts/maya/api/workio.py

@@ -1,11 +1,12 @@
 """Host API required Work Files tool"""
 import os
 from maya import cmds
-from avalon import api
+
+from openpype.pipeline import HOST_WORKFILE_EXTENSIONS
 
 
 def file_extensions():
-    return api.HOST_WORKFILE_EXTENSIONS["maya"]
+    return HOST_WORKFILE_EXTENSIONS["maya"]
 
 
 def has_unsaved_changes():

openpype/hosts/maya/plugins/create/create_multiverse_usd.py

@@ -0,0 +1,51 @@
+from openpype.hosts.maya.api import plugin, lib
+
+
+class CreateMultiverseUsd(plugin.Creator):
+    """Multiverse USD data"""
+
+    name = "usdMain"
+    label = "Multiverse USD"
+    family = "usd"
+    icon = "cubes"
+
+    def __init__(self, *args, **kwargs):
+        super(CreateMultiverseUsd, self).__init__(*args, **kwargs)
+
+        # Add animation data first, since it maintains order.
+        self.data.update(lib.collect_animation_data(True))
+
+        self.data["stripNamespaces"] = False
+        self.data["mergeTransformAndShape"] = False
+        self.data["writeAncestors"] = True
+        self.data["flattenParentXforms"] = False
+        self.data["writeSparseOverrides"] = False
+        self.data["useMetaPrimPath"] = False
+        self.data["customRootPath"] = ''
+        self.data["customAttributes"] = ''
+        self.data["nodeTypesToIgnore"] = ''
+        self.data["writeMeshes"] = True
+        self.data["writeCurves"] = True
+        self.data["writeParticles"] = True
+        self.data["writeCameras"] = False
+        self.data["writeLights"] = False
+        self.data["writeJoints"] = False
+        self.data["writeCollections"] = False
+        self.data["writePositions"] = True
+        self.data["writeNormals"] = True
+        self.data["writeUVs"] = True
+        self.data["writeColorSets"] = False
+        self.data["writeTangents"] = False
+        self.data["writeRefPositions"] = False
+        self.data["writeBlendShapes"] = False
+        self.data["writeDisplayColor"] = False
+        self.data["writeSkinWeights"] = False
+        self.data["writeMaterialAssignment"] = False
+        self.data["writeHardwareShader"] = False
+        self.data["writeShadingNetworks"] = False
+        self.data["writeTransformMatrix"] = True
+        self.data["writeUsdAttributes"] = False
+        self.data["timeVaryingTopology"] = False
+        self.data["customMaterialNamespace"] = ''
+        self.data["numTimeSamples"] = 1
+        self.data["timeSamplesSpan"] = 0.0

openpype/hosts/maya/plugins/create/create_multiverse_usd_comp.py

@@ -0,0 +1,23 @@
+from openpype.hosts.maya.api import plugin, lib
+
+
+class CreateMultiverseUsdComp(plugin.Creator):
+    """Create Multiverse USD Composition"""
+
+    name = "usdCompositionMain"
+    label = "Multiverse USD Composition"
+    family = "usdComposition"
+    icon = "cubes"
+
+    def __init__(self, *args, **kwargs):
+        super(CreateMultiverseUsdComp, self).__init__(*args, **kwargs)
+
+        # Add animation data first, since it maintains order.
+        self.data.update(lib.collect_animation_data(True))
+
+        self.data["stripNamespaces"] = False
+        self.data["mergeTransformAndShape"] = False
+        self.data["flattenContent"] = False
+        self.data["writePendingOverrides"] = False
+        self.data["numTimeSamples"] = 1
+        self.data["timeSamplesSpan"] = 0.0

openpype/hosts/maya/plugins/create/create_multiverse_usd_over.py

@@ -0,0 +1,28 @@
+from openpype.hosts.maya.api import plugin, lib
+
+
+class CreateMultiverseUsdOver(plugin.Creator):
+    """Multiverse USD data"""
+
+    name = "usdOverrideMain"
+    label = "Multiverse USD Override"
+    family = "usdOverride"
+    icon = "cubes"
+
+    def __init__(self, *args, **kwargs):
+        super(CreateMultiverseUsdOver, self).__init__(*args, **kwargs)
+
+        # Add animation data first, since it maintains order.
+        self.data.update(lib.collect_animation_data(True))
+
+        self.data["writeAll"] = False
+        self.data["writeTransforms"] = True
+        self.data["writeVisibility"] = True
+        self.data["writeAttributes"] = True
+        self.data["writeMaterials"] = True
+        self.data["writeVariants"] = True
+        self.data["writeVariantsDefinition"] = True
+        self.data["writeActiveState"] = True
+        self.data["writeNamespaces"] = False
+        self.data["numTimeSamples"] = 1
+        self.data["timeSamplesSpan"] = 0.0

openpype/hosts/maya/plugins/create/create_review.py

@@ -15,6 +15,14 @@ class CreateReview(plugin.Creator):
     keepImages = False
     isolate = False
     imagePlane = True
+    transparency = [
+        "preset",
+        "simple",
+        "object sorting",
+        "weighted average",
+        "depth peeling",
+        "alpha cut"
+    ]
 
     def __init__(self, *args, **kwargs):
         super(CreateReview, self).__init__(*args, **kwargs)
@@ -28,5 +36,6 @@ class CreateReview(plugin.Creator):
         data["isolate"] = self.isolate
         data["keepImages"] = self.keepImages
         data["imagePlane"] = self.imagePlane
+        data["transparency"] = self.transparency
 
         self.data = data

openpype/hosts/maya/plugins/inventory/import_modelrender.py

@@ -1,6 +1,8 @@
 import json
-from avalon import api, io
+from avalon import io
+from bson.objectid import ObjectId
 from openpype.pipeline import (
+    InventoryAction,
     get_representation_context,
     get_representation_path_from_context,
 )
@@ -10,7 +12,7 @@ from openpype.hosts.maya.api.lib import (
 )
 
 
-class ImportModelRender(api.InventoryAction):
+class ImportModelRender(InventoryAction):
 
     label = "Import Model Render Sets"
     icon = "industry"
@@ -39,7 +41,7 @@ class ImportModelRender(api.InventoryAction):
                     nodes.append(n)
 
             repr_doc = io.find_one({
-                "_id": io.ObjectId(container["representation"]),
+                "_id": ObjectId(container["representation"]),
             })
             version_id = repr_doc["parent"]
 

openpype/hosts/maya/plugins/inventory/import_reference.py

@@ -1,11 +1,10 @@
 from maya import cmds
 
-from avalon import api
-
+from openpype.pipeline import InventoryAction
 from openpype.hosts.maya.api.plugin import get_reference_node
 
 
-class ImportReference(api.InventoryAction):
+class ImportReference(InventoryAction):
     """Imports selected reference to inside of the file."""
 
     label = "Import Reference"

openpype/hosts/maya/plugins/load/load_multiverse_usd.py

@@ -0,0 +1,102 @@
+# -*- coding: utf-8 -*-
+import maya.cmds as cmds
+
+from openpype.pipeline import (
+    load,
+    get_representation_path
+)
+from openpype.hosts.maya.api.lib import (
+    maintained_selection,
+    namespaced,
+    unique_namespace
+)
+from openpype.hosts.maya.api.pipeline import containerise
+
+
+class MultiverseUsdLoader(load.LoaderPlugin):
+    """Load the USD by Multiverse"""
+
+    families = ["model", "usd", "usdComposition", "usdOverride",
+                "pointcache", "animation"]
+    representations = ["usd", "usda", "usdc", "usdz", "abc"]
+
+    label = "Read USD by Multiverse"
+    order = -10
+    icon = "code-fork"
+    color = "orange"
+
+    def load(self, context, name=None, namespace=None, options=None):
+
+        asset = context['asset']['name']
+        namespace = namespace or unique_namespace(
+            asset + "_",
+            prefix="_" if asset[0].isdigit() else "",
+            suffix="_",
+        )
+
+        # Create the shape
+        cmds.loadPlugin("MultiverseForMaya", quiet=True)
+
+        shape = None
+        transform = None
+        with maintained_selection():
+            cmds.namespace(addNamespace=namespace)
+            with namespaced(namespace, new=False):
+                import multiverse
+                shape = multiverse.CreateUsdCompound(self.fname)
+                transform = cmds.listRelatives(
+                    shape, parent=True, fullPath=True)[0]
+
+                # Lock the shape node so the user cannot delete it.
+                cmds.lockNode(shape, lock=True)
+
+        nodes = [transform, shape]
+        self[:] = nodes
+
+        return containerise(
+            name=name,
+            namespace=namespace,
+            nodes=nodes,
+            context=context,
+            loader=self.__class__.__name__)
+
+    def update(self, container, representation):
+        # type: (dict, dict) -> None
+        """Update container with specified representation."""
+        node = container['objectName']
+        assert cmds.objExists(node), "Missing container"
+
+        members = cmds.sets(node, query=True) or []
+        shapes = cmds.ls(members, type="mvUsdCompoundShape")
+        assert shapes, "Cannot find mvUsdCompoundShape in container"
+
+        path = get_representation_path(representation)
+
+        import multiverse
+        for shape in shapes:
+            multiverse.SetUsdCompoundAssetPaths(shape, [path])
+
+        cmds.setAttr("{}.representation".format(node),
+                     str(representation["_id"]),
+                     type="string")
+
+    def switch(self, container, representation):
+        self.update(container, representation)
+
+    def remove(self, container):
+        # type: (dict) -> None
+        """Remove loaded container."""
+        # Delete container and its contents
+        if cmds.objExists(container['objectName']):
+            members = cmds.sets(container['objectName'], query=True) or []
+            cmds.delete([container['objectName']] + members)
+
+        # Remove the namespace, if empty
+        namespace = container['namespace']
+        if cmds.namespace(exists=namespace):
+            members = cmds.namespaceInfo(namespace, listNamespace=True)
+            if not members:
+                cmds.namespace(removeNamespace=namespace)
+            else:
+                self.log.warning("Namespace not deleted because it "
+                                 "still has members: %s", namespace)

openpype/hosts/maya/plugins/load/load_vrayproxy.py

@@ -7,6 +7,8 @@ loader will use them instead of native vray vrmesh format.
 """
 import os
 
+from bson.objectid import ObjectId
+
 import maya.cmds as cmds
 
 from avalon import io
@@ -186,7 +188,7 @@ class VRayProxyLoader(load.LoaderPlugin):
         abc_rep = io.find_one(
             {
                 "type": "representation",
-                "parent": io.ObjectId(version_id),
+                "parent": ObjectId(version_id),
                 "name": "abc"
             })
 

openpype/hosts/maya/plugins/publish/extract_maya_scene_raw.py

@@ -6,7 +6,7 @@ from maya import cmds
 
 import openpype.api
 from openpype.hosts.maya.api.lib import maintained_selection
-from avalon.pipeline import AVALON_CONTAINER_ID
+from openpype.pipeline import AVALON_CONTAINER_ID
 
 
 class ExtractMayaSceneRaw(openpype.api.Extractor):

openpype/hosts/maya/plugins/publish/extract_multiverse_usd.py

@@ -0,0 +1,210 @@
+import os
+import six
+
+from maya import cmds
+
+import openpype.api
+from openpype.hosts.maya.api.lib import maintained_selection
+
+
+class ExtractMultiverseUsd(openpype.api.Extractor):
+    """Extractor for USD by Multiverse."""
+
+    label = "Extract Multiverse USD"
+    hosts = ["maya"]
+    families = ["usd"]
+
+    @property
+    def options(self):
+        """Overridable options for Multiverse USD Export
+
+        Given in the following format
+            - {NAME: EXPECTED TYPE}
+
+        If the overridden option's type does not match,
+        the option is not included and a warning is logged.
+
+        """
+
+        return {
+            "stripNamespaces": bool,
+            "mergeTransformAndShape": bool,
+            "writeAncestors": bool,
+            "flattenParentXforms": bool,
+            "writeSparseOverrides": bool,
+            "useMetaPrimPath": bool,
+            "customRootPath": str,
+            "customAttributes": str,
+            "nodeTypesToIgnore": str,
+            "writeMeshes": bool,
+            "writeCurves": bool,
+            "writeParticles": bool,
+            "writeCameras": bool,
+            "writeLights": bool,
+            "writeJoints": bool,
+            "writeCollections": bool,
+            "writePositions": bool,
+            "writeNormals": bool,
+            "writeUVs": bool,
+            "writeColorSets": bool,
+            "writeTangents": bool,
+            "writeRefPositions": bool,
+            "writeBlendShapes": bool,
+            "writeDisplayColor": bool,
+            "writeSkinWeights": bool,
+            "writeMaterialAssignment": bool,
+            "writeHardwareShader": bool,
+            "writeShadingNetworks": bool,
+            "writeTransformMatrix": bool,
+            "writeUsdAttributes": bool,
+            "timeVaryingTopology": bool,
+            "customMaterialNamespace": str,
+            "numTimeSamples": int,
+            "timeSamplesSpan": float
+        }
+
+    @property
+    def default_options(self):
+        """The default options for Multiverse USD extraction."""
+
+        return {
+            "stripNamespaces": False,
+            "mergeTransformAndShape": False,
+            "writeAncestors": True,
+            "flattenParentXforms": False,
+            "writeSparseOverrides": False,
+            "useMetaPrimPath": False,
+            "customRootPath": str(),
+            "customAttributes": str(),
+            "nodeTypesToIgnore": str(),
+            "writeMeshes": True,
+            "writeCurves": True,
+            "writeParticles": True,
+            "writeCameras": False,
+            "writeLights": False,
+            "writeJoints": False,
+            "writeCollections": False,
+            "writePositions": True,
+            "writeNormals": True,
+            "writeUVs": True,
+            "writeColorSets": False,
+            "writeTangents": False,
+            "writeRefPositions": False,
+            "writeBlendShapes": False,
+            "writeDisplayColor": False,
+            "writeSkinWeights": False,
+            "writeMaterialAssignment": False,
+            "writeHardwareShader": False,
+            "writeShadingNetworks": False,
+            "writeTransformMatrix": True,
+            "writeUsdAttributes": False,
+            "timeVaryingTopology": False,
+            "customMaterialNamespace": str(),
+            "numTimeSamples": 1,
+            "timeSamplesSpan": 0.0
+        }
+
+    def parse_overrides(self, instance, options):
+        """Inspect data of instance to determine overridden options"""
+
+        for key in instance.data:
+            if key not in self.options:
+                continue
+
+            # Ensure the data is of correct type
+            value = instance.data[key]
+            if isinstance(value, six.text_type):
+                value = str(value)
+            if not isinstance(value, self.options[key]):
+                self.log.warning(
+                    "Overridden attribute {key} was of "
+                    "the wrong type: {invalid_type} "
+                    "- should have been {valid_type}".format(
+                        key=key,
+                        invalid_type=type(value).__name__,
+                        valid_type=self.options[key].__name__))
+                continue
+
+            options[key] = value
+
+        return options
+
+    def process(self, instance):
+        # Load plugin firstly
+        cmds.loadPlugin("MultiverseForMaya", quiet=True)
+
+        # Define output file path
+        staging_dir = self.staging_dir(instance)
+        file_name = "{}.usd".format(instance.name)
+        file_path = os.path.join(staging_dir, file_name)
+        file_path = file_path.replace('\\', '/')
+
+        # Parse export options
+        options = self.default_options
+        options = self.parse_overrides(instance, options)
+        self.log.info("Export options: {0}".format(options))
+
+        # Perform extraction
+        self.log.info("Performing extraction ...")
+
+        with maintained_selection():
+            members = instance.data("setMembers")
+            members = cmds.ls(members,
+                              dag=True,
+                              shapes=True,
+                              type=("mesh"),
+                              noIntermediate=True,
+                              long=True)
+            self.log.info('Collected object {}'.format(members))
+
+            import multiverse
+
+            time_opts = None
+            frame_start = instance.data['frameStart']
+            frame_end = instance.data['frameEnd']
+            handle_start = instance.data['handleStart']
+            handle_end = instance.data['handleEnd']
+            step = instance.data['step']
+            fps = instance.data['fps']
+            if frame_end != frame_start:
+                time_opts = multiverse.TimeOptions()
+
+                time_opts.writeTimeRange = True
+                time_opts.frameRange = (
+                    frame_start - handle_start, frame_end + handle_end)
+                time_opts.frameIncrement = step
+                time_opts.numTimeSamples = instance.data["numTimeSamples"]
+                time_opts.timeSamplesSpan = instance.data["timeSamplesSpan"]
+                time_opts.framePerSecond = fps
+
+            asset_write_opts = multiverse.AssetWriteOptions(time_opts)
+            options_discard_keys = {
+                'numTimeSamples',
+                'timeSamplesSpan',
+                'frameStart',
+                'frameEnd',
+                'handleStart',
+                'handleEnd',
+                'step',
+                'fps'
+            }
+            for key, value in options.items():
+                if key in options_discard_keys:
+                    continue
+                setattr(asset_write_opts, key, value)
+
+            multiverse.WriteAsset(file_path, members, asset_write_opts)
+
+        if "representations" not in instance.data:
+            instance.data["representations"] = []
+
+        representation = {
+            'name': 'usd',
+            'ext': 'usd',
+            'files': file_name,
+            "stagingDir": staging_dir
+        }
+        instance.data["representations"].append(representation)
+
+        self.log.info("Extracted instance {} to {}".format(
+            instance.name, file_path))

openpype/hosts/maya/plugins/publish/extract_multiverse_usd_comp.py

@@ -0,0 +1,151 @@
+import os
+
+from maya import cmds
+
+import openpype.api
+from openpype.hosts.maya.api.lib import maintained_selection
+
+
+class ExtractMultiverseUsdComposition(openpype.api.Extractor):
+    """Extractor of Multiverse USD Composition."""
+
+    label = "Extract Multiverse USD Composition"
+    hosts = ["maya"]
+    families = ["usdComposition"]
+
+    @property
+    def options(self):
+        """Overridable options for Multiverse USD Export
+
+        Given in the following format
+            - {NAME: EXPECTED TYPE}
+
+        If the overridden option's type does not match,
+        the option is not included and a warning is logged.
+
+        """
+
+        return {
+            "stripNamespaces": bool,
+            "mergeTransformAndShape": bool,
+            "flattenContent": bool,
+            "writePendingOverrides": bool,
+            "numTimeSamples": int,
+            "timeSamplesSpan": float
+        }
+
+    @property
+    def default_options(self):
+        """The default options for Multiverse USD extraction."""
+
+        return {
+            "stripNamespaces": True,
+            "mergeTransformAndShape": False,
+            "flattenContent": False,
+            "writePendingOverrides": False,
+            "numTimeSamples": 1,
+            "timeSamplesSpan": 0.0
+        }
+
+    def parse_overrides(self, instance, options):
+        """Inspect data of instance to determine overridden options"""
+
+        for key in instance.data:
+            if key not in self.options:
+                continue
+
+            # Ensure the data is of correct type
+            value = instance.data[key]
+            if not isinstance(value, self.options[key]):
+                self.log.warning(
+                    "Overridden attribute {key} was of "
+                    "the wrong type: {invalid_type} "
+                    "- should have been {valid_type}".format(
+                        key=key,
+                        invalid_type=type(value).__name__,
+                        valid_type=self.options[key].__name__))
+                continue
+
+            options[key] = value
+
+        return options
+
+    def process(self, instance):
+        # Load plugin firstly
+        cmds.loadPlugin("MultiverseForMaya", quiet=True)
+
+        # Define output file path
+        staging_dir = self.staging_dir(instance)
+        file_name = "{}.usd".format(instance.name)
+        file_path = os.path.join(staging_dir, file_name)
+        file_path = file_path.replace('\\', '/')
+
+        # Parse export options
+        options = self.default_options
+        options = self.parse_overrides(instance, options)
+        self.log.info("Export options: {0}".format(options))
+
+        # Perform extraction
+        self.log.info("Performing extraction ...")
+
+        with maintained_selection():
+            members = instance.data("setMembers")
+            members = cmds.ls(members,
+                              dag=True,
+                              shapes=True,
+                              type="mvUsdCompoundShape",
+                              noIntermediate=True,
+                              long=True)
+            self.log.info('Collected object {}'.format(members))
+
+            import multiverse
+
+            time_opts = None
+            frame_start = instance.data['frameStart']
+            frame_end = instance.data['frameEnd']
+            handle_start = instance.data['handleStart']
+            handle_end = instance.data['handleEnd']
+            step = instance.data['step']
+            fps = instance.data['fps']
+            if frame_end != frame_start:
+                time_opts = multiverse.TimeOptions()
+
+                time_opts.writeTimeRange = True
+                time_opts.frameRange = (
+                    frame_start - handle_start, frame_end + handle_end)
+                time_opts.frameIncrement = step
+                time_opts.numTimeSamples = instance.data["numTimeSamples"]
+                time_opts.timeSamplesSpan = instance.data["timeSamplesSpan"]
+                time_opts.framePerSecond = fps
+
+            comp_write_opts = multiverse.CompositionWriteOptions()
+            options_discard_keys = {
+                'numTimeSamples',
+                'timeSamplesSpan',
+                'frameStart',
+                'frameEnd',
+                'handleStart',
+                'handleEnd',
+                'step',
+                'fps'
+            }
+            for key, value in options.items():
+                if key in options_discard_keys:
+                    continue
+                setattr(comp_write_opts, key, value)
+
+            multiverse.WriteComposition(file_path, members, comp_write_opts)
+
+        if "representations" not in instance.data:
+            instance.data["representations"] = []
+
+        representation = {
+            'name': 'usd',
+            'ext': 'usd',
+            'files': file_name,
+            "stagingDir": staging_dir
+        }
+        instance.data["representations"].append(representation)
+
+        self.log.info("Extracted instance {} to {}".format(
+            instance.name, file_path))

openpype/hosts/maya/plugins/publish/extract_multiverse_usd_over.py

@@ -0,0 +1,139 @@
+import os
+
+import openpype.api
+from openpype.hosts.maya.api.lib import maintained_selection
+
+from maya import cmds
+
+
+class ExtractMultiverseUsdOverride(openpype.api.Extractor):
+    """Extractor for USD Override by Multiverse."""
+
+    label = "Extract Multiverse USD Override"
+    hosts = ["maya"]
+    families = ["usdOverride"]
+
+    @property
+    def options(self):
+        """Overridable options for Multiverse USD Export
+
+        Given in the following format
+            - {NAME: EXPECTED TYPE}
+
+        If the overridden option's type does not match,
+        the option is not included and a warning is logged.
+
+        """
+
+        return {
+            "writeAll": bool,
+            "writeTransforms": bool,
+            "writeVisibility": bool,
+            "writeAttributes": bool,
+            "writeMaterials": bool,
+            "writeVariants": bool,
+            "writeVariantsDefinition": bool,
+            "writeActiveState": bool,
+            "writeNamespaces": bool,
+            "numTimeSamples": int,
+            "timeSamplesSpan": float
+        }
+
+    @property
+    def default_options(self):
+        """The default options for Multiverse USD extraction."""
+
+        return {
+            "writeAll": False,
+            "writeTransforms": True,
+            "writeVisibility": True,
+            "writeAttributes": True,
+            "writeMaterials": True,
+            "writeVariants": True,
+            "writeVariantsDefinition": True,
+            "writeActiveState": True,
+            "writeNamespaces": False,
+            "numTimeSamples": 1,
+            "timeSamplesSpan": 0.0
+        }
+
+    def process(self, instance):
+        # Load plugin firstly
+        cmds.loadPlugin("MultiverseForMaya", quiet=True)
+
+        # Define output file path
+        staging_dir = self.staging_dir(instance)
+        file_name = "{}.usda".format(instance.name)
+        file_path = os.path.join(staging_dir, file_name)
+        file_path = file_path.replace("\\", "/")
+
+        # Parse export options
+        options = self.default_options
+        self.log.info("Export options: {0}".format(options))
+
+        # Perform extraction
+        self.log.info("Performing extraction ...")
+
+        with maintained_selection():
+            members = instance.data("setMembers")
+            members = cmds.ls(members,
+                              dag=True,
+                              shapes=True,
+                              type="mvUsdCompoundShape",
+                              noIntermediate=True,
+                              long=True)
+            self.log.info("Collected object {}".format(members))
+
+            # TODO: Deal with asset, composition, overide with options.
+            import multiverse
+
+            time_opts = None
+            frame_start = instance.data["frameStart"]
+            frame_end = instance.data["frameEnd"]
+            handle_start = instance.data["handleStart"]
+            handle_end = instance.data["handleEnd"]
+            step = instance.data["step"]
+            fps = instance.data["fps"]
+            if frame_end != frame_start:
+                time_opts = multiverse.TimeOptions()
+
+                time_opts.writeTimeRange = True
+                time_opts.frameRange = (
+                    frame_start - handle_start, frame_end + handle_end)
+                time_opts.frameIncrement = step
+                time_opts.numTimeSamples = instance.data["numTimeSamples"]
+                time_opts.timeSamplesSpan = instance.data["timeSamplesSpan"]
+                time_opts.framePerSecond = fps
+
+            over_write_opts = multiverse.OverridesWriteOptions(time_opts)
+            options_discard_keys = {
+                "numTimeSamples",
+                "timeSamplesSpan",
+                "frameStart",
+                "frameEnd",
+                "handleStart",
+                "handleEnd",
+                "step",
+                "fps"
+            }
+            for key, value in options.items():
+                if key in options_discard_keys:
+                    continue
+                setattr(over_write_opts, key, value)
+
+            for member in members:
+                multiverse.WriteOverrides(file_path, member, over_write_opts)
+
+        if "representations" not in instance.data:
+            instance.data["representations"] = []
+
+        representation = {
+            "name": "usd",
+            "ext": "usd",
+            "files": file_name,
+            "stagingDir": staging_dir
+        }
+        instance.data["representations"].append(representation)
+
+        self.log.info("Extracted instance {} to {}".format(
+            instance.name, file_path))

openpype/hosts/maya/plugins/publish/extract_playblast.py

@@ -73,6 +73,11 @@ class ExtractPlayblast(openpype.api.Extractor):
         pm.currentTime(refreshFrameInt - 1, edit=True)
         pm.currentTime(refreshFrameInt, edit=True)
 
+        # Override transparency if requested.
+        transparency = instance.data.get("transparency", 0)
+        if transparency != 0:
+            preset["viewport2_options"]["transparencyAlgorithm"] = transparency
+
         # Isolate view is requested by having objects in the set besides a
         # camera.
         if preset.pop("isolate_view", False) and instance.data.get("isolate"):