From 1278a3fd32de4aba3f762ef110b14559344822a9 Mon Sep 17 00:00:00 2001 From: "anas.fadil" Date: Mon, 27 Jun 2022 12:52:24 +0200 Subject: [PATCH 01/13] first implementation --- openpype/hosts/nuke/api/lib.py | 57 ++ .../hosts/nuke/api/lib_template_builder.py | 247 ++++++++ openpype/hosts/nuke/api/pipeline.py | 27 +- openpype/hosts/nuke/api/template_loader.py | 539 ++++++++++++++++++ .../hosts/nuke/plugins/load/load_image.py | 2 +- openpype/lib/abstract_template_loader.py | 479 ++++++++++++++++ openpype/lib/avalon_context.py | 15 + openpype/lib/build_template.py | 66 +++ openpype/lib/build_template_exceptions.py | 35 ++ .../defaults/project_settings/nuke.json | 9 + .../projects_schema/schema_project_nuke.json | 4 + .../schema_templated_workfile.json | 45 ++ .../schema_templated_workfile_build.json | 34 ++ openpype/tools/utils/widgets.py | 4 +- 14 files changed, 1560 insertions(+), 3 deletions(-) create mode 100644 openpype/hosts/nuke/api/lib_template_builder.py create mode 100644 openpype/hosts/nuke/api/template_loader.py create mode 100644 openpype/lib/abstract_template_loader.py create mode 100644 openpype/lib/build_template.py create mode 100644 openpype/lib/build_template_exceptions.py create mode 100644 openpype/settings/entities/schemas/projects_schema/schema_templated_workfile.json create mode 100644 openpype/settings/entities/schemas/projects_schema/schema_templated_workfile_build.json diff --git a/openpype/hosts/nuke/api/lib.py b/openpype/hosts/nuke/api/lib.py index ba8aa7a8dba..93e6a912df0 100644 --- a/openpype/hosts/nuke/api/lib.py +++ b/openpype/hosts/nuke/api/lib.py @@ -2604,3 +2604,60 @@ def ls_img_sequence(path): } return False + + + +def get_io(nodes): + + """ get the input and the output of a group of nodes + """ + if len(nodes) == 0 : + raise Exception("there is no nodes in the list") + if len(nodes) > 1: + input = None + output = None + for n in nodes : + if "Input" in n.name() : + input = n + break + + for n in nodes : + if "Output" in n.name(): + output = n + break + if input == None : + raise Exception("No Input found") + if output == None : + raise Exception("No Output found") + + else : + input = output = nodes[0] + + return input, output + + + +def get_extremes(nodes): + + """ get the 4 numbers that represent the box of a group of nodes """ + if len(nodes) == 0 : + raise Exception("there is no nodes in the list") + nodes_xpos = [n.xpos() for n in nodes] + \ + [n.xpos() + n.screenWidth() for n in nodes] + + nodes_ypos = [n.ypos() for n in nodes] + \ + [n.ypos() + n.screenHeight() for n in nodes] + min_x, min_y = (min(nodes_xpos),min(nodes_ypos)) + max_x, max_y = (max(nodes_xpos),max(nodes_ypos)) + return min_x, min_y , max_x, max_y + + +def refresh_node(node): + + """ correct a bug caused by the multi-threading of nuke + refresh the node to make sure that it takes the desired attributes """ + + x = node.xpos() + y = node.ypos() + nuke.autoplaceSnap(node) + node.setXYpos(x,y) \ No newline at end of file diff --git a/openpype/hosts/nuke/api/lib_template_builder.py b/openpype/hosts/nuke/api/lib_template_builder.py new file mode 100644 index 00000000000..12867f3fff1 --- /dev/null +++ b/openpype/hosts/nuke/api/lib_template_builder.py @@ -0,0 +1,247 @@ +from collections import OrderedDict + +from attr import attributes + +# import maya.cmds as cmds +# from avalon.maya.lib import imprint +from openpype.vendor.python.common import qargparse +from openpype.tools.utils.widgets import OptionDialog +from openpype.hosts.nuke.api.lib import imprint +import nuke +# from avalon.maya.pipeline import get_main_window +# from openpype.hosts.nuke.api.pipeline import get_main_window + + +# To change as enum +build_types = ["context_asset", "linked_asset", "all_assets"] + + + + + + +def get_placeholder_attributes(node, enumerate = False): + list_atts = ['builder_type', 'family', 'representation', 'loader', 'loader_args', 'order', 'asset', 'subset', 'hierarchy', 'siblings', 'last_loaded'] + d = {} + for attr in node.knobs().keys() : + if attr in list_atts : + if enumerate : + try : + d[attr] = node.knob(attr).values() + except : + d[attr] = node.knob(attr).getValue() + else : + d[attr] = node.knob(attr).getValue() + + return d + + +def delete_placeholder_attributes(node): + ''' + function to delete all extra placeholder attributes + ''' + extra_attributes = get_placeholder_attributes(node) + for attribute in extra_attributes.keys(): + try : + node.removeKnob(node.knobs()[attribute]) + except ValueError: + continue + + +def hide_placeholder_attributes(node): + ''' + function to hide all extra placeholder attributes + ''' + extra_attributes = get_placeholder_attributes(node) + for attribute in extra_attributes.keys(): + try : + node.knob(attribute).setVisible(False) + except ValueError: + continue + + + +def create_placeholder(): + + args = placeholder_window() + + if not args: + return # operation canceled, no locator created + + # selection = cmds.ls(selection=True) + selection = nuke.selectedNodes() + + # placeholder = cmds.spaceLocator(name="_TEMPLATE_PLACEHOLDER_")[0] + + + placeholder = nuke.nodes.NoOp() + + + placeholder.setName('PLACEHOLDER') + placeholder.knob('tile_color').setValue(4278190335) + # nuke.collapseToGroup(show = True) + + # if selection: + # cmds.parent(placeholder, selection[0]) + + # custom arg parse to force empty data query + # and still imprint them on placeholder + # and getting items when arg is of type Enumerator + options = OrderedDict() + for arg in args: + if not type(arg) == qargparse.Separator: + options[str(arg)] = arg._data.get("items") or arg.read() + imprint(placeholder, options) + imprint(placeholder, {'is_placeholder' : True}) + + + # Add helper attributes to keep placeholder info + + + # to add attributes : + # knoob = nuke.String_Knob("anas", "anasss") + # knoob.setValue("Fadil") + # placeholder.addKnob(knoob) + # imprint_enum(placeholder, args) + + +def update_placeholder(): + placeholder = nuke.selectedNodes() + if len(placeholder) == 0: + raise ValueError("No node selected") + if len(placeholder) > 1: + raise ValueError("Too many selected nodes") + placeholder = placeholder[0] + + args = placeholder_window(get_placeholder_attributes(placeholder)) + #delete placeholder attributes + delete_placeholder_attributes(placeholder) + if not args: + return # operation canceled + + options = OrderedDict() + for arg in args: + if not type(arg) == qargparse.Separator: + options[str(arg)] = arg._data.get("items") or arg.read() + imprint(placeholder, options) + # imprint_enum(placeholder, args) + + +def imprint_enum(placeholder, args): + """ + Imprint method doesn't act properly with enums. + Replacing the functionnality with this for now + """ + enum_values = {str(arg): arg.read() + for arg in args if arg._data.get("items")} + string_to_value_enum_table = { + build: i for i, build + in enumerate(build_types)} + attrs = {} + for key, value in enum_values.items(): + attrs[key] = string_to_value_enum_table[value] + # try : + # nuke.setPreset(nuke.getNodeClassName(placeholder),"attributes",attrs) + # except Exception: + + # setattr( + # placeholder , key, + # string_to_value_enum_table[value]) + # raise Exception (getattr( + # placeholder , key)) + + + +def placeholder_window(options=None): + from openpype.hosts.nuke.api.pipeline import get_main_window + options = options or dict() + dialog = OptionDialog(parent=get_main_window()) + dialog.setWindowTitle("Create Placeholder") + + args = [ + qargparse.Separator("Main attributes"), + qargparse.Enum( + "builder_type", + label="Asset Builder Type", + default=options.get("builder_type", 0), + items=build_types, + help="""Asset Builder Type +Builder type describe what template loader will look for. + +context_asset : Template loader will look for subsets of +current context asset (Asset bob will find asset) + +linked_asset : Template loader will look for assets linked +to current context asset. +Linked asset are looked in avalon database under field "inputLinks" +""" + ), + qargparse.String( + "family", + default=options.get("family", ""), + label="OpenPype Family", + placeholder="ex: model, look ..."), + qargparse.String( + "representation", + default=options.get("representation", ""), + label="OpenPype Representation", + placeholder="ex: ma, abc ..."), + qargparse.String( + "loader", + default=options.get("loader", ""), + label="Loader", + placeholder="ex: ReferenceLoader, LightLoader ...", + help="""Loader + +Defines what openpype loader will be used to load assets. +Useable loader depends on current host's loader list. +Field is case sensitive. +"""), + qargparse.String( + "loader_args", + default=options.get("loader_args", ""), + label="Loader Arguments", + placeholder='ex: {"camera":"persp", "lights":True}', + help="""Loader + +Defines a dictionnary of arguments used to load assets. +Useable arguments depend on current placeholder Loader. +Field should be a valid python dict. Anything else will be ignored. +"""), + qargparse.Integer( + "order", + default=options.get("order", 0), + min=0, + max=999, + label="Order", + placeholder="ex: 0, 100 ... (smallest order loaded first)", + help="""Order + +Order defines asset loading priority (0 to 999) +Priority rule is : "lowest is first to load"."""), + qargparse.Separator( + "Optional attributes "), + qargparse.String( + "asset", + default=options.get("asset", ""), + label="Asset filter", + placeholder="regex filtering by asset name", + help="Filtering assets by matching field regex to asset's name"), + qargparse.String( + "subset", + default=options.get("subset", ""), + label="Subset filter", + placeholder="regex filtering by subset name", + help="Filtering assets by matching field regex to subset's name"), + qargparse.String( + "hierarchy", + default=options.get("hierarchy", ""), + label="Hierarchy filter", + placeholder="regex filtering by asset's hierarchy", + help="Filtering assets by matching field asset's hierarchy") + ] + dialog.create(args) + if not dialog.exec_(): + return None + + return args diff --git a/openpype/hosts/nuke/api/pipeline.py b/openpype/hosts/nuke/api/pipeline.py index 2785eb65cd9..f9eab87bf1e 100644 --- a/openpype/hosts/nuke/api/pipeline.py +++ b/openpype/hosts/nuke/api/pipeline.py @@ -1,6 +1,10 @@ import os import importlib from collections import OrderedDict +from openpype.lib.build_template import build_workfile_template, update_workfile_template +from openpype.hosts.nuke.api.lib_template_builder import ( + create_placeholder, update_placeholder +) import nuke @@ -10,7 +14,7 @@ from openpype.api import ( Logger, BuildWorkfile, - get_current_project_settings + get_current_project_settings, ) from openpype.lib import register_event_callback from openpype.pipeline import ( @@ -210,6 +214,27 @@ def _install_menu(): lambda: BuildWorkfile().process() ) + + menu_template = menu.addMenu("Template Builder") #creating template menu + menu_template.addCommand( + "Build Workfile from template", + lambda: build_workfile_template() + ) + menu_template.addCommand( + "Update Workfile", + lambda: update_workfile_template() + ) + menu_template.addSeparator() + menu_template.addCommand( + "Create Place Holder", + lambda: create_placeholder() + ) + menu_template.addCommand( + "Update Place Holder", + lambda: update_placeholder() + ) + + menu.addSeparator() menu.addCommand( "Experimental tools...", diff --git a/openpype/hosts/nuke/api/template_loader.py b/openpype/hosts/nuke/api/template_loader.py new file mode 100644 index 00000000000..2bcff2ca1f8 --- /dev/null +++ b/openpype/hosts/nuke/api/template_loader.py @@ -0,0 +1,539 @@ + +from time import sleep +from openpype.hosts.nuke.api.lib_template_builder import delete_placeholder_attributes, get_placeholder_attributes, hide_placeholder_attributes, placeholder_window +from openpype.lib.abstract_template_loader import ( + AbstractPlaceholder, + AbstractTemplateLoader) +from openpype.lib.build_template_exceptions import TemplateAlreadyImported +import nuke +from openpype.hosts.nuke.api.lib import ( + find_free_space_to_paste_nodes, get_extremes, get_io, imprint, refresh_node, reset_selection, select_nodes ) +PLACEHOLDER_SET = 'PLACEHOLDERS_SET' + + +class NukeTemplateLoader(AbstractTemplateLoader): + """Concrete implementation of AbstractTemplateLoader for Nuke + + """ + + def import_template(self, path): + """Import template into current scene. + Block if a template is already loaded. + + Args: + path (str): A path to current template (usually given by + get_template_path implementation) + + Returns: + bool: Wether the template was succesfully imported or not + """ + + #TODO check if the template is already imported + + nuke.nodePaste(path) + reset_selection() + + + return True + + def preload(self, placeholder, loaders_by_name, last_representation): + placeholder.data["nodes_init"] = nuke.allNodes() + placeholder.data["_id"] = last_representation['_id'] + + + + + def populate_template(self, ignored_ids=None) : + place_holders = self.get_template_nodes() + while len(place_holders) > 0 : + super().populate_template(ignored_ids) + place_holders = self.get_template_nodes() + + + @staticmethod + def get_template_nodes(): + attributes = [] + groups = [nuke.thisGroup()] + while len(groups) > 0 : + group = groups.pop(0) + + for node in group.nodes() : + if "builder_type" in node.knobs().keys() and ( 'is_placeholder' not in node.knobs().keys() or 'is_placeholder' in node.knobs().keys() \ + and node.knob('is_placeholder').value() ) : + attributes += [node] + if isinstance(node,nuke.Group) : + groups.append(node) + + + return attributes + + def update_missing_containers(self): + d = {} + + for n in nuke.allNodes(): + refresh_node(n) + if 'id_rep' in n.knobs().keys(): + d[n.knob('id_rep').getValue()] = [] + for n in nuke.allNodes(): + if 'id_rep' in n.knobs().keys(): + d[n.knob('id_rep').getValue()] += [n.name()] + for s in d.values() : + for name in s : + n = nuke.toNode(name) + if 'builder_type' in n.knobs().keys(): + break + if 'builder_type' not in n.knobs().keys(): + continue + + print("je suis rentrĂ©") + placeholder = nuke.nodes.NoOp() + placeholder.setName('PLACEHOLDER') + placeholder.knob('tile_color').setValue(4278190335) + imprint(placeholder, get_placeholder_attributes(n, enumerate= True)) + print(n.name(), "anananan") + placeholder.setXYpos(int(n.knob('x').getValue()), int(n.knob('y').getValue())) + imprint(placeholder, {'nb_children' : 1}) + refresh_node(placeholder) + + self.populate_template(self.get_loaded_containers_by_id()) + + def get_loaded_containers_by_id(self): + ids = {} + for n in nuke.allNodes(): + if 'id_rep' in n.knobs().keys(): + ids[n.knob('id_rep').getValue()] = 0 + ids = list(ids.keys()) + + + return ids + + + def get_placeholders(self): + placeholders = super().get_placeholders() + return placeholders + + + + + + def delete_placeholder(self, placeholder): + # min_x, min_y , max_x, max_y = get_extremes(selectedNodes) + node = placeholder.data['node'] + lastLoaded = placeholder.data['last_loaded'] + + if len(lastLoaded) > 0: + if 'last_loaded' in node.knobs().keys(): + for s in node.knob('last_loaded').values(): + n = nuke.toNode(s) + try : + delete_placeholder_attributes(n) + except : + pass + + lastLoaded_names = [] + for l in lastLoaded : + lastLoaded_names.append(l.name()) + imprint(node, {'last_loaded' : lastLoaded_names}) + + for n in lastLoaded : + refresh_node(n) + refresh_node(node) + if 'builder_type' not in n.knobs().keys(): + imprint(n, get_placeholder_attributes(node, enumerate= True)) + imprint(n, {'is_placeholder' : False}) + hide_placeholder_attributes(n) + n.knob('is_placeholder').setVisible(False) + imprint(n, {'x' : node.xpos(), 'y' : node.ypos()}) + n.knob('x').setVisible(False) + n.knob('y').setVisible(False) + nuke.delete(node) + + + + + +class NukePlaceholder(AbstractPlaceholder): + """Concrete implementation of AbstractPlaceholder for Nuke + + """ + + optional_attributes = {'asset', 'subset', 'hierarchy'} + + def get_data(self, node): + user_data = dict() + for attr in self.attributes.union(self.optional_attributes): + dictKnobs = node.knobs() + if attr in dictKnobs.keys() : + user_data[attr] = dictKnobs[attr].getValue() + user_data['node'] = node + if 'nodes_toReplace' in dictKnobs.keys() : + names = dictKnobs['nodes_toReplace'].values() + nodes = [] + for name in names : + nodes.append(nuke.toNode(name)) + user_data['nodes_toReplace'] = nodes + else : + user_data['nodes_toReplace'] = [node] + + if 'nb_children' in dictKnobs.keys() : + user_data['nb_children'] = int(dictKnobs['nb_children'].getValue()) + else : + user_data['nb_children'] = 0 + if 'siblings' in dictKnobs.keys() : + print(' \n /*/*/ ',dictKnobs['siblings']) + user_data['siblings'] = dictKnobs['siblings'].values() + else : + user_data['siblings'] = [] + + fullName = node.fullName() + user_data['group_name'] = fullName.rpartition('.')[0] + user_data['last_loaded'] = [] + + self.data = user_data + + def parent_in_hierarchy(self, containers): + return + + + + + def clean(self): + + + reset_selection() #deselect all selected nodes + + + node = self.data['node'] + + # use of autoplace snap to be sure that we have the right values (updated) of screenWidth and screenHeight + + + + selectedNodes = [] + nodes_loaded = list(set(nuke.allNodes())-set(self.data["nodes_init"])) # getting the last nodes added + + for n in nodes_loaded : + n.setSelected(True) + refresh_node(n) + selectedNodes.append(n) + + + groupName = self.data['group_name'] + + if (len(groupName) > 0): + # new_node.setSelected(True) + nuke.nodeCopy("%clipboard%") + for n in nuke.selectedNodes(): + nuke.delete(n) + group = nuke.toNode(groupName) + group.begin() + nuke.nodePaste("%clipboard%") + for n in nuke.selectedNodes(): + + n.setSelected(True) + refresh_node(n) + selectedNodes.append(n) + + + + selectedNodes = nuke.selectedNodes() + self.data['last_loaded'] = selectedNodes + reset_selection() + input, output = get_io(selectedNodes) + + copies = None + + #positioning of the loaded nodes + min_x, min_y , max_x, max_y = get_extremes(selectedNodes) + + for n in selectedNodes : + xpos = (n.xpos() - min_x) + node.xpos() + ypos = (n.ypos() - min_y) + node.ypos() + n.setXYpos(xpos, ypos) + + + # save the id of representation for all imported nodes + d = {"id_rep" : str(self.data['_id'])} + + for n in selectedNodes : + if 'builder_type' not in n.knobs().keys(): + imprint(n, d) + n.knob('id_rep').setVisible(False) + + # fix the problem of Z-order + orders_bd = [] + for n in selectedNodes : + if isinstance(n,nuke.BackdropNode) : + orders_bd.append(n.knob("z_order").getValue()) + + if len(orders_bd) > 0 : + + min_order = min(orders_bd) + siblings = self.data["siblings"] + + orders_sib = [] + for s in siblings : + n = nuke.toNode(s) + if isinstance(n,nuke.BackdropNode) : + orders_sib.append(n.knob("z_order").getValue()) + if len(orders_sib) > 0: + max_order = max(orders_sib) + for n in selectedNodes : + if isinstance(n,nuke.BackdropNode) : + n.knob("z_order").setValue(n.knob("z_order").getValue() + max_order-min_order + 1) + + + + if self.data['nb_children'] == 0 : + + #Adjust backdrop dimensions and node positions by getting the difference of dimensions between what was + diff_y = max_y - min_y - node.screenHeight() # difference of heights + diff_x = max_x - min_x - node.screenWidth() # difference of widths + + + if diff_y > 0 or diff_x > 0 : + for n in nuke.allNodes() : + if n != node and n not in selectedNodes : + imprint(n, {'x_init' : n.xpos(), 'y_init' : n.ypos()}) + n.knob('x_init').setVisible(False) + n.knob('y_init').setVisible(False) + if 'bdwidth' in n.knobs().keys(): + imprint(n, {'w_init' : n.screenWidth(), 'h_init' : n.screenHeight()}) + n.knob('w_init').setVisible(False) + n.knob('h_init').setVisible(False) + + if not isinstance(n, nuke.BackdropNode) or isinstance(n, nuke.BackdropNode) and node not in n.getNodes(): + if n.xpos()+n.screenWidth() >= node.xpos() + node.screenWidth(): + + n.setXpos(n.xpos() + diff_x) + print(n.screenHeight(), n.name()) + + + + if n.ypos() + n.screenHeight() >= node.ypos() + node.screenHeight() : + n.setYpos(n.ypos() + diff_y) + + + else : + width = n.knob("bdwidth").getValue() + height = n.knob("bdheight").getValue() + n.knob("bdwidth").setValue(width + diff_x) + n.knob("bdheight").setValue(height + diff_y) + + + + + + + + reset_selection() + + for n in node.dependent(): + for i in range(n.inputs()): + if n.input(i) == node: + n.setInput(i,output) + + for n in node.dependencies(): + for i in range(node.inputs()): + if node.input(i) == n: + input.setInput(0,n) + + for n in selectedNodes: + if "builder_type" in n.knobs().keys() and ( 'is_placeholder' not in n.knobs().keys() or 'is_placeholder' in n.knobs().keys() \ + and n.knob('is_placeholder').value() ): + siblings_nodes = list(set(selectedNodes) - set([n])) + siblings_name = [] + for s in siblings_nodes: + siblings_name.append(s.name()) + siblings = {"siblings":siblings_name} + imprint(n, siblings) + + self.data['nodes_toReplace'] = selectedNodes + + elif len(self.data['siblings']) > 0 : + siblings = self.data['siblings'] + copies ={} + siblings_node = [] + new_nodes = [] + + + #creating copies of the palce_holder siblings (the ones who were loaded with it) for the new nodes added + new_nodes_name = [] + for s in siblings: + n = nuke.toNode(s) + refresh_node(n) + + siblings_node.append(n) + reset_selection() + n.setSelected(True) + print("heeeeeeight", n.screenHeight()) + nuke.nodeCopy("%clipboard%") + reset_selection() + nuke.nodePaste("%clipboard%") + new_node = nuke.selectedNodes()[0] + print("heeeeeeight2", new_node.screenHeight()) + x_init = int(new_node.knob('x_init').getValue()) + y_init = int(new_node.knob('y_init').getValue()) + new_node.setXYpos(x_init, y_init) + if isinstance(new_node, nuke.BackdropNode) : + w_init = new_node.knob('w_init').getValue() + h_init = new_node.knob('h_init').getValue() + new_node.knob('bdwidth').setValue(w_init) + new_node.knob('bdheight').setValue(h_init) + refresh_node(n) + # print("heeeeeeight2", new_node.screenHeight()) + + + # new_node.setXYpos(n.xpos(),n.ypos()) + if 'id_rep' in n.knobs().keys(): + n.removeKnob(n.knob('id_rep')) + new_nodes.append(new_node) + new_nodes_name.append(new_node.name()) + copies[s] = new_node + + + min_xxx, min_yyy , max_xxx, max_yyy = get_extremes(selectedNodes) + diff_y = max_yyy - min_yyy - node.screenHeight() # difference of heights + diff_x = max_xxx - min_xxx - node.screenWidth() # difference of widths + + + if diff_y > 0 or diff_x > 0 : + for n in new_nodes : + if not isinstance(n, nuke.BackdropNode) or isinstance(n, nuke.BackdropNode) and node not in n.getNodes(): + if n.xpos()+n.screenWidth() >= node.xpos() + node.screenWidth(): + n.setXpos(n.xpos() + diff_x) + + if n.ypos() + n.screenHeight() >= node.ypos() + node.screenHeight() : + n.setYpos(n.ypos() + diff_y) + + else : + width = n.knob("bdwidth").getValue() + height = n.knob("bdheight").getValue() + n.knob("bdwidth").setValue(width + diff_x) + n.knob("bdheight").setValue(height + diff_y) + + refresh_node(n) + + node.removeKnob(node.knob('siblings')) + imprint(node, {'siblings' : new_nodes_name}) + + + + inp, out = get_io(siblings_node) + inp_copy, out_copy = (copies[inp.name()], copies[out.name()]) + + + for node_init in siblings_node : + if node_init != out : + node_copy = copies[node_init.name()] + for n in node_init.dependent(): + for i in range(n.inputs()): + if n.input(i) == node_init: + if n in siblings_node: + copies[n.name()].setInput(i, node_copy) + else : + input.setInput(0,node_copy) + + for n in node_init.dependencies(): + for i in range(node_init.inputs()): + if node_init.input(i) == n: + if node_init == inp : + inp_copy.setInput(i,n) + elif n in siblings_node: + node_copy.setInput(i, copies[n.name()]) + else : + node_copy.setInput(i, output) + + inp.setInput(0, out_copy) + + + + min_xx , min_yy , max_xx , max_yy = get_extremes(new_nodes) + minX, _ , maxX, _ = get_extremes(siblings_node) + offset_y = max_yy-min_yy +20 + offset_x = abs(max_xx - min_xx - maxX + minX) + + for n in nuke.allNodes(): + + + if n.ypos() >= min_yy and n not in selectedNodes+new_nodes and n != node : + n.setYpos(n.ypos() + offset_y) + # if 'x' in n.knobs().keys() : + # n.removeKnob(n.knob('x')) + # n.removeKnob(n.knob('y')) + # imprint(n, {'x' : node.xpos() + offset_x, 'y' : node.ypos() + offset_y}) + + if isinstance(n, nuke.BackdropNode) and set(new_nodes) <= set(n.getNodes()) : + height = n.knob("bdheight").getValue() + n.knob("bdheight").setValue(height + offset_y) + width = n.knob("bdwidth").getValue() + n.knob("bdwidth").setValue(width + offset_x) + + new_siblings = [] + for n in new_nodes : + new_siblings.append(n.name()) + self.data['siblings'] = new_siblings + + else : + xpointer, ypointer = find_free_space_to_paste_nodes( + selectedNodes, direction="bottom", offset=200 + ) + n = nuke.createNode("NoOp") + reset_selection() + nuke.delete(n) + for n in selectedNodes : + xpos = (n.xpos() - min_x) + xpointer + ypos = (n.ypos() - min_y) + ypointer + n.setXYpos(xpos, ypos) + + + self.data['nb_children'] += 1 + reset_selection() + nuke.root().begin() # go back to root group + + + def convert_to_db_filters(self, current_asset, linked_asset): + if self.data['builder_type'] == "context_asset": + return [{ + "type": "representation", + "context.asset": { + "$eq": current_asset, "$regex": self.data['asset']}, + "context.subset": {"$regex": self.data['subset']}, + "context.hierarchy": {"$regex": self.data['hierarchy']}, + "context.representation": self.data['representation'], + "context.family": self.data['family'], + }] + + elif self.data['builder_type'] == "linked_asset": + return [{ + "type": "representation", + "context.asset": { + "$eq": asset_name, "$regex": self.data['asset']}, + "context.subset": {"$regex": self.data['subset']}, + "context.hierarchy": {"$regex": self.data['hierarchy']}, + "context.representation": self.data['representation'], + "context.family": self.data['family'], + } for asset_name in linked_asset] + + else: + return [{ + "type": "representation", + "context.asset": {"$regex": self.data['asset']}, + "context.subset": {"$regex": self.data['subset']}, + "context.hierarchy": {"$regex": self.data['hierarchy']}, + "context.representation": self.data['representation'], + "context.family": self.data['family'], + }] + + def err_message(self): + return ( + "Error while trying to load a representation.\n" + "Either the subset wasn't published or the template is malformed." + "\n\n" + "Builder was looking for :\n{attributes}".format( + attributes="\n".join([ + "{}: {}".format(key.title(), value) + for key, value in self.data.items()] + ) + ) + ) diff --git a/openpype/hosts/nuke/plugins/load/load_image.py b/openpype/hosts/nuke/plugins/load/load_image.py index 6df286a4f74..f33a81141c1 100644 --- a/openpype/hosts/nuke/plugins/load/load_image.py +++ b/openpype/hosts/nuke/plugins/load/load_image.py @@ -1,6 +1,6 @@ import nuke -import qargparse +from openpype.vendor.python.common import qargparse from openpype.pipeline import ( legacy_io, diff --git a/openpype/lib/abstract_template_loader.py b/openpype/lib/abstract_template_loader.py new file mode 100644 index 00000000000..2dde74a65c0 --- /dev/null +++ b/openpype/lib/abstract_template_loader.py @@ -0,0 +1,479 @@ +import os +from abc import ABCMeta, abstractmethod + +import traceback + +import six +import openpype +import openpype.pipeline.legacy_io as io +from openpype.lib.avalon_context import get_loaders_by_name +from openpype.settings import get_project_settings +from openpype.lib import Anatomy, get_linked_assets +from openpype.api import PypeLogger as Logger + +from functools import reduce + +from openpype.lib.build_template_exceptions import ( + TemplateAlreadyImported, + TemplateLoadingFailed, + TemplateProfileNotFound, + TemplateNotFound +) + + +def update_representations(entities, entity): + if entity['context']['subset'] not in entities: + entities[entity['context']['subset']] = entity + else: + current = entities[entity['context']['subset']] + incomming = entity + entities[entity['context']['subset']] = max( + current, incomming, + key=lambda entity: entity["context"].get("version", -1)) + + return entities + + +def parse_loader_args(loader_args): + if not loader_args: + return dict() + try: + parsed_args = eval(loader_args) + if not isinstance(parsed_args, dict): + return dict() + else: + return parsed_args + except Exception as err: + print( + "Error while parsing loader arguments '{}'.\n{}: {}\n\n" + "Continuing with default arguments. . .".format( + loader_args, + err.__class__.__name__, + err)) + return dict() + + +@six.add_metaclass(ABCMeta) +class AbstractTemplateLoader: + """ + Abstraction of Template Loader. + + Properties: + template_path : property to get current template path + + Methods: + import_template : Abstract Method. Used to load template, + depending on current host + get_template_nodes : Abstract Method. Used to query nodes acting + as placeholders. Depending on current host + """ + + def __init__(self, placeholder_class): + + self.loaders_by_name = get_loaders_by_name() + self.current_asset = io.Session["AVALON_ASSET"] + self.project_name = io.Session["AVALON_PROJECT"] + self.host_name = io.Session["AVALON_APP"] + self.task_name = io.Session["AVALON_TASK"] + self.placeholder_class = placeholder_class + self.current_asset_docs = io.find_one({ + "type": "asset", + "name": self.current_asset + }) + self.task_type = ( + self.current_asset_docs + .get("data", {}) + .get("tasks", {}) + .get(self.task_name, {}) + .get("type") + ) + + self.log = Logger().get_logger("BUILD TEMPLATE") + + self.log.info( + "BUILDING ASSET FROM TEMPLATE :\n" + "Starting templated build for {asset} in {project}\n\n" + "Asset : {asset}\n" + "Task : {task_name} ({task_type})\n" + "Host : {host}\n" + "Project : {project}\n".format( + asset=self.current_asset, + host=self.host_name, + project=self.project_name, + task_name=self.task_name, + task_type=self.task_type + )) + # Skip if there is no loader + if not self.loaders_by_name: + self.log.warning( + "There is no registered loaders. No assets will be loaded") + return + + def template_already_imported(self, err_msg): + """In case template was already loaded. + Raise the error as a default action. + + Override this method in your template loader implementation + to manage this case.""" + self.log.error("{}: {}".format( + err_msg.__class__.__name__, + err_msg)) + raise TemplateAlreadyImported(err_msg) + + def template_loading_failed(self, err_msg): + """In case template loading failed + Raise the error as a default action. + + Override this method in your template loader implementation + to manage this case. + """ + self.log.error("{}: {}".format( + err_msg.__class__.__name__, + err_msg)) + raise TemplateLoadingFailed(err_msg) + + @property + def template_path(self): + """ + Property returning template path. Avoiding setter. + Getting template path from open pype settings based on current avalon + session and solving the path variables if needed. + + Returns: + str: Solved template path + + Raises: + TemplateProfileNotFound: No profile found from settings for + current avalon session + KeyError: Could not solve path because a key does not exists + in avalon context + TemplateNotFound: Solved path does not exists on current filesystem + """ + project_name = self.project_name + host_name = self.host_name + task_name = self.task_name + task_type = self.task_type + + anatomy = Anatomy(project_name) + project_settings = get_project_settings(project_name) + + build_info = project_settings[host_name]['templated_workfile_build'] + profiles = build_info['profiles'] + + for prf in profiles: + if prf['task_types'] and task_type not in prf['task_types']: + continue + if prf['task_names'] and task_name not in prf['task_names']: + continue + path = prf['path'] + break + else: # IF no template were found (no break happened) + raise TemplateProfileNotFound( + "No matching profile found for task '{}' of type '{}' " + "with host '{}'".format(task_name, task_type, host_name) + ) + if path is None: + raise TemplateLoadingFailed( + "Template path is not set.\n" + "Path need to be set in {}\\Template Workfile Build " + "Settings\\Profiles".format(host_name.title())) + try: + solved_path = None + while True: + solved_path = anatomy.path_remapper(path) + if solved_path is None: + solved_path = path + if solved_path == path: + break + path = solved_path + except KeyError as missing_key: + raise KeyError( + "Could not solve key '{}' in template path '{}'".format( + missing_key, path)) + finally: + solved_path = os.path.normpath(solved_path) + + if not os.path.exists(solved_path): + raise TemplateNotFound( + "Template found in openPype settings for task '{}' with host " + "'{}' does not exists. (Not found : {})".format( + task_name, host_name, solved_path)) + + self.log.info("Found template at : '{}'".format(solved_path)) + + return solved_path + + def populate_template(self, ignored_ids=None): + """ + Use template placeholders to load assets and parent them in hierarchy + + Arguments : + ignored_ids : + + Returns: + None + """ + loaders_by_name = self.loaders_by_name + current_asset = self.current_asset + linked_assets = [asset['name'] for asset + in get_linked_assets(self.current_asset_docs)] + + ignored_ids = ignored_ids or [] + placeholders = self.get_placeholders() + for placeholder in placeholders: + placeholder_representations = self.get_placeholder_representations( + placeholder, + current_asset, + linked_assets + ) + for representation in placeholder_representations: + + self.preload(placeholder, loaders_by_name, representation) + if self.load_data_is_incorrect( + placeholder, + representation, + ignored_ids): + continue + + self.log.info( + "Loading {}_{} with loader {}\n" + "Loader arguments used : {}".format( + representation['context']['asset'], + representation['context']['subset'], + placeholder.loader, + placeholder.data['loader_args'])) + + try: + container = self.load( + placeholder, loaders_by_name, representation) + except Exception: + self.load_failed(placeholder, representation) + else: + self.load_succeed(placeholder, container) + finally: + self.postload(placeholder) + self.delete_placeholder(placeholder) + + + def get_placeholder_representations( + self, placeholder, current_asset, linked_assets): + placeholder_db_filters = placeholder.convert_to_db_filters( + current_asset, + linked_assets) + # get representation by assets. + for db_filter in placeholder_db_filters: + placeholder_representations = list(io.find(db_filter)) + for representation in reduce(update_representations, + placeholder_representations, + dict()).values(): + yield representation + + def load_data_is_incorrect( + self, placeholder, last_representation, ignored_ids): + if not last_representation: + self.log.warning(placeholder.err_message()) + return True + if (str(last_representation['_id']) in ignored_ids): + print("Ignoring : ", last_representation['_id']) + return True + return False + + def preload(self, placeholder, loaders_by_name, last_representation): + pass + + def delete_placeholder(self, placeholder): + pass + + + + def load(self, placeholder, loaders_by_name, last_representation): + from openpype.pipeline.load import load_with_repre_context, get_representation_context + representation = get_representation_context(last_representation) + return load_with_repre_context( + loaders_by_name[placeholder.loader], + representation, + options= parse_loader_args(placeholder.data['loader_args'])) + + + def load_succeed(self, placeholder, container): + placeholder.parent_in_hierarchy(container) + + def load_failed(self, placeholder, last_representation): + self.log.warning("Got error trying to load {}:{} with {}\n\n" + "{}".format(last_representation['context']['asset'], + last_representation['context']['subset'], + placeholder.loader, + traceback.format_exc())) + + def postload(self, placeholder): + placeholder.clean() + + def update_missing_containers(self): + loaded_containers_ids = self.get_loaded_containers_by_id() + self.populate_template(ignored_ids=loaded_containers_ids) + + def get_placeholders(self): + placeholder_class = self.placeholder_class + placeholders = map(placeholder_class, self.get_template_nodes()) + valid_placeholders = filter(placeholder_class.is_valid, placeholders) + sorted_placeholders = sorted(valid_placeholders, + key=placeholder_class.order) + return sorted_placeholders + + @abstractmethod + def get_loaded_containers_by_id(self): + """ + Collect already loaded containers for updating scene + + Return: + dict (string, node): A dictionnary id as key + and containers as value + """ + pass + + @abstractmethod + def import_template(self, template_path): + """ + Import template in current host + + Args: + template_path (str): fullpath to current task and + host's template file + + Return: + None + """ + pass + + @abstractmethod + def get_template_nodes(self): + """ + Returning a list of nodes acting as host placeholders for + templating. The data representation is by user. + AbstractLoadTemplate (and LoadTemplate) won't directly manipulate nodes + + Args : + None + + Returns: + list(AnyNode): Solved template path + """ + pass + + +@six.add_metaclass(ABCMeta) +class AbstractPlaceholder: + """Abstraction of placeholders logic + + Properties: + attributes: A list of mandatory attribute to decribe placeholder + and assets to load. + optional_attributes: A list of optional attribute to decribe + placeholder and assets to load + loader: Name of linked loader to use while loading assets + is_context: Is placeholder linked + to context asset (or to linked assets) + + Methods: + is_repres_valid: + loader: + order: + is_valid: + get_data: + parent_in_hierachy: + + """ + + attributes = {'builder_type', 'family', 'representation', + 'order', 'loader', 'loader_args'} + optional_attributes = {} + + def __init__(self, node): + self.get_data(node) + + def order(self): + """Get placeholder order. + Order is used to sort them by priority + Priority is lowset first, highest last + (ex: + 1: First to load + 100: Last to load) + + Returns: + Int: Order priority + """ + return self.data.get('order') + + @property + def loader(self): + """Return placeholder loader type + + Returns: + string: Loader name + """ + return self.data.get('loader') + + @property + def is_context(self): + """Return placeholder type + context_asset: For loading current asset + linked_asset: For loading linked assets + + Returns: + bool: true if placeholder is a context placeholder + """ + return self.data.get('builder_type') == 'context_asset' + + def is_valid(self): + """Test validity of placeholder + i.e.: every attributes exists in placeholder data + + Returns: + Bool: True if every attributes are a key of data + """ + if set(self.attributes).issubset(self.data.keys()): + print("Valid placeholder : {}".format(self.data["node"])) + return True + print("Placeholder is not valid : {}".format(self.data["node"])) + return False + + @abstractmethod + def parent_in_hierarchy(self, containers): + """Place container in correct hierarchy + given by placeholder + + Args: + containers (String): Container name returned back by + placeholder's loader. + """ + pass + + @abstractmethod + def clean(self): + """Clean placeholder from hierarchy after loading assets. + """ + pass + + @abstractmethod + def convert_to_db_filters(self, current_asset, linked_asset): + """map current placeholder data as a db filter + args: + current_asset (String): Name of current asset in context + linked asset (list[String]) : Names of assets linked to + current asset in context + + Returns: + dict: a dictionnary describing a filter to look for asset in + a database + """ + pass + + @abstractmethod + def get_data(self, node): + """ + Collect placeholders information. + + Args: + node (AnyNode): A unique node decided by Placeholder implementation + """ + pass diff --git a/openpype/lib/avalon_context.py b/openpype/lib/avalon_context.py index 9d8a92cfe9b..94a25fef0fd 100644 --- a/openpype/lib/avalon_context.py +++ b/openpype/lib/avalon_context.py @@ -1588,6 +1588,21 @@ def _collect_last_version_repres(self, asset_entities): return output +@with_pipeline_io +def get_loaders_by_name(): + + from openpype.pipeline.load.plugins import discover_loader_plugins + loaders_by_name = {} + for loader in discover_loader_plugins(): + loader_name = loader.__name__ + if loader_name in loaders_by_name: + raise KeyError( + "Duplicated loader name {0}!".format(loader_name) + ) + loaders_by_name[loader_name] = loader + return loaders_by_name + + @with_pipeline_io def get_creator_by_name(creator_name, case_sensitive=False): """Find creator plugin by name. diff --git a/openpype/lib/build_template.py b/openpype/lib/build_template.py new file mode 100644 index 00000000000..900a0205219 --- /dev/null +++ b/openpype/lib/build_template.py @@ -0,0 +1,66 @@ +import imp +import openpype +from .abstract_template_loader import ( + AbstractPlaceholder, + AbstractTemplateLoader) + +import importlib + +from .build_template_exceptions import ( + TemplateLoadingFailed, + TemplateAlreadyImported, + MissingHostTemplateModule, + MissingTemplatePlaceholderClass, + MissingTemplateLoaderClass +) + +_module_path_format = 'openpype.hosts.{host}.template_loader' + +def build_workfile_template(*args): + + # raise MissingHostTemplateModule( + # "No template loader found for host ") + template_loader = build_template_loader() + try: + template_loader.import_template(template_loader.template_path) + except TemplateAlreadyImported as err: + template_loader.template_already_imported(err) + except TemplateLoadingFailed as err: + template_loader.template_loading_failed(err) + else: + template_loader.populate_template() + + +def update_workfile_template(*args): + template_loader = build_template_loader() + template_loader.update_missing_containers() + + +def build_template_loader(): + from openpype.pipeline.context_tools import registered_host + host_name = registered_host().__name__.partition('.')[2] + host_name = host_name.partition('.')[2] + module_path = _module_path_format.format(host=host_name) + print(10,module_path) + print(11,host_name) + try : + module = importlib.import_module(module_path) + except : + raise Exception(host_name + " " +registered_host().__name__ ) + if not module: + raise MissingHostTemplateModule( + "No template loader found for host {}".format(host_name)) + + template_loader_class = openpype.lib.classes_from_module( + AbstractTemplateLoader, module) + template_placeholder_class = openpype.lib.classes_from_module( + AbstractPlaceholder, module) + + if not template_loader_class: + raise MissingTemplateLoaderClass() + template_loader_class = template_loader_class[0] + + if not template_placeholder_class: + raise MissingTemplatePlaceholderClass() + template_placeholder_class = template_placeholder_class[0] + return template_loader_class(template_placeholder_class) diff --git a/openpype/lib/build_template_exceptions.py b/openpype/lib/build_template_exceptions.py new file mode 100644 index 00000000000..7a5075e3dc9 --- /dev/null +++ b/openpype/lib/build_template_exceptions.py @@ -0,0 +1,35 @@ +class MissingHostTemplateModule(Exception): + """Error raised when expected module does not exists""" + pass + + +class MissingTemplatePlaceholderClass(Exception): + """Error raised when module doesn't implement a placeholder class""" + pass + + +class MissingTemplateLoaderClass(Exception): + """Error raised when module doesn't implement a template loader class""" + pass + + +class TemplateNotFound(Exception): + """Exception raised when template does not exist.""" + pass + + +class TemplateProfileNotFound(Exception): + """Exception raised when current profile + doesn't match any template profile""" + pass + + +class TemplateAlreadyImported(Exception): + """Error raised when Template was already imported by host for + this session""" + pass + + +class TemplateLoadingFailed(Exception): + """Error raised whend Template loader was unable to load the template""" + pass diff --git a/openpype/settings/defaults/project_settings/nuke.json b/openpype/settings/defaults/project_settings/nuke.json index 128d4407327..2281f9cea69 100644 --- a/openpype/settings/defaults/project_settings/nuke.json +++ b/openpype/settings/defaults/project_settings/nuke.json @@ -277,5 +277,14 @@ } ] }, + "templated_workfile_build": { + "profiles": [ + { + "task_types": [], + "task_names": [], + "path": "path\\to\\template" + } + ] + }, "filters": {} } \ No newline at end of file diff --git a/openpype/settings/entities/schemas/projects_schema/schema_project_nuke.json b/openpype/settings/entities/schemas/projects_schema/schema_project_nuke.json index bc572cbdc8d..7ee7d5693ee 100644 --- a/openpype/settings/entities/schemas/projects_schema/schema_project_nuke.json +++ b/openpype/settings/entities/schemas/projects_schema/schema_project_nuke.json @@ -300,6 +300,10 @@ "type": "schema_template", "name": "template_workfile_options" }, + { + "type": "schema", + "name": "schema_templated_workfile_build" + }, { "type": "schema", "name": "schema_publish_gui_filter" diff --git a/openpype/settings/entities/schemas/projects_schema/schema_templated_workfile.json b/openpype/settings/entities/schemas/projects_schema/schema_templated_workfile.json new file mode 100644 index 00000000000..7379978154f --- /dev/null +++ b/openpype/settings/entities/schemas/projects_schema/schema_templated_workfile.json @@ -0,0 +1,45 @@ +[{ + "type": "dict", + "collapsible": true, + "key": "templated_workfile_builder", + "label": "Templated Workfile Builder", + "children": [ + { + "type": "list", + "key": "templates", + "label": "Templates", + "is_group": true, + "use_label_wrap": true, + "object_type": { + "type": "dict", + "children": [ + { + "type": "task-types-enum", + "key": "task_types", + "label": "Task types" + }, + { + "type": "task-types-enum", + "key": "task_names", + "label": "Task names" + }, + { + "type": "splitter" + }, + { + "type": "label", + "label": "Absolute path to workfile template or OpenPype Anatomy text is accepted." + }, + { + "type": "path", + "key": "path", + "label": "Path", + "multiplatform": true, + "multipath": false + } + ] + } + } + ] +} +] diff --git a/openpype/settings/entities/schemas/projects_schema/schema_templated_workfile_build.json b/openpype/settings/entities/schemas/projects_schema/schema_templated_workfile_build.json new file mode 100644 index 00000000000..afb15bad620 --- /dev/null +++ b/openpype/settings/entities/schemas/projects_schema/schema_templated_workfile_build.json @@ -0,0 +1,34 @@ +{ + "type": "dict", + "collapsible": true, + "key": "templated_workfile_build", + "label": "Templated Workfile Build Settings", + "children": [ + { + "type": "list", + "key": "profiles", + "label": "Profiles", + "object_type": { + "type": "dict", + "children": [ + { + "key": "task_types", + "label": "Task types", + "type": "task-types-enum" + }, + { + "key": "task_names", + "label": "Task names", + "type": "list", + "object_type": "text" + }, + { + "key": "path", + "label": "Path to template", + "type": "text" + } + ] + } + } + ] +} \ No newline at end of file diff --git a/openpype/tools/utils/widgets.py b/openpype/tools/utils/widgets.py index d5ae909be8a..c9c30617362 100644 --- a/openpype/tools/utils/widgets.py +++ b/openpype/tools/utils/widgets.py @@ -1,7 +1,9 @@ import logging +from pickletools import optimize from Qt import QtWidgets, QtCore, QtGui -import qargparse +from openpype.vendor.python.common import qargparse +# import argparse import qtawesome from openpype.style import ( get_objected_colors, From f2b0e0c49b884940d57b0f59c3cb1abc6ec699ee Mon Sep 17 00:00:00 2001 From: "anas.fadil" Date: Mon, 4 Jul 2022 18:04:07 +0200 Subject: [PATCH 02/13] clean divided --- openpype/hosts/nuke/api/lib.py | 56 +- .../hosts/nuke/api/lib_template_builder.py | 71 +- openpype/hosts/nuke/api/pipeline.py | 16 +- openpype/hosts/nuke/api/template_loader.py | 627 +++++++++--------- openpype/lib/abstract_template_loader.py | 11 +- openpype/lib/build_template.py | 24 +- 6 files changed, 376 insertions(+), 429 deletions(-) diff --git a/openpype/hosts/nuke/api/lib.py b/openpype/hosts/nuke/api/lib.py index 93e6a912df0..b105912a36a 100644 --- a/openpype/hosts/nuke/api/lib.py +++ b/openpype/hosts/nuke/api/lib.py @@ -2606,50 +2606,49 @@ def ls_img_sequence(path): return False - def get_io(nodes): """ get the input and the output of a group of nodes """ - if len(nodes) == 0 : + if not nodes: raise Exception("there is no nodes in the list") if len(nodes) > 1: input = None output = None - for n in nodes : - if "Input" in n.name() : + for n in nodes: + if "Input" in n.name(): input = n break - for n in nodes : + for n in nodes: if "Output" in n.name(): output = n break - if input == None : + if input is None: raise Exception("No Input found") - if output == None : + if output is None: raise Exception("No Output found") - - else : + else: input = output = nodes[0] return input, output - def get_extremes(nodes): """ get the 4 numbers that represent the box of a group of nodes """ - if len(nodes) == 0 : + if not nodes: raise Exception("there is no nodes in the list") - nodes_xpos = [n.xpos() for n in nodes] + \ - [n.xpos() + n.screenWidth() for n in nodes] + + nodes_xpos = [n.xpos() for n in nodes] + \ + [n.xpos() + n.screenWidth() for n in nodes] + + nodes_ypos = [n.ypos() for n in nodes] + \ + [n.ypos() + n.screenHeight() for n in nodes] - nodes_ypos = [n.ypos() for n in nodes] + \ - [n.ypos() + n.screenHeight() for n in nodes] - min_x, min_y = (min(nodes_xpos),min(nodes_ypos)) - max_x, max_y = (max(nodes_xpos),max(nodes_ypos)) - return min_x, min_y , max_x, max_y + min_x, min_y = (min(nodes_xpos), min(nodes_ypos)) + max_x, max_y = (max(nodes_xpos), max(nodes_ypos)) + return min_x, min_y, max_x, max_y def refresh_node(node): @@ -2660,4 +2659,23 @@ def refresh_node(node): x = node.xpos() y = node.ypos() nuke.autoplaceSnap(node) - node.setXYpos(x,y) \ No newline at end of file + node.setXYpos(x, y) + + +def refresh_nodes(nodes): + for n in nodes: + refresh_node(n) + + +def get_names_from_nodes(nodes): + names = [] + for node in nodes: + names.append(node.name()) + return names + + +def get_nodes_from_names(names): + nodes = [] + for name in names: + nodes.append(nuke.toNode(name)) + return nodes \ No newline at end of file diff --git a/openpype/hosts/nuke/api/lib_template_builder.py b/openpype/hosts/nuke/api/lib_template_builder.py index 12867f3fff1..e552e9f5fd5 100644 --- a/openpype/hosts/nuke/api/lib_template_builder.py +++ b/openpype/hosts/nuke/api/lib_template_builder.py @@ -1,7 +1,5 @@ from collections import OrderedDict -from attr import attributes - # import maya.cmds as cmds # from avalon.maya.lib import imprint from openpype.vendor.python.common import qargparse @@ -9,31 +7,28 @@ from openpype.hosts.nuke.api.lib import imprint import nuke # from avalon.maya.pipeline import get_main_window -# from openpype.hosts.nuke.api.pipeline import get_main_window # To change as enum build_types = ["context_asset", "linked_asset", "all_assets"] +def get_placeholder_attributes(node, enumerate=False): + list_atts = ['builder_type', 'family', 'representation', 'loader', + 'loader_args', 'order', 'asset', 'subset', + 'hierarchy', 'siblings', 'last_loaded'] + attributes = {} + for attr in node.knobs().keys(): + if attr in list_atts: + if enumerate: + try: + attributes[attr] = node.knob(attr).values() + except AttributeError: + attributes[attr] = node.knob(attr).getValue() + else: + attributes[attr] = node.knob(attr).getValue() - - - -def get_placeholder_attributes(node, enumerate = False): - list_atts = ['builder_type', 'family', 'representation', 'loader', 'loader_args', 'order', 'asset', 'subset', 'hierarchy', 'siblings', 'last_loaded'] - d = {} - for attr in node.knobs().keys() : - if attr in list_atts : - if enumerate : - try : - d[attr] = node.knob(attr).values() - except : - d[attr] = node.knob(attr).getValue() - else : - d[attr] = node.knob(attr).getValue() - - return d + return attributes def delete_placeholder_attributes(node): @@ -42,8 +37,8 @@ def delete_placeholder_attributes(node): ''' extra_attributes = get_placeholder_attributes(node) for attribute in extra_attributes.keys(): - try : - node.removeKnob(node.knobs()[attribute]) + try: + node.removeKnob(node.knob(attribute)) except ValueError: continue @@ -54,13 +49,12 @@ def hide_placeholder_attributes(node): ''' extra_attributes = get_placeholder_attributes(node) for attribute in extra_attributes.keys(): - try : + try: node.knob(attribute).setVisible(False) except ValueError: continue - def create_placeholder(): args = placeholder_window() @@ -68,21 +62,9 @@ def create_placeholder(): if not args: return # operation canceled, no locator created - # selection = cmds.ls(selection=True) - selection = nuke.selectedNodes() - - # placeholder = cmds.spaceLocator(name="_TEMPLATE_PLACEHOLDER_")[0] - - placeholder = nuke.nodes.NoOp() - - placeholder.setName('PLACEHOLDER') placeholder.knob('tile_color').setValue(4278190335) - # nuke.collapseToGroup(show = True) - - # if selection: - # cmds.parent(placeholder, selection[0]) # custom arg parse to force empty data query # and still imprint them on placeholder @@ -92,29 +74,19 @@ def create_placeholder(): if not type(arg) == qargparse.Separator: options[str(arg)] = arg._data.get("items") or arg.read() imprint(placeholder, options) - imprint(placeholder, {'is_placeholder' : True}) - - - # Add helper attributes to keep placeholder info - - - # to add attributes : - # knoob = nuke.String_Knob("anas", "anasss") - # knoob.setValue("Fadil") - # placeholder.addKnob(knoob) - # imprint_enum(placeholder, args) + imprint(placeholder, {'is_placeholder': True}) def update_placeholder(): placeholder = nuke.selectedNodes() - if len(placeholder) == 0: + if not placeholder: raise ValueError("No node selected") if len(placeholder) > 1: raise ValueError("Too many selected nodes") placeholder = placeholder[0] args = placeholder_window(get_placeholder_attributes(placeholder)) - #delete placeholder attributes + # delete placeholder attributes delete_placeholder_attributes(placeholder) if not args: return # operation canceled @@ -151,7 +123,6 @@ def imprint_enum(placeholder, args): # placeholder , key)) - def placeholder_window(options=None): from openpype.hosts.nuke.api.pipeline import get_main_window options = options or dict() diff --git a/openpype/hosts/nuke/api/pipeline.py b/openpype/hosts/nuke/api/pipeline.py index f9eab87bf1e..b8aa23b885c 100644 --- a/openpype/hosts/nuke/api/pipeline.py +++ b/openpype/hosts/nuke/api/pipeline.py @@ -1,7 +1,8 @@ import os import importlib from collections import OrderedDict -from openpype.lib.build_template import build_workfile_template, update_workfile_template +from openpype.lib.build_template import (build_workfile_template, + update_workfile_template) from openpype.hosts.nuke.api.lib_template_builder import ( create_placeholder, update_placeholder ) @@ -214,27 +215,24 @@ def _install_menu(): lambda: BuildWorkfile().process() ) - - menu_template = menu.addMenu("Template Builder") #creating template menu + menu_template = menu.addMenu("Template Builder") # creating template menu menu_template.addCommand( "Build Workfile from template", lambda: build_workfile_template() - ) + ) menu_template.addCommand( "Update Workfile", lambda: update_workfile_template() - ) + ) menu_template.addSeparator() menu_template.addCommand( "Create Place Holder", lambda: create_placeholder() - ) + ) menu_template.addCommand( "Update Place Holder", lambda: update_placeholder() - ) - - + ) menu.addSeparator() menu.addCommand( "Experimental tools...", diff --git a/openpype/hosts/nuke/api/template_loader.py b/openpype/hosts/nuke/api/template_loader.py index 2bcff2ca1f8..2e4bc6eab9f 100644 --- a/openpype/hosts/nuke/api/template_loader.py +++ b/openpype/hosts/nuke/api/template_loader.py @@ -1,13 +1,16 @@ - -from time import sleep -from openpype.hosts.nuke.api.lib_template_builder import delete_placeholder_attributes, get_placeholder_attributes, hide_placeholder_attributes, placeholder_window +from openpype.hosts.nuke.api.lib_template_builder import ( + delete_placeholder_attributes, get_placeholder_attributes, + hide_placeholder_attributes) from openpype.lib.abstract_template_loader import ( AbstractPlaceholder, AbstractTemplateLoader) -from openpype.lib.build_template_exceptions import TemplateAlreadyImported +# from openpype.lib.build_template_exceptions import TemplateAlreadyImported import nuke +from collections import defaultdict from openpype.hosts.nuke.api.lib import ( - find_free_space_to_paste_nodes, get_extremes, get_io, imprint, refresh_node, reset_selection, select_nodes ) + find_free_space_to_paste_nodes, get_extremes, get_io, imprint, + refresh_node, refresh_nodes, reset_selection, + get_names_from_nodes, get_nodes_from_names) PLACEHOLDER_SET = 'PLACEHOLDERS_SET' @@ -28,128 +31,136 @@ def import_template(self, path): bool: Wether the template was succesfully imported or not """ - #TODO check if the template is already imported + # TODO check if the template is already imported nuke.nodePaste(path) reset_selection() - return True def preload(self, placeholder, loaders_by_name, last_representation): placeholder.data["nodes_init"] = nuke.allNodes() placeholder.data["_id"] = last_representation['_id'] + reset_selection() + groups_name = placeholder.data['group_name'] + if groups_name: + # nuke.nodeCopy("%clipboard%") + # for n in nuke.selectedNodes(): + # nuke.delete(n) + group = nuke.toNode(groups_name) + group.begin() + # nuke.nodePaste("%clipboard%") + for n in nuke.selectedNodes(): + refresh_node(n) - - def populate_template(self, ignored_ids=None) : - place_holders = self.get_template_nodes() - while len(place_holders) > 0 : + def populate_template(self, ignored_ids=None): + place_holders = self.get_template_nodes() + while len(place_holders) > 0: super().populate_template(ignored_ids) place_holders = self.get_template_nodes() - @staticmethod def get_template_nodes(): - attributes = [] - groups = [nuke.thisGroup()] - while len(groups) > 0 : - group = groups.pop(0) - - for node in group.nodes() : - if "builder_type" in node.knobs().keys() and ( 'is_placeholder' not in node.knobs().keys() or 'is_placeholder' in node.knobs().keys() \ - and node.knob('is_placeholder').value() ) : - attributes += [node] - if isinstance(node,nuke.Group) : - groups.append(node) - - - return attributes + placeholders = [] + allGroups = [nuke.thisGroup()] + while len(allGroups) > 0: + group = allGroups.pop(0) + for node in group.nodes(): + if "builder_type" in node.knobs().keys() and ( + 'is_placeholder' not in node.knobs().keys() + or 'is_placeholder' in node.knobs().keys() + and node.knob('is_placeholder').value()): + if 'empty' in node.knobs().keys()\ + and node.knob('empty').value(): + continue + placeholders += [node] + if isinstance(node, nuke.Group): + allGroups.append(node) - def update_missing_containers(self): - d = {} + return placeholders + def update_missing_containers(self): + nodes_byId = {} + nodes_byId = defaultdict(lambda: [], nodes_byId) for n in nuke.allNodes(): refresh_node(n) if 'id_rep' in n.knobs().keys(): - d[n.knob('id_rep').getValue()] = [] + nodes_byId[n.knob('id_rep').getValue()] = [] for n in nuke.allNodes(): if 'id_rep' in n.knobs().keys(): - d[n.knob('id_rep').getValue()] += [n.name()] - for s in d.values() : - for name in s : + nodes_byId[n.knob('id_rep').getValue()] += [n.name()] + for s in nodes_byId.values(): + n = None + for name in s: n = nuke.toNode(name) if 'builder_type' in n.knobs().keys(): break - if 'builder_type' not in n.knobs().keys(): - continue - - print("je suis rentrĂ©") - placeholder = nuke.nodes.NoOp() - placeholder.setName('PLACEHOLDER') - placeholder.knob('tile_color').setValue(4278190335) - imprint(placeholder, get_placeholder_attributes(n, enumerate= True)) - print(n.name(), "anananan") - placeholder.setXYpos(int(n.knob('x').getValue()), int(n.knob('y').getValue())) - imprint(placeholder, {'nb_children' : 1}) - refresh_node(placeholder) + if n is not None and 'builder_type' in n.knobs().keys(): + + placeholder = nuke.nodes.NoOp() + placeholder.setName('PLACEHOLDER') + placeholder.knob('tile_color').setValue(4278190335) + attributes = get_placeholder_attributes(n, enumerate=True) + imprint(placeholder, attributes) + x = int(n.knob('x').getValue()) + y = int(n.knob('y').getValue()) + placeholder.setXYpos(x, y) + imprint(placeholder, {'nb_children': 1}) + refresh_node(placeholder) self.populate_template(self.get_loaded_containers_by_id()) def get_loaded_containers_by_id(self): - ids = {} + ids = [] for n in nuke.allNodes(): - if 'id_rep' in n.knobs().keys(): - ids[n.knob('id_rep').getValue()] = 0 - ids = list(ids.keys()) - + if 'id_rep' in n.knobs(): + ids.append(n.knob('id_rep').getValue()) + # Removes duplicates in the list + ids = list(set(ids)) return ids - def get_placeholders(self): placeholders = super().get_placeholders() return placeholders - - - - - + def delete_placeholder(self, placeholder): - # min_x, min_y , max_x, max_y = get_extremes(selectedNodes) + # min_x, min_y , max_x, max_y = get_extremes(nodes_loaded) node = placeholder.data['node'] lastLoaded = placeholder.data['last_loaded'] - - if len(lastLoaded) > 0: - if 'last_loaded' in node.knobs().keys(): - for s in node.knob('last_loaded').values(): - n = nuke.toNode(s) - try : - delete_placeholder_attributes(n) - except : - pass - - lastLoaded_names = [] - for l in lastLoaded : - lastLoaded_names.append(l.name()) - imprint(node, {'last_loaded' : lastLoaded_names}) - - for n in lastLoaded : - refresh_node(n) - refresh_node(node) - if 'builder_type' not in n.knobs().keys(): - imprint(n, get_placeholder_attributes(node, enumerate= True)) - imprint(n, {'is_placeholder' : False}) - hide_placeholder_attributes(n) - n.knob('is_placeholder').setVisible(False) - imprint(n, {'x' : node.xpos(), 'y' : node.ypos()}) - n.knob('x').setVisible(False) - n.knob('y').setVisible(False) - nuke.delete(node) - - + if 'delete' in placeholder.data.keys()\ + and placeholder.data['delete'] is False: + imprint(node, {"empty": True}) + else: + if lastLoaded: + if 'last_loaded' in node.knobs().keys(): + for s in node.knob('last_loaded').values(): + n = nuke.toNode(s) + try: + delete_placeholder_attributes(n) + except Exception: + pass + + lastLoaded_names = [] + for loadedNode in lastLoaded: + lastLoaded_names.append(loadedNode.name()) + imprint(node, {'last_loaded': lastLoaded_names}) + for n in lastLoaded: + refresh_node(n) + refresh_node(node) + if 'builder_type' not in n.knobs().keys(): + attributes = get_placeholder_attributes(node, True) + imprint(n, attributes) + imprint(n, {'is_placeholder': False}) + hide_placeholder_attributes(n) + n.knob('is_placeholder').setVisible(False) + imprint(n, {'x': node.xpos(), 'y': node.ypos()}) + n.knob('x').setVisible(False) + n.knob('y').setVisible(False) + nuke.delete(node) class NukePlaceholder(AbstractPlaceholder): @@ -161,28 +172,27 @@ class NukePlaceholder(AbstractPlaceholder): def get_data(self, node): user_data = dict() + dictKnobs = node.knobs() for attr in self.attributes.union(self.optional_attributes): - dictKnobs = node.knobs() - if attr in dictKnobs.keys() : + if attr in dictKnobs.keys(): user_data[attr] = dictKnobs[attr].getValue() user_data['node'] = node - if 'nodes_toReplace' in dictKnobs.keys() : + if 'nodes_toReplace' in dictKnobs.keys(): names = dictKnobs['nodes_toReplace'].values() nodes = [] - for name in names : + for name in names: nodes.append(nuke.toNode(name)) user_data['nodes_toReplace'] = nodes - else : + else: user_data['nodes_toReplace'] = [node] - if 'nb_children' in dictKnobs.keys() : + if 'nb_children' in dictKnobs.keys(): user_data['nb_children'] = int(dictKnobs['nb_children'].getValue()) - else : + else: user_data['nb_children'] = 0 - if 'siblings' in dictKnobs.keys() : - print(' \n /*/*/ ',dictKnobs['siblings']) + if 'siblings' in dictKnobs.keys(): user_data['siblings'] = dictKnobs['siblings'].values() - else : + else: user_data['siblings'] = [] fullName = node.fullName() @@ -194,219 +204,90 @@ def get_data(self, node): def parent_in_hierarchy(self, containers): return - - - - def clean(self): - - - reset_selection() #deselect all selected nodes - - - node = self.data['node'] - - # use of autoplace snap to be sure that we have the right values (updated) of screenWidth and screenHeight - - - - selectedNodes = [] - nodes_loaded = list(set(nuke.allNodes())-set(self.data["nodes_init"])) # getting the last nodes added - - for n in nodes_loaded : + def create_sib_copies(self): + # creating copies of the palce_holder siblings (the ones who were + # loaded with it) for the new nodes added + copies = {} + siblings = get_nodes_from_names(self.data['siblings']) + for n in siblings: + reset_selection() n.setSelected(True) - refresh_node(n) - selectedNodes.append(n) - - - groupName = self.data['group_name'] - - if (len(groupName) > 0): - # new_node.setSelected(True) nuke.nodeCopy("%clipboard%") - for n in nuke.selectedNodes(): - nuke.delete(n) - group = nuke.toNode(groupName) - group.begin() + reset_selection() nuke.nodePaste("%clipboard%") - for n in nuke.selectedNodes(): - - n.setSelected(True) + new_node = nuke.selectedNodes()[0] + x_init = int(new_node.knob('x_init').getValue()) + y_init = int(new_node.knob('y_init').getValue()) + new_node.setXYpos(x_init, y_init) + if isinstance(new_node, nuke.BackdropNode): + w_init = new_node.knob('w_init').getValue() + h_init = new_node.knob('h_init').getValue() + new_node.knob('bdwidth').setValue(w_init) + new_node.knob('bdheight').setValue(h_init) refresh_node(n) - selectedNodes.append(n) - - - selectedNodes = nuke.selectedNodes() - self.data['last_loaded'] = selectedNodes - reset_selection() - input, output = get_io(selectedNodes) - - copies = None - - #positioning of the loaded nodes - min_x, min_y , max_x, max_y = get_extremes(selectedNodes) - - for n in selectedNodes : - xpos = (n.xpos() - min_x) + node.xpos() - ypos = (n.ypos() - min_y) + node.ypos() - n.setXYpos(xpos, ypos) - - - # save the id of representation for all imported nodes - d = {"id_rep" : str(self.data['_id'])} - - for n in selectedNodes : - if 'builder_type' not in n.knobs().keys(): - imprint(n, d) - n.knob('id_rep').setVisible(False) + if 'id_rep' in n.knobs().keys(): + n.removeKnob(n.knob('id_rep')) + copies[n.name()] = new_node + return copies + def fix_z_order(self): # fix the problem of Z-order orders_bd = [] - for n in selectedNodes : - if isinstance(n,nuke.BackdropNode) : + nodes_loaded = self.data['last_loaded'] + for n in nodes_loaded: + if isinstance(n, nuke.BackdropNode): orders_bd.append(n.knob("z_order").getValue()) - if len(orders_bd) > 0 : + if orders_bd: min_order = min(orders_bd) siblings = self.data["siblings"] orders_sib = [] - for s in siblings : - n = nuke.toNode(s) - if isinstance(n,nuke.BackdropNode) : - orders_sib.append(n.knob("z_order").getValue()) - if len(orders_sib) > 0: - max_order = max(orders_sib) - for n in selectedNodes : - if isinstance(n,nuke.BackdropNode) : - n.knob("z_order").setValue(n.knob("z_order").getValue() + max_order-min_order + 1) - - - - if self.data['nb_children'] == 0 : - - #Adjust backdrop dimensions and node positions by getting the difference of dimensions between what was - diff_y = max_y - min_y - node.screenHeight() # difference of heights - diff_x = max_x - min_x - node.screenWidth() # difference of widths - - - if diff_y > 0 or diff_x > 0 : - for n in nuke.allNodes() : - if n != node and n not in selectedNodes : - imprint(n, {'x_init' : n.xpos(), 'y_init' : n.ypos()}) - n.knob('x_init').setVisible(False) - n.knob('y_init').setVisible(False) - if 'bdwidth' in n.knobs().keys(): - imprint(n, {'w_init' : n.screenWidth(), 'h_init' : n.screenHeight()}) - n.knob('w_init').setVisible(False) - n.knob('h_init').setVisible(False) - - if not isinstance(n, nuke.BackdropNode) or isinstance(n, nuke.BackdropNode) and node not in n.getNodes(): - if n.xpos()+n.screenWidth() >= node.xpos() + node.screenWidth(): - - n.setXpos(n.xpos() + diff_x) - print(n.screenHeight(), n.name()) - - - - if n.ypos() + n.screenHeight() >= node.ypos() + node.screenHeight() : - n.setYpos(n.ypos() + diff_y) - - - else : - width = n.knob("bdwidth").getValue() - height = n.knob("bdheight").getValue() - n.knob("bdwidth").setValue(width + diff_x) - n.knob("bdheight").setValue(height + diff_y) - - - - - - - - reset_selection() - - for n in node.dependent(): - for i in range(n.inputs()): - if n.input(i) == node: - n.setInput(i,output) - - for n in node.dependencies(): - for i in range(node.inputs()): - if node.input(i) == n: - input.setInput(0,n) - - for n in selectedNodes: - if "builder_type" in n.knobs().keys() and ( 'is_placeholder' not in n.knobs().keys() or 'is_placeholder' in n.knobs().keys() \ - and n.knob('is_placeholder').value() ): - siblings_nodes = list(set(selectedNodes) - set([n])) - siblings_name = [] - for s in siblings_nodes: - siblings_name.append(s.name()) - siblings = {"siblings":siblings_name} - imprint(n, siblings) - - self.data['nodes_toReplace'] = selectedNodes - - elif len(self.data['siblings']) > 0 : - siblings = self.data['siblings'] - copies ={} - siblings_node = [] - new_nodes = [] - - - #creating copies of the palce_holder siblings (the ones who were loaded with it) for the new nodes added - new_nodes_name = [] for s in siblings: n = nuke.toNode(s) + if isinstance(n, nuke.BackdropNode): + orders_sib.append(n.knob("z_order").getValue()) + if orders_sib: + max_order = max(orders_sib) + for n in nodes_loaded: + if isinstance(n, nuke.BackdropNode): + z_order = n.knob("z_order").getValue() + n.knob("z_order").setValue( + z_order + max_order - min_order + 1) + + def update_nodes(self, nodes): + # Adjust backdrop dimensions and node positions by getting + # the difference of dimensions between what was + node = self.data['node'] + width_ph = node.screenWidth() + height_ph = node.screenHeight() + nodes_loaded = self.data['last_loaded'] + min_x, min_y, max_x, max_y = get_extremes(nodes_loaded) + + # difference of heights + diff_y = max_y - min_y - height_ph + # difference of widths + diff_x = max_x - min_x - width_ph + + if diff_y > 0 or diff_x > 0: + for n in nodes: refresh_node(n) + if n != node and n not in nodes_loaded: + width = n.screenWidth() + height = n.screenHeight() + if not isinstance(n, nuke.BackdropNode)\ + or isinstance(n, nuke.BackdropNode)\ + and node not in n.getNodes(): + if n.xpos() + width >= node.xpos() + width_ph: - siblings_node.append(n) - reset_selection() - n.setSelected(True) - print("heeeeeeight", n.screenHeight()) - nuke.nodeCopy("%clipboard%") - reset_selection() - nuke.nodePaste("%clipboard%") - new_node = nuke.selectedNodes()[0] - print("heeeeeeight2", new_node.screenHeight()) - x_init = int(new_node.knob('x_init').getValue()) - y_init = int(new_node.knob('y_init').getValue()) - new_node.setXYpos(x_init, y_init) - if isinstance(new_node, nuke.BackdropNode) : - w_init = new_node.knob('w_init').getValue() - h_init = new_node.knob('h_init').getValue() - new_node.knob('bdwidth').setValue(w_init) - new_node.knob('bdheight').setValue(h_init) - refresh_node(n) - # print("heeeeeeight2", new_node.screenHeight()) - - - # new_node.setXYpos(n.xpos(),n.ypos()) - if 'id_rep' in n.knobs().keys(): - n.removeKnob(n.knob('id_rep')) - new_nodes.append(new_node) - new_nodes_name.append(new_node.name()) - copies[s] = new_node - - - min_xxx, min_yyy , max_xxx, max_yyy = get_extremes(selectedNodes) - diff_y = max_yyy - min_yyy - node.screenHeight() # difference of heights - diff_x = max_xxx - min_xxx - node.screenWidth() # difference of widths - - - if diff_y > 0 or diff_x > 0 : - for n in new_nodes : - if not isinstance(n, nuke.BackdropNode) or isinstance(n, nuke.BackdropNode) and node not in n.getNodes(): - if n.xpos()+n.screenWidth() >= node.xpos() + node.screenWidth(): n.setXpos(n.xpos() + diff_x) - if n.ypos() + n.screenHeight() >= node.ypos() + node.screenHeight() : + if n.ypos() + height >= node.ypos() + height_ph: n.setYpos(n.ypos() + diff_y) - else : + else: width = n.knob("bdwidth").getValue() height = n.knob("bdheight").getValue() n.knob("bdwidth").setValue(width + diff_x) @@ -414,83 +295,171 @@ def clean(self): refresh_node(n) - node.removeKnob(node.knob('siblings')) - imprint(node, {'siblings' : new_nodes_name}) + def imprint_inits(self): + for n in nuke.allNodes(): + refresh_node(n) + imprint(n, {'x_init': n.xpos(), 'y_init': n.ypos()}) + n.knob('x_init').setVisible(False) + n.knob('y_init').setVisible(False) + width = n.screenWidth() + height = n.screenHeight() + if 'bdwidth' in n.knobs().keys(): + imprint(n, {'w_init': width, 'h_init': height}) + n.knob('w_init').setVisible(False) + n.knob('h_init').setVisible(False) + + def imprint_siblings(self): + nodes_loaded = self.data['last_loaded'] + d = {"id_rep": str(self.data['_id'])} + + for n in nodes_loaded: + if "builder_type" in n.knobs().keys()\ + and ('is_placeholder' not in n.knobs().keys() + or 'is_placeholder' in n.knobs().keys() + and n.knob('is_placeholder').value()): + + siblingss = list(set(nodes_loaded) - set([n])) + siblings_name = [] + for s in siblingss: + siblings_name.append(s.name()) + siblings = {"siblings": siblings_name} + imprint(n, siblings) + + elif 'builder_type' not in n.knobs().keys(): + # save the id of representation for all imported nodes + imprint(n, d) + # n.knob('id_rep').setVisible(False) + refresh_node(n) + + def set_loaded_connections(self): + node = self.data['node'] + input, output = get_io(self.data['last_loaded']) + for n in node.dependent(): + for i in range(n.inputs()): + if n.input(i) == node: + n.setInput(i, output) + + for n in node.dependencies(): + for i in range(node.inputs()): + if node.input(i) == n: + input.setInput(0, n) + + def set_copies_connections(self, copies): + input, output = get_io(self.data['last_loaded']) + siblings = get_nodes_from_names(self.data['siblings']) + inp, out = get_io(siblings) + inp_copy, out_copy = (copies[inp.name()], copies[out.name()]) + + for node_init in siblings: + if node_init != out: + node_copy = copies[node_init.name()] + for n in node_init.dependent(): + for i in range(n.inputs()): + if n.input(i) == node_init: + if n in siblings: + copies[n.name()].setInput(i, node_copy) + else: + input.setInput(0, node_copy) + + for n in node_init.dependencies(): + for i in range(node_init.inputs()): + if node_init.input(i) == n: + if node_init == inp: + inp_copy.setInput(i, n) + elif n in siblings: + node_copy.setInput(i, copies[n.name()]) + else: + node_copy.setInput(i, output) + + inp.setInput(0, out_copy) + def clean(self): + # deselect all selected nodes + node = self.data['node'] - inp, out = get_io(siblings_node) - inp_copy, out_copy = (copies[inp.name()], copies[out.name()]) + # getting the latest nodes added + nodes_init = self.data["nodes_init"] + nodes_loaded = list(set(nuke.allNodes()) - set(nodes_init)) + if not nodes_loaded: + self.data['delete'] = False + return + self.data['last_loaded'] = nodes_loaded + reset_selection() + refresh_nodes(nodes_loaded) + + # positioning of the loaded nodes + min_x, min_y, _, _ = get_extremes(nodes_loaded) + + for n in nodes_loaded: + xpos = (n.xpos() - min_x) + node.xpos() + ypos = (n.ypos() - min_y) + node.ypos() + n.setXYpos(xpos, ypos) + refresh_nodes(nodes_loaded) - for node_init in siblings_node : - if node_init != out : - node_copy = copies[node_init.name()] - for n in node_init.dependent(): - for i in range(n.inputs()): - if n.input(i) == node_init: - if n in siblings_node: - copies[n.name()].setInput(i, node_copy) - else : - input.setInput(0,node_copy) + self.fix_z_order() + self.imprint_siblings() - for n in node_init.dependencies(): - for i in range(node_init.inputs()): - if node_init.input(i) == n: - if node_init == inp : - inp_copy.setInput(i,n) - elif n in siblings_node: - node_copy.setInput(i, copies[n.name()]) - else : - node_copy.setInput(i, output) + if self.data['nb_children'] == 0: + self.imprint_inits() + self.update_nodes(nuke.allNodes()) - inp.setInput(0, out_copy) + # update dependecies and dependent + self.set_loaded_connections() + elif self.data['siblings']: + siblings = get_nodes_from_names(self.data['siblings']) + refresh_nodes(siblings) - - min_xx , min_yy , max_xx , max_yy = get_extremes(new_nodes) - minX, _ , maxX, _ = get_extremes(siblings_node) - offset_y = max_yy-min_yy +20 + copies = self.create_sib_copies() + new_nodes = list(copies.values()) + self.update_nodes(new_nodes) + node.removeKnob(node.knob('siblings')) + new_nodes_name = get_names_from_nodes(new_nodes) + imprint(node, {'siblings': new_nodes_name}) + self.set_copies_connections(copies) + + min_xx, min_yy, max_xx, max_yy = get_extremes(new_nodes) + minX, _, maxX, _ = get_extremes(siblings) + offset_y = max_yy - min_yy + 20 offset_x = abs(max_xx - min_xx - maxX + minX) for n in nuke.allNodes(): - - if n.ypos() >= min_yy and n not in selectedNodes+new_nodes and n != node : + if (n.ypos() >= min_yy + and n not in nodes_loaded + new_nodes + and n != node): n.setYpos(n.ypos() + offset_y) - # if 'x' in n.knobs().keys() : - # n.removeKnob(n.knob('x')) - # n.removeKnob(n.knob('y')) - # imprint(n, {'x' : node.xpos() + offset_x, 'y' : node.ypos() + offset_y}) - if isinstance(n, nuke.BackdropNode) and set(new_nodes) <= set(n.getNodes()) : + if isinstance(n, nuke.BackdropNode)\ + and set(new_nodes) <= set(n.getNodes()): height = n.knob("bdheight").getValue() n.knob("bdheight").setValue(height + offset_y) width = n.knob("bdwidth").getValue() n.knob("bdwidth").setValue(width + offset_x) new_siblings = [] - for n in new_nodes : + for n in new_nodes: new_siblings.append(n.name()) self.data['siblings'] = new_siblings - else : + else: xpointer, ypointer = find_free_space_to_paste_nodes( - selectedNodes, direction="bottom", offset=200 + nodes_loaded, direction="bottom", offset=200 ) n = nuke.createNode("NoOp") reset_selection() nuke.delete(n) - for n in selectedNodes : + for n in nodes_loaded: xpos = (n.xpos() - min_x) + xpointer ypos = (n.ypos() - min_y) + ypointer n.setXYpos(xpos, ypos) - - self.data['nb_children'] += 1 + self.data['nb_children'] += 1 reset_selection() - nuke.root().begin() # go back to root group - + # go back to root group + nuke.root().begin() def convert_to_db_filters(self, current_asset, linked_asset): if self.data['builder_type'] == "context_asset": @@ -530,7 +499,7 @@ def err_message(self): "Error while trying to load a representation.\n" "Either the subset wasn't published or the template is malformed." "\n\n" - "Builder was looking for :\n{attributes}".format( + "Builder was looking for:\n{attributes}".format( attributes="\n".join([ "{}: {}".format(key.title(), value) for key, value in self.data.items()] diff --git a/openpype/lib/abstract_template_loader.py b/openpype/lib/abstract_template_loader.py index 2dde74a65c0..604573be25f 100644 --- a/openpype/lib/abstract_template_loader.py +++ b/openpype/lib/abstract_template_loader.py @@ -4,7 +4,6 @@ import traceback import six -import openpype import openpype.pipeline.legacy_io as io from openpype.lib.avalon_context import get_loaders_by_name from openpype.settings import get_project_settings @@ -242,7 +241,6 @@ def populate_template(self, ignored_ids=None): representation['context']['subset'], placeholder.loader, placeholder.data['loader_args'])) - try: container = self.load( placeholder, loaders_by_name, representation) @@ -254,7 +252,6 @@ def populate_template(self, ignored_ids=None): self.postload(placeholder) self.delete_placeholder(placeholder) - def get_placeholder_representations( self, placeholder, current_asset, linked_assets): placeholder_db_filters = placeholder.convert_to_db_filters( @@ -284,16 +281,14 @@ def preload(self, placeholder, loaders_by_name, last_representation): def delete_placeholder(self, placeholder): pass - - def load(self, placeholder, loaders_by_name, last_representation): - from openpype.pipeline.load import load_with_repre_context, get_representation_context + from openpype.pipeline.load import (load_with_repre_context, + get_representation_context) representation = get_representation_context(last_representation) return load_with_repre_context( loaders_by_name[placeholder.loader], representation, - options= parse_loader_args(placeholder.data['loader_args'])) - + options=parse_loader_args(placeholder.data['loader_args'])) def load_succeed(self, placeholder, container): placeholder.parent_in_hierarchy(container) diff --git a/openpype/lib/build_template.py b/openpype/lib/build_template.py index 900a0205219..d068ad79d74 100644 --- a/openpype/lib/build_template.py +++ b/openpype/lib/build_template.py @@ -1,11 +1,9 @@ -import imp -import openpype +from openpype.pipeline import registered_host +from openpype.lib import classes_from_module +from importlib import import_module from .abstract_template_loader import ( AbstractPlaceholder, AbstractTemplateLoader) - -import importlib - from .build_template_exceptions import ( TemplateLoadingFailed, TemplateAlreadyImported, @@ -16,6 +14,7 @@ _module_path_format = 'openpype.hosts.{host}.template_loader' + def build_workfile_template(*args): # raise MissingHostTemplateModule( @@ -37,23 +36,20 @@ def update_workfile_template(*args): def build_template_loader(): - from openpype.pipeline.context_tools import registered_host host_name = registered_host().__name__.partition('.')[2] host_name = host_name.partition('.')[2] module_path = _module_path_format.format(host=host_name) - print(10,module_path) - print(11,host_name) - try : - module = importlib.import_module(module_path) - except : - raise Exception(host_name + " " +registered_host().__name__ ) + try: + module = import_module(module_path) + except Exception as e: + print("Error during module import for host " + host_name + ". " + e) if not module: raise MissingHostTemplateModule( "No template loader found for host {}".format(host_name)) - template_loader_class = openpype.lib.classes_from_module( + template_loader_class = classes_from_module( AbstractTemplateLoader, module) - template_placeholder_class = openpype.lib.classes_from_module( + template_placeholder_class = classes_from_module( AbstractPlaceholder, module) if not template_loader_class: From 87be0db1fe433a3fb52e984c24c4c15a644c3f83 Mon Sep 17 00:00:00 2001 From: "anas.fadil" Date: Tue, 5 Jul 2022 12:22:23 +0200 Subject: [PATCH 03/13] clean divided into multiple commented methods --- openpype/hosts/nuke/api/lib.py | 12 ++ openpype/hosts/nuke/api/template_loader.py | 133 +++++++++++++-------- 2 files changed, 92 insertions(+), 53 deletions(-) diff --git a/openpype/hosts/nuke/api/lib.py b/openpype/hosts/nuke/api/lib.py index b105912a36a..4116964ad31 100644 --- a/openpype/hosts/nuke/api/lib.py +++ b/openpype/hosts/nuke/api/lib.py @@ -2668,6 +2668,12 @@ def refresh_nodes(nodes): def get_names_from_nodes(nodes): + """ + get list of nodes names + + Arguments : + nodes(list) : list of nodes (nuke nodes) to convert into names (str)""" + names = [] for node in nodes: names.append(node.name()) @@ -2675,6 +2681,12 @@ def get_names_from_nodes(nodes): def get_nodes_from_names(names): + """ + get list of nuke nodes from their names + + Arguments : + names(list) : list of names (str) to convert into nodes""" + nodes = [] for name in names: nodes.append(nuke.toNode(name)) diff --git a/openpype/hosts/nuke/api/template_loader.py b/openpype/hosts/nuke/api/template_loader.py index 2e4bc6eab9f..58a781f9cab 100644 --- a/openpype/hosts/nuke/api/template_loader.py +++ b/openpype/hosts/nuke/api/template_loader.py @@ -205,8 +205,13 @@ def parent_in_hierarchy(self, containers): return def create_sib_copies(self): - # creating copies of the palce_holder siblings (the ones who were - # loaded with it) for the new nodes added + """ creating copies of the palce_holder siblings (the ones who were + loaded with it) for the new nodes added + + Returns : + copies (dict) : with copied nodes names and their copies + """ + copies = {} siblings = get_nodes_from_names(self.data['siblings']) for n in siblings: @@ -232,7 +237,8 @@ def create_sib_copies(self): return copies def fix_z_order(self): - # fix the problem of Z-order + """ + fix the problem of z_order when a backdrop is loaded""" orders_bd = [] nodes_loaded = self.data['last_loaded'] for n in nodes_loaded: @@ -257,44 +263,62 @@ def fix_z_order(self): n.knob("z_order").setValue( z_order + max_order - min_order + 1) - def update_nodes(self, nodes): - # Adjust backdrop dimensions and node positions by getting - # the difference of dimensions between what was - node = self.data['node'] - width_ph = node.screenWidth() - height_ph = node.screenHeight() - nodes_loaded = self.data['last_loaded'] - min_x, min_y, max_x, max_y = get_extremes(nodes_loaded) + def update_nodes(self, nodes, considered_nodes, offset_y=None): + """ Adjust backdrop nodes dimensions and positions considering some nodes + sizes - # difference of heights - diff_y = max_y - min_y - height_ph - # difference of widths - diff_x = max_x - min_x - width_ph + Arguments: + nodes (list): list of nodes to update + considered_nodes (list) : list of nodes to consider while updating + positions and dimensions + offset (int) : distance between copies + """ + node = self.data['node'] + + min_x, min_y, max_x, max_y = get_extremes(considered_nodes) + + diff_x = diff_y = 0 + contained_nodes = [] # for backdrops + + if offset_y is None: + width_ph = node.screenWidth() + height_ph = node.screenHeight() + diff_y = max_y - min_y - height_ph + diff_x = max_x - min_x - width_ph + contained_nodes = [node] + min_x = node.xpos() + min_y = node.ypos() + else: + siblings = get_nodes_from_names(self.data['siblings']) + minX, _, maxX, _ = get_extremes(siblings) + diff_y = max_y - min_y + 20 + diff_x = abs(max_x - min_x - maxX + minX) + contained_nodes = considered_nodes if diff_y > 0 or diff_x > 0: for n in nodes: refresh_node(n) - if n != node and n not in nodes_loaded: - width = n.screenWidth() - height = n.screenHeight() + if n != node and n not in considered_nodes: + if not isinstance(n, nuke.BackdropNode)\ or isinstance(n, nuke.BackdropNode)\ - and node not in n.getNodes(): - if n.xpos() + width >= node.xpos() + width_ph: - + and not set(contained_nodes) <= set(n.getNodes()): + if offset_y is None and n.xpos() >= min_x: n.setXpos(n.xpos() + diff_x) - if n.ypos() + height >= node.ypos() + height_ph: + if n.ypos() >= min_y: n.setYpos(n.ypos() + diff_y) else: - width = n.knob("bdwidth").getValue() - height = n.knob("bdheight").getValue() + width = n.screenWidth() + height = n.screenHeight() n.knob("bdwidth").setValue(width + diff_x) n.knob("bdheight").setValue(height + diff_y) refresh_node(n) + # def update + def imprint_inits(self): for n in nuke.allNodes(): refresh_node(n) @@ -309,6 +333,11 @@ def imprint_inits(self): n.knob('h_init').setVisible(False) def imprint_siblings(self): + """ + - add siblings names to placeholder attributes (nodes loaded with it) + - add Id to the attributes of all the other nodes + """ + nodes_loaded = self.data['last_loaded'] d = {"id_rep": str(self.data['_id'])} @@ -332,6 +361,9 @@ def imprint_siblings(self): refresh_node(n) def set_loaded_connections(self): + """ + set inputs and outputs of loaded nodes""" + node = self.data['node'] input, output = get_io(self.data['last_loaded']) for n in node.dependent(): @@ -345,6 +377,12 @@ def set_loaded_connections(self): input.setInput(0, n) def set_copies_connections(self, copies): + """ + set inputs and outputs of the copies + + Arguments : + copies (dict) : with copied nodes names and their copies + """ input, output = get_io(self.data['last_loaded']) siblings = get_nodes_from_names(self.data['siblings']) inp, out = get_io(siblings) @@ -398,53 +436,42 @@ def clean(self): n.setXYpos(xpos, ypos) refresh_nodes(nodes_loaded) - self.fix_z_order() + self.fix_z_order() # fix the problem of z_order for backdrops self.imprint_siblings() if self.data['nb_children'] == 0: - self.imprint_inits() - self.update_nodes(nuke.allNodes()) + # save initial nodes postions and dimensions, update them + # and set inputs and outputs of loaded nodes - # update dependecies and dependent + self.imprint_inits() + self.update_nodes(nuke.allNodes(), nodes_loaded) self.set_loaded_connections() elif self.data['siblings']: + # create copies of placeholder siblings for the new loaded nodes, + # set their inputs and outpus and update all nodes positions and + # dimensions and siblings names + siblings = get_nodes_from_names(self.data['siblings']) refresh_nodes(siblings) - copies = self.create_sib_copies() - new_nodes = list(copies.values()) - self.update_nodes(new_nodes) + new_nodes = list(copies.values()) # copies nodes + self.update_nodes(new_nodes, nodes_loaded) node.removeKnob(node.knob('siblings')) new_nodes_name = get_names_from_nodes(new_nodes) imprint(node, {'siblings': new_nodes_name}) self.set_copies_connections(copies) - min_xx, min_yy, max_xx, max_yy = get_extremes(new_nodes) - minX, _, maxX, _ = get_extremes(siblings) - offset_y = max_yy - min_yy + 20 - offset_x = abs(max_xx - min_xx - maxX + minX) - - for n in nuke.allNodes(): - - if (n.ypos() >= min_yy - and n not in nodes_loaded + new_nodes - and n != node): - n.setYpos(n.ypos() + offset_y) - - if isinstance(n, nuke.BackdropNode)\ - and set(new_nodes) <= set(n.getNodes()): - height = n.knob("bdheight").getValue() - n.knob("bdheight").setValue(height + offset_y) - width = n.knob("bdwidth").getValue() - n.knob("bdwidth").setValue(width + offset_x) - - new_siblings = [] - for n in new_nodes: - new_siblings.append(n.name()) + self.update_nodes(nuke.allNodes(), + new_nodes + nodes_loaded, 20) + + new_siblings = get_names_from_nodes(new_nodes) self.data['siblings'] = new_siblings else: + # if the placeholder doesn't have siblings, the loaded + # nodes will be placed in a free space + xpointer, ypointer = find_free_space_to_paste_nodes( nodes_loaded, direction="bottom", offset=200 ) From 9b6a231d77a2f500acf2b113715a24f3bfa4dd7b Mon Sep 17 00:00:00 2001 From: "anas.fadil" Date: Tue, 5 Jul 2022 13:55:15 +0200 Subject: [PATCH 04/13] clean divided into multiple commented methods --- openpype/hosts/nuke/api/template_loader.py | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/openpype/hosts/nuke/api/template_loader.py b/openpype/hosts/nuke/api/template_loader.py index 58a781f9cab..b2331d1c866 100644 --- a/openpype/hosts/nuke/api/template_loader.py +++ b/openpype/hosts/nuke/api/template_loader.py @@ -238,7 +238,8 @@ def create_sib_copies(self): def fix_z_order(self): """ - fix the problem of z_order when a backdrop is loaded""" + fix the problem of z_order when a backdrop is loaded + """ orders_bd = [] nodes_loaded = self.data['last_loaded'] for n in nodes_loaded: @@ -317,9 +318,10 @@ def update_nodes(self, nodes, considered_nodes, offset_y=None): refresh_node(n) - # def update - def imprint_inits(self): + """ + add initial positions and dimensions to the attributes + """ for n in nuke.allNodes(): refresh_node(n) imprint(n, {'x_init': n.xpos(), 'y_init': n.ypos()}) @@ -429,7 +431,6 @@ def clean(self): # positioning of the loaded nodes min_x, min_y, _, _ = get_extremes(nodes_loaded) - for n in nodes_loaded: xpos = (n.xpos() - min_x) + node.xpos() ypos = (n.ypos() - min_y) + node.ypos() @@ -469,7 +470,7 @@ def clean(self): self.data['siblings'] = new_siblings else: - # if the placeholder doesn't have siblings, the loaded + # if the placeholder doesn't have siblings, the loaded # nodes will be placed in a free space xpointer, ypointer = find_free_space_to_paste_nodes( From 4fcad750cf9a9475b20da05d4d546f4df8cd37c1 Mon Sep 17 00:00:00 2001 From: "anas.fadil" Date: Tue, 5 Jul 2022 16:44:06 +0200 Subject: [PATCH 05/13] doc --- website/docs/artist_hosts_hiero.md | 49 ++++++++++++++++++ website/docs/assets/nuke_addProfile.png | Bin 0 -> 24604 bytes .../assets/nuke_buildWorfileFromTemplate.png | Bin 0 -> 29798 bytes .../docs/assets/nuke_createPlaceHolder.png | Bin 0 -> 30703 bytes .../assets/nuke_fillingExtraAttributes.png | Bin 0 -> 30953 bytes website/docs/assets/nuke_placeHolderNode.png | Bin 0 -> 4010 bytes .../docs/assets/nuke_updatePlaceHolder.png | Bin 0 -> 30608 bytes website/docs/assets/nuke_updateWorkfile.png | Bin 0 -> 30968 bytes 8 files changed, 49 insertions(+) create mode 100644 website/docs/assets/nuke_addProfile.png create mode 100644 website/docs/assets/nuke_buildWorfileFromTemplate.png create mode 100644 website/docs/assets/nuke_createPlaceHolder.png create mode 100644 website/docs/assets/nuke_fillingExtraAttributes.png create mode 100644 website/docs/assets/nuke_placeHolderNode.png create mode 100644 website/docs/assets/nuke_updatePlaceHolder.png create mode 100644 website/docs/assets/nuke_updateWorkfile.png diff --git a/website/docs/artist_hosts_hiero.md b/website/docs/artist_hosts_hiero.md index dc6f1696e7c..d8501cc826a 100644 --- a/website/docs/artist_hosts_hiero.md +++ b/website/docs/artist_hosts_hiero.md @@ -202,3 +202,52 @@ This video shows a way to publish shot look as effect from Hiero to Nuke. ### Assembling edit from published shot versions + +### Create Place Holder + +This tool creates a Place Holder, which is a node that will be replaced by published instances. + +![Create menu](assets/nuke_createPlaceHolder.png) + +:::note +All published instances that will replace the place holder must contain unique input and output nodes in case they will not be imported as one node. +::: + + +The informations about these objects are given by the user by filling the extra attributes of the Place Holder + +![Create menu](assets/nuke_fillingExtraAttributes.png) + + +#### Result +- Create a red node called `PLACEHOLDER` which can be manipulated as wanted by using it in nodes graph. + +![Create menu](assets/nuke_placeHolderNode.png) + +### Update Place Holder +This tool alows the user to change the informations filled in the extra attributes of the selected Place Holder. + +![Create menu](assets/nuke_updatePlaceHolder.png) + +### Add a profile +The path to the template that we were working on must be added as a profile on Project Settings. + +![Create menu](assets/nuke_addProfile.png) + +### Build Workfile from template +This tool imports the template used and replaces the existed Place Holders with the corresponding published objects (which can contain Place Holders too). In case there is no published items with the description given, the place holder will remain in the node graph. + +![Create menu](assets/nuke_buildWorfileFromTemplate.png) + +:::note +In case the instance that will replace the Place holder **A** contains another Place Holder **B** that points to many published elements, all the nodes that were imported with **A** except **B** will be duplicated for each element that will replace **B** +::: + +### Update Workfile +This tool can be used to check if there are some instances that were published after the last build, so they will be imported. + +![Create menu](assets/nuke_updateWorkfile.png) + +:::note +Imported instances must not be deleted because they contain extra attributes that will be used to update the workfile since the place holder is been deleted. +::: \ No newline at end of file diff --git a/website/docs/assets/nuke_addProfile.png b/website/docs/assets/nuke_addProfile.png new file mode 100644 index 0000000000000000000000000000000000000000..37578df7f52ee4b61e3ba0725d999fc4940288ea GIT binary patch literal 24604 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 literal 0 HcmV?d00001 diff --git a/website/docs/assets/nuke_buildWorfileFromTemplate.png b/website/docs/assets/nuke_buildWorfileFromTemplate.png new file mode 100644 index 0000000000000000000000000000000000000000..77d2de2ff85841cf7910dc714c60e531002b2344 GIT binary patch literal 29798 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 literal 0 HcmV?d00001 diff --git a/website/docs/assets/nuke_createPlaceHolder.png b/website/docs/assets/nuke_createPlaceHolder.png new file mode 100644 index 0000000000000000000000000000000000000000..93fb4de9d01adc65bff170cdaaeaa576074a956f GIT binary patch literal 30703 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 literal 0 HcmV?d00001 diff --git a/website/docs/assets/nuke_fillingExtraAttributes.png b/website/docs/assets/nuke_fillingExtraAttributes.png new file mode 100644 index 0000000000000000000000000000000000000000..146c4d9db61284233c486a83708a8473969f7e44 GIT binary patch literal 30953 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 VDq4MW`0iqf*?J3R#?G+V@jnmA5kmj~ literal 0 HcmV?d00001 diff --git a/website/docs/assets/nuke_placeHolderNode.png b/website/docs/assets/nuke_placeHolderNode.png new file mode 100644 index 0000000000000000000000000000000000000000..ac9e83b9d67c5c976c99bb9016a47a9836eadb39 GIT binary patch literal 4010 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 literal 0 HcmV?d00001 diff --git a/website/docs/assets/nuke_updatePlaceHolder.png b/website/docs/assets/nuke_updatePlaceHolder.png new file mode 100644 index 0000000000000000000000000000000000000000..58fac2a7e4c9cbd482c9de7374b0b31661116602 GIT binary patch literal 30608 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≪6 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 XvZ_}FZZN?sQ_soEs7Mz|8a@3#;PNPY literal 0 HcmV?d00001 diff --git a/website/docs/assets/nuke_updateWorkfile.png b/website/docs/assets/nuke_updateWorkfile.png new file mode 100644 index 0000000000000000000000000000000000000000..aeeebb123f0971938f79f7b086eb291eb99158fa GIT binary patch literal 30968 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%0A68dafrch8 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 CMAer7 literal 0 HcmV?d00001 From 2b4cd2a7c644afd4ee0a1f585e527bd54b41be7a Mon Sep 17 00:00:00 2001 From: "anas.fadil" Date: Tue, 5 Jul 2022 16:57:14 +0200 Subject: [PATCH 06/13] doc --- openpype/hosts/nuke/api/template_loader.py | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/openpype/hosts/nuke/api/template_loader.py b/openpype/hosts/nuke/api/template_loader.py index b2331d1c866..9885ac4cdcc 100644 --- a/openpype/hosts/nuke/api/template_loader.py +++ b/openpype/hosts/nuke/api/template_loader.py @@ -84,10 +84,7 @@ def get_template_nodes(): def update_missing_containers(self): nodes_byId = {} nodes_byId = defaultdict(lambda: [], nodes_byId) - for n in nuke.allNodes(): - refresh_node(n) - if 'id_rep' in n.knobs().keys(): - nodes_byId[n.knob('id_rep').getValue()] = [] + for n in nuke.allNodes(): if 'id_rep' in n.knobs().keys(): nodes_byId[n.knob('id_rep').getValue()] += [n.name()] @@ -127,7 +124,6 @@ def get_placeholders(self): return placeholders def delete_placeholder(self, placeholder): - # min_x, min_y , max_x, max_y = get_extremes(nodes_loaded) node = placeholder.data['node'] lastLoaded = placeholder.data['last_loaded'] if 'delete' in placeholder.data.keys()\ From 5b0fdd88377b467c7752e60597a97998fedf51ec Mon Sep 17 00:00:00 2001 From: Thomas Fricard Date: Tue, 5 Jul 2022 17:12:26 +0200 Subject: [PATCH 07/13] fix linting errors --- openpype/hosts/nuke/api/lib.py | 16 +++++----- .../hosts/nuke/api/lib_template_builder.py | 11 +++---- openpype/hosts/nuke/api/template_loader.py | 32 +++++++++---------- openpype/lib/abstract_template_loader.py | 4 +-- 4 files changed, 30 insertions(+), 33 deletions(-) diff --git a/openpype/hosts/nuke/api/lib.py b/openpype/hosts/nuke/api/lib.py index 4116964ad31..f9b5a715e8d 100644 --- a/openpype/hosts/nuke/api/lib.py +++ b/openpype/hosts/nuke/api/lib.py @@ -2611,9 +2611,9 @@ def get_io(nodes): """ get the input and the output of a group of nodes """ if not nodes: - raise Exception("there is no nodes in the list") + raise Exception("there is no nodes in the list") if len(nodes) > 1: - input = None + input = None output = None for n in nodes: if "Input" in n.name(): @@ -2639,7 +2639,7 @@ def get_extremes(nodes): """ get the 4 numbers that represent the box of a group of nodes """ if not nodes: raise Exception("there is no nodes in the list") - + nodes_xpos = [n.xpos() for n in nodes] + \ [n.xpos() + n.screenWidth() for n in nodes] @@ -2655,7 +2655,7 @@ def refresh_node(node): """ correct a bug caused by the multi-threading of nuke refresh the node to make sure that it takes the desired attributes """ - + x = node.xpos() y = node.ypos() nuke.autoplaceSnap(node) @@ -2670,7 +2670,7 @@ def refresh_nodes(nodes): def get_names_from_nodes(nodes): """ get list of nodes names - + Arguments : nodes(list) : list of nodes (nuke nodes) to convert into names (str)""" @@ -2683,11 +2683,11 @@ def get_names_from_nodes(nodes): def get_nodes_from_names(names): """ get list of nuke nodes from their names - + Arguments : names(list) : list of names (str) to convert into nodes""" - + nodes = [] for name in names: nodes.append(nuke.toNode(name)) - return nodes \ No newline at end of file + return nodes diff --git a/openpype/hosts/nuke/api/lib_template_builder.py b/openpype/hosts/nuke/api/lib_template_builder.py index e552e9f5fd5..e021b795d50 100644 --- a/openpype/hosts/nuke/api/lib_template_builder.py +++ b/openpype/hosts/nuke/api/lib_template_builder.py @@ -1,12 +1,9 @@ from collections import OrderedDict -# import maya.cmds as cmds -# from avalon.maya.lib import imprint from openpype.vendor.python.common import qargparse from openpype.tools.utils.widgets import OptionDialog from openpype.hosts.nuke.api.lib import imprint import nuke -# from avalon.maya.pipeline import get_main_window # To change as enum @@ -21,7 +18,7 @@ def get_placeholder_attributes(node, enumerate=False): for attr in node.knobs().keys(): if attr in list_atts: if enumerate: - try: + try: attributes[attr] = node.knob(attr).values() except AttributeError: attributes[attr] = node.knob(attr).getValue() @@ -56,7 +53,7 @@ def hide_placeholder_attributes(node): def create_placeholder(): - + args = placeholder_window() if not args: @@ -109,7 +106,7 @@ def imprint_enum(placeholder, args): string_to_value_enum_table = { build: i for i, build in enumerate(build_types)} - attrs = {} + attrs = {} for key, value in enum_values.items(): attrs[key] = string_to_value_enum_table[value] # try : @@ -121,7 +118,7 @@ def imprint_enum(placeholder, args): # string_to_value_enum_table[value]) # raise Exception (getattr( # placeholder , key)) - + def placeholder_window(options=None): from openpype.hosts.nuke.api.pipeline import get_main_window diff --git a/openpype/hosts/nuke/api/template_loader.py b/openpype/hosts/nuke/api/template_loader.py index 9885ac4cdcc..55b2bed8d5b 100644 --- a/openpype/hosts/nuke/api/template_loader.py +++ b/openpype/hosts/nuke/api/template_loader.py @@ -30,12 +30,12 @@ def import_template(self, path): Returns: bool: Wether the template was succesfully imported or not """ - + # TODO check if the template is already imported nuke.nodePaste(path) reset_selection() - + return True def preload(self, placeholder, loaders_by_name, last_representation): @@ -56,7 +56,7 @@ def preload(self, placeholder, loaders_by_name, last_representation): refresh_node(n) def populate_template(self, ignored_ids=None): - place_holders = self.get_template_nodes() + place_holders = self.get_template_nodes() while len(place_holders) > 0: super().populate_template(ignored_ids) place_holders = self.get_template_nodes() @@ -84,7 +84,7 @@ def get_template_nodes(): def update_missing_containers(self): nodes_byId = {} nodes_byId = defaultdict(lambda: [], nodes_byId) - + for n in nuke.allNodes(): if 'id_rep' in n.knobs().keys(): nodes_byId[n.knob('id_rep').getValue()] += [n.name()] @@ -122,7 +122,7 @@ def get_loaded_containers_by_id(self): def get_placeholders(self): placeholders = super().get_placeholders() return placeholders - + def delete_placeholder(self, placeholder): node = placeholder.data['node'] lastLoaded = placeholder.data['last_loaded'] @@ -143,7 +143,7 @@ def delete_placeholder(self, placeholder): for loadedNode in lastLoaded: lastLoaded_names.append(loadedNode.name()) imprint(node, {'last_loaded': lastLoaded_names}) - + for n in lastLoaded: refresh_node(n) refresh_node(node) @@ -198,16 +198,16 @@ def get_data(self, node): self.data = user_data def parent_in_hierarchy(self, containers): - return + return def create_sib_copies(self): """ creating copies of the palce_holder siblings (the ones who were - loaded with it) for the new nodes added - + loaded with it) for the new nodes added + Returns : copies (dict) : with copied nodes names and their copies """ - + copies = {} siblings = get_nodes_from_names(self.data['siblings']) for n in siblings: @@ -241,7 +241,7 @@ def fix_z_order(self): for n in nodes_loaded: if isinstance(n, nuke.BackdropNode): orders_bd.append(n.knob("z_order").getValue()) - + if orders_bd: min_order = min(orders_bd) @@ -271,7 +271,7 @@ def update_nodes(self, nodes, considered_nodes, offset_y=None): offset (int) : distance between copies """ node = self.data['node'] - + min_x, min_y, max_x, max_y = get_extremes(considered_nodes) diff_x = diff_y = 0 @@ -344,7 +344,7 @@ def imprint_siblings(self): and ('is_placeholder' not in n.knobs().keys() or 'is_placeholder' in n.knobs().keys() and n.knob('is_placeholder').value()): - + siblingss = list(set(nodes_loaded) - set([n])) siblings_name = [] for s in siblingss: @@ -357,7 +357,7 @@ def imprint_siblings(self): imprint(n, d) # n.knob('id_rep').setVisible(False) refresh_node(n) - + def set_loaded_connections(self): """ set inputs and outputs of loaded nodes""" @@ -424,7 +424,7 @@ def clean(self): self.data['last_loaded'] = nodes_loaded reset_selection() refresh_nodes(nodes_loaded) - + # positioning of the loaded nodes min_x, min_y, _, _ = get_extremes(nodes_loaded) for n in nodes_loaded: @@ -446,7 +446,7 @@ def clean(self): elif self.data['siblings']: # create copies of placeholder siblings for the new loaded nodes, - # set their inputs and outpus and update all nodes positions and + # set their inputs and outpus and update all nodes positions and # dimensions and siblings names siblings = get_nodes_from_names(self.data['siblings']) diff --git a/openpype/lib/abstract_template_loader.py b/openpype/lib/abstract_template_loader.py index 604573be25f..48735803009 100644 --- a/openpype/lib/abstract_template_loader.py +++ b/openpype/lib/abstract_template_loader.py @@ -251,13 +251,13 @@ def populate_template(self, ignored_ids=None): finally: self.postload(placeholder) self.delete_placeholder(placeholder) - + def get_placeholder_representations( self, placeholder, current_asset, linked_assets): placeholder_db_filters = placeholder.convert_to_db_filters( current_asset, linked_assets) - # get representation by assets. + # get representation by assets. for db_filter in placeholder_db_filters: placeholder_representations = list(io.find(db_filter)) for representation in reduce(update_representations, From 703f66003effbfa26dc23e65737e9d6df30c114d Mon Sep 17 00:00:00 2001 From: "anas.fadil" Date: Tue, 5 Jul 2022 17:53:50 +0200 Subject: [PATCH 08/13] useless comments removed --- openpype/hosts/nuke/api/pipeline.py | 6 +- openpype/hosts/nuke/api/template_loader.py | 65 ++++++++++------------ openpype/lib/build_template.py | 2 - 3 files changed, 32 insertions(+), 41 deletions(-) diff --git a/openpype/hosts/nuke/api/pipeline.py b/openpype/hosts/nuke/api/pipeline.py index b8aa23b885c..18fccd9c5d6 100644 --- a/openpype/hosts/nuke/api/pipeline.py +++ b/openpype/hosts/nuke/api/pipeline.py @@ -1,8 +1,10 @@ import os import importlib from collections import OrderedDict -from openpype.lib.build_template import (build_workfile_template, - update_workfile_template) +from openpype.lib.build_template import ( + build_workfile_template, + update_workfile_template +) from openpype.hosts.nuke.api.lib_template_builder import ( create_placeholder, update_placeholder ) diff --git a/openpype/hosts/nuke/api/template_loader.py b/openpype/hosts/nuke/api/template_loader.py index 9885ac4cdcc..5f374b6b663 100644 --- a/openpype/hosts/nuke/api/template_loader.py +++ b/openpype/hosts/nuke/api/template_loader.py @@ -4,13 +4,12 @@ from openpype.lib.abstract_template_loader import ( AbstractPlaceholder, AbstractTemplateLoader) -# from openpype.lib.build_template_exceptions import TemplateAlreadyImported import nuke from collections import defaultdict from openpype.hosts.nuke.api.lib import ( find_free_space_to_paste_nodes, get_extremes, get_io, imprint, refresh_node, refresh_nodes, reset_selection, - get_names_from_nodes, get_nodes_from_names) + get_names_from_nodes, get_nodes_from_names, select_nodes) PLACEHOLDER_SET = 'PLACEHOLDERS_SET' @@ -42,19 +41,6 @@ def preload(self, placeholder, loaders_by_name, last_representation): placeholder.data["nodes_init"] = nuke.allNodes() placeholder.data["_id"] = last_representation['_id'] - reset_selection() - groups_name = placeholder.data['group_name'] - - if groups_name: - # nuke.nodeCopy("%clipboard%") - # for n in nuke.selectedNodes(): - # nuke.delete(n) - group = nuke.toNode(groups_name) - group.begin() - # nuke.nodePaste("%clipboard%") - for n in nuke.selectedNodes(): - refresh_node(n) - def populate_template(self, ignored_ids=None): place_holders = self.get_template_nodes() while len(place_holders) > 0: @@ -84,7 +70,7 @@ def get_template_nodes(): def update_missing_containers(self): nodes_byId = {} nodes_byId = defaultdict(lambda: [], nodes_byId) - + for n in nuke.allNodes(): if 'id_rep' in n.knobs().keys(): nodes_byId[n.knob('id_rep').getValue()] += [n.name()] @@ -173,14 +159,6 @@ def get_data(self, node): if attr in dictKnobs.keys(): user_data[attr] = dictKnobs[attr].getValue() user_data['node'] = node - if 'nodes_toReplace' in dictKnobs.keys(): - names = dictKnobs['nodes_toReplace'].values() - nodes = [] - for name in names: - nodes.append(nuke.toNode(name)) - user_data['nodes_toReplace'] = nodes - else: - user_data['nodes_toReplace'] = [node] if 'nb_children' in dictKnobs.keys(): user_data['nb_children'] = int(dictKnobs['nb_children'].getValue()) @@ -198,16 +176,16 @@ def get_data(self, node): self.data = user_data def parent_in_hierarchy(self, containers): - return + return def create_sib_copies(self): """ creating copies of the palce_holder siblings (the ones who were - loaded with it) for the new nodes added - - Returns : - copies (dict) : with copied nodes names and their copies + loaded with it) for the new nodes added + + Returns: + copies(dict) : with copied nodes names and their copies """ - + copies = {} siblings = get_nodes_from_names(self.data['siblings']) for n in siblings: @@ -345,17 +323,15 @@ def imprint_siblings(self): or 'is_placeholder' in n.knobs().keys() and n.knob('is_placeholder').value()): - siblingss = list(set(nodes_loaded) - set([n])) - siblings_name = [] - for s in siblingss: - siblings_name.append(s.name()) + siblings = list(set(nodes_loaded) - set([n])) + siblings_name = get_names_from_nodes(siblings) siblings = {"siblings": siblings_name} imprint(n, siblings) elif 'builder_type' not in n.knobs().keys(): # save the id of representation for all imported nodes imprint(n, d) - # n.knob('id_rep').setVisible(False) + n.knob('id_rep').setVisible(False) refresh_node(n) def set_loaded_connections(self): @@ -409,6 +385,22 @@ def set_copies_connections(self, copies): inp.setInput(0, out_copy) + def move_to_placeholder_group(self, nodes_loaded): + """ + opening the placeholder's group and copying loaded nodes in it""" + groups_name = self.data['group_name'] + reset_selection() + select_nodes(nodes_loaded) + if groups_name: + nuke.nodeCopy("%clipboard%") + for n in nuke.selectedNodes(): + nuke.delete(n) + group = nuke.toNode(groups_name) + group.begin() + nuke.nodePaste("%clipboard%") + nodes_loaded = nuke.selectedNodes() + return nodes_loaded + def clean(self): # deselect all selected nodes @@ -420,9 +412,8 @@ def clean(self): if not nodes_loaded: self.data['delete'] = False return - + nodes_loaded = self.move_to_placeholder_group(nodes_loaded) self.data['last_loaded'] = nodes_loaded - reset_selection() refresh_nodes(nodes_loaded) # positioning of the loaded nodes diff --git a/openpype/lib/build_template.py b/openpype/lib/build_template.py index d068ad79d74..863a1e67681 100644 --- a/openpype/lib/build_template.py +++ b/openpype/lib/build_template.py @@ -17,8 +17,6 @@ def build_workfile_template(*args): - # raise MissingHostTemplateModule( - # "No template loader found for host ") template_loader = build_template_loader() try: template_loader.import_template(template_loader.template_path) From 74135facb7b219d31760fb95c3982a55648d3db9 Mon Sep 17 00:00:00 2001 From: "anas.fadil" Date: Thu, 7 Jul 2022 18:12:37 +0200 Subject: [PATCH 09/13] update doc --- .../hosts/nuke/api/lib_template_builder.py | 13 ++------ openpype/hosts/nuke/api/template_loader.py | 7 +++- website/docs/artist_hosts_hiero.md | 31 +++++++++++------- website/docs/assets/nuke_buildworkfile.png | Bin 0 -> 36149 bytes website/docs/assets/nuke_placeholder.png | Bin 0 -> 12169 bytes .../docs/assets/nuke_publishedinstance.png | Bin 0 -> 20541 bytes 6 files changed, 28 insertions(+), 23 deletions(-) create mode 100644 website/docs/assets/nuke_buildworkfile.png create mode 100644 website/docs/assets/nuke_placeholder.png create mode 100644 website/docs/assets/nuke_publishedinstance.png diff --git a/openpype/hosts/nuke/api/lib_template_builder.py b/openpype/hosts/nuke/api/lib_template_builder.py index e021b795d50..b97ebf718e7 100644 --- a/openpype/hosts/nuke/api/lib_template_builder.py +++ b/openpype/hosts/nuke/api/lib_template_builder.py @@ -18,7 +18,7 @@ def get_placeholder_attributes(node, enumerate=False): for attr in node.knobs().keys(): if attr in list_atts: if enumerate: - try: + try: attributes[attr] = node.knob(attr).values() except AttributeError: attributes[attr] = node.knob(attr).getValue() @@ -72,6 +72,7 @@ def create_placeholder(): options[str(arg)] = arg._data.get("items") or arg.read() imprint(placeholder, options) imprint(placeholder, {'is_placeholder': True}) + placeholder.knob('is_placeholder').setVisible(False) def update_placeholder(): @@ -93,7 +94,6 @@ def update_placeholder(): if not type(arg) == qargparse.Separator: options[str(arg)] = arg._data.get("items") or arg.read() imprint(placeholder, options) - # imprint_enum(placeholder, args) def imprint_enum(placeholder, args): @@ -109,15 +109,6 @@ def imprint_enum(placeholder, args): attrs = {} for key, value in enum_values.items(): attrs[key] = string_to_value_enum_table[value] - # try : - # nuke.setPreset(nuke.getNodeClassName(placeholder),"attributes",attrs) - # except Exception: - - # setattr( - # placeholder , key, - # string_to_value_enum_table[value]) - # raise Exception (getattr( - # placeholder , key)) def placeholder_window(options=None): diff --git a/openpype/hosts/nuke/api/template_loader.py b/openpype/hosts/nuke/api/template_loader.py index 8b7a0e5746d..d63b3ba3cff 100644 --- a/openpype/hosts/nuke/api/template_loader.py +++ b/openpype/hosts/nuke/api/template_loader.py @@ -387,7 +387,12 @@ def set_copies_connections(self, copies): def move_to_placeholder_group(self, nodes_loaded): """ - opening the placeholder's group and copying loaded nodes in it""" + opening the placeholder's group and copying loaded nodes in it. + + Returns : + nodes_loaded (list): the new list of pasted nodes + """ + groups_name = self.data['group_name'] reset_selection() select_nodes(nodes_loaded) diff --git a/website/docs/artist_hosts_hiero.md b/website/docs/artist_hosts_hiero.md index d8501cc826a..d44edda5dd3 100644 --- a/website/docs/artist_hosts_hiero.md +++ b/website/docs/artist_hosts_hiero.md @@ -205,46 +205,55 @@ This video shows a way to publish shot look as effect from Hiero to Nuke. ### Create Place Holder +![Create menu](assets/nuke_createPlaceHolder.png) + This tool creates a Place Holder, which is a node that will be replaced by published instances. -![Create menu](assets/nuke_createPlaceHolder.png) +![Create menu](assets/nuke_placeHolderNode.png) +#### Result +- Create a red node called `PLACEHOLDER` which can be manipulated as wanted by using it in Node Graph. + +![Create menu](assets/nuke_placeholder.png) :::note -All published instances that will replace the place holder must contain unique input and output nodes in case they will not be imported as one node. +All published instances that will replace the place holder must contain unique input and output nodes in case they will not be imported as a single node. ::: +![Create menu](assets/nuke_publishedinstance.png) + The informations about these objects are given by the user by filling the extra attributes of the Place Holder ![Create menu](assets/nuke_fillingExtraAttributes.png) -#### Result -- Create a red node called `PLACEHOLDER` which can be manipulated as wanted by using it in nodes graph. - -![Create menu](assets/nuke_placeHolderNode.png) ### Update Place Holder -This tool alows the user to change the informations filled in the extra attributes of the selected Place Holder. +This tool alows the user to change the information provided in the extra attributes of the selected Place Holder. ![Create menu](assets/nuke_updatePlaceHolder.png) ### Add a profile -The path to the template that we were working on must be added as a profile on Project Settings. +The path to the template we were working on must be added as a profile on Project Settings. ![Create menu](assets/nuke_addProfile.png) ### Build Workfile from template -This tool imports the template used and replaces the existed Place Holders with the corresponding published objects (which can contain Place Holders too). In case there is no published items with the description given, the place holder will remain in the node graph. +This tool imports the template used and replaces the existed PlaceHolders with the corresponding published objects (which can contain Place Holders too). In case there is no published items with the description given, the place holder will remain in the node graph. ![Create menu](assets/nuke_buildWorfileFromTemplate.png) +#### Result +- Replace `PLACEHOLDER` node in the template with the published instance corresponding to the informations provided in extra attributes of the Place Holder + +![Create menu](assets/nuke_buildworkfile.png) + :::note -In case the instance that will replace the Place holder **A** contains another Place Holder **B** that points to many published elements, all the nodes that were imported with **A** except **B** will be duplicated for each element that will replace **B** +In case the instance that will replace the Place holder **A** contains another Place Holder **B** that points to many published elements, all the nodes that were imported with **A** except **B** will be duplicated for each element that will replace **B** ::: ### Update Workfile -This tool can be used to check if there are some instances that were published after the last build, so they will be imported. +This tool can be used to check if some instances were published after the last build, so they will be imported. ![Create menu](assets/nuke_updateWorkfile.png) diff --git a/website/docs/assets/nuke_buildworkfile.png b/website/docs/assets/nuke_buildworkfile.png new file mode 100644 index 0000000000000000000000000000000000000000..e3d8d07f7c959324c1224f88079084813ad7c101 GIT binary patch literal 36149 zcmZsCbzIaz_b#ZQG$J7#QqtWaAR?VhNGUB{N(m?u(jwhmOS5!JOM~RnA>AEI+(GaA zd++_+%RjLDjhQ)f=A7qw&LL1mNd^m@1RV(p2}}0%OEn}U8d$&U+s6!ak9;6r`(G*dM^bM_!NuhBb64}k{TI)a5jT~ znHt^7cgb;rX!97K@aopn9j2o-W_+Ro>sjdc?`ca*8TMB-J*|F2_0_Gr`b=&Y=!0Sf zT`RROc>djw#jiM>0ti#r1&5uH z+(Gta8(*qN`r+&A7MWMn>A_=2OQrnF+v0dg^rpK>| zPW5N{f4JR0IIZvPG$uvEIySLYdsKi^NblfG8`~Rg(Nx!idF6eLO>@&DiN# z-U_PiTy|d^$uTEWy)yBPAJuQRmm3#4hNpH zN!z_QA+s!TkEIn9?o(14NGW;}2UAk~+`M1#6nA&9?>(|!Q*`G5hHyN$SVD=i&7#qb zbPOw*q>2T~R(P@b%F;0Ygx7h&3-@;&<;pdC)@QwA#0LGGWNDEQyNZ2Nj#)m!SL2$YQ(W#YOR0-;dX7S6Ghcq<4MPSD@zeqnX z?inuv9@uyf(;EGeAyk($GGjF)_{0%KCYAfu5eugg9+Ee(&yGw`%N{#~4j4i(a7F zHu^Gp(n7#VbMg3nwD{FKM&r&9Y8IBhzh?49Jdh~u`HX!3_3PIQvx<95JL#q^+f6eg ze@X>+m^Ilbq&F+^PYo`^=wSXFmRY0^*|v?kufDim%$hC-4nD%#f4h79R+C)2zhXE- zAz`7v_?SGY=A#cvphKZ(17SyYOqbbNre^JzL>FRiJde#b&ovirJ2|o^cr)<$rmwkc zT}wn3m}j-=bCG?qy9qn&K&q0aTEE5N;xU|Mx$Mn-I$sRH z+jXMhio|=+!o+Pp@TW`shI4HoRYpP@LLl|1|2*Oy<{9yzj)AdT;Rzx%UDWDq+KZKN zB9HK$_|YlmyO$8omkf#1mJQzL`|lLuI3&!}lwOW!0m}tBDE5quME=H89xpkg5}tm7 zqpUn$bd*uob6;6mx#^-alD%pF#YkH7>hb$)UX*H4?dkyxWp-tyl%dp-4UvQWeUm{K z16Oxf6`lNMdgk7*1zMsy%`K5Zj-K@ov0ck;lNp4PZ>%h#4=E@N@Cn?$r|t#j=04om zxO5^3eW=@XxG-%ey1##%Q8oVcWb0(&&+2B$bJnAuBW=M^_&9pAA`VVRZ?A=v!^jTW zM|!`0*b=FAlbY}92&O2UUwCe%rjLYnhUW7&`q!`5ouQ;%9){OMb183D2eH>u=o3qR zHyKGETKsmzKAP>=!-RVlZ}(32Kk2lecaZuxe~hb1sV%(}_nJPO-xpD?T>chHU9X(K zSO$MQ%EWJf#zyzv5^2qL9fnv{4x^)PiA>&@c60Y4^ZJtg$=&%r@=fuAW=|Dt`t`TH z-l#w?vYNcX-Qcj{($)Pg|LrC)NMHL4ws|FPUql8xrYbtPnoIk164%Fv6^5uvfrIT; z!DG01jEnnobF6@FX6>a3{atuhfP4D)iFDwLbNl|njCaV{BOo}kNZ5D-YZp?%oFG+7 zl$pm|Q@AD_EV!&9jXdZp=E6YZ)34?TXL)0GNvxc3GM|OwIjK^PsJmDG_k}r%iJi

=-Qwg~sFK#=Fyw)a9rjcCcJZMh> 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 DVlFeL literal 0 HcmV?d00001 diff --git a/website/docs/assets/nuke_placeholder.png b/website/docs/assets/nuke_placeholder.png new file mode 100644 index 0000000000000000000000000000000000000000..d899ff742ce32a76317645bcf60fdf256f98b0c8 GIT binary patch literal 12169 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 Date: Wed, 20 Jul 2022 17:00:49 +0200 Subject: [PATCH 10/13] empty problem solved --- .../hosts/nuke/api/lib_template_builder.py | 4 ++-- openpype/hosts/nuke/api/template_loader.py | 19 ++++++++++++------- website/docs/artist_hosts_hiero.md | 12 +++++++++--- 3 files changed, 23 insertions(+), 12 deletions(-) diff --git a/openpype/hosts/nuke/api/lib_template_builder.py b/openpype/hosts/nuke/api/lib_template_builder.py index b97ebf718e7..2d2dcee42fa 100644 --- a/openpype/hosts/nuke/api/lib_template_builder.py +++ b/openpype/hosts/nuke/api/lib_template_builder.py @@ -84,10 +84,10 @@ def update_placeholder(): placeholder = placeholder[0] args = placeholder_window(get_placeholder_attributes(placeholder)) - # delete placeholder attributes - delete_placeholder_attributes(placeholder) if not args: return # operation canceled + # delete placeholder attributes + delete_placeholder_attributes(placeholder) options = OrderedDict() for arg in args: diff --git a/openpype/hosts/nuke/api/template_loader.py b/openpype/hosts/nuke/api/template_loader.py index d63b3ba3cff..5a63bcaf1e9 100644 --- a/openpype/hosts/nuke/api/template_loader.py +++ b/openpype/hosts/nuke/api/template_loader.py @@ -55,8 +55,7 @@ def get_template_nodes(): group = allGroups.pop(0) for node in group.nodes(): if "builder_type" in node.knobs().keys() and ( - 'is_placeholder' not in node.knobs().keys() - or 'is_placeholder' in node.knobs().keys() + 'is_placeholder' in node.knobs().keys() and node.knob('is_placeholder').value()): if 'empty' in node.knobs().keys()\ and node.knob('empty').value(): @@ -74,6 +73,9 @@ def update_missing_containers(self): for n in nuke.allNodes(): if 'id_rep' in n.knobs().keys(): nodes_byId[n.knob('id_rep').getValue()] += [n.name()] + if 'empty' in n.knobs().keys(): + n.removeKnob(n.knob('empty')) + imprint(n, {"empty": False}) for s in nodes_byId.values(): n = None for name in s: @@ -112,8 +114,9 @@ def get_placeholders(self): def delete_placeholder(self, placeholder): node = placeholder.data['node'] lastLoaded = placeholder.data['last_loaded'] - if 'delete' in placeholder.data.keys()\ - and placeholder.data['delete'] is False: + if not placeholder.data['delete']: + if 'empty' in node.knobs().keys(): + node.removeKnob(node.knob('empty')) imprint(node, {"empty": True}) else: if lastLoaded: @@ -172,7 +175,7 @@ def get_data(self, node): fullName = node.fullName() user_data['group_name'] = fullName.rpartition('.')[0] user_data['last_loaded'] = [] - + user_data['delete'] = False self.data = user_data def parent_in_hierarchy(self, containers): @@ -414,8 +417,10 @@ def clean(self): # getting the latest nodes added nodes_init = self.data["nodes_init"] nodes_loaded = list(set(nuke.allNodes()) - set(nodes_init)) - if not nodes_loaded: - self.data['delete'] = False + print(nodes_loaded) + if nodes_loaded: + self.data['delete'] = True + else: return nodes_loaded = self.move_to_placeholder_group(nodes_loaded) self.data['last_loaded'] = nodes_loaded diff --git a/website/docs/artist_hosts_hiero.md b/website/docs/artist_hosts_hiero.md index d44edda5dd3..d14dcd1c015 100644 --- a/website/docs/artist_hosts_hiero.md +++ b/website/docs/artist_hosts_hiero.md @@ -203,6 +203,15 @@ This video shows a way to publish shot look as effect from Hiero to Nuke. + +# Nuke Build Workfile +This is a tool of Node Graph initialisation using a pre-created template. + +### Add a profile +The path to the template that will be used in the initialisation must be added as a profile on Project Settings. + +![Create menu](assets/nuke_addProfile.png) + ### Create Place Holder ![Create menu](assets/nuke_createPlaceHolder.png) @@ -233,10 +242,7 @@ This tool alows the user to change the information provided in the extra attribu ![Create menu](assets/nuke_updatePlaceHolder.png) -### Add a profile -The path to the template we were working on must be added as a profile on Project Settings. -![Create menu](assets/nuke_addProfile.png) ### Build Workfile from template This tool imports the template used and replaces the existed PlaceHolders with the corresponding published objects (which can contain Place Holders too). In case there is no published items with the description given, the place holder will remain in the node graph. From 35296118d3bd9524495e1c07504d19fd857638a7 Mon Sep 17 00:00:00 2001 From: Thomas Fricard Date: Thu, 21 Jul 2022 10:20:15 +0200 Subject: [PATCH 11/13] fix linting --- openpype/hosts/nuke/api/lib_template_builder.py | 2 +- openpype/tools/utils/widgets.py | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/openpype/hosts/nuke/api/lib_template_builder.py b/openpype/hosts/nuke/api/lib_template_builder.py index 2d2dcee42fa..b95a6edf7b5 100644 --- a/openpype/hosts/nuke/api/lib_template_builder.py +++ b/openpype/hosts/nuke/api/lib_template_builder.py @@ -18,7 +18,7 @@ def get_placeholder_attributes(node, enumerate=False): for attr in node.knobs().keys(): if attr in list_atts: if enumerate: - try: + try: attributes[attr] = node.knob(attr).values() except AttributeError: attributes[attr] = node.knob(attr).getValue() diff --git a/openpype/tools/utils/widgets.py b/openpype/tools/utils/widgets.py index c9c30617362..97fc349defc 100644 --- a/openpype/tools/utils/widgets.py +++ b/openpype/tools/utils/widgets.py @@ -1,5 +1,4 @@ import logging -from pickletools import optimize from Qt import QtWidgets, QtCore, QtGui from openpype.vendor.python.common import qargparse From c730b070f53b27dce8050e41aee899110b502885 Mon Sep 17 00:00:00 2001 From: "anas.fadil" Date: Thu, 28 Jul 2022 11:55:25 +0200 Subject: [PATCH 12/13] import qargparse fixed --- openpype/hosts/nuke/api/template_loader.py | 3 ++- openpype/tools/utils/widgets.py | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/openpype/hosts/nuke/api/template_loader.py b/openpype/hosts/nuke/api/template_loader.py index 5a63bcaf1e9..861498d2e59 100644 --- a/openpype/hosts/nuke/api/template_loader.py +++ b/openpype/hosts/nuke/api/template_loader.py @@ -310,6 +310,7 @@ def imprint_inits(self): imprint(n, {'w_init': width, 'h_init': height}) n.knob('w_init').setVisible(False) n.knob('h_init').setVisible(False) + refresh_node(n) def imprint_siblings(self): """ @@ -410,7 +411,7 @@ def move_to_placeholder_group(self, nodes_loaded): return nodes_loaded def clean(self): - + print("cleaaaaar") # deselect all selected nodes node = self.data['node'] diff --git a/openpype/tools/utils/widgets.py b/openpype/tools/utils/widgets.py index c9c30617362..3f5bafd17d5 100644 --- a/openpype/tools/utils/widgets.py +++ b/openpype/tools/utils/widgets.py @@ -2,7 +2,7 @@ from pickletools import optimize from Qt import QtWidgets, QtCore, QtGui -from openpype.vendor.python.common import qargparse +import qargparse # import argparse import qtawesome from openpype.style import ( From a2ad8c3101d764eb8e00aa4c284ce00fb581a1e2 Mon Sep 17 00:00:00 2001 From: "anas.fadil" Date: Thu, 28 Jul 2022 12:05:34 +0200 Subject: [PATCH 13/13] import qargparse fixed --- openpype/hosts/nuke/plugins/load/load_image.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/openpype/hosts/nuke/plugins/load/load_image.py b/openpype/hosts/nuke/plugins/load/load_image.py index f33a81141c1..6df286a4f74 100644 --- a/openpype/hosts/nuke/plugins/load/load_image.py +++ b/openpype/hosts/nuke/plugins/load/load_image.py @@ -1,6 +1,6 @@ import nuke -from openpype.vendor.python.common import qargparse +import qargparse from openpype.pipeline import ( legacy_io,