Maya: implement matchmove publishing

openpype/hosts/maya/api/lib.py

@@ -2511,7 +2511,8 @@ def bake_to_world_space(nodes,
                         preserve_outside_keys=False,
                         disable_implicit_control=True,
                         shape=True,
-                        step=1.0):
+                        step=1.0,
+                        copy_input_connections=False):
     """Bake the nodes to world space transformation (incl. other attributes)
 
     Bakes the transforms to world space (while maintaining all its animated
@@ -2571,7 +2572,8 @@ def _get_attrs(node):
             new_name = "{0}_baked".format(short_name)
             new_node = cmds.duplicate(node,
                                       name=new_name,
-                                      renameChildren=True)[0]
+                                      renameChildren=True,
+                                      inputConnections=copy_input_connections)[0]  # noqa
 
             # Connect all attributes on the node except for transform
             # attributes
@@ -2622,10 +2624,14 @@ def _get_attrs(node):
             for attr in transform_attrs:
                 cmds.setAttr('{0}.{1}'.format(new_node, attr), lock=False)
 
+            scale_keys = _remove_scale_keys(node)
+
             # Constraints
             delete_bin.extend(cmds.parentConstraint(node, new_node, mo=False))
             delete_bin.extend(cmds.scaleConstraint(node, new_node, mo=False))
 
+            _set_scale_keys(scale_keys)
+
             world_space_nodes.append(new_node)
 
         bake(world_space_nodes,
@@ -2639,6 +2645,58 @@ def _get_attrs(node):
     return world_space_nodes
 
 
+def _remove_scale_keys(node):
+    """Remove keys on scale attributes on source camera.
+
+    Constraint parenting doesn't work with keyed scale attributes. This method
+    removes keys, they need to be set again after constraint parenting.
+    Args:
+        node (str): identifier of original camera
+    Returns
+        (dict): {camera.scaleAttribute : [time1, time2]}
+    Raises:
+        RuntimeError: when scale key is non default (eg. != 1.0)
+    """
+    scale_attrs = set(["sx", "sy", "sz"])
+
+    saved_keys = {}
+    default_scale_value = 1.0
+    for attr in scale_attrs:
+        orig_node_attr = '{0}.{1}'.format(node, attr)
+
+        times = cmds.keyframe(orig_node_attr, query=True, timeChange=True)
+        if not times:
+            continue
+        else:
+            values = cmds.keyframe(orig_node_attr, query=True,
+                                   valueChange=True)
+            invalid_times = [time for time, value in zip(times, values) if
+                             value != default_scale_value]
+            if invalid_times:
+                raise RuntimeError(
+                    "{} scale keys contain non default values at {}.".format(
+                        node, invalid_times) +
+                    "These cannot be baked out. Please remove keys for " +
+                    "scale attributes")
+        saved_keys[orig_node_attr] = [(time, time) for time in times]
+
+    for orig_node_attr, times in saved_keys.items():
+        cmds.cutKey(orig_node_attr, time=times, option="keys")
+
+    return saved_keys
+
+
+def _set_scale_keys(scale_keys):
+    """Adds keys back on scale attributes on source camera.
+
+    Args:
+        (dict): {camera.scaleAttribute : [(time1, time1), (time2, time2)]}
+    """
+    for orig_node_attr, times in scale_keys.items():
+        cleaned_times = [time[0] for time in times]
+        cmds.setKeyframe(orig_node_attr, time=cleaned_times)
+
+
 def load_capture_preset(data=None):
     """Convert OpenPype Extract Playblast settings to `capture` arguments
 

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

@@ -0,0 +1,32 @@
+from openpype.hosts.maya.api import (
+    lib,
+    plugin
+)
+from openpype.lib import BoolDef
+
+
+class MatchMove(plugin.MayaCreator):
+    """Instance for more complex setup of cameras.
+
+    Might contain multiple cameras, geometries etc.
+
+    It is expected to be extracted into .abc or .ma
+    """
+
+    identifier = "io.openpype.creators.maya.matchmove"
+    label = "Matchmove"
+    family = "matchmove"
+    icon = "video-camera"
+
+    def get_instance_attr_defs(self):
+
+        defs = lib.collect_animation_defs()
+
+        defs.extend([
+            BoolDef("bakeToWorldSpace",
+                    label="Bake Cameras to World-Space",
+                    tooltip="Bake Cameras to World-Space",
+                    default=True),
+        ])
+
+        return defs

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

@@ -101,7 +101,8 @@ class ReferenceLoader(openpype.hosts.maya.api.plugin.ReferenceLoader):
                 "camerarig",
                 "staticMesh",
                 "skeletalMesh",
-                "mvLook"]
+                "mvLook",
+                "matchmove"]
 
     representations = ["ma", "abc", "fbx", "mb"]
 

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

@@ -6,17 +6,21 @@
 from openpype.hosts.maya.api import lib
 
 
-class ExtractCameraAlembic(publish.Extractor):
+class ExtractCameraAlembic(publish.Extractor,
+                           publish.OptionalPyblishPluginMixin):
     """Extract a Camera as Alembic.
 
-    The cameras gets baked to world space by default. Only when the instance's
+    The camera gets baked to world space by default. Only when the instance's
     `bakeToWorldSpace` is set to False it will include its full hierarchy.
 
+    'camera' family expects only single camera, if multiple cameras are needed,
+    'matchmove' is better choice.
+
     """
 
     label = "Camera (Alembic)"
     hosts = ["maya"]
-    families = ["camera"]
+    families = ["camera", "matchmove"]
     bake_attributes = []
 
     def process(self, instance):
@@ -35,10 +39,11 @@ def process(self, instance):
 
         # validate required settings
         assert isinstance(step, float), "Step must be a float value"
-        camera = cameras[0]
 
         # Define extract output file path
         dir_path = self.staging_dir(instance)
+        if not os.path.exists(dir_path):
+            os.makedirs(dir_path)
         filename = "{0}.abc".format(instance.name)
         path = os.path.join(dir_path, filename)
 
@@ -64,9 +69,10 @@ def process(self, instance):
 
                 # if baked, drop the camera hierarchy to maintain
                 # clean output and backwards compatibility
-                camera_root = cmds.listRelatives(
-                    camera, parent=True, fullPath=True)[0]
-                job_str += ' -root {0}'.format(camera_root)
+                camera_roots = cmds.listRelatives(
+                    cameras, parent=True, fullPath=True)
+                for camera_root in camera_roots:
+                    job_str += ' -root {0}'.format(camera_root)
 
                 for member in members:
                     descendants = cmds.listRelatives(member,

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

@@ -7,6 +7,9 @@
 
 from openpype.pipeline import publish
 from openpype.hosts.maya.api import lib
+from openpype.lib import (
+    BoolDef
+)
 
 
 def massage_ma_file(path):
@@ -78,7 +81,8 @@ def unlock(plug):
             cmds.disconnectAttr(source, destination)
 
 
-class ExtractCameraMayaScene(publish.Extractor):
+class ExtractCameraMayaScene(publish.Extractor,
+                             publish.OptionalPyblishPluginMixin):
     """Extract a Camera as Maya Scene.
 
     This will create a duplicate of the camera that will be baked *with*
@@ -88,6 +92,9 @@ class ExtractCameraMayaScene(publish.Extractor):
     The cameras gets baked to world space by default. Only when the instance's
     `bakeToWorldSpace` is set to False it will include its full hierarchy.
 
+    'camera' family expects only single camera, if multiple cameras are needed,
+    'matchmove' is better choice.
+
     Note:
         The extracted Maya ascii file gets "massaged" removing the uuid values
         so they are valid for older versions of Fusion (e.g. 6.4)
@@ -96,9 +103,11 @@ class ExtractCameraMayaScene(publish.Extractor):
 
     label = "Camera (Maya Scene)"
     hosts = ["maya"]
-    families = ["camera"]
+    families = ["camera", "matchmove"]
     scene_type = "ma"
 
+    keep_input_connections = False
+
     def process(self, instance):
         """Plugin entry point."""
         # get settings
@@ -131,15 +140,15 @@ def process(self, instance):
                              "bake to world space is ignored...")
 
         # get cameras
-        members = cmds.ls(instance.data['setMembers'], leaf=True, shapes=True,
-                          long=True, dag=True)
-        cameras = cmds.ls(members, leaf=True, shapes=True, long=True,
-                          dag=True, type="camera")
+        members = set(cmds.ls(instance.data['setMembers'], leaf=True,
+                      shapes=True, long=True, dag=True))
+        cameras = set(cmds.ls(members, leaf=True, shapes=True, long=True,
+                      dag=True, type="camera"))
 
         # validate required settings
         assert isinstance(step, float), "Step must be a float value"
-        camera = cameras[0]
-        transform = cmds.listRelatives(camera, parent=True, fullPath=True)
+        transforms = cmds.listRelatives(list(cameras),
+                                        parent=True, fullPath=True)
 
         # Define extract output file path
         dir_path = self.staging_dir(instance)
@@ -151,23 +160,31 @@ def process(self, instance):
             with lib.evaluation("off"):
                 with lib.suspended_refresh():
                     if bake_to_worldspace:
-                        self.log.debug(
-                            "Performing camera bakes: {}".format(transform))
+                        self.log.info(
+                            "Performing camera bakes: {}".format(transforms))
+                        attr_values = self.get_attr_values_from_data(
+                            instance.data)
+                        keep_input_connections = attr_values.get("keep_input_connections")  # noqa
+
                         baked = lib.bake_to_world_space(
-                            transform,
+                            transforms,
                             frame_range=[start, end],
-                            step=step
+                            step=step,
+                            copy_input_connections=keep_input_connections
                         )
-                        baked_camera_shapes = cmds.ls(baked,
-                                               type="camera",
-                                               dag=True,
-                                               shapes=True,
-                                               long=True)
-
-                        members = members + baked_camera_shapes
-                        members.remove(camera)
+                        baked_camera_shapes = set(cmds.ls(baked,
+                                                  type="camera",
+                                                  dag=True,
+                                                  shapes=True,
+                                                  long=True))
+
+                        for cam in baked_camera_shapes:
+                            self.ensure_image_plane_attachment(cam)
+
+                        members.update(baked_camera_shapes)
+                        members.difference_update(cameras)
                     else:
-                        baked_camera_shapes = cmds.ls(cameras,
+                        baked_camera_shapes = cmds.ls(list(cameras),
                                                       type="camera",
                                                       dag=True,
                                                       shapes=True,
@@ -186,8 +203,8 @@ def process(self, instance):
                         unlock(plug)
                         cmds.setAttr(plug, value)
 
-                    self.log.debug("Performing extraction..")
-                    cmds.select(cmds.ls(members, dag=True,
+                    self.log.info("Performing extraction..")
+                    cmds.select(cmds.ls(list(members), dag=True,
                                         shapes=True, long=True), noExpand=True)
                     cmds.file(path,
                               force=True,
@@ -202,6 +219,8 @@ def process(self, instance):
 
                     # Delete the baked hierarchy
                     if bake_to_worldspace:
+                        for cam in baked_camera_shapes:
+                            self.ensure_image_plane_attachment(cam, True)
                         cmds.delete(baked)
                     if self.scene_type == "ma":
                         massage_ma_file(path)
@@ -219,3 +238,40 @@ def process(self, instance):
 
         self.log.debug("Extracted instance '{0}' to: {1}".format(
             instance.name, path))
+
+    @classmethod
+    def get_attribute_defs(cls):
+        defs = super(ExtractCameraMayaScene, cls).get_attribute_defs()
+
+        defs.extend([
+            BoolDef("keep_input_connections",
+                    label="Keep Input Connections",
+                    tooltip="Preserving input connections will allow Image Planes to stay connected on publish",  # noqa
+                    default=cls.keep_input_connections),
+
+        ])
+
+        return defs
+
+    def ensure_image_plane_attachment(self, camera, reattach=False):
+        """Reattaches image planes to baked or original cameras.
+
+        Baked cameras are duplicates of original ones, even with
+        `keep_input_connections` the connection of image plane is still on the
+        original one. This attaches it to duplicated camera properly.
+        If 'reattach' it attaches back image plane to original camera.
+        TODO figure out use of some context manager
+        (`delete_after` doesnt work)
+        """
+        image_planes = cmds.listConnections(camera, type="imagePlane")
+        if not image_planes:
+            return
+        if reattach:
+            # find original camera name
+            camera = camera[0:camera.find("_baked")]
+
+        image_planes = [x.split("->")[1] for x in image_planes]
+        for image_plane in image_planes:
+            self.log.debug("reattaching {}".format(image_plane))
+            cmds.imagePlane(image_plane, edit=True, detach=True)
+            cmds.imagePlane(image_plane, edit=True, camera=camera)

openpype/settings/defaults/project_settings/maya.json

@@ -1338,6 +1338,12 @@
             "active": true,
             "bake_attributes": []
         },
+        "ExtractCameraMayaScene": {
+            "enabled": true,
+            "optional": true,
+            "active": true,
+            "keep_input_connections": false
+        },
         "ExtractGLB": {
             "enabled": true,
             "active": true,