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
