def colorButtons(bd, hex_group, blk):
'''create ColorCode buttons
@bd: backdrop node (obj)
@hex_group: color scheme (dic {'type': [font (hex), tile (hex), button (hex)]})
@blk: black color (str)
'''
## Inherit from:
## (https://github.com/mb0rt/Nuke-NodeHelpers/blob/master/mbort/backdrop_palette/backdrop.py)
# Create Knobs
# Tab
tab = nuke.Tab_Knob('Backdrop+ColorCode')
# Label
label_link = nuke.Link_Knob('label_link', 'label')
label_link.makeLink(bd.name(), 'label')
# Font
font_link = nuke.Link_Knob('note_font_link', 'font')
font_link.makeLink(bd.name(), 'note_font')
# Font Size
font_size_link = nuke.Link_Knob('note_font_size_link', '')
font_size_link.makeLink(bd.name(), 'note_font_size')
font_size_link.clearFlag(nuke.STARTLINE)
# font Color
font_color_link = nuke.Link_Knob('note_font_color_link', 'font color')
font_color_link.makeLink(bd.name(), 'note_font_color')
font_color_link.clearFlag(nuke.STARTLINE)
# Divider
k_div = nuke.Text_Knob('')
# add Tab
bd.addKnob(tab)
# Color Code
counter = 0
hex_group_keys = hex_group.keys()
hex_group_keys.remove('*Random')
for t in sorted(hex_group_keys):
name = "bt_%s" % (t)
label = "<font color='#%s'>%s</font> <b>%s" % (hex_group[t][2], blk, t)
cmd = "n=nuke.thisNode();\
n['tile_color'].setValue(int('%sFF',16));\
n['note_font_color'].setValue(int('%sFF', 16));\
n['note_font'].setValue('bold')" % (hex_group[t][1], hex_group[t][0])
cc_knob = nuke.PyScript_Knob(name, label, cmd)
cc_knob.setTooltip(t)
# If First Item
if counter == 0 or counter == 5:
cc_knob.setFlag(nuke.STARTLINE)
else:
cc_knob.clearFlag(nuke.STARTLINE)
bd.addKnob(cc_knob)
counter += 1
# Add Knobs
bd.addKnob(k_div)
bd.addKnob(label_link)
bd.addKnob(font_link)
bd.addKnob(font_size_link)
bd.addKnob(font_color_link)
def on_backdrop_created(node):
"""
Adds 'Backdrop Pallete' tabs and knobs for newly created `nuke.BackdropNode`
nodes. If a `nuke.Tab_Knob` with name "Backdrop" already exists on specified
node, tab creation is aborted.
Args:
node(`nuke.BackdropNode`): node to add 'Backdrop Pallete' tab and knobs.
"""
# bail if was already created.
if node.knob("Backdrop"):
on_backdrop_user_created(node)
return
# add a new tab
tab = nuke.Tab_Knob('Backdrop')
node.addKnob(tab)
# link label knob
label_link = nuke.Link_Knob('label_link', 'label')
label_link.makeLink(node.name(), 'label')
node.addKnob(label_link)
# link font knob
font_link = nuke.Link_Knob('note_font_link', 'font')
font_link.makeLink(node.name(), 'note_font')
node.addKnob(font_link)
# link font size knob
font_size_link = nuke.Link_Knob('note_font_size_link', '')
font_size_link.makeLink(node.name(), 'note_font_size')
font_size_link.clearFlag(nuke.STARTLINE)
node.addKnob(font_size_link)
# link position/size
position_links = [['x', 'xpos'], ['y', 'ypos'], ['w', 'bdwidth'], ['h', 'bdheight']]
for i in range(len(position_links)):
name = position_links[i][0]
target = position_links[i][1]
link_knob = nuke.Link_Knob('%s_link' % name)
link_knob.setLabel("%s:" % name)
link_knob.makeLink(node.name(), target)
if i == 0:
link_knob.setFlag(nuke.STARTLINE)
else:
link_knob.clearFlag(nuke.STARTLINE)
node.addKnob(link_knob)
# nuke 9 bug fix
node.knobs()[target].clearFlag(nuke.INVISIBLE)
node.knobs()[target].setVisible(False)
# create palette/color/icon/position widget
theme_knob = nuke.PyCustom_Knob("Colors", "", "backdrop_palette.backdrop_widget.ColorSwatch(nuke.thisNode())")
theme_knob.setFlag(nuke.STARTLINE)
node.addKnob(theme_knob)
def add_light(_thru=False, node=None, light_selection='none'):
"""Add a light to the rfxGrade gizmo"""
logger.debug('adding light {0}', light_selection)
if _thru:
metrics.log_feature(APP_NAME, 'add light')
# ------------------- Setup -------------------------------------- #
# builder node start
builder_dot = nuke.toNode('builder_dot')
# bottom of plus-stack
plus_stack = crawl.up(builder_dot)[0]
# copy node start
copy_dot = nuke.toNode('copy_dot')
# bottom of copy stack
copy_stack = crawl.up(copy_dot)[0]
# copy graded lights back into channels
graded_lights = nuke.toNode('copyfrom_dot')
# ------------------- Add Nodes ---------------------------------- #
# add light to the plus stack
added_light = nuke.nodes.Merge2(output='rgb', operation='plus')
light_name = added_light.name()
# move and connect
move.under(added_light, plus_stack)
added_light.setInput(0, plus_stack)
added_light.setInput(1, plus_stack)
builder_dot.setInput(0, added_light)
# add light to the copy stack
copied_light = nuke.nodes.Merge2(Bchannels='none', operation='copy')
copied_light['Achannels'].setExpression("{}.Achannels".format(light_name))
copied_light['output'].setExpression("{}.Achannels".format(light_name))
copied_light['disable'].setExpression("{}.disable".format(light_name))
# move and connect
move.under(copied_light, copy_stack)
copied_light.setInput(0, copy_stack)
copied_light.setInput(1, graded_lights)
copy_dot.setInput(0, copied_light)
# ------------------- Knobs -------------------------------------- #
link = nuke.Link_Knob((added_light.name() + '_link'), 'light')
link.clearFlag(nuke.STARTLINE)
link.makeLink(added_light.name(), 'Achannels')
disableLink = nuke.Link_Knob((added_light.name() + '_disable_lnk'), 'mute')
disableLink.clearFlag(nuke.STARTLINE)
disableLink.makeLink(added_light.name(), 'disable')
remove_button = nuke.PyScript_Knob((added_light.name() + "_rmb"), 'X')
remove_button.setValue(
"import vfx_utils.plutonium.gizmos.rfx_grade as rfx_grade\n"
"rfx_grade.remove_light('{}', '{}')"
"".format(light_name, copied_light.name()))
remove_button.setFlag(nuke.STARTLINE)
node.addKnob(remove_button)
node.addKnob(link)
node.addKnob(disableLink)
# due to a glitch in the way channels are interpreted by the link-knob,
# this value must be set after the knob is created.
added_light['Achannels'].setValue(light_selection)
return added_light
def add_matte(node=None, matte_layer=None):
"""adds the required nodes and connections for a new matte in
multimatte gizmo"""
logger.debug('adding matte: {}'.format(matte_layer))
# ------------------- Setup -------------------------------------- #
# Get information required to build the nodes...
builder = nuke.toNode('builder_dot')
start_position = crawl.up(builder)[0]
# ------------------- Build Nodes -------------------------------- #
# Make the Copy Node
copy_channel = matte_layer
to_channel = 'rgba.alpha'
copy_matte = create.copy([copy_channel], [to_channel])
copy_matte.setInput(1, start_position)
# Make the Plus Node
alpha_plus = create.add_alphas()
# ------------------- Inputs and Placement ----------------------- #
alpha_plus.setInput(1, copy_matte)
alpha_plus.setInput(0, start_position)
builder.setInput(0, alpha_plus)
alpha_plus.setXYpos(0, 0)
move.under(alpha_plus, start_position)
move.left(copy_matte, alpha_plus, offset=50)
# ------------------- Knobs -------------------------------------- #
# text label
text_label = nuke.Text_Knob(ujoin(alpha_plus.name(), 'lbl'), '')
text_label.clearFlag(nuke.STARTLINE)
text_label.clearFlag(nuke.ENDLINE)
text_label.setValue(matte_layer[6:])
# mix control
mix_link = nuke.Link_Knob(ujoin(alpha_plus.name(), 'mix'), ' ')
mix_link.clearFlag(nuke.STARTLINE)
mix_link.makeLink(alpha_plus.name(), 'mix')
# merge operation
op_link = nuke.Link_Knob(ujoin(alpha_plus.name(), 'op'), '')
op_link.clearFlag(nuke.STARTLINE)
op_link.makeLink(alpha_plus.name(), 'operation')
# remove this matte
remove_btn = nuke.PyScript_Knob(ujoin(alpha_plus.name(), 'rm'), 'X')
rm_script = ('from vfx_utils.plutonium.gizmos import multimatte'
'\nmultimatte.remove_matte("{}", "{}")')
rm_formatted = rm_script.format(alpha_plus.name(), copy_matte.name())
remove_btn.setValue(rm_formatted)
remove_btn.setFlag(nuke.STARTLINE)
# add knobs to interface
node.addKnob(remove_btn)
node.addKnob(op_link)
node.addKnob(text_label)
node.addKnob(mix_link)
mix_link.clearFlag(nuke.STARTLINE)
def on_backdrop_created(node):
if node.knob("Backdrop"):
on_backdrop_user_created(node)
return
# add a new tab
tab = nuke.Tab_Knob('Backdrop')
node.addKnob(tab)
# link label knob
label_link = nuke.Link_Knob('label_link', 'label')
label_link.makeLink(node.name(), 'label')
node.addKnob(label_link)
# link font knob
font_link = nuke.Link_Knob('note_font_link', 'font')
font_link.makeLink(node.name(), 'note_font')
node.addKnob(font_link)
# link font size knob
font_size_link = nuke.Link_Knob('note_font_size_link', '')
font_size_link.makeLink(node.name(), 'note_font_size')
font_size_link.clearFlag(nuke.STARTLINE)
node.addKnob(font_size_link)
# link position/size
position_links = [['x', 'xpos'], ['y', 'ypos'], ['w', 'bdwidth'],
['h', 'bdheight']]
for i in range(len(position_links)):
name = position_links[i][0]
target = position_links[i][1]
link_knob = nuke.Link_Knob('%s_link' % name)
link_knob.setLabel("%s:" % name)
link_knob.makeLink(node.name(), target)
if i == 0:
link_knob.setFlag(nuke.STARTLINE)
else:
link_knob.clearFlag(nuke.STARTLINE)
node.addKnob(link_knob)
# nuke 9 fix
node.knobs()[target].clearFlag(nuke.INVISIBLE)
node.knobs()[target].setVisible(False)
# create palette/color/icon/position widget
theme_knob = nuke.PyCustom_Knob(
"Colors", "",
"backdrop_palette.backdrop_widget.ColorSwatch( nuke.thisNode() )")
theme_knob.setFlag(nuke.STARTLINE)
node.addKnob(theme_knob)
def createWriteSoundTab(node):
#### create knobs
tabKnob = nuke.Tab_Knob('WriteSound')
channelKnob = nuke.Link_Knob('channels_name', 'channels')
fileKnob = nuke.Link_Knob('file_name', 'file')
proxyKnob = nuke.Link_Knob('proxy_name', 'proxy')
divideKnob = nuke.Text_Knob('')
colorKnob = nuke.Link_Knob('colorspace_name', 'colorspace')
preMultKnob = nuke.Link_Knob('premultiplied_name', 'premultiplied')
rawDataKnob = nuke.Link_Knob('raw data name', 'raw data')
viewsKnob = nuke.Link_Knob('views_name', 'views')
typeKnob = nuke.Link_Knob('file type name', 'file type')
orderKnob = nuke.Link_Knob('render_order_name', 'render order')
buttonKnob = nuke.PyScript_Knob('Render With Sound')
#### make links to the Original Write
channelKnob.setLink('channels')
fileKnob.setLink('file')
proxyKnob.setLink('proxy')
colorKnob.setLink('colorspace')
preMultKnob.setLink('premultiplied')
rawDataKnob.setLink('raw')
viewsKnob.setLink('views')
typeKnob.setLink('file_type')
orderKnob.setLink('render_order')
script = """
############ This section by Fredrik Brannbacka #############
##
## Make sure you set the sounds file path
macSound = 'PATH/TO/SOUND/FILE'
winSound = 'C:/Program Files (x86)/Nuke5.1v5/plugins/user/BIP.wav'
def playSound():
if nuke.env["MACOS"]:
sys.path.append('/System/Library/Frameworks/Python.framework/Versions/2.5/Extras/lib/python')
sys.path.append('/System/Library/Frameworks/Python.framework/Versions/2.5/Extras/lib/python/PyObjC')
from AppKit import NSSound
sound = NSSound.alloc()
sound.initWithContentsOfFile_byReference_(macSound, True)
sound.play()
elif nuke.env["WIN32"]:
import winsound
winsound.PlaySound(winSound, winsound.SND_FILENAME|winsound.SND_ASYNC)
node = nuke.selectedNode()
if node.Class()=='Write':
start,end = nuke.getFramesAndViews('Render Range','%i,%i' % (nuke.root()['first_frame'].value(),nuke.root()['last_frame'].value()))[0].split(',',2)
if nuke.execute(node.name(),int(start),int(end)):
playSound()
"""
buttonKnob.setValue(script)
#### add knobs to node
for k in [tabKnob, channelKnob, fileKnob, proxyKnob, divideKnob, colorKnob, preMultKnob, rawDataKnob, viewsKnob, typeKnob, orderKnob, buttonKnob]:
node.addKnob(k)
def createReadGroup(node,grp):
knobs=['file','cacheLocal','format','proxy','proxy_format','first','before','last','after','frame_mode','frame','origfirst','origlast','on_error','reload','colorspace','premultiplied','raw','auto_alpha','offset_negative_display_window']
for k in knobs:
l = nuke.Link_Knob(k)
l.makeLink(node.name(), k)
grp.addKnob( l )
if not node.knobs()[k].getFlag(nuke.STARTLINE):
l.clearFlag(nuke.STARTLINE)
def addFrameionodetab(node):
"""Adds frame.io settings tab to the node"""
if not 'frameio' in node.knobs():
node.addKnob( nuke.Tab_Knob('frameio' , 'frame.io') )
node.addKnob( nuke.Link_Knob('frameiousername' , 'Username') )
node.addKnob( nuke.Link_Knob('frameioproject' , 'Project' , ) )
node['frameiousername'].setLink('root.frameiousername')
node['frameioproject'].setLink('root.frameioproject')
openbrowser = 'import webbrowser\nurl = "https://app.frame.io/?f=" + nuke.thisNode()["filereferenceid"].value()\nwebbrowser.open_new_tab(url)'
node.addKnob(nuke.PyScript_Knob( 'openbrowser', 'Open upload in browser',openbrowser ))
node.addKnob( nuke.Text_Knob('line1' , '') )
node.addKnob( nuke.String_Knob('filereferenceid' , 'filereferenceid') )
node.addKnob( nuke.String_Knob('folderid' , 'folderid') )
node.addKnob( nuke.String_Knob('projectid' , 'projectid') )
node['openbrowser'].setFlag(nuke.STARTLINE)
node['filereferenceid'].setEnabled(False)
node['folderid'].setEnabled(False)
node['projectid'].setEnabled(False)
def set_link(knob, target, source, name=None, label=None, startline=True):
"""Sets up a Link_Knob between a source node's knob and a target node.
Args:
knob : (str)
The name of the target knob to be linked.
source : <nuke.node>
The node the knob will be linked from.
target : <nuke.node>
The node where the link knob will be placed on.
name=None : (str)
If given, this label will override any name from the linked knob.
label=None : (str)
If given, this label will override any label from the linked
knob.
startline=True : (bool)
If True, the Link_Knob will start a new line. This is Nuke's
default. If False, we'll clear the STARTLINE flag.
Returns:
(<nuke.Link_Knob>)
The created Link_Knob.
Raises:
N/A
"""
name = name if name else source[knob].name()
label = label if label else source[knob].label()
link_args = [name]
if label: # label could still be blank
link_args.append(label)
link_knob = nuke.Link_Knob(*link_args)
# Link the knob
link_knob.setLink('{node}.{knob}'.format(node=source.name(), knob=knob))
if not startline:
link_knob.clearFlag(nuke.STARTLINE)
target.addKnob(link_knob)
return link_knob
def main():
grp = nuke.selectedNode()
with grp:
for node in nuke.allNodes():
found = 0
switch = 0
for k in node.knobs():
if node.knob(k).isAnimated():
label = nuke.Text_Knob(node.name() + "_divider",
node.name())
if not switch:
grp.addKnob(label)
l = nuke.Link_Knob(k)
l.makeLink(node.name(), k)
l.setName(node.name() + '_' + k)
grp.addKnob(l)
node.knob(k).removeKey(0)
switch = 1
if switch:
l = nuke.Link_Knob('disable')
l.makeLink(node.name(), 'disable')
l.setName(node.name() + '_disable')
grp.addKnob(l)
def add_point(node=None):
"""add a pointmatte to the gizmo"""
with node:
# ------------------- Setup ---------------------------------- #
builder = nuke.toNode('builder_dot')
start_position = crawl.up(builder)[0]
point_nodes = [
int(n.name()[-1]) for n in filters.by_class(key='pointMatte')
]
point_num = (max(point_nodes) + 1) if point_nodes else 1
prefix = 'point_{}'.format(point_num)
# ------------------- Create Nodes --------------------------- #
point_matte = nuke.nodes.rfxPointMatte()
point_matte.setName(prefix)
merge_points = nuke.nodes.Merge2(operation='plus')
merge_points.setName(prefix + '_merge')
# ------------------- Move Into Position --------------------- #
move.left(point_matte, start_position)
move.under(merge_points, start_position)
# ------------------- Set Up Connections --------------------- #
point_matte.setInput(0, start_position)
merge_points.setInput(0, start_position)
merge_points.setInput(1, point_matte)
builder.setInput(0, merge_points)
# ------------------- Knobs and Expressions ------------------ #
knoblist = [
'hr', 'Position_value', 'Position_dropper', 'type', 'hr',
'rotate_TXT', 'xSlider', 'ySlider', 'zSlider', 'hr', 'scale_TXT',
'overall_scale', 'scale_x', 'scale_y', 'scale_z', 'hr', 'feather',
'hr', 'Gamma1_value', 'hr', 'massage', 'hr'
]
new_tab = nuke.Tab_Knob('_'.join((prefix, 'controls')))
node.addKnob(new_tab)
merge_op_knob = nuke.Link_Knob('_'.join((prefix, 'merge_op')))
merge_op_knob.setLink(merge_points.name() + '.operation')
merge_op_knob.setLabel('operation')
node.addKnob(merge_op_knob)
merge_mix_knob = nuke.Link_Knob('_'.join((prefix, 'merge_mix')))
merge_mix_knob.setLink(merge_points.name() + '.mix')
merge_mix_knob.setLabel('mix')
node.addKnob(merge_mix_knob)
for k in knoblist:
if k == 'hr':
knob = nuke.Text_Knob('')
knob.setName('_'.join((prefix, 'hr')))
knob.setLabel('')
else:
knob = nuke.Link_Knob('_'.join((prefix, k)))
knob.setLink('.'.join((point_matte.name(), k)))
knob.setLabel(point_matte[k].label())
if k == 'massage':
knob.setLabel(k)
node.addKnob(knob)
del_button = nuke.PyScript_Knob('_'.join((prefix, 'del')))
del_button.setLabel('Remove Point')
del_button.setValue(
'from vfx_utils.plutonium.gizmos import pointmatte\n'
'pointmatte.delete_point(point_num={})\n'
''.format(point_num))
node.addKnob(del_button)
def process(self):
inputs = []
outputs = []
instance = nuke.toNode(self.data["subset"])
selected_node = None
# use selection
if (self.options or {}).get("useSelection"):
nodes = self.nodes
if not (len(nodes) < 2):
msg = ("Select only one node. The node "
"you want to connect to, "
"or tick off `Use selection`")
self.log.error(msg)
nuke.message(msg)
if len(nodes) == 0:
msg = (
"No nodes selected. Please select a single node to connect"
" to or tick off `Use selection`")
self.log.error(msg)
nuke.message(msg)
selected_node = nodes[0]
inputs = [selected_node]
outputs = selected_node.dependent()
if instance:
if (instance.name() in selected_node.name()):
selected_node = instance.dependencies()[0]
# if node already exist
if instance:
# collect input / outputs
inputs = instance.dependencies()
outputs = instance.dependent()
selected_node = inputs[0]
# remove old one
nuke.delete(instance)
# recreate new
write_data = {
"nodeclass": self.n_class,
"families": [self.family],
"avalon": self.data,
"creator": self.__class__.__name__
}
if self.presets.get('fpath_template'):
self.log.info("Adding template path from preset")
write_data.update(
{"fpath_template": self.presets["fpath_template"]})
else:
self.log.info("Adding template path from plugin")
write_data.update({
"fpath_template": ("{work}/prerenders/nuke/{subset}"
"/{subset}.{frame}.{ext}")
})
self.log.info("write_data: {}".format(write_data))
write_node = lib.create_write_node(self.data["subset"],
write_data,
input=selected_node,
prenodes=[],
review=False)
# relinking to collected connections
for i, input in enumerate(inputs):
write_node.setInput(i, input)
write_node.autoplace()
for output in outputs:
output.setInput(0, write_node)
# open group node
write_node.begin()
for n in nuke.allNodes():
# get write node
if n.Class() in "Write":
w_node = n
write_node.end()
# add inner write node Tab
write_node.addKnob(nuke.Tab_Knob("WriteLinkedKnobs"))
# linking knobs to group property panel
linking_knobs = ["channels", "___", "first", "last", "use_limit"]
for k in linking_knobs:
if "___" in k:
write_node.addKnob(nuke.Text_Knob(''))
else:
lnk = nuke.Link_Knob(k)
lnk.makeLink(w_node.name(), k)
lnk.setName(k.replace('_', ' ').capitalize())
lnk.clearFlag(nuke.STARTLINE)
write_node.addKnob(lnk)
return write_node
16),
note_font_size=fntSize)
n.showControlPanel()
#Creating additional tabs
chTab = nuke.Tab_Knob('mainTabTK', 'backdropTK')
chLogo = nuke.Text_Knob(
'logo1', '',
'<font color="lightgreen" size="5">backdrop</font><font color="#FFCC66" size="5">TK</font>'
)
chLogo1 = nuke.Text_Knob(
'logo1', '',
'<font color="lightgreen" size="2">by Timur Khodzhaev</font>')
chlabel = nuke.Link_Knob('label_1', 'label')
chlabel.makeLink(n.name(), 'label')
n.addKnob(chTab)
# n.addKnob(chLogo)
# n.addKnob(chLogo1)
n.addKnob(chlabel)
nameList = []
# Creating presets buttons in the node
for i in presetList:
nameList.append(i[0])
for i, v in enumerate(presetList):
def textureTrackSetup(DIP):
# Create variables
# DIP = nuke.selectedNode()
channels = DIP.channels()
global m_layers
m_layers = []
# Create sorted list of DIP layers
global layers
layers = sorted(list(set([c.split('.')[0] for c in channels])))
# Look for layers that have "m_" and append them to m_layers
for layer in layers:
if "m_" in layer:
m_layers.append(layer)
print("Added " + str(layer))
if len(m_layers) < 1:
nuke.message('No layers starting with "m_" found...')
return
# Create DIP layer if it's not found
if 'DIP' not in nuke.layers():
nuke.Layer('DIP', ['DIP.red', 'DIP.green', 'DIP.blue', 'DIP.alpha'])
"DIP layer not found. Creating DIP layer."
else:
print("DIP layer found.")
# Clear selection
#nukescripts.clear_selection_recursive()
# Create tex01 layer if not found
if 'tex01' not in nuke.layers():
nuke.Layer('tex01',
['tex01.red', 'tex01.green', 'tex01.blue', 'tex01.alpha'])
nukescripts.clear_selection_recursive()
DIP['selected'].setValue(True)
grp = nuke.createNode('Group', inpanel=False)
grp.setName('TPD_TextureTrack')
grp['xpos'].setValue(DIP.xpos())
grp['ypos'].setValue(85 + DIP.ypos())
grp.setInput(0, DIP)
print('Created Group node')
text = nuke.Text_Knob(
'title', ' ',
'<i>TPD_TextureTrack</i></b> {}<br>by Noah Catan<br><br><b>'.format(
version))
div1 = nuke.Text_Knob('div', ' ')
grp.addKnob(text)
grp.addKnob(div1)
global_scale = nuke.Double_Knob('global_scale', 'global scale')
global_rotate = nuke.Double_Knob('global_rotate', 'global rotate')
div = nuke.Text_Knob('div', ' ')
grp.addKnob(global_scale)
grp.addKnob(global_rotate)
grp.addKnob(div)
grp['global_scale'].setRange(1, 5)
grp['global_scale'].setValue(1)
grp['global_rotate'].setRange(0, 360)
grp['global_rotate'].setValue(0)
with grp:
input1 = nuke.nodes.Input()
dot = nuke.nodes.Dot(xpos=34 + input1.xpos(),
ypos=200 + input1.ypos(),
inputs=[input1])
create_nodeTree(dot)
'''for transform in transformList:
knobTarget = "{}.{}".format(transform.name(), 'scaleOffset')
linkedKnobs.append(knobTarget)
for knob in linkedKnobs:
link_knob = nuke.Link_Knob("{}".format(layers[linkedKnobs.index(knob)]))
link_knob.setLink(knob)
grp.addKnob(link_knob)'''
for knob in knobList:
link_knob = nuke.Link_Knob('{}'.format(knob[9:]))
link_knob.setLink(knob)
grp.addKnob(link_knob)
def add_zone(node=None):
"""add a zone with corresponding nodes and controls to an rfxTimeZones node"""
metrics.log_feature(APP_NAME, 'add zone')
with node:
# ------------------- Setup ---------------------------------- #
color_choices = [(1, 0, 0, 1), (0, 1, 0, 1), (0, 0, 1, 1),
(1, 1, 0, 1), (0, 1, 1, 1), (1, 0, 1, 1)]
zones = [int(n.name()[-1]) for n in filters.by_class(key='Input')
if 'zone' in n.name()]
print "zones"
zone_num = (max(zones) + 1) if zones else 1
color_num = zone_num - 1
prev_preview = nuke.toNode('zone_{}_stack'.format(color_num))
color_num = color_num if color_num <= len(color_choices) else 0
prefix = 'zone_{}'.format(zone_num)
builder = nuke.toNode('builder_dot')
start_position = crawl.up(builder)[0]
switch = nuke.toNode('preview_zones')
print "a"
# ------------------- Create Nodes --------------------------- #
copy_alpha = create.copy(['rgba.alpha'], ['rgba.alpha'])
copy_alpha.setName('_'.join((prefix, 'copy')))
const = nuke.nodes.Constant()
const['color'].setValue(color_choices[color_num])
const.setName('_'.join((prefix, 'const')))
copy_to_const = nuke.nodes.Merge2(operation='mask')
copy_to_const.setName('_'.join((prefix, 'color_copy')))
preview_stack = nuke.nodes.Merge2(operation='plus')
preview_stack.setName('_'.join((prefix, 'stack')))
zone_over = nuke.nodes.Merge2(operation='matte')
zone_over.setName('_'.join((prefix, 'merge')))
zone_time = nuke.nodes.TimeOffset()
zone_time.setName('_'.join((prefix, 'time')))
zone_input = nuke.nodes.Input()
zone_input['name'].setValue(prefix)
print "b"
# ------------------- Move Nodes into Position --------------- #
move.under(zone_over, start_position, offset=120)
move.left(copy_alpha, zone_over)
move.under(copy_to_const, copy_alpha)
move.left(const, copy_to_const)
move.right(preview_stack, copy_to_const, offset=200)
move.left(zone_input, copy_alpha)
move.above(zone_time, copy_alpha)
# ------------------- Inputs --------------------------------- #
zone_over.setInput(0, start_position)
zone_over.setInput(1, copy_alpha)
copy_alpha.setInput(0, zone_time)
copy_alpha.setInput(1, zone_input)
zone_time.setInput(0, start_position)
builder.setInput(0, zone_over)
copy_to_const.setInput(0, const)
copy_to_const.setInput(1, copy_alpha)
preview_stack.setInput(0, prev_preview)
preview_stack.setInput(1, copy_to_const)
switch.setInput(1, preview_stack)
# ------------------- Knobs and Expressions ------------------ #
zone_control = nuke.Link_Knob('zone_{}_control'.format(zone_num))
zone_control.setLink(zone_time.name() + '.time_offset')
zone_control.setLabel(prefix + ' offset')
zone_delete = nuke.PyScript_Knob('zone_{}_del'.format(zone_num))
zone_delete.setLabel('delete')
zone_delete.setValue('from vfx_utils.plutonium.gizmos import timezones\n'
'timezones.delete_zone(zone_num={})'
''.format(zone_num))
zone_color = nuke.Link_Knob('zone_{}_color'.format(zone_num))
zone_color.setLabel('preview color')
zone_color.clearFlag(nuke.STARTLINE)
zone_color.setLink(const.name() + '.color')
node.addKnob(zone_control)
node.addKnob(zone_delete)
node.addKnob(zone_color)