def process(self): nodes = list() if (self.options or {}).get("useSelection"): nodes = self.nodes if len(nodes) >= 1: # loop selected nodes for n in nodes: data = self.data.copy() if len(nodes) > 1: # rename subset name only if more # then one node are selected subset = self.family + n["name"].value().capitalize() data["subset"] = subset # change node color n["tile_color"].setValue(int(self.node_color, 16)) # add avalon knobs anlib.set_avalon_knob_data(n, data) return True else: msg = str("Please select nodes you " "wish to add to a container") self.log.error(msg) nuke.message(msg) return else: # if selected is off then create one node camera_node = nuke.createNode("Camera2") camera_node["tile_color"].setValue(int(self.node_color, 16)) # add avalon knobs instance = anlib.set_avalon_knob_data(camera_node, self.data) return instance
def load(self, context, name=None, namespace=None, options=None): representation = context["representation"] nodes = list() for name, data in representation["data"]["sequence"].items(): read = nuke.Node("Read") nodes.append(read) self.set_path(read, aov_name=name, file_name=data["fname"]) self.set_format(read, data["resolution"]) self.set_range(read, start=data["seqStart"], end=data["seqEnd"]) # Mark aov name lib.set_avalon_knob_data(read, {("aov", "AOV"): name}) asset = context["asset"] asset_name = asset["data"].get("shortName", asset["name"]) families = context["subset"]["data"]["families"] family_name = families[0].split(".")[-1] namespace = namespace or "%s_%s" % (asset_name, family_name) pipeline.containerise(name=context["subset"]["name"], namespace=namespace, nodes=nodes, context=context, loader=self.__class__.__name__, no_backdrop=True)
def process(self): from nukescripts import autoBackdrop nodes = list() if (self.options or {}).get("useSelection"): nodes = self.nodes if len(nodes) >= 1: anlib.select_nodes(nodes) bckd_node = autoBackdrop() bckd_node["name"].setValue("{}_BDN".format(self.name)) bckd_node["tile_color"].setValue(int(self.node_color, 16)) bckd_node["note_font_size"].setValue(24) bckd_node["label"].setValue("[{}]".format(self.name)) # add avalon knobs instance = anlib.set_avalon_knob_data(bckd_node, self.data) return instance else: msg = str("Please select nodes you " "wish to add to a container") self.log.error(msg) nuke.message(msg) return else: bckd_node = autoBackdrop() bckd_node["name"].setValue("{}_BDN".format(self.name)) bckd_node["tile_color"].setValue(int(self.node_color, 16)) bckd_node["note_font_size"].setValue(24) bckd_node["label"].setValue("[{}]".format(self.name)) # add avalon knobs instance = anlib.set_avalon_knob_data(bckd_node, self.data) return instance
def process(self): if (self.options or {}).get("useSelection"): nodes = self.nodes self.log.info(len(nodes)) if len(nodes) == 1: anlib.select_nodes(nodes) node = nodes[-1] # check if Group node if node.Class() in "Group": node["name"].setValue("{}_GZM".format(self.name)) node["tile_color"].setValue(int(self.node_color, 16)) return anlib.set_avalon_knob_data(node, self.data) else: msg = ("Please select a group node " "you wish to publish as the gizmo") self.log.error(msg) nuke.message(msg) if len(nodes) >= 2: anlib.select_nodes(nodes) nuke.makeGroup() gizmo_node = nuke.selectedNode() gizmo_node["name"].setValue("{}_GZM".format(self.name)) gizmo_node["tile_color"].setValue(int(self.node_color, 16)) # add sticky node wit guide with gizmo_node: sticky = nuke.createNode("StickyNote") sticky["label"].setValue( "Add following:\n- set Input" " nodes\n- set one Output1\n" "- create User knobs on the group") # add avalon knobs return anlib.set_avalon_knob_data(gizmo_node, self.data) else: msg = ("Please select nodes you " "wish to add to the gizmo") self.log.error(msg) nuke.message(msg) return else: with anlib.maintained_selection(): gizmo_node = nuke.createNode("Group") gizmo_node["name"].setValue("{}_GZM".format(self.name)) gizmo_node["tile_color"].setValue(int(self.node_color, 16)) # add sticky node wit guide with gizmo_node: sticky = nuke.createNode("StickyNote") sticky["label"].setValue( "Add following:\n- add Input" " nodes\n- add one Output1\n" "- create User knobs on the group") # add avalon knobs return anlib.set_avalon_knob_data(gizmo_node, self.data)
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 build_sequences(cls, sequences, root_path, group_name, stamp_name, start, end): cls.resolve_path(sequences, root_path) # Filter out multi-channle sequence multiaovs = OrderedDict() singleaovs = OrderedDict() for aov_name in sorted(sequences, key=lambda k: k.lower()): data = sequences[aov_name] if cls.is_singleaov(data["_resolved"], start): singleaovs[aov_name] = data else: multiaovs[aov_name] = data multiaov_reads = list() singleaov_reads = OrderedDict() lib.reset_selection() for aov_name, data in multiaovs.items(): read = nuke.Node("Read") read["selected"].setValue(False) read.autoplace() path = data["_resolved"] cls.set_path(read, aov_name=aov_name, path=path) # cls.set_format(read, data["resolution"]) cls.set_range(read, start=start, end=end) # Mark aov name lib.set_avalon_knob_data(read, {("aov", "AOV"): aov_name}) multiaov_reads.append(read) nodes = multiaov_reads[:] if singleaovs: if "beauty" in singleaovs: # Default channel (RGBA) for exr_merge beauty_name = "beauty" else: # Ask artist if want to assign a beauty if not found beauty_name = cls.pick_beauty(singleaovs, group_name) with command.viewer_update_and_undo_stop(): group = nuke.createNode("Group") group.autoplace() with nuke_lib.group_scope(group): for aov_name, data in singleaovs.items(): read = nuke.Node("Read") read["selected"].setValue(False) read.autoplace() path = data["_resolved"] cls.set_path(read, aov_name=aov_name, path=path) # cls.set_format(read, data["resolution"]) cls.set_range(read, start=start, end=end) # Mark aov name knob = ("aov", "AOV") lib.set_avalon_knob_data(read, {knob: aov_name}) singleaov_reads[aov_name] = read if beauty_name: beauty = singleaov_reads.pop(beauty_name) else: beauty = singleaov_reads.popitem()[1] nuke_lib.exr_merge(beauty, singleaov_reads.values()) output = nuke.createNode("Output") output.autoplace() stamp = nuke.createNode("PostageStamp") stamp.setName(stamp_name) group.setName(group_name) nodes += [stamp, group] + group.nodes() return nodes