Merge pull request #190 from tokejepsen/feature/harmony_backdrop_publishing

Publish backdrops with templates.

pype/plugins/harmony/load/load_template.py

@@ -14,6 +14,19 @@ class ImportTemplateLoader(api.Loader):
     label = "Import Template"
 
     def load(self, context, name=None, namespace=None, data=None):
+        # Make backdrops from metadata.
+        backdrops = context["representation"]["data"].get("backdrops", [])
+
+        func = """function func(args)
+        {
+            Backdrop.addBackdrop("Top", args[0]);
+        }
+        func
+        """
+        for backdrop in backdrops:
+            harmony.send({"function": func, "args": [backdrop]})
+
+        # Import template.
         temp_dir = tempfile.mkdtemp()
         zip_file = api.get_representation_path(context["representation"])
         template_path = os.path.join(temp_dir, "temp.tpl")

pype/plugins/harmony/publish/collect_instances.py

@@ -18,7 +18,7 @@ class CollectInstances(pyblish.api.ContextPlugin):
     order = pyblish.api.CollectorOrder
     hosts = ["harmony"]
     families_mapping = {
-        "render": ["imagesequence", "review"],
+        "render": ["imagesequence", "review", "ftrack"],
         "harmony.template": []
     }
 
@@ -45,7 +45,6 @@ class CollectInstances(pyblish.api.ContextPlugin):
                 {"function": "node.getEnable", "args": [node]}
             )["result"]
             instance.data["families"] = self.families_mapping[data["family"]]
-            instance.data["families"].append("ftrack")
 
             # Produce diagnostic message for any graphical
             # user interface interested in visualising it.

pype/plugins/harmony/publish/extract_template.py

@@ -7,6 +7,7 @@ from avalon import harmony
 
 class ExtractTemplate(pype.api.Extractor):
     """Extract the connected nodes to the composite instance."""
+
     label = "Extract Template"
     hosts = ["harmony"]
     families = ["harmony.template"]
@@ -14,36 +15,78 @@ class ExtractTemplate(pype.api.Extractor):
     def process(self, instance):
         staging_dir = self.staging_dir(instance)
 
-        self.log.info("Outputting template to %s" % staging_dir)
+        self.log.info("Outputting template to {}".format(staging_dir))
 
-        self.dependencies = []
-        self.get_dependencies(instance[0])
+        dependencies = []
+        self.get_dependencies(instance[0], dependencies)
 
+        # Get backdrops.
+        backdrops = {}
+        for dependency in dependencies:
+            for backdrop in self.get_backdrops(dependency):
+                backdrops[backdrop["title"]["text"]] = backdrop
+        unique_backdrops = [backdrops[x] for x in set(backdrops.keys())]
+
+        # Get non-connected nodes within backdrops.
+        all_nodes = harmony.send(
+            {"function": "node.subNodes", "args": ["Top"]}
+        )["result"]
+        for node in [x for x in all_nodes if x not in dependencies]:
+            within_unique_backdrops = bool(
+                [x for x in self.get_backdrops(node) if x in unique_backdrops]
+            )
+            if within_unique_backdrops:
+                dependencies.append(node)
+
+        # Make sure we dont export the instance node.
+        if instance[0] in dependencies:
+            dependencies.remove(instance[0])
+
+        # Export template.
         func = """function func(args)
         {
-            var nodes = args[0];
+            // Add an extra node just so a new group can be created.
+            var temp_node = node.add("Top", "temp_note", "NOTE", 0, 0, 0);
+            var template_group = node.createGroup(temp_node, "temp_group");
+            node.deleteNode( template_group + "/temp_note" );
+
+            // This will make Node View to focus on the new group.
             selection.clearSelection();
-            for (var i = 0 ; i < nodes.length; i++)
-            {
-                selection.addNodeToSelection(nodes[i]);
-            }
-        }
-        func
-        """
-        harmony.send({"function": func, "args": [self.dependencies]})
-        func = """function func(args)
-        {
-            copyPaste.createTemplateFromSelection(args[0], args[1]);
-        }
-        func
-        """
-        harmony.send(
-            {
-                "function": func,
-                "args": ["{}.tpl".format(instance.name), staging_dir]
-            }
-        )
+            selection.addNodeToSelection(template_group);
+            Action.perform("onActionEnterGroup()", "Node View");
 
+            // Recreate backdrops in group.
+            for (var i = 0 ; i < args[0].length; i++)
+            {
+                Backdrop.addBackdrop(template_group, args[0][i]);
+            };
+
+            // Copy-paste the selected nodes into the new group.
+            var drag_object = copyPaste.copy(args[1], 1, frame.numberOf, "");
+            copyPaste.pasteNewNodes(drag_object, template_group, "");
+
+            // Select all nodes within group and export as template.
+            Action.perform( "selectAll()", "Node View" );
+            copyPaste.createTemplateFromSelection(args[2], args[3]);
+
+            // Unfocus the group in Node view, delete all nodes and backdrops
+            // created during the process.
+            Action.perform("onActionUpToParent()", "Node View");
+            node.deleteNode(template_group, true, true);
+        }
+        func
+        """
+        harmony.send({
+            "function": func,
+            "args": [
+                unique_backdrops,
+                dependencies,
+                "{}.tpl".format(instance.name),
+                staging_dir
+            ]
+        })
+
+        # Prep representation.
         os.chdir(staging_dir)
         shutil.make_archive(
             "{}".format(instance.name),
@@ -55,11 +98,44 @@ class ExtractTemplate(pype.api.Extractor):
             "name": "tpl",
             "ext": "zip",
             "files": "{}.zip".format(instance.name),
-            "stagingDir": staging_dir,
+            "stagingDir": staging_dir
         }
         instance.data["representations"] = [representation]
 
-    def get_dependencies(self, node):
+    def get_backdrops(self, node):
+        func = """function func(probe_node)
+        {
+            var backdrops = Backdrop.backdrops("Top");
+            var valid_backdrops = [];
+            for(var i=0; i<backdrops.length; i++)
+            {
+                var position = backdrops[i].position;
+
+                var x_valid = false;
+                var node_x = node.coordX(probe_node);
+                if (position.x < node_x && node_x < (position.x + position.w)){
+                    x_valid = true
+                };
+
+                var y_valid = false;
+                var node_y = node.coordY(probe_node);
+                if (position.y < node_y && node_y < (position.y + position.h)){
+                    y_valid = true
+                };
+
+                if (x_valid && y_valid){
+                    valid_backdrops.push(backdrops[i])
+                };
+            }
+            return valid_backdrops;
+        }
+        func
+        """
+        return harmony.send(
+            {"function": func, "args": [node]}
+        )["result"]
+
+    def get_dependencies(self, node, dependencies):
         func = """function func(args)
         {
             var target_node = args[0];
@@ -82,9 +158,9 @@ class ExtractTemplate(pype.api.Extractor):
             if not dependency:
                 continue
 
-            if dependency in self.dependencies:
+            if dependency in dependencies:
                 continue
 
-            self.dependencies.append(dependency)
+            dependencies.append(dependency)
 
-            self.get_dependencies(dependency)
+            self.get_dependencies(dependency, dependencies)