def precomp_copyToGroup(precomp): ## group context is set to precomp, so back up one level. nuke.endGroup() g = nuke.nodes.Group() with precomp: nuke.selectAll() nuke.nodeCopy ( '%clipboard%' ) with g: nuke.nodePaste( '%clipboard%' ) for k in ['label', 'icon', 'indicators', 'tile_color', 'disable']: v = precomp[k].getValue() if v: g[k].setValue( v )
def update(self, container, representation): """Update the Loader's path Nuke automatically tries to reset some variables when changing the loader's path to a new file. These automatic changes are to its inputs: """ # get main variables # Get version from io version = io.find_one({ "type": "version", "_id": representation["parent"] }) # get corresponding node GN = nuke.toNode(container['objectName']) file = api.get_representation_path(representation).replace("\\", "/") name = container['name'] version_data = version.get("data", {}) vname = version.get("name", None) first = version_data.get("frameStart", None) last = version_data.get("frameEnd", None) namespace = container['namespace'] colorspace = version_data.get("colorspace", None) object_name = "{}_{}".format(name, namespace) add_keys = [ "frameStart", "frameEnd", "handleStart", "handleEnd", "source", "author", "fps" ] data_imprint = { "representation": str(representation["_id"]), "frameStart": first, "frameEnd": last, "version": vname, "colorspaceInput": colorspace, "objectName": object_name } for k in add_keys: data_imprint.update({k: version_data[k]}) # adding nodes to node graph # just in case we are in group lets jump out of it nuke.endGroup() with anlib.maintained_selection(): xpos = GN.xpos() ypos = GN.ypos() avalon_data = anlib.get_avalon_knob_data(GN) nuke.delete(GN) # add group from nk nuke.nodePaste(file) GN = nuke.selectedNode() anlib.set_avalon_knob_data(GN, avalon_data) GN.setXYpos(xpos, ypos) GN["name"].setValue(object_name) # get all versions in list versions = io.find({ "type": "version", "parent": version["parent"] }).distinct('name') max_version = max(versions) # change color of node if version.get("name") not in [max_version]: GN["tile_color"].setValue(int("0xd88467ff", 16)) else: GN["tile_color"].setValue(int(self.node_color, 16)) self.log.info("udated to version: {}".format(version.get("name"))) return update_container(GN, data_imprint)
def load(self, context, name, namespace, data): """ Loading function to get Gizmo into node graph Arguments: context (dict): context of version name (str): name of the version namespace (str): asset name data (dict): compulsory attribute > not used Returns: nuke node: containerised nuke node object """ # get main variables version = context['version'] version_data = version.get("data", {}) vname = version.get("name", None) first = version_data.get("frameStart", None) last = version_data.get("frameEnd", None) namespace = namespace or context['asset']['name'] colorspace = version_data.get("colorspace", None) object_name = "{}_{}".format(name, namespace) # prepare data for imprinting # add additional metadata from the version to imprint to Avalon knob add_keys = [ "frameStart", "frameEnd", "handleStart", "handleEnd", "source", "author", "fps" ] data_imprint = { "frameStart": first, "frameEnd": last, "version": vname, "colorspaceInput": colorspace, "objectName": object_name } for k in add_keys: data_imprint.update({k: version_data[k]}) # getting file path file = self.fname.replace("\\", "/") # adding nodes to node graph # just in case we are in group lets jump out of it nuke.endGroup() with anlib.maintained_selection(): # add group from nk nuke.nodePaste(file) GN = nuke.selectedNode() GN["name"].setValue(object_name) return containerise(node=GN, name=name, namespace=namespace, context=context, loader=self.__class__.__name__, data=data_imprint)
def load(self, context, name, namespace, data): """ Loading function to get the soft effects to particular read node Arguments: context (dict): context of version name (str): name of the version namespace (str): asset name data (dict): compulsory attribute > not used Returns: nuke node: containerised nuke node object """ # import dependencies from avalon.nuke import containerise # get main variables version = context['version'] version_data = version.get("data", {}) vname = version.get("name", None) first = version_data.get("frameStart", None) last = version_data.get("frameEnd", None) workfile_first_frame = int(nuke.root()["first_frame"].getValue()) namespace = namespace or context['asset']['name'] colorspace = version_data.get("colorspace", None) object_name = "{}_{}".format(name, namespace) # prepare data for imprinting # add additional metadata from the version to imprint to Avalon knob add_keys = [ "frameStart", "frameEnd", "handleStart", "handleEnd", "source", "author", "fps" ] data_imprint = { "frameStart": first, "frameEnd": last, "version": vname, "colorspaceInput": colorspace, "objectName": object_name } for k in add_keys: data_imprint.update({k: version_data[k]}) # getting file path file = self.fname.replace("\\", "/") # getting data from json file with unicode conversion with open(file, "r") as f: json_f = { self.byteify(key): self.byteify(value) for key, value in json.load(f).iteritems() } # get correct order of nodes by positions on track and subtrack nodes_order = self.reorder_nodes(json_f["effects"]) # adding nodes to node graph # just in case we are in group lets jump out of it nuke.endGroup() GN = nuke.createNode("Group") GN["name"].setValue(object_name) # adding content to the group node with GN: pre_node = nuke.createNode("Input") pre_node["name"].setValue("rgb") for ef_name, ef_val in nodes_order.items(): node = nuke.createNode(ef_val["class"]) for k, v in ef_val["node"].items(): if k in self.ignore_attr: continue try: node[k].value() except NameError as e: self.log.warning(e) continue if isinstance(v, list) and len(v) > 4: node[k].setAnimated() for i, value in enumerate(v): if isinstance(value, list): for ci, cv in enumerate(value): node[k].setValueAt( cv, (workfile_first_frame + i), ci) else: node[k].setValueAt(value, (workfile_first_frame + i)) else: node[k].setValue(v) node.setInput(0, pre_node) pre_node = node output = nuke.createNode("Output") output.setInput(0, pre_node) # try to place it under Viewer1 if not self.connect_active_viewer(GN): nuke.delete(GN) return GN["tile_color"].setValue(int("0x3469ffff", 16)) self.log.info("Loaded lut setup: `{}`".format(GN["name"].value())) return containerise(node=GN, name=name, namespace=namespace, context=context, loader=self.__class__.__name__, data=data_imprint)
def update(self, container, representation): """Update the Loader's path Nuke automatically tries to reset some variables when changing the loader's path to a new file. These automatic changes are to its inputs: """ from avalon.nuke import (update_container) # get main variables # Get version from io version = io.find_one({ "type": "version", "_id": representation["parent"] }) # get corresponding node GN = nuke.toNode(container['objectName']) file = api.get_representation_path(representation).replace("\\", "/") name = container['name'] version_data = version.get("data", {}) vname = version.get("name", None) first = version_data.get("frameStart", None) last = version_data.get("frameEnd", None) workfile_first_frame = int(nuke.root()["first_frame"].getValue()) namespace = container['namespace'] colorspace = version_data.get("colorspace", None) object_name = "{}_{}".format(name, namespace) add_keys = [ "frameStart", "frameEnd", "handleStart", "handleEnd", "source", "author", "fps" ] data_imprint = { "representation": str(representation["_id"]), "frameStart": first, "frameEnd": last, "version": vname, "colorspaceInput": colorspace, "objectName": object_name } for k in add_keys: data_imprint.update({k: version_data[k]}) # Update the imprinted representation update_container(GN, data_imprint) # getting data from json file with unicode conversion with open(file, "r") as f: json_f = { self.byteify(key): self.byteify(value) for key, value in json.load(f).iteritems() } # get correct order of nodes by positions on track and subtrack nodes_order = self.reorder_nodes(json_f["effects"]) # adding nodes to node graph # just in case we are in group lets jump out of it nuke.endGroup() # adding content to the group node with GN: # first remove all nodes [nuke.delete(n) for n in nuke.allNodes()] # create input node pre_node = nuke.createNode("Input") pre_node["name"].setValue("rgb") for ef_name, ef_val in nodes_order.items(): node = nuke.createNode(ef_val["class"]) for k, v in ef_val["node"].items(): if k in self.ignore_attr: continue try: node[k].value() except NameError as e: self.log.warning(e) continue if isinstance(v, list) and len(v) > 3: node[k].setAnimated() for i, value in enumerate(v): if isinstance(value, list): for ci, cv in enumerate(value): node[k].setValueAt( cv, (workfile_first_frame + i), ci) else: node[k].setValueAt(value, (workfile_first_frame + i)) else: node[k].setValue(v) node.setInput(0, pre_node) pre_node = node # create output node output = nuke.createNode("Output") output.setInput(0, pre_node) # try to place it under Viewer1 if not self.connect_active_viewer(GN): nuke.delete(GN) return # get all versions in list versions = io.find({ "type": "version", "parent": version["parent"] }).distinct('name') max_version = max(versions) # change color of node if version.get("name") not in [max_version]: GN["tile_color"].setValue(int("0xd84f20ff", 16)) else: GN["tile_color"].setValue(int("0x3469ffff", 16)) self.log.info("udated to version: {}".format(version.get("name")))
def load(self, context, name, namespace, data): from avalon.nuke import containerise # for k, v in context.items(): # log.info("key: `{}`, value: {}\n".format(k, v)) version = context['version'] version_data = version.get("data", {}) vname = version.get("name", None) first = version_data.get("frameStart", None) last = version_data.get("frameEnd", None) # Fallback to asset name when namespace is None if namespace is None: namespace = context['asset']['name'] file = self.fname.replace("\\", "/") self.log.info("file: {}\n".format(self.fname)) precomp_name = context["representation"]["context"]["subset"] self.log.info("versionData: {}\n".format(context["version"]["data"])) # add additional metadata from the version to imprint to Avalon knob add_keys = [ "frameStart", "frameEnd", "handleStart", "handleEnd", "source", "author", "fps" ] data_imprint = { "startingFrame": first, "frameStart": first, "frameEnd": last, "version": vname } for k in add_keys: data_imprint.update({k: context["version"]['data'][k]}) data_imprint.update({"objectName": precomp_name}) # group context is set to precomp, so back up one level. nuke.endGroup() # P = nuke.nodes.LiveGroup("file {}".format(file)) P = nuke.createNode("Precomp", "file {}".format(file)) # Set colorspace defined in version data colorspace = context["version"]["data"].get("colorspace", None) self.log.info("colorspace: {}\n".format(colorspace)) # ['version', 'file', 'reading', 'output', 'useOutput'] P["name"].setValue("{}_{}".format(name, namespace)) P["useOutput"].setValue(True) with P: # iterate trough all nodes in group node and find pype writes writes = [ n.name() for n in nuke.allNodes() if n.Class() == "Group" if get_avalon_knob_data(n) ] # create panel for selecting output panel_choices = " ".join(writes) panel_label = "Select write node for output" p = nuke.Panel("Select Write Node") p.addEnumerationPulldown(panel_label, panel_choices) p.show() P["output"].setValue(p.value(panel_label)) P["tile_color"].setValue(0xff0ff0ff) return containerise(node=P, name=name, namespace=namespace, context=context, loader=self.__class__.__name__, data=data_imprint)
def load(self, context, name, namespace, data): """ Loading function to import .nk file into script and wrap it on backdrop Arguments: context (dict): context of version name (str): name of the version namespace (str): asset name data (dict): compulsory attribute > not used Returns: nuke node: containerised nuke node object """ # get main variables version = context['version'] version_data = version.get("data", {}) vname = version.get("name", None) first = version_data.get("frameStart", None) last = version_data.get("frameEnd", None) namespace = namespace or context['asset']['name'] colorspace = version_data.get("colorspace", None) object_name = "{}_{}".format(name, namespace) # prepare data for imprinting # add additional metadata from the version to imprint to Avalon knob add_keys = [ "frameStart", "frameEnd", "handleStart", "handleEnd", "source", "author", "fps" ] data_imprint = { "frameStart": first, "frameEnd": last, "version": vname, "colorspaceInput": colorspace, "objectName": object_name } for k in add_keys: data_imprint.update({k: version_data[k]}) # getting file path file = self.fname.replace("\\", "/") # adding nodes to node graph # just in case we are in group lets jump out of it nuke.endGroup() # Get mouse position n = nuke.createNode("NoOp") xcursor, ycursor = (n.xpos(), n.ypos()) anlib.reset_selection() nuke.delete(n) bdn_frame = 50 with anlib.maintained_selection(): # add group from nk nuke.nodePaste(file) # get all pasted nodes new_nodes = list() nodes = nuke.selectedNodes() # get pointer position in DAG xpointer, ypointer = pnlib.find_free_space_to_paste_nodes( nodes, direction="right", offset=200 + bdn_frame) # reset position to all nodes and replace inputs and output for n in nodes: anlib.reset_selection() xpos = (n.xpos() - xcursor) + xpointer ypos = (n.ypos() - ycursor) + ypointer n.setXYpos(xpos, ypos) # replace Input nodes for dots if n.Class() in "Input": dot = nuke.createNode("Dot") new_name = n.name().replace("INP", "DOT") dot.setName(new_name) dot["label"].setValue(new_name) dot.setXYpos(xpos, ypos) new_nodes.append(dot) # rewire dep = n.dependent() for d in dep: index = next( (i for i, dpcy in enumerate(d.dependencies()) if n is dpcy), 0) d.setInput(index, dot) # remove Input node anlib.reset_selection() nuke.delete(n) continue # replace Input nodes for dots elif n.Class() in "Output": dot = nuke.createNode("Dot") new_name = n.name() + "_DOT" dot.setName(new_name) dot["label"].setValue(new_name) dot.setXYpos(xpos, ypos) new_nodes.append(dot) # rewire dep = next((d for d in n.dependencies()), None) if dep: dot.setInput(0, dep) # remove Input node anlib.reset_selection() nuke.delete(n) continue else: new_nodes.append(n) # reselect nodes with new Dot instead of Inputs and Output anlib.reset_selection() anlib.select_nodes(new_nodes) # place on backdrop bdn = nukescripts.autoBackdrop() # add frame offset xpos = bdn.xpos() - bdn_frame ypos = bdn.ypos() - bdn_frame bdwidth = bdn["bdwidth"].value() + (bdn_frame * 2) bdheight = bdn["bdheight"].value() + (bdn_frame * 2) bdn["xpos"].setValue(xpos) bdn["ypos"].setValue(ypos) bdn["bdwidth"].setValue(bdwidth) bdn["bdheight"].setValue(bdheight) bdn["name"].setValue(object_name) bdn["label"].setValue( "Version tracked frame: \n`{}`\n\nPLEASE DO NOT REMOVE OR MOVE \nANYTHING FROM THIS FRAME!" .format(object_name)) bdn["note_font_size"].setValue(20) return containerise(node=bdn, name=name, namespace=namespace, context=context, loader=self.__class__.__name__, data=data_imprint)