def clear_Constant_link():
nodes = nuke.selectedNodes()
for i in nodes:
deps = nuke.dependencies(i, nuke.EXPRESSIONS)
for knob_name in deps:
if knob_name.Class() == "Constant":
i.knob('disable').clearAnimated()
def inputHide(self):
self.edit(1)
for n in nuke.allNodes():
name = n.name()
if n.knob('hide_input'):
if n.Class() != 'Viewer':
x = n.knob('hide_input')
value = x.value()
if value == 0:
self.dicModif[name] = self.darkColor
else:
self.dicModif[name] = self.goodColor
n.setSelected(1)
dependenciesOfWrite = nuke.dependencies([n])
for d in dependenciesOfWrite:
self.dicModif[name] = self.goodColor
else:
self.dicModif[name] = self.darkColor
#Add Viewer Nodes
viewer = nuke.allNodes('Viewer')
for i in viewer:
name = i.name()
self.dicModif[name] = self.darkColor
#Store Data
self.edit(0)
def upstream(node, max_depth=-1, deps=set([])):
if max_depth != 0:
new_deps = set([n for n in nuke.dependencies(node, what=connection_filter) if n not in deps])
deps |= new_deps
for dep in new_deps:
upstream(dep, max_depth-1, deps)
return deps
def get_dependent_nodes(root):
"""
Returns a list of all of the root node's dependencies.
Uses `nuke.dependencies()`. This will work with cyclical dependencies.
"""
all_deps = set([root])
all_deps.update(nuke.dependencies(list(all_deps)))
seen = set()
while True:
diff = all_deps - seen
to_add = nuke.dependencies(list(diff))
all_deps.update(to_add)
seen.update(diff)
if len(diff) == 0:
break
return list(all_deps)
def _nodes_in_tree(self, outputs, blacklist_nodes):
tree = set()
for output in outputs:
deps = set()
if output["disable"].value():
continue
children = nuke.dependencies(output)
while len(children) != 0:
new_children = []
for child in children:
new_children += nuke.dependencies(child)
deps = deps.union([c.name() for c in children])
children = new_children
deps_valid = deps.difference(blacklist_nodes)
tree = tree.union(deps_valid)
return tree
def get_dependent_nodes(root):
"""
Returns a list of all of the root node's dependencies.
Uses `nuke.dependencies()`. This will work with cyclical dependencies.
"""
all_deps = set([root])
all_deps.update(nuke.dependencies(list(all_deps)))
seen = set()
while True:
diff = all_deps - seen
to_add = nuke.dependencies(list(diff))
all_deps.update(to_add)
seen.update(diff)
if len(diff) == 0:
break
return list(all_deps)
def _useAsInputProcess():
n = nuke.selectedNode()
[i['selected'].setValue(False) for i in nuke.allNodes()]
# FIXME: these two calls should have the arguments in the same order, or even better change the node bindings so they can go.
if nuke.dependencies([n], nuke.INPUTS | nuke.HIDDEN_INPUTS) or nuke.dependentNodes(nuke.INPUTS | nuke.HIDDEN_INPUTS, [n]):
m = nuke.createNode(n.Class())
else:
m = n
if m is not n: _copyKnobsFromScriptToScript(n, m)
viewer = nuke.activeViewer().node()
viewer['input_process'].setValue(True)
viewer['input_process_node'].setValue(m.name())
def get_upstream_nodes(nodes, flags=nuke.INPUTS | nuke.HIDDEN_INPUTS):
""" Return all nodes in the tree of the node. """
ret = set()
if isinstance(nodes, nuke.Node):
nodes = [nodes]
nodes = list(nodes)
while nodes:
deps = nuke.dependencies(nodes, flags)
nodes = [n for n in deps if n not in ret and n not in nodes]
ret.update(set(deps))
return ret
def selectConnectedNodes(startNodes):
"""sel all nodes in the tree of selected node"""
allDeps = set()
depsList = [startNodes]
evaluateAll = True
while depsList:
deps = nuke.dependencies(depsList)
depsList = [i for i in deps if i not in allDeps and not allDeps.add(i)]
for i in allDeps:
i['selected'].setValue(True)
return list(nuke.selectedNodes())
def connected(nodes, upstream=True, downstream=True):
# return all upstream and/or downstream nodes of node
# based on nuke.overrides.selectConnectedNodes()
all_deps = set()
deps_list = nodes
evaluate_all = True
while deps_list:
deps = []
if upstream:
deps += nuke.dependencies(deps_list, connection_filter)
if downstream:
deps += nuke.dependentNodes(connection_filter, deps_list, evaluate_all)
evaluate_all = False
deps_list = [d for d in deps if d not in all_deps and not all_deps.add(d)]
return all_deps
def _get_upstream(nodes, flags=nuke.INPUTS | nuke.HIDDEN_INPUTS):
ret = set()
if isinstance(nodes, nuke.Node):
nodes = [nodes]
nodes = tuple(nodes)
while nodes:
deps = nuke.dependencies(nodes, flags)
nodes = [
n for n in deps
if n not in ret and n not in nodes and n.Class() in (
'Merge2', 'Shuffle')
]
ret.update(set(deps))
return ret
def checkDependencies(node, type='Read'):
#print node.name()
depNodes = nuke.dependencies(node, nuke.INPUTS | nuke.HIDDEN_INPUTS | nuke.EXPRESSIONS)
#print depNodes
nodes = []
for depNode in depNodes:
if depNode.Class() == 'Read':
#print 'found '+depNode.name()
return depNode
else:
nodes.append(depNode)
#print nodes
if nodes:
for dep in nodes:
result = checkDependencies(dep)
return result
def copySpecial():
"""copy selection, paste and reconnect (just one node)"""
depNode = nuke.dependencies(nuke.selectedNode())
dependNode = nuke.dependentNodes(nuke.INPUTS or nuke.HIDDEN_INPUTS or nuke.EXPRESSIONS, [nuke.selectedNode()])
i = 0
if dependNode[0].Class() in ['Scene', 'MergeGeo']:
i = nuke.inputs(dependNode[0])+1
nuke.nodeCopy(nukescripts.cut_paste_file())
for node in nuke.allNodes():
node['selected'].setValue(0)
nuke.nodePaste(nukescripts.cut_paste_file())
newNode = nuke.selectedNode()
newNode.setInput(0, depNode[0])
dependNode[0].setInput(i+1, newNode)
def loop(_input_node, _input_node_name, _max):
#LOOPING UNTIL EXPONENTIAL LEVEL IS REACHED
exponential_multi(_input_node, _max)
#CREATING AND HOOKING UP IBK GIZMO
target = nuke.selectedNode()
dep_node = nuke.dependencies(nuke.toNode(_input_node_name))
topnode_node = nuke.toNode(dep_node[0].name())
screen_color = nuke.toNode(_input_node_name)['screen_type'].value()
ibk_gizmo = create_ibk_gizmo()
expression = "C-{}".format(screen_color)
ibk_gizmo['st'].setValue(expression)
ibk_gizmo.setInput(0, topnode_node)
ibk_gizmo.setInput(1, target)
ibk_gizmo.setInput(2, None)
#ibk_gizmo.setXpos(nuke.toNode(_input_node_name).xpos() - 250)
return
def stack_ibk(max):
#CONSTANTS
MAX = max
MULTIVALUE = 0
#VALIDATION
try:
MASTER_IBK = nuke.selectedNode().name()
M_IBK_NAME = str(MASTER_IBK)
except:
nuke.message("Please select an IBKColourV3, Dude")
if nuke.selectedNode().Class() != "IBKColourV3":
nuke.message("Please select an IBKColourV3, Dude")
return None
else:
#LOOPING UNTIL EXPONENTIAL LEVEL IS REACHED
exponential_multi(MASTER_IBK,MAX)
#CREATING AND HOOKING UP IBK GIZMO
target = nuke.selectedNode()
dep_node = nuke.dependencies(nuke.toNode(M_IBK_NAME))
topnode_node = nuke.toNode(dep_node[0].name())
ibk_gizmo = create_ibk_gizmo()
ibk_gizmo.setInput(0, topnode_node)
ibk_gizmo.setInput(1, target)
ibk_gizmo.setInput(2, None)
return
def precomp_selected():
nodes = nuke.selectedNodes()
if len(nodes) == 0:
g = nuke.createNode( "Precomp" )
return
options = PrecompOptions()
if not options.askUserForOptions():
return False
sel = nodes[0]
## select upstream nodes
if len( nodes ) == 1:
upstreamNodes = nuke.dependencies( nodes )
while len ( upstreamNodes ) != 0:
nodes += upstreamNodes
upstreamNodes = nuke.dependencies( upstreamNodes )
left = right = nodes[0].xpos()
top = bottom = nodes[0].ypos()
nodeSize = 100
titleHeight = 50
inputs = []
for n in nodes:
n["selected"].setValue ( True )
if n.xpos() < left:
left = n.xpos()
if n.xpos() > right:
right = n.xpos()
if n.ypos() < top:
top = n.ypos()
if n.ypos() > bottom:
bottom = n.ypos()
for i in range( 0, n.inputs() ):
if not n.input(i):
continue
if not n.input(i) in nodes:
inputs.append( n.input(i) )
## find all the dependent nodes
inputDeps = []
expressionDeps = []
for n in nodes:
for d in nuke.dependentNodes( nuke.INPUTS, [n]):
if d not in nodes:
if d.Class() != 'Viewer':
inputIndices = [i for i in range(d.inputs()) if d.input(i) == n]
inputDeps.append( (d, inputIndices) )
for d in nuke.dependencies( [n], nuke.EXPRESSIONS ):
if d not in nodes:
expressionDeps.append( d )
if len(inputDeps) > 1:
nuke.message( "You cannot precomp the selected nodes because there are multiple outputs." )
return
addLinkedExpressionNodes = False
if len(expressionDeps) > 0:
addLinkedExpressionNodes = nuke.ask( "Warning: The selected nodes have expressions to nodes outside the precomp. Do you want to copy these nodes to the precomp?" )
## make group and export
if len( nodes ) == 1 and nodes[0].Class() == "Group":
group = nodes[0]
else:
group = nuke.makeGroup( False )
with group:
outputInputs = []
output = group.output()
for i in range(0, output.inputs()):
outputInputs.append( output.input(i) )
## insert write node or use existing one
outInp = output.input(0)
if outInp is None or outInp.Class() != "Write":
w = nuke.createNode( "Write", inpanel = False)
w.setInput( 0, None )
else:
w = outInp
for i in range(0, len(outputInputs) ):
w.setInput( i, outputInputs[i] )
output.setInput(i, None )
output.setInput(0, w )
w.knob("file").setValue( options.renderPath )
type = os.path.splitext( options.renderPath)[1][1:].lower()
w.knob("file_type").setValue( type )
w.knob("channels").setValue( options.channels )
for n in nuke.allNodes():
n['selected'].setValue( False )
if addLinkedExpressionNodes:
for n in nuke.allNodes():
n['selected'].setValue( False )
for n in expressionDeps:
n['selected'].setValue( True )
nuke.nodeCopy ( '%clipboard%' )
with group:
nuke.nodePaste( '%clipboard%' )
writeOk = True
with group:
try:
nuke.tcl("export_as_precomp", options.scriptPath)
except:
nuke.message( "Could not write precomp script, permission denied, please specify a different \'script path\' and try again.")
writeOk = False
for n in nuke.selectedNodes():
n['selected'].setValue( False )
if group != nodes[0]:
group['selected'].setValue( False )
nuke.delete( group )
if not writeOk:
for n in nuke.selectedNodes():
n['selected'].setValue( False )
for n in nodes:
n['selected'].setValue( True )
return
## reload saved out script
g = nuke.createNode( "Precomp" )
g[ "file" ].setValue( options.scriptPath )
#nuke.tprint( "Selected Node: " + sel.name() )
for d in inputDeps:
node = d[0]
for inp in d[1]:
#nuke.tprint ( "Reconnecting dep " + node.name() + " input " + str(inp) )
node.setInput(inp, g)
## reconnect inputs, if any
for i in range(0, len(inputs)):
#nuke.tprint ( "Reconnecting input " + inputs[i].name() + " " + str(i) )
g.setInput(i, inputs[i] )
pad = 5
if options.addBackdrop:
b = nuke.createNode( "BackdropNode", inpanel = False )
width = int(math.fabs(right - left)) + (pad * 2) + nodeSize
height = int(math.fabs(bottom - top)) + ( pad * 2 ) + nodeSize + titleHeight
b['label'].setValue( os.path.basename( options.scriptPath ) )
b['note_font_size'].setValue( 18 )
b.setXYpos( left - pad * 2, top - ( pad * 2) - titleHeight )
b.knob( "bdwidth" ).setValue( width )
b.knob( "bdheight").setValue( height )
b.knob( "z_order" ).setValue( 0 )
b['selected'].setValue(False)
g.setXYpos( b.xpos() + width/2 - nodeSize/2, b.ypos() + height + pad * 2 )
elif options.delete:
for n in nodes:
nuke.delete( n )
if len(inputs) > 0:
nuke.message( "Warning: The precomp script requires inputs and may not render the same independent of its parent script." )
return group
def clear_the_linked_objects():
nodes = nuke.selectedNodes()
for i in nodes:
deps = nuke.dependencies(i, nuke.EXPRESSIONS)
if deps:
i.knob('disable').clearAnimated()
