Merge branch 'develop' into feature/895-add-option-to-define-paht-to-workfile-template

openpype/hosts/blender/plugins/create/create_setdress.py

@@ -1,25 +0,0 @@
-import bpy
-
-from avalon import api, blender
-import openpype.hosts.blender.api.plugin
-
-
-class CreateSetDress(openpype.hosts.blender.api.plugin.Creator):
-    """A grouped package of loaded content"""
-
-    name = "setdressMain"
-    label = "Set Dress"
-    family = "setdress"
-    icon = "cubes"
-    defaults = ["Main", "Anim"]
-
-    def process(self):
-        asset = self.data["asset"]
-        subset = self.data["subset"]
-        name = openpype.hosts.blender.api.plugin.asset_name(asset, subset)
-        collection = bpy.data.collections.new(name=name)
-        bpy.context.scene.collection.children.link(collection)
-        self.data['task'] = api.Session.get('AVALON_TASK')
-        blender.lib.imprint(collection, self.data)
-
-        return collection

openpype/hosts/blender/plugins/load/load_layout.py

@@ -25,9 +25,6 @@ class BlendLayoutLoader(plugin.AssetLoader):
     icon = "code-fork"
     color = "orange"
 
-    animation_creator_name = "CreateAnimation"
-    setdress_creator_name = "CreateSetDress"
-
     def _remove(self, objects, obj_container):
         for obj in list(objects):
             if obj.type == 'ARMATURE':
@@ -293,7 +290,6 @@ class UnrealLayoutLoader(plugin.AssetLoader):
     color = "orange"
 
     animation_creator_name = "CreateAnimation"
-    setdress_creator_name = "CreateSetDress"
 
     def _remove_objects(self, objects):
         for obj in list(objects):
@@ -383,7 +379,7 @@ class UnrealLayoutLoader(plugin.AssetLoader):
 
     def _process(
         self, libpath, layout_container, container_name, representation,
-        actions, parent
+        actions, parent_collection
     ):
         with open(libpath, "r") as fp:
             data = json.load(fp)
@@ -392,6 +388,11 @@ class UnrealLayoutLoader(plugin.AssetLoader):
         layout_collection = bpy.data.collections.new(container_name)
         scene.collection.children.link(layout_collection)
 
+        parent = parent_collection
+
+        if parent is None:
+            parent = scene.collection
+
         all_loaders = api.discover(api.Loader)
 
         avalon_container = bpy.data.collections.get(
@@ -516,23 +517,9 @@ class UnrealLayoutLoader(plugin.AssetLoader):
         container_metadata["libpath"] = libpath
         container_metadata["lib_container"] = lib_container
 
-        # Create a setdress subset to contain all the animation for all
-        # the rigs in the layout
-        creator_plugin = get_creator_by_name(self.setdress_creator_name)
-        if not creator_plugin:
-            raise ValueError("Creator plugin \"{}\" was not found.".format(
-                self.setdress_creator_name
-            ))
-        parent = api.create(
-            creator_plugin,
-            name="animation",
-            asset=api.Session["AVALON_ASSET"],
-            options={"useSelection": True},
-            data={"dependencies": str(context["representation"]["_id"])})
-
         layout_collection = self._process(
             libpath, layout_container, container_name,
-            str(context["representation"]["_id"]), None, parent)
+            str(context["representation"]["_id"]), None, None)
 
         container_metadata["obj_container"] = layout_collection
 

openpype/hosts/blender/plugins/load/load_rig.py

@@ -107,6 +107,9 @@ class BlendRigLoader(plugin.AssetLoader):
 
             if action is not None:
                 local_obj.animation_data.action = action
+            elif local_obj.animation_data.action is not None:
+                plugin.prepare_data(
+                    local_obj.animation_data.action, collection_name)
 
             # Set link the drivers to the local object
             if local_obj.data.animation_data:

openpype/hosts/blender/plugins/publish/extract_animation_collection.py

@@ -1,61 +0,0 @@
-import os
-import json
-
-import openpype.api
-import pyblish.api
-
-import bpy
-
-
-class ExtractSetDress(openpype.api.Extractor):
-    """Extract setdress."""
-
-    label = "Extract SetDress"
-    hosts = ["blender"]
-    families = ["setdress"]
-    optional = True
-    order = pyblish.api.ExtractorOrder + 0.1
-
-    def process(self, instance):
-        stagingdir = self.staging_dir(instance)
-
-        json_data = []
-
-        for i in instance.context:
-            collection = i.data.get("name")
-            container = None
-            for obj in bpy.data.collections[collection].objects:
-                if obj.type == "ARMATURE":
-                    container_name = obj.get("avalon").get("container_name")
-                    container = bpy.data.collections[container_name]
-            if container:
-                json_dict = {
-                    "subset": i.data.get("subset"),
-                    "container": container.name,
-                }
-                json_dict["instance_name"] = container.get("avalon").get(
-                    "instance_name"
-                )
-                json_data.append(json_dict)
-
-        if "representations" not in instance.data:
-            instance.data["representations"] = []
-
-        json_filename = f"{instance.name}.json"
-        json_path = os.path.join(stagingdir, json_filename)
-
-        with open(json_path, "w+") as file:
-            json.dump(json_data, fp=file, indent=2)
-
-        json_representation = {
-            "name": "json",
-            "ext": "json",
-            "files": json_filename,
-            "stagingDir": stagingdir,
-        }
-        instance.data["representations"].append(json_representation)
-
-        self.log.info(
-            "Extracted instance '{}' to: {}".format(instance.name,
-                                                    json_representation)
-        )

openpype/hosts/blender/plugins/publish/extract_fbx_animation.py

@@ -1,4 +1,5 @@
 import os
+import json
 
 import openpype.api
 
@@ -121,6 +122,25 @@ class ExtractAnimationFBX(openpype.api.Extractor):
                 pair[1].user_clear()
                 bpy.data.actions.remove(pair[1])
 
+        json_filename = f"{instance.name}.json"
+        json_path = os.path.join(stagingdir, json_filename)
+
+        json_dict = {}
+
+        collection = instance.data.get("name")
+        container = None
+        for obj in bpy.data.collections[collection].objects:
+            if obj.type == "ARMATURE":
+                container_name = obj.get("avalon").get("container_name")
+                container = bpy.data.collections[container_name]
+        if container:
+            json_dict = {
+                "instance_name": container.get("avalon").get("instance_name")
+            }
+
+        with open(json_path, "w+") as file:
+            json.dump(json_dict, fp=file, indent=2)
+
         if "representations" not in instance.data:
             instance.data["representations"] = []
 
@@ -130,7 +150,15 @@ class ExtractAnimationFBX(openpype.api.Extractor):
             'files': fbx_filename,
             "stagingDir": stagingdir,
         }
+        json_representation = {
+            'name': 'json',
+            'ext': 'json',
+            'files': json_filename,
+            "stagingDir": stagingdir,
+        }
         instance.data["representations"].append(fbx_representation)
+        instance.data["representations"].append(json_representation)
+
 
         self.log.info("Extracted instance '{}' to: {}".format(
                       instance.name, fbx_representation))

openpype/hosts/hiero/api/lib.py

@@ -214,7 +214,9 @@ def get_track_items(
             # add all if no track_type is defined
             return_list.append(track_item)
 
-    return return_list
+    # return output list but make sure all items are TrackItems
+    return [_i for _i in return_list
+            if type(_i) == hiero.core.TrackItem]
 
 
 def get_track_item_pype_tag(track_item):

openpype/hosts/hiero/plugins/publish/extract_clip_effects.py

@@ -52,10 +52,11 @@ class ExtractClipEffects(openpype.api.Extractor):
         instance.data["representations"] = list()
 
         transfer_data = [
-            "handleStart", "handleEnd", "sourceIn", "sourceOut",
-            "frameStart", "frameEnd", "sourceInH", "sourceOutH",
-            "clipIn", "clipOut", "clipInH", "clipOutH", "asset", "track",
-            "version"
+            "handleStart", "handleEnd",
+            "sourceStart", "sourceStartH", "sourceEnd", "sourceEndH",
+            "frameStart", "frameEnd",
+            "clipIn", "clipOut", "clipInH", "clipOutH",
+            "asset", "version"
         ]
 
         # pass data to version

openpype/hosts/hiero/plugins/publish/precollect_clip_effects.py

@@ -5,7 +5,7 @@ import pyblish.api
 class PreCollectClipEffects(pyblish.api.InstancePlugin):
     """Collect soft effects instances."""
 
-    order = pyblish.api.CollectorOrder - 0.508
+    order = pyblish.api.CollectorOrder - 0.579
     label = "Pre-collect Clip Effects Instances"
     families = ["clip"]
 
@@ -24,7 +24,8 @@ class PreCollectClipEffects(pyblish.api.InstancePlugin):
         self.clip_in_h = self.clip_in - self.handle_start
         self.clip_out_h = self.clip_out + self.handle_end
 
-        track = instance.data["trackItem"]
+        track_item = instance.data["item"]
+        track = track_item.parent()
         track_index = track.trackIndex()
         tracks_effect_items = instance.context.data.get("tracksEffectItems")
         clip_effect_items = instance.data.get("clipEffectItems")
@@ -112,7 +113,12 @@ class PreCollectClipEffects(pyblish.api.InstancePlugin):
         node = sitem.node()
         node_serialized = self.node_serialisation(node)
         node_name = sitem.name()
-        node_class = re.sub(r"\d+", "", node_name)
+
+        if "_" in node_name:
+            node_class = re.sub(r"(?:_)[_0-9]+", "", node_name)  # more numbers
+        else:
+            node_class = re.sub(r"\d+", "", node_name)  # one number
+
         # collect timelineIn/Out
         effect_t_in = int(sitem.timelineIn())
         effect_t_out = int(sitem.timelineOut())
@@ -121,6 +127,7 @@ class PreCollectClipEffects(pyblish.api.InstancePlugin):
             return
 
         self.log.debug("node_name: `{}`".format(node_name))
+        self.log.debug("node_class: `{}`".format(node_class))
 
         return {node_name: {
             "class": node_class,

openpype/hosts/hiero/plugins/publish/precollect_instances.py

@@ -2,6 +2,9 @@ import pyblish
 import openpype
 from openpype.hosts.hiero import api as phiero
 from openpype.hosts.hiero.otio import hiero_export
+import hiero
+
+from compiler.ast import flatten
 
 # # developer reload modules
 from pprint import pformat
@@ -14,18 +17,40 @@ class PrecollectInstances(pyblish.api.ContextPlugin):
     label = "Precollect Instances"
     hosts = ["hiero"]
 
+    audio_track_items = []
+
     def process(self, context):
-        otio_timeline = context.data["otioTimeline"]
+        self.otio_timeline = context.data["otioTimeline"]
+
         selected_timeline_items = phiero.get_track_items(
-            selected=True, check_enabled=True, check_tagged=True)
+            selected=True, check_tagged=True, check_enabled=True)
+
+        # only return enabled track items
+        if not selected_timeline_items:
+            selected_timeline_items = phiero.get_track_items(
+                check_enabled=True, check_tagged=True)
+
         self.log.info(
             "Processing enabled track items: {}".format(
                 selected_timeline_items))
 
+        # add all tracks subtreck effect items to context
+        all_tracks = hiero.ui.activeSequence().videoTracks()
+        tracks_effect_items = self.collect_sub_track_items(all_tracks)
+        context.data["tracksEffectItems"] = tracks_effect_items
+
+        # process all sellected timeline track items
         for track_item in selected_timeline_items:
 
             data = {}
             clip_name = track_item.name()
+            source_clip = track_item.source()
+
+            # get clips subtracks and anotations
+            annotations = self.clip_annotations(source_clip)
+            subtracks = self.clip_subtrack(track_item)
+            self.log.debug("Annotations: {}".format(annotations))
+            self.log.debug(">> Subtracks: {}".format(subtracks))
 
             # get openpype tag data
             tag_data = phiero.get_track_item_pype_data(track_item)
@@ -76,12 +101,15 @@ class PrecollectInstances(pyblish.api.ContextPlugin):
                 "item": track_item,
                 "families": families,
                 "publish": tag_data["publish"],
-                "fps": context.data["fps"]
+                "fps": context.data["fps"],
+
+                # clip's effect
+                "clipEffectItems": subtracks,
+                "clipAnnotations": annotations
             })
 
             # otio clip data
-            otio_data = self.get_otio_clip_instance_data(
-                otio_timeline, track_item) or {}
+            otio_data = self.get_otio_clip_instance_data(track_item) or {}
             self.log.debug("__ otio_data: {}".format(pformat(otio_data)))
             data.update(otio_data)
             self.log.debug("__ data: {}".format(pformat(data)))
@@ -185,6 +213,10 @@ class PrecollectInstances(pyblish.api.ContextPlugin):
         item = data.get("item")
         clip_name = item.name()
 
+        # test if any audio clips
+        if not self.test_any_audio(item):
+            return
+
         asset = data["asset"]
         subset = "audioMain"
 
@@ -215,7 +247,28 @@ class PrecollectInstances(pyblish.api.ContextPlugin):
         self.log.debug(
             "_ instance.data: {}".format(pformat(instance.data)))
 
-    def get_otio_clip_instance_data(self, otio_timeline, track_item):
+    def test_any_audio(self, track_item):
+        # collect all audio tracks to class variable
+        if not self.audio_track_items:
+            for otio_clip in self.otio_timeline.each_clip():
+                if otio_clip.parent().kind != "Audio":
+                    continue
+                self.audio_track_items.append(otio_clip)
+
+        # get track item timeline range
+        timeline_range = self.create_otio_time_range_from_timeline_item_data(
+            track_item)
+
+        # loop trough audio track items and search for overlaping clip
+        for otio_audio in self.audio_track_items:
+            parent_range = otio_audio.range_in_parent()
+
+            # if any overaling clip found then return True
+            if openpype.lib.is_overlapping_otio_ranges(
+                    parent_range, timeline_range, strict=False):
+                return True
+
+    def get_otio_clip_instance_data(self, track_item):
         """
         Return otio objects for timeline, track and clip
 
@@ -231,7 +284,7 @@ class PrecollectInstances(pyblish.api.ContextPlugin):
         ti_track_name = track_item.parent().name()
         timeline_range = self.create_otio_time_range_from_timeline_item_data(
             track_item)
-        for otio_clip in otio_timeline.each_clip():
+        for otio_clip in self.otio_timeline.each_clip():
             track_name = otio_clip.parent().name
             parent_range = otio_clip.range_in_parent()
             if ti_track_name not in track_name:
@@ -258,3 +311,76 @@ class PrecollectInstances(pyblish.api.ContextPlugin):
 
         return hiero_export.create_otio_time_range(
             frame_start, frame_duration, fps)
+
+    @staticmethod
+    def collect_sub_track_items(tracks):
+        """
+        Returns dictionary with track index as key and list of subtracks
+        """
+        # collect all subtrack items
+        sub_track_items = {}
+        for track in tracks:
+            items = track.items()
+
+            # skip if no clips on track > need track with effect only
+            if items:
+                continue
+
+            # skip all disabled tracks
+            if not track.isEnabled():
+                continue
+
+            track_index = track.trackIndex()
+            _sub_track_items = flatten(track.subTrackItems())
+
+            # continue only if any subtrack items are collected
+            if len(_sub_track_items) < 1:
+                continue
+
+            enabled_sti = []
+            # loop all found subtrack items and check if they are enabled
+            for _sti in _sub_track_items:
+                # checking if not enabled
+                if not _sti.isEnabled():
+                    continue
+                if isinstance(_sti, hiero.core.Annotation):
+                    continue
+                # collect the subtrack item
+                enabled_sti.append(_sti)
+
+            # continue only if any subtrack items are collected
+            if len(enabled_sti) < 1:
+                continue
+
+            # add collection of subtrackitems to dict
+            sub_track_items[track_index] = enabled_sti
+
+        return sub_track_items
+
+    @staticmethod
+    def clip_annotations(clip):
+        """
+        Returns list of Clip's hiero.core.Annotation
+        """
+        annotations = []
+        subTrackItems = flatten(clip.subTrackItems())
+        annotations += [item for item in subTrackItems if isinstance(
+            item, hiero.core.Annotation)]
+        return annotations
+
+    @staticmethod
+    def clip_subtrack(clip):
+        """
+        Returns list of Clip's hiero.core.SubTrackItem
+        """
+        subtracks = []
+        subTrackItems = flatten(clip.parent().subTrackItems())
+        for item in subTrackItems:
+            # avoid all anotation
+            if isinstance(item, hiero.core.Annotation):
+                continue
+            # # avoid all not anaibled
+            if not item.isEnabled():
+                continue
+            subtracks.append(item)
+        return subtracks

openpype/hosts/hiero/plugins/publish/precollect_workfile.py

@@ -75,10 +75,26 @@ class PrecollectWorkfile(pyblish.api.ContextPlugin):
             "activeProject": project,
             "otioTimeline": otio_timeline,
             "currentFile": curent_file,
-            "fps": fps,
+            "colorspace": self.get_colorspace(project),
+            "fps": fps
         }
         context.data.update(context_data)
 
         self.log.info("Creating instance: {}".format(instance))
         self.log.debug("__ instance.data: {}".format(pformat(instance.data)))
         self.log.debug("__ context_data: {}".format(pformat(context_data)))
+
+    def get_colorspace(self, project):
+        # get workfile's colorspace properties
+        return {
+            "useOCIOEnvironmentOverride": project.useOCIOEnvironmentOverride(),
+            "lutSetting16Bit": project.lutSetting16Bit(),
+            "lutSetting8Bit": project.lutSetting8Bit(),
+            "lutSettingFloat": project.lutSettingFloat(),
+            "lutSettingLog": project.lutSettingLog(),
+            "lutSettingViewer": project.lutSettingViewer(),
+            "lutSettingWorkingSpace": project.lutSettingWorkingSpace(),
+            "lutUseOCIOForExport": project.lutUseOCIOForExport(),
+            "ocioConfigName": project.ocioConfigName(),
+            "ocioConfigPath": project.ocioConfigPath()
+        }

openpype/hosts/nuke/api/lib.py

@@ -1060,7 +1060,7 @@ class WorkfileSettings(object):
         # replace reset resolution from avalon core to pype's
         self.reset_frame_range_handles()
         # add colorspace menu item
-        # self.set_colorspace()
+        self.set_colorspace()
 
     def set_favorites(self):
         work_dir = os.getenv("AVALON_WORKDIR")

openpype/hosts/nuke/plugins/load/load_effects.py

@@ -4,18 +4,19 @@ import json
 from collections import OrderedDict
 
 
-class LoadLuts(api.Loader):
+class LoadEffects(api.Loader):
     """Loading colorspace soft effect exported from nukestudio"""
 
-    representations = ["lutJson"]
-    families = ["lut"]
+    representations = ["effectJson"]
+    families = ["effect"]
 
-    label = "Load Luts - nodes"
+    label = "Load Effects - nodes"
     order = 0
     icon = "cc"
     color = style.colors.light
     ignore_attr = ["useLifetime"]
 
+
     def load(self, context, name, namespace, data):
         """
         Loading function to get the soft effects to particular read node
@@ -66,15 +67,15 @@ class LoadLuts(api.Loader):
                       for key, value in json.load(f).iteritems()}
 
         # get correct order of nodes by positions on track and subtrack
-        nodes_order = self.reorder_nodes(json_f["effects"])
+        nodes_order = self.reorder_nodes(json_f)
 
         # adding nodes to node graph
         # just in case we are in group lets jump out of it
         nuke.endGroup()
 
-        GN = nuke.createNode("Group")
-
-        GN["name"].setValue(object_name)
+        GN = nuke.createNode(
+            "Group",
+            "name {}_1".format(object_name))
 
         # adding content to the group node
         with GN:
@@ -186,7 +187,7 @@ class LoadLuts(api.Loader):
                       for key, value in json.load(f).iteritems()}
 
         # get correct order of nodes by positions on track and subtrack
-        nodes_order = self.reorder_nodes(json_f["effects"])
+        nodes_order = self.reorder_nodes(json_f)
 
         # adding nodes to node graph
         # just in case we are in group lets jump out of it
@@ -266,7 +267,11 @@ class LoadLuts(api.Loader):
             None: if nothing found
         """
         search_name = "{0}_{1}".format(asset, subset)
-        node = [n for n in nuke.allNodes() if search_name in n["name"].value()]
+
+        node = [
+            n for n in nuke.allNodes(filter="Read")
+            if search_name in n["file"].value()
+        ]
         if len(node) > 0:
             rn = node[0]
         else:
@@ -286,8 +291,10 @@ class LoadLuts(api.Loader):
 
     def reorder_nodes(self, data):
         new_order = OrderedDict()
-        trackNums = [v["trackIndex"] for k, v in data.items()]
-        subTrackNums = [v["subTrackIndex"] for k, v in data.items()]
+        trackNums = [v["trackIndex"] for k, v in data.items()
+                     if isinstance(v, dict)]
+        subTrackNums = [v["subTrackIndex"] for k, v in data.items()
+                        if isinstance(v, dict)]
 
         for trackIndex in range(
                 min(trackNums), max(trackNums) + 1):
@@ -300,6 +307,7 @@ class LoadLuts(api.Loader):
 
     def get_item(self, data, trackIndex, subTrackIndex):
         return {key: val for key, val in data.items()
+                if isinstance(val, dict)
                 if subTrackIndex == val["subTrackIndex"]
                 if trackIndex == val["trackIndex"]}
 

openpype/hosts/nuke/plugins/load/load_effects_ip.py

@@ -5,13 +5,13 @@ from collections import OrderedDict
 from openpype.hosts.nuke.api import lib
 
 
-class LoadLutsInputProcess(api.Loader):
+class LoadEffectsInputProcess(api.Loader):
     """Loading colorspace soft effect exported from nukestudio"""
 
-    representations = ["lutJson"]
-    families = ["lut"]
+    representations = ["effectJson"]
+    families = ["effect"]
 
-    label = "Load Luts - Input Process"
+    label = "Load Effects - Input Process"
     order = 0
     icon = "eye"
     color = style.colors.alert
@@ -67,15 +67,15 @@ class LoadLutsInputProcess(api.Loader):
                       for key, value in json.load(f).iteritems()}
 
         # get correct order of nodes by positions on track and subtrack
-        nodes_order = self.reorder_nodes(json_f["effects"])
+        nodes_order = self.reorder_nodes(json_f)
 
         # adding nodes to node graph
         # just in case we are in group lets jump out of it
         nuke.endGroup()
 
-        GN = nuke.createNode("Group")
-
-        GN["name"].setValue(object_name)
+        GN = nuke.createNode(
+            "Group",
+            "name {}_1".format(object_name))
 
         # adding content to the group node
         with GN:
@@ -190,7 +190,7 @@ class LoadLutsInputProcess(api.Loader):
                       for key, value in json.load(f).iteritems()}
 
         # get correct order of nodes by positions on track and subtrack
-        nodes_order = self.reorder_nodes(json_f["effects"])
+        nodes_order = self.reorder_nodes(json_f)
 
         # adding nodes to node graph
         # just in case we are in group lets jump out of it
@@ -304,8 +304,10 @@ class LoadLutsInputProcess(api.Loader):
 
     def reorder_nodes(self, data):
         new_order = OrderedDict()
-        trackNums = [v["trackIndex"] for k, v in data.items()]
-        subTrackNums = [v["subTrackIndex"] for k, v in data.items()]
+        trackNums = [v["trackIndex"] for k, v in data.items()
+                     if isinstance(v, dict)]
+        subTrackNums = [v["subTrackIndex"] for k, v in data.items()
+                        if isinstance(v, dict)]
 
         for trackIndex in range(
                 min(trackNums), max(trackNums) + 1):
@@ -318,6 +320,7 @@ class LoadLutsInputProcess(api.Loader):
 
     def get_item(self, data, trackIndex, subTrackIndex):
         return {key: val for key, val in data.items()
+                if isinstance(val, dict)
                 if subTrackIndex == val["subTrackIndex"]
                 if trackIndex == val["trackIndex"]}
 

openpype/hosts/nuke/startup/menu.py

@@ -1,6 +1,7 @@
 from openpype.hosts.nuke.api.lib import (
     on_script_load,
-    check_inventory_versions
+    check_inventory_versions,
+    WorkfileSettings
 )
 
 import nuke
@@ -9,8 +10,14 @@ from openpype.api import Logger
 log = Logger().get_logger(__name__)
 
 
-nuke.addOnScriptSave(on_script_load)
+# fix ffmpeg settings on script
+nuke.addOnScriptLoad(on_script_load)
+
+# set checker for last versions on loaded containers
 nuke.addOnScriptLoad(check_inventory_versions)
 nuke.addOnScriptSave(check_inventory_versions)
 
+# # set apply all workfile settings on script load and save
+nuke.addOnScriptLoad(WorkfileSettings().set_context_settings)
+
 log.info('Automatic syncing of write file knob to script version')

openpype/hosts/tvpaint/api/__init__.py

@@ -19,6 +19,10 @@ CREATE_PATH = os.path.join(PLUGINS_DIR, "create")
 
 
 def on_instance_toggle(instance, old_value, new_value):
+    # Review may not have real instance in wokrfile metadata
+    if not instance.data.get("uuid"):
+        return
+
     instance_id = instance.data["uuid"]
     found_idx = None
     current_instances = pipeline.list_instances()

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

@@ -1,19 +0,0 @@
-from avalon.tvpaint import pipeline
-from openpype.hosts.tvpaint.api import plugin
-
-
-class CreateReview(plugin.Creator):
-    """Review for global review of all layers."""
-    name = "review"
-    label = "Review"
-    family = "review"
-    icon = "cube"
-    defaults = ["Main"]
-
-    def process(self):
-        instances = pipeline.list_instances()
-        for instance in instances:
-            if instance["family"] == self.family:
-                self.log.info("Review family is already Created.")
-                return
-        super(CreateReview, self).process()

openpype/hosts/tvpaint/plugins/publish/collect_instances.py

@@ -17,6 +17,20 @@ class CollectInstances(pyblish.api.ContextPlugin):
             json.dumps(workfile_instances, indent=4)
         ))
 
+        # Backwards compatibility for workfiles that already have review
+        #   instance in metadata.
+        review_instance_exist = False
+        for instance_data in workfile_instances:
+            if instance_data["family"] == "review":
+                review_instance_exist = True
+                break
+
+        # Fake review instance if review was not found in metadata families
+        if not review_instance_exist:
+            workfile_instances.append(
+                self._create_review_instance_data(context)
+            )
+
         for instance_data in workfile_instances:
             instance_data["fps"] = context.data["sceneFps"]
 
@@ -90,6 +104,16 @@ class CollectInstances(pyblish.api.ContextPlugin):
                 instance, json.dumps(instance.data, indent=4)
             ))
 
+    def _create_review_instance_data(self, context):
+        """Fake review instance data."""
+
+        return {
+            "family": "review",
+            "asset": context.data["workfile_context"]["asset"],
+            # Dummy subset name
+            "subset": "reviewMain"
+        }
+
     def create_render_layer_instance(self, context, instance_data):
         name = instance_data["name"]
         # Change label

openpype/hosts/unreal/plugins/load/load_animation.py

@@ -1,4 +1,5 @@
 import os
+import json
 
 from avalon import api, pipeline
 from avalon.unreal import lib
@@ -61,10 +62,16 @@ class AnimationFBXLoader(api.Loader):
         task = unreal.AssetImportTask()
         task.options = unreal.FbxImportUI()
 
-        # If there are no options, the process cannot be automated
-        if options:
+        libpath = self.fname.replace("fbx", "json")
+
+        with open(libpath, "r") as fp:
+            data = json.load(fp)
+
+        instance_name = data.get("instance_name")
+
+        if instance_name:
             automated = True
-            actor_name = 'PersistentLevel.' + options.get('instance_name')
+            actor_name = 'PersistentLevel.' + instance_name
             actor = unreal.EditorLevelLibrary.get_actor_reference(actor_name)
             skeleton = actor.skeletal_mesh_component.skeletal_mesh.skeleton
             task.options.set_editor_property('skeleton', skeleton)
@@ -81,16 +88,31 @@ class AnimationFBXLoader(api.Loader):
 
         # set import options here
         task.options.set_editor_property(
-            'automated_import_should_detect_type', True)
+            'automated_import_should_detect_type', False)
         task.options.set_editor_property(
-            'original_import_type', unreal.FBXImportType.FBXIT_ANIMATION)
+            'original_import_type', unreal.FBXImportType.FBXIT_SKELETAL_MESH)
+        task.options.set_editor_property(
+            'mesh_type_to_import', unreal.FBXImportType.FBXIT_ANIMATION)
         task.options.set_editor_property('import_mesh', False)
         task.options.set_editor_property('import_animations', True)
+        task.options.set_editor_property('override_full_name', True)
 
-        task.options.skeletal_mesh_import_data.set_editor_property(
-            'import_content_type',
-            unreal.FBXImportContentType.FBXICT_SKINNING_WEIGHTS
+        task.options.anim_sequence_import_data.set_editor_property(
+            'animation_length',
+            unreal.FBXAnimationLengthImportType.FBXALIT_EXPORTED_TIME
         )
+        task.options.anim_sequence_import_data.set_editor_property(
+            'import_meshes_in_bone_hierarchy', False)
+        task.options.anim_sequence_import_data.set_editor_property(
+            'use_default_sample_rate', True)
+        task.options.anim_sequence_import_data.set_editor_property(
+            'import_custom_attribute', True)
+        task.options.anim_sequence_import_data.set_editor_property(
+            'import_bone_tracks', True)
+        task.options.anim_sequence_import_data.set_editor_property(
+            'remove_redundant_keys', True)
+        task.options.anim_sequence_import_data.set_editor_property(
+            'convert_scene', True)
 
         unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])
 

openpype/hosts/unreal/plugins/load/load_setdress.py

@@ -1,127 +0,0 @@
-import json
-
-from avalon import api
-import unreal
-
-
-class AnimationCollectionLoader(api.Loader):
-    """Load Unreal SkeletalMesh from FBX"""
-
-    families = ["setdress"]
-    representations = ["json"]
-
-    label = "Load Animation Collection"
-    icon = "cube"
-    color = "orange"
-
-    def load(self, context, name, namespace, options):
-        from avalon import api, pipeline
-        from avalon.unreal import lib
-        from avalon.unreal import pipeline as unreal_pipeline
-        import unreal
-
-        # Create directory for asset and avalon container
-        root = "/Game/Avalon/Assets"
-        asset = context.get('asset').get('name')
-        suffix = "_CON"
-
-        tools = unreal.AssetToolsHelpers().get_asset_tools()
-        asset_dir, container_name = tools.create_unique_asset_name(
-            "{}/{}".format(root, asset), suffix="")
-
-        container_name += suffix
-
-        unreal.EditorAssetLibrary.make_directory(asset_dir)
-
-        libpath = self.fname
-
-        with open(libpath, "r") as fp:
-            data = json.load(fp)
-
-        all_loaders = api.discover(api.Loader)
-
-        for element in data:
-            reference = element.get('_id')
-
-            loaders = api.loaders_from_representation(all_loaders, reference)
-            loader = None
-            for l in loaders:
-                if l.__name__ == "AnimationFBXLoader":
-                    loader = l
-                    break
-
-            if not loader:
-                continue
-
-            instance_name = element.get('instance_name')
-
-            api.load(
-                loader,
-                reference,
-                namespace=instance_name,
-                options=element
-            )
-
-        # Create Asset Container
-        lib.create_avalon_container(
-            container=container_name, path=asset_dir)
-
-        data = {
-            "schema": "openpype:container-2.0",
-            "id": pipeline.AVALON_CONTAINER_ID,
-            "asset": asset,
-            "namespace": asset_dir,
-            "container_name": container_name,
-            "loader": str(self.__class__.__name__),
-            "representation": context["representation"]["_id"],
-            "parent": context["representation"]["parent"],
-            "family": context["representation"]["context"]["family"]
-        }
-        unreal_pipeline.imprint(
-            "{}/{}".format(asset_dir, container_name), data)
-
-        asset_content = unreal.EditorAssetLibrary.list_assets(
-            asset_dir, recursive=True, include_folder=True
-        )
-
-        return asset_content
-
-    def update(self, container, representation):
-        from avalon import api, io
-        from avalon.unreal import pipeline
-
-        source_path = api.get_representation_path(representation)
-
-        with open(source_path, "r") as fp:
-            data = json.load(fp)
-
-        animation_containers = [
-            i for i in pipeline.ls() if
-            i.get('asset') == container.get('asset') and
-            i.get('family') == 'animation']
-
-        for element in data:
-            new_version = io.find_one({"_id": io.ObjectId(element.get('_id'))})
-            new_version_number = new_version.get('context').get('version')
-            anim_container = None
-            for i in animation_containers:
-                if i.get('container_name') == (element.get('subset') + "_CON"):
-                    anim_container = i
-                    break
-            if not anim_container:
-                continue
-
-            api.update(anim_container, new_version_number)
-
-        container_path = "{}/{}".format(container["namespace"],
-                                        container["objectName"])
-        # update metadata
-        pipeline.imprint(
-            container_path,
-            {
-                "representation": str(representation["_id"]),
-                "parent": str(representation["parent"])
-            })
-
-    def remove(self, container):
-        unreal.EditorAssetLibrary.delete_directory(container["namespace"])