def confirm(self):
if self.checkFakeEnter() == False:
self.answerList = [
self.in1.lineEdit.text(),
self.out1.lineEdit.text(),
self.in2.lineEdit.text(),
self.out2.lineEdit.text()
]
self.createList = []
for x in self.answerList:
if not x in nuke.layers() and not x in self.extras:
self.createList.append(x)
if not self.createList == []:
self.hide()
if nuke.ask(
'''<font left>The following layers don't exist. Do you want to create them?
<i>%s</i>''' % '''
'''.join(self.createList)):
for l in self.createList:
nuke.Layer(l, [
'%s.red' % l,
'%s.green' % l,
'%s.blue' % l,
'%s.alpha' % l
])
self.show()
if self.node == None or not self.modifyNodeCheckBox.isChecked():
with self.context:
if self.typeCheckbox.isChecked():
node = nuke.createNode('ShuffleCopy')
else:
node = nuke.createNode('Shuffle')
else:
node = self.node
node['in'].setValue(self.answerList[0])
node['out'].setValue(self.answerList[1])
node['in2'].setValue(self.answerList[2])
node['out2'].setValue(self.answerList[3])
self.close()
def _update_encyptomatte_setup_layers(gizmo):
setup_layers = gizmo.knob('setupLayers').value()
num_layers = gizmo.knob('cryptoLayers').value()
input_layers = gizmo.knob('inputCryptoLayers').value()
crypto_layer = _legal_nuke_layer_name(gizmo.knob('cryptoLayer').value())
if not setup_layers:
gizmo.knob('manifestKey').setValue("")
for ch_add, ch_remove in zip(GIZMO_ADD_CHANNEL_KNOBS,
GIZMO_REMOVE_CHANNEL_KNOBS):
gizmo.knob(ch_add).setValue("none")
gizmo.knob(ch_remove).setValue("none")
return
all_layers = nuke.layers()
num_ch = len(GIZMO_ADD_CHANNEL_KNOBS)
for i, ch_add, ch_remove in zip(list(range(num_ch)),
GIZMO_ADD_CHANNEL_KNOBS,
GIZMO_REMOVE_CHANNEL_KNOBS):
this_layer = "{0}{1:02d}".format(crypto_layer, i)
# Add
if i < num_layers:
if not this_layer in all_layers:
channels = [
"%s.%s" % (this_layer, c)
for c in ['red', 'green', 'blue', 'alpha']
]
nuke.Layer(this_layer, channels)
gizmo.knob(ch_add).setValue(this_layer)
gizmo.knob(ch_remove).setValue("none")
else:
gizmo.knob(ch_add).setValue("none")
if i <= input_layers:
gizmo.knob(ch_remove).setValue(this_layer)
else:
gizmo.knob(ch_remove).setValue("none")
def exrCompile(self, x, y):
s1 = nuke.nodes.ShuffleCopy()
self.sGroup.append(s1)
s1.autoplace()
if s1.canSetInput(0, self.node) and s1.canSetInput(1, self.node2):
s1.setInput(0, self.node)
s1.setInput(1, self.node2)
chan = s1["in2"].value()
s1["red"].setValue('red')
s1["green"].setValue('green')
s1["blue"].setValue('blue')
s1["alpha"].setValue('alpha')
self.name(self.node2)
nameTemp = ''
listTemp = []
#listTemp=str.split(self.currentlayerName,'_')
listTemp = self.currentlayerName
#for x in range(int(float(self.removeFront)),len(listTemp)-int(float(self.removeBack)),1):
#nameTemp= nameTemp+'_'+listTemp[x]
nameTemp = listTemp
nuke.tprint(nameTemp)
currentlayerNameRed = str(nameTemp) + ".red"
currentlayerNameGreen = str(nameTemp) + ".green"
currentlayerNameBlue = str(nameTemp) + ".blue"
currentlayerNameAlpha = str(nameTemp) + ".alpha"
nuke.Layer(nameTemp, [
currentlayerNameRed, currentlayerNameGreen,
currentlayerNameBlue, currentlayerNameAlpha
])
s1["out"].setValue(nameTemp)
self.node = s1
self.node.knob("selected").setValue(False)
self.node2.knob("selected").setValue(False)
else:
pass
def rePass():
node = nuke.selectedNode()
p = ShapePanel(node)
v = { 'ol': { 'shuffle':{}, 'copy':[], 'curr_channel_index':{}, 'remove':[] } }
order = ['red','green','blue','alpha']
if p.showModalDialog(): #show dialog
k=0
# loop through all rows
while k < len(p.layers):
j = str(k)
tmp_layer = p.var['mp_layer'+j].value()
tmp_layer_new = p.var['mp_layernew'+j].value()
tmp_remove = p.var['mp_remove'+j].value()
# add to copy list
if tmp_layer_new:
a_layer = tmp_layer_new.strip().split('.')
if tmp_layer not in v['ol']['curr_channel_index']:
v['ol']['curr_channel_index'][tmp_layer] = 0
curr_index = v['ol']['curr_channel_index'][tmp_layer]
if len(a_layer) > 1:
s_from = tmp_layer + '.' + p.layers[tmp_layer][curr_index]
s_to = tmp_layer_new
nuke.Layer(a_layer[0], [s_to])
v['ol']['copy'].append({'from': s_from, 'to': s_to})
v['ol']['curr_channel_index'][tmp_layer] += 1
else:
a_tmp_layers_new = []
a_tmp_channels = []
for channel in p.layers[tmp_layer]:
s_from = tmp_layer + '.' + channel
s_to = tmp_layer_new + '.' + channel
a_tmp_layers_new.append(s_to)
a_tmp_channels.append(channel)
v['ol']['copy'].append({'from': s_from, 'to': s_to})
v['ol']['curr_channel_index'][tmp_layer] += 1
if (False not in [ e in order for e in a_tmp_channels ]):
# sort channel order to ['red','green','blue','alpha']
a_tmp_layers_new.sort(key=lambda L: order.index(L.split('.')[1]))
# create new layer and its channels
nuke.Layer(tmp_layer_new, a_tmp_layers_new)
# add to remove list
if tmp_remove and tmp_layer not in v['ol']['remove']:
if tmp_layer != 'rgba':
v['ol']['remove'].append(tmp_layer)
k += 1
# copy layers
while len(v['ol']['copy']) > 0:
tmp_layers = []
s_range = 4 if len(v['ol']['copy']) > 4 else len(v['ol']['copy'])
for i in range(s_range):
tmp_layers.append(v['ol']['copy'][0])
v['ol']['copy'].pop(0)
node = copyNodes(node, tmp_layers, 'Copy Node')
# remove layers
k = 0
counter = 0
tmp_layers = []
while k < len(v['ol']['remove']):
counter += 1
tmp_layers.append(v['ol']['remove'][k])
k += 1
if counter == 4 or k >= len(v['ol']['remove']):
counter = 0
node = removeNodes(node, tmp_layers, 'Remove Layers')
tmp_layers = []
def grainBuild(nodes_merge):
'''
Build Grain nodes set up
'''
node_color, spacing, ch_grain = defaultValue()
nuke.Layer(ch_grain, ["%s.red", "%s.green", "%s.blue", "%s.alpha"])
console = []
grain_merge = []
for n in nodes_merge:
base_node, m_A, m_ASide, m_pos = n
spacing = (80, 74)
node_color = 1163603199 # Dark Green
node_connected = base_node.dependent(nuke.INPUTS | nuke.HIDDEN_INPUTS)
# Create Nodes
## Dot node
node_dot = nuke.nodes.Dot(inputs=[m_A], tile_color=node_color)
node_dot_diff = (node_dot.screenHeight() -
base_node.screenHeight()) / 2
if m_ASide < 0:
node_dot.setXpos(m_pos[0] + spacing[0] * m_ASide)
else:
node_dot.setXpos(m_pos[0] + base_node.screenWidth() +
spacing[0] * m_ASide)
node_dot.setYpos(m_pos[1] - node_dot_diff)
base_node.setInput(1, node_dot)
## Shuffle node
node_shuffle = nuke.nodes.Shuffle(inputs=[node_dot],
tile_color=node_color,
label='[value out]')
node_shuffle.hideControlPanel()
node_shuffle_diff = (node_dot.screenWidth() -
node_shuffle.screenWidth()) / 2
node_shuffle.setXpos(node_dot.xpos() + node_shuffle_diff)
node_shuffle.setYpos(node_dot.ypos() + spacing[1])
node_shuffle['in'].setValue('alpha')
node_shuffle['out'].setValue(ch_grain)
## Merge node
node_grainMerge = nuke.nodes.Merge2(inputs=[base_node, node_shuffle],
tile_color=node_color,
operation='screen',
Achannels='alpha',
Bchannels='grain',
output=ch_grain)
node_grainMerge.hideControlPanel()
node_grainMerge.setXpos(base_node.xpos())
node_grainMerge.setYpos(node_shuffle.ypos())
nodeInsert(base_node, node_grainMerge)
console.append(base_node.name())
grain_merge.append(node_grainMerge)
print "Grain Channel set up for\n%s" % console
# if len(console_fail)>0:
# print "Grain Channel fail to set up for\n%s" % console_fail
# else:
# pass
return grain_merge
def create_rgba_layer(lpass):
'''
Creates an rgba layer
'''
lpass = nuke.Layer('{}'.format(lpass.upper()), ['{}.red'.format(lpass.upper()), '{}.green'.format(lpass.upper()), '{}.blue'.format(lpass.upper()), '{}.alpha'.format(lpass.upper())])
def create_lp_layer(lpass):
'''
Creates an alpha layer based on a Light Pass List item
'''
lpass = nuke.Layer('LGHT_{}'.format(lpass.upper()), ['LGHT_{}.alpha'.format(lpass.upper())])
def create():
"""
For a selected group of read nodes from the same rendering process (i.e.
same naming pattern, using "." as a separator for Render Elements), create
a multichannel EXR.
"""
def is_number(value):
"""
Check if a value is a number by trying to cast it as an integer
:param value: Input value to check
:type: any
"""
try:
int(value)
return True
except ValueError:
return False
exr_data = {
'channels': 'all',
'file_type': 'exr',
'datatype': '16 bit half',
'compression': 'Zip (1 scanline)',
'reading': True
}
copy_data = {
'from0': 'red',
'to0': '{0}.red',
'from1': 'green',
'to1': '{0}.green',
'from2': 'blue',
'to2': '{0}.blue',
'from3': 'none',
'to3': 'none'
}
import nuke
if not nuke.selectedNodes():
return
passes = []
rgba = None
for node in nuke.selectedNodes():
if node.Class() != 'Read':
continue
fp_base = os.path.basename(node['file'].value())
split_vals = fp_base.split('.')
if len(split_vals) > 2 and not is_number(split_vals[-2]):
passes.append(node)
else:
rgba = node
last_copy = None
for pass_read in sorted(passes,
key=lambda x: os.path.basename(x['file'].value()).
split('.')[-2].lower()):
pass_name = os.path.basename(pass_read['file'].value()).split('.')[-2]
nuke.Layer(pass_name, [
'{0}.red'.format(pass_name), '{0}.green'.format(pass_name),
'{0}.blue'.format(pass_name)
])
if not last_copy:
copy = nuke.nodes.Copy(name='copy_{0}'.format(pass_name),
inputs=[rgba, pass_read])
last_copy = copy
else:
copy = nuke.nodes.Copy(name='copy_{0}'.format(pass_name),
inputs=[last_copy, pass_read])
last_copy = copy
for attr, value in copy_data.iteritems():
copy[attr].setValue(value.format(pass_name))
write = nuke.nodes.Write(name='multichannel_write', inputs=[last_copy])
write['file'].setValue(rgba['file'].value().replace(
'.exr', '_multichannel.exr'))
for attr, value in exr_data.iteritems():
write[attr].setValue(value)
def autoShuffleReads(nodes):
import re
import nuke
nuke.Undo().name('organize and split')
nuke.Undo().begin()
readList = []
yPosAvg = 0
xPosAvg = 0
count = 0
try:
nodes # does a exist in the current namespace
except NameError:
nodes = nuke.selectedNodes()
for curNode in nodes:
if curNode.Class() == 'Read':
readList.append({'file': nuke.filename(curNode), 'node': curNode})
yPosAvg = yPosAvg + curNode['ypos'].value()
xPosAvg = xPosAvg + curNode['xpos'].value()
count += 1
readListSorted = sorted(readList, key=lambda k: k['file'])
xPosAvg = int(xPosAvg / count)
yPosAvg = int(yPosAvg / count)
count = 0
for readNode in readListSorted:
readNode['node']['xpos'].setValue(xPosAvg - 110 * count)
readNode['node']['ypos'].setValue(yPosAvg)
readNode['node']['selected'].setValue(True)
count += 1
for n in nuke.selectedNodes():
n.autoplace()
prevNode = nuke.nodes.Dot()
originalDot = prevNode
for curNode in nuke.selectedNodes():
if curNode.Class() == 'Read':
count += 1
filename = nuke.filename(curNode)
passName = filename.split('.')[1]
if re.match(r'^[A-Za-z0-9_]+$', passName):
newLayer = nuke.Layer(passName, [
passName + '.red', passName + '.green', passName + '.blue'
])
shuffle = nuke.nodes.Shuffle(label=passName, inputs=[curNode])
shuffle['out'].setValue(passName)
dotNode = nuke.nodes.Dot(inputs=[shuffle])
copyNode = nuke.nodes.Copy(inputs=[prevNode, dotNode],
channels=passName,
selected=True)
prevNode = copyNode
else:
masterNode = curNode
if count % 2 == 0:
curNode['ypos'].setValue(curNode['ypos'].value() + 110)
originalDot.setInput(0, masterNode)
backdrop = nukescripts.autoBackdrop()
backdrop.knob('tile_color').setValue(2139062271)
nuke.Undo().end()
def SequenceLoader(self):
'''main function construct the image group'''
dir_renderVersion = joinPath(self.lgtPath.text(),
self.renderVersion_mu.currentText())
if dir_renderVersion == None:
nuke.message("Import Canceled")
else:
name_renderVersion = os.path.basename(
dir_renderVersion.rstrip('/')) # TIO_orbit_1k_v001
ver_renderVersion = int(name_renderVersion.split('_v')[1])
RGBA = 'beauty'
# Building Image Group
ls_aov = getAOVs(dir_renderVersion)
for p in ls_aov[ls_aov.keys()[0]]:
nuke.Layer(p, [
'%s.red' % p,
'%s.green' % p,
'%s.blue' % p,
'%s.alpha' % p
])
# nodeLabel = '%s\nv%s' % (name_renderVersion.split('_v')[0], name_renderVersion.split('_v')[1])
nodeLabel = "nuke.thisNode().name()+'\\n'+nuke.thisNode()['tx_version'].value()+'\\n\\n'+nuke.thisNode()['tx_layer'].value()+'\\n'+'v'+nuke.thisNode()['int_thisVersion'].value()"
for l in ls_aov.keys():
imgGroup = nuke.nodes.Group(autolabel=nodeLabel,
postage_stamp=1)
imgGroup.setName('kpRead1')
t_tab = nuke.Tab_Knob('tb_user', 'kpRead')
k_pipeline = nuke.Text_Knob('kupipeline', 'kpRead',
'kpRead') # Ku Pipeline Identifier
k_renderVersion = nuke.Text_Knob(
'tx_version', '<b>render: </b>',
name_renderVersion.split('_v')[0])
mod = os.path.basename(__file__).split('.py')[0]
k_verUp = nuke.PyScript_Knob(
'btn_verUp', '<b>▲</b>',
'%s.versionUp(nuke.thisNode())' % mod)
k_verDown = nuke.PyScript_Knob(
'btn_verDown', '<b>▼</b>',
'%s.versionDown(nuke.thisNode())' % mod)
k_verLatest = nuke.PyScript_Knob(
'btn_verLatest', '<b>★</b>',
'%s.versionLatest(nuke.thisNode())' % mod)
k_thisVersion = nuke.Text_Knob('int_thisVersion',
'<b>version: </b>')
k_thisVersion.setValue('%03d' % ver_renderVersion)
k_renderLayer = nuke.Text_Knob('tx_layer', '<b>layer: </b>', l)
k_div = nuke.Text_Knob('', "<b>Switch Version:</b>")
k_path = nuke.Text_Knob('tx_dir', '<b>path: </b>',
dir_renderVersion)
# k_aov = nuke.Text_Knob('tx_aov', '<b>aovs: </b>', '\n'.join(ls_aov[l]))
# k_thisVersion.setEnabled(False)
k_thisVersion.setFlag(nuke.STARTLINE)
k_path.setVisible(False)
k_verUp.setFlag(nuke.STARTLINE)
k_verUp.setTooltip("Version Up")
k_verDown.clearFlag(nuke.STARTLINE)
k_verDown.setTooltip("Version Down")
k_verLatest.clearFlag(nuke.STARTLINE)
k_verLatest.setTooltip("Latest Version")
k_pipeline.setVisible(False)
for k in [
t_tab, k_pipeline, k_path, k_renderVersion,
k_thisVersion, k_renderLayer, k_div, k_verUp,
k_verDown, k_verLatest
]:
imgGroup.addKnob(k)
with imgGroup:
aov_beauty = None
aov_rest = []
for p in ls_aov[l]:
path = joinPath(dir_renderVersion, l, p)
createRead(path)
aov_beauty = nuke.toNode(RGBA)
aov_rest = [
n for n in nuke.allNodes('Read') if n != aov_beauty
]
shuffling(aov_beauty, aov_rest)
self.close()
def breakdown(sel, createWrites, renderTo):
'''
create breakdown with all the shuffle nodes etc.
'''
createWrites = createWrites
renderTo = renderTo
sel = sel
leftOffset = findMostLeftNode() - 300
i = 0
createdNodes = []
for n in sel:
#step01
# step01 has some special features so all necessary steps here in a row
if i == 0:
posX = sel[i].xpos()
posY = sel[i].ypos()
#shuffle
shuffle = nuke.nodes.Shuffle()
shuffle.setInput(0, sel[0])
shuffle.setXpos(leftOffset)
shuffle.setYpos(posY)
createdNodes.append(shuffle)
#creating channels
chTemp = "step%s" % (i + 1)
r_temp = "step%s" % (i + 1) + ".red"
g_temp = "step%s" % (i + 1) + ".green"
b_temp = "step%s" % (i + 1) + ".blue"
newLayer = nuke.Layer(chTemp, [r_temp, g_temp, b_temp])
#setting up the shuffle nodes inputs and outputs
shuffle.knob("out").setValue(("step%s" % (i + 1)))
if createWrites:
w = nuke.nodes.Write()
w.setInput(0, shuffle)
w.setXpos(leftOffset - 120)
w.setYpos(posY)
w.knob("file").setValue(renderTo + "step%s.jpg" % (i + 1))
w.knob("channels").setValue("step%s" % (i + 1))
#remove
remove = nuke.nodes.Remove()
remove.knob("operation").setValue("keep")
remove.knob("channels").setValue("step1")
remove.setInput(0, createdNodes[i])
remove.setXpos(leftOffset)
remove.setYpos(posY + 70)
createdNodes.append(remove)
i += 1
#step02+
#all next steps
else:
posX = sel[i].xpos()
posY = sel[i].ypos()
shuffle = nuke.nodes.ShuffleCopy()
shuffle.setInput(1, sel[i])
shuffle.setInput(0, createdNodes[i])
shuffle.setXpos(leftOffset)
shuffle.setYpos(posY)
createdNodes.append(shuffle)
#creating channels
chTemp = "step%s" % (i + 1)
r_temp = "step%s" % (i + 1) + ".red"
g_temp = "step%s" % (i + 1) + ".green"
b_temp = "step%s" % (i + 1) + ".blue"
newLayer = nuke.Layer(chTemp, [r_temp, g_temp, b_temp])
#setting up the shuffle nodes inputs and outputs
shuffle.knob("out2").setValue(("step%s" % (i + 1)))
shuffle['red'].setValue('red2')
shuffle['green'].setValue('green2')
shuffle['blue'].setValue('blue2')
shuffle['alpha'].setValue('alpha2')
shuffle['black'].setValue('red')
shuffle['white'].setValue('green')
shuffle['red2'].setValue('blue')
shuffle['green2'].setValue('alpha')
if createWrites:
w = nuke.nodes.Write()
w.setInput(0, shuffle)
w.setXpos(leftOffset - 120)
w.setYpos(posY)
w.knob("file").setValue(renderTo + "step%s.jpg" % (i + 1))
w.knob("channels").setValue("step%s" % (i + 1))
i += 1
#final
layersheet = nuke.nodes.LayerContactSheet()
layersheet.setInput(0, createdNodes[(len(createdNodes) - 1)])
layersheet.setXpos(leftOffset)
layersheet.setYpos(posY + 50)
createdNodes.append(layersheet)
if createWrites:
w = nuke.nodes.Write()
w.setInput(0, layersheet)
w.setXpos(leftOffset)
w.setYpos(posY + 150)
w.knob("file").setValue(renderTo + "layersheet.jpg")
w.knob("channels").setValue("rgb")
def relightComp(self):
self.fromRGBA = ['from0', 'from1', 'from2', 'from3']
self.toRGBA = ['to0', 'to1', 'to2', 'to3']
self.RGBA = ['red', 'green', 'blue', 'alpha']
self.aovNodes = {}
# build an aov dictionary
for readNode, gradeNodes in self.readNodes:
if 'beauty' in readNode.name():
self.aovNodes['beauty'] = readNode
for aov in self.aovs:
if readNode.name() == aov:
self.aovNodes[aov] = readNode
# build the layers and channels
for aovNode in self.aovNodes:
channels = len(self.aovNodes[aovNode].channels())
for x in range(0, channels):
nuke.Layer(aovNode, [aovNode + "." + self.RGBA[x]])
ypos = self.lastNodes[-1][1].ypos()
self.linkAov(self.lastNodes[-1][1], '__Pworld')
self.linkAov(self.copyNodes[-1], '__Nworld')
self.linkAov(self.copyNodes[-1], 'z')
pointCloudNode = nuke.nodes.PositionToPoints2(
inputs=[self.copyNodes[-1]])
pointCloudNode.knob('P_channel').setValue('__Pworld')
pointCloudNode.knob('N_channel').setValue('__Nworld')
pointCloudNode.setXpos(self.copyNodes[-1].xpos() + 140)
pointCloudNode.setYpos(self.copyNodes[-1].ypos())
defaultCameras = [
'Producer Perspective', 'Producer Top', 'Producer Bottom',
'Producer Front', 'Producer Back', 'Producer Right',
'Producer Left'
]
cameraPath = "%s/data/export/cameras.fbx" % self.currentPath
cameraNode = nuke.nodes.Camera2(file=cameraPath, read_from_file=True)
cameraName = [
camera for camera in cameraNode.knob('fbx_node_name').values()
if camera not in defaultCameras
][0]
cameraNode.knob('fbx_node_name').setValue(cameraName)
cameraNode.setXpos(pointCloudNode.xpos() + 140)
cameraNode.setYpos(pointCloudNode.ypos())
lightNode = nuke.nodes.Light()
lightNode.setXpos(cameraNode.xpos() + 140)
lightNode.setYpos(cameraNode.ypos())
sceneNode = nuke.nodes.Scene(
inputs=[cameraNode, pointCloudNode, lightNode])
sceneNode.setXpos(cameraNode.xpos())
sceneNode.setYpos(cameraNode.ypos() + 140)
phongNode = nuke.nodes.Phong()
phongNode.setXpos(sceneNode.xpos())
phongNode.setYpos(sceneNode.ypos() + 140)
relightNode = nuke.nodes.ReLight()
relightNode.connectInput(0, sceneNode)
relightNode.connectInput(1, cameraNode)
relightNode.connectInput(2, self.copyNodes[-1])
relightNode.connectInput(0, phongNode)
relightNode.knob('position').value()
relightNode.knob('point')
relightNode.knob('normal').setValue('__Nworld')
relightNode.knob('position').setValue('__Pworld')
relightNode.setXpos(pointCloudNode.xpos())
relightNode.setYpos(sceneNode.ypos() + 140)
keyerNode = nuke.nodes.Keyer(inputs=[relightNode])
keyerNode.setYpos(relightNode.ypos() + 140)
keyerNode.knob('operation').setValue('luminance key')
colorCorrectNode = nuke.nodes.ColorCorrect(
inputs=[self.copyNodes[-1], keyerNode])
colorCorrectNode.setXpos(self.copyNodes[-1].xpos())
colorCorrectNode.setYpos(keyerNode.ypos() + 140)
colorCorrectNode.knob('gain').setValue(5)
def buildAOVDivide(aovkey, filepath, first, last, lastShuffle, xpos_read, dot):
xpos_shuffle = lastShuffle['xpos'].value()
aovPass = str(aovkey)
aovFpn = str(filepath)
aovPassGreen = str(aovPass + ".green")
aovPassRed = str(aovPass + ".red")
aovPassBlue = str(aovPass + ".blue")
aovPassAlpha = str(aovPass + ".alpha")
aovFirstFrame = first
aovLastFrame = last
aovReadNodeName = str(aovPass[3:] + '_Read')
# create AOV read node
readNode = nuke.nodes.Read(name=aovReadNodeName,
file=aovFpn,
xpos=xpos_read,
ypos=lastShuffle.ypos() + 100,
postage_stamp=False,
first=aovFirstFrame,
last=aovLastFrame,
origfirst=aovFirstFrame,
origlast=aovLastFrame)
# create AOV layer in nuke
nuke.Layer(aovPass, [aovPassRed, aovPassGreen, aovPassBlue, aovPassAlpha])
# create shuffle and shuffle in aov pass, except for light, gi, zDepth
shuffleNode = nuke.nodes.ShuffleCopy(name=aovPass,
out=aovPass,
red='red',
green='green',
blue='blue',
selected=True,
xpos=xpos_shuffle,
ypos=lastShuffle.ypos() + 100)
diffuse = nuke.toNode('diffuse_Read')
lightDiv = nuke.nodes.Merge(name="lightDiv",
operation='divide',
selected=True,
xpos=readNode['xpos'].value() + 150,
ypos=shuffleNode['ypos'].value())
lightDiv.setInput(0, diffuse)
lightDiv.setInput(1, readNode)
copyAlpha_light = nuke.nodes.Copy(from0='rgba.alpha',
to0='rgba.alpha',
selected=True,
xpos=readNode['xpos'].value() + 300,
ypos=shuffleNode['ypos'].value() - 10)
copyAlpha_light.setInput(0, lightDiv)
copyAlpha_light.setInput(1, dot)
premultLight = nuke.nodes.Premult(selected=True,
xpos=readNode['xpos'].value() + 450,
ypos=shuffleNode['ypos'].value())
premultLight.setInput(0, copyAlpha_light)
shuffleNode.setInput(1, premultLight)
shuffleNode.setInput(0, lastShuffle)
aovPass2 = aovPass.replace('raw', '').replace('t',
'ting').replace('L', 'l')
aovPass2Green = str(aovPass2 + ".green")
aovPass2Red = str(aovPass2 + ".red")
aovPass2Blue = str(aovPass2 + ".blue")
aovPass2Alpha = str(aovPass2 + ".alpha")
nuke.Layer(aovPass2,
[aovPass2Red, aovPass2Green, aovPass2Blue, aovPass2Alpha])
shuffleNode2 = nuke.nodes.ShuffleCopy(name=aovPass2,
out=aovPass2,
red='red',
green='green',
blue='blue',
selected=True,
xpos=xpos_shuffle,
ypos=shuffleNode.ypos() + 50)
shuffleNode2.setInput(1, readNode)
shuffleNode2.setInput(0, shuffleNode)
lastShuffle = shuffleNode2
return lastShuffle
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 makeCrowd(group):
''' Atists hits make crowd button and we make a crowd '''
with group:
# get a list of points we want to creat cards on
points = []
if group['useSelection'].value() and len(
group['vertexStore'].value()) > 0:
allPoints = retrieveSavedVertices(group)
points = everyNthPointOfPoints(allPoints, group)
else:
allPoints = verticesFromInput(group)
points = everyNthPointOfPoints(allPoints, group)
cardWarningLevel = 500
if len(points) > cardWarningLevel:
if not nuke.ask(
'Are you sure you want to create %s cards? This may take a long time...'
% (len(points))):
return
#delete the old scene
removePreviousScene(group)
with group:
# pity the fool who doesn't use default node graph preferences
prefs = nuke.toNode('preferences')
gridWidth = prefs['GridWidth'].value()
gridHeight = prefs['GridHeight'].value()
lookDot = nuke.toNode('lookDot')
img1 = nuke.toNode('img1')
lastXY = [img1['xpos'].value() - gridWidth, img1['ypos'].value()]
lookDot.setYpos(int(lastXY[1] + gridHeight * 76))
switchInputs = imageInputList(group)
# make channels, channel strings are used later in node creation
crowdRandomColorStr = 'crowdRandomColor'
nuke.Layer(crowdRandomColorStr, ['red', 'green', 'blue'])
crowdIDStr = 'crowdID'
nuke.Layer(crowdIDStr, ['id', 'sprite'])
'''
crowdCharacterMaskStr = 'crowdCharacterMask'
nuke.Layer( crowdCharacterMaskStr , ['alpha'] )
'''
crowdMirrorMaskStr = 'crowdMirrorMask'
nuke.Layer(crowdMirrorMaskStr, ['alpha'])
transformGeoList = []
cardList = []
whichInput = 0
for i in range(len(points)):
point = points[i]
# make a switch to plug in the image inputs
inputSwitch = nuke.createNode('Switch', inpanel=False)
inputSwitch.setName('imgSwitch')
inputSwitch['label'].setValue(
'which: [value which]\nauto-generated')
inputSwitch.setXpos(int(lastXY[0] + gridWidth))
inputSwitch.setYpos(int(lastXY[1] + gridHeight * 20))
for j in range(len(switchInputs)):
inputSwitch.setInput(j, nuke.toNode(switchInputs[j]))
# Input switch to chose what images appear on what cards
# TODO: Make a a fucntion for Duplication radius
inputFromDuplicationRadius = whichInput
ifStepExpr = '[string match [value inputOrder] "Step"]?%s' % (
whichInput)
ifRandomExpr = '[string match [value inputOrder] "Random"]?'\
'rint(random(%s+%s,1)*%s)' % ('parent.inputSeed', i, len(switchInputs)-1)
inputSwitch['which'].setExpression(
'%s:%s:%s' %
(ifStepExpr, ifRandomExpr, str(inputFromDuplicationRadius)))
whichInput = whichInput + 1
if whichInput >= len(switchInputs):
whichInput = 0
'''
# make the id channel
idShuffle = nuke.createNode('Shuffle', inpanel = False)
idShuffle.setName('aov_idShuffle')
idShuffle['in'].setValue('none')
idShuffle['out'].setValue(crowdIDStr)
idShuffle['label'].setValue('([value out])\nauto-generated')
idShuffle['disable'].setExpression('!parent.displayAOVs')
idShuffle.setXpos(int(lastXY[0]+gridWidth))
idShuffle.setYpos(int(lastXY[1]+gridHeight*30))
# make the id mult
idKnob = nuke.Int_Knob('ID','ID')
idKnob.setValue(i)
idMult = nuke.createNode('Multiply' ,inpanel = False)
idMult.addKnob( idKnob )
idMult.setName('aov_idMult')
idMult['channels'].setValue(crowdIDStr)
idMult['value'].setSingleValue(True)
idMult['value'].setExpression('%s' % ('this.ID+1'))
#idMult['maskChannelInput'].setValue('rgba.alpha')
idMult['label'].setValue('auto-generated')
idMult['disable'].setExpression('!parent.aov_id')
idMult.setXpos(int(lastXY[0]+gridWidth))
idMult.setYpos(int(lastXY[1]+gridHeight*32))
'''
# make the id expression
idExpr = nuke.createNode('Expression', inpanel=False)
idExpr.setName('aov_idExpr')
idExpr['temp_name0'].setValue('id')
idExpr['temp_expr0'].setValue(str(i))
idExpr['temp_name1'].setValue('inp')
idExpr['temp_expr1'].setValue('[value %s.which]' %
inputSwitch.name())
idExpr['channel0'].setValue(crowdIDStr)
idExpr['channel0'].enableChannel(0, True)
idExpr['channel0'].enableChannel(1, False)
idExpr['channel0'].enableChannel(2, False)
idExpr['expr0'].setValue('id*rgba.alpha')
idExpr['channel1'].setValue(crowdIDStr)
idExpr['channel1'].enableChannel(0, False)
idExpr['channel1'].enableChannel(1, True)
idExpr['channel1'].enableChannel(2, False)
idExpr['expr1'].setValue('inp*rgba.alpha')
idExpr['channel2'].setValue('none')
idExpr['channel3'].setValue('none')
idExpr['label'].setValue('auto-generated')
idExpr['disable'].setExpression('!parent.displayAOVs')
idExpr.setXpos(int(lastXY[0] + gridWidth))
idExpr.setYpos(int(lastXY[1] + gridHeight * 30))
# make the grade layer which shuffles in the alpha
randomShuffle = nuke.createNode('Shuffle', inpanel=False)
randomShuffle.setName('aov_randomShuffle')
randomShuffle['in'].setValue('alpha')
randomShuffle['out'].setValue(crowdRandomColorStr)
randomShuffle['label'].setValue('([value out])\nauto-generated')
randomShuffle['disable'].setExpression('!parent.displayAOVs')
randomShuffle.setXpos(int(lastXY[0] + gridWidth))
randomShuffle.setYpos(int(lastXY[1] + gridHeight * 40))
# make the grade layer mult
randomColorMult = nuke.createNode('Multiply', inpanel=False)
randomColorMult.setName('aov_randomMult')
randomColorMult['channels'].setValue(crowdRandomColorStr)
randomColorMult['value'].setSingleValue(False)
randomColorMult['value'].setExpression(
'random(%s+%s,1)' % ('parent.aov_randomSeed', str(i + 0)), 0)
randomColorMult['value'].setExpression(
'random(%s+%s,1)' % ('parent.aov_randomSeed', str(i + 1)), 1)
randomColorMult['value'].setExpression(
'random(%s+%s,1)' % ('parent.aov_randomSeed', str(i + 2)), 2)
randomColorMult['unpremult'].setValue('rgba.alpha')
randomColorMult['label'].setValue('auto-generated')
randomColorMult['disable'].setExpression('!parent.displayAOVs')
randomColorMult.setXpos(int(lastXY[0] + gridWidth))
randomColorMult.setYpos(int(lastXY[1] + gridHeight * 42))
# make the character mask which can be used for lighting
'''
charMaskShuffle = nuke.createNode('Shuffle', inpanel = False)
charMaskShuffle['in'].setValue('alpha')
charMaskShuffle['out'].setValue(crowdCharacterMaskStr)
charMaskShuffle['label'].setValue('([value out])\nauto-generated')
charMaskShuffle.setXpos(int(lastXY[0]+gridWidth))
charMaskShuffle.setYpos(int(lastXY[1]+gridHeight*40))
'''
# make the mirror mask which can be used for flipping AOVs
mirrorMaskShuffle = nuke.createNode('Shuffle', inpanel=False)
mirrorMaskShuffle.setName('aov_mirrorShuffle')
mirrorMaskShuffle['in'].setValue('alpha')
mirrorMaskShuffle['out'].setValue(crowdMirrorMaskStr)
mirrorMaskShuffle['label'].setValue(
'([value out])\nauto-generated')
mirrorMaskShuffle['disable'].setExpression('!parent.displayAOVs')
mirrorMaskShuffle.setXpos(int(lastXY[0] + gridWidth))
mirrorMaskShuffle.setYpos(int(lastXY[1] + gridHeight * 50))
# make the mirror for flopping random cards
idKnob = nuke.Int_Knob('mirrorID', 'mirrorID')
idKnob.setValue(i)
flop = nuke.createNode('Mirror2', inpanel=False)
flop.addKnob(idKnob)
flop['flop'].setValue(True)
flop['disable'].setExpression(
'parent.mirror?random(this.mirrorID+parent.mirrorSeed,1)>0.5?1:0:1'
)
flop['label'].setValue('auto-generated')
flop.setXpos(int(lastXY[0] + gridWidth))
flop.setYpos(int(lastXY[1] + gridHeight * 52))
# make the mirror mask mult which can be used for flipping AOVs
mirrorMaskMult = nuke.createNode('Multiply', inpanel=False)
mirrorMaskMult.setName('aov_mirrorMult')
mirrorMaskMult['channels'].setValue(crowdMirrorMaskStr)
mirrorMaskMult['value'].setValue(0)
mirrorMaskMult['disable'].setExpression(
'parent.displayAOVs?!input0.disable:1')
mirrorMaskMult['label'].setValue('(auto-generated')
mirrorMaskMult.setXpos(int(lastXY[0] + gridWidth))
mirrorMaskMult.setYpos(int(lastXY[1] + gridHeight * 54))
# make the time offset
idKnob = nuke.Int_Knob('offsetID', 'offsetID')
idKnob.setValue(i)
timeOffset = nuke.createNode('TimeOffset', inpanel=False)
timeOffset.addKnob(nuke.Tab_Knob('User'))
timeOffset.addKnob(idKnob)
timeOffsetRandomizeExpr = 'rint(random(parent.timeOffsetSeed+%s,1)*parent.timeOffset*2-parent.timeOffset)' % (
'this.offsetID')
timeOffsetStepExpr = 'parent.timeOffset?parent.timeOffsetStep*this.offsetID%abs(parent.timeOffset):0'
timeOffset['time_offset'].setExpression(
'parent.timeOffsetRandomize?%s:%s' %
(timeOffsetRandomizeExpr, timeOffsetStepExpr))
timeOffset['label'].setValue(
'[value time_offset] frames\nauto-generated')
timeOffset.setXpos(int(lastXY[0] + gridWidth))
timeOffset.setYpos(int(lastXY[1] + gridHeight * 60))
# make the card
idKnob = nuke.Double_Knob('cardID', 'cardID')
idKnob.setRange(0, 100)
idOffsetKnob = nuke.Double_Knob('cardIDOffset', 'cardIDOffset')
idOffsetKnob.setRange(0, 100)
card = nuke.createNode('Card', inpanel=False)
card.addKnob(nuke.Tab_Knob('User'))
card.addKnob(idKnob)
card.addKnob(idOffsetKnob)
card['cardIDOffset'].setExpression('parent.displayPercentOffset+this.cardID<=100?'\
'parent.displayPercentOffset+this.cardID:this.cardID-100+parent.displayPercentOffset')
card['disable'].setExpression(
'$gui?parent.displayPercentage<100?parent.displayPercentage>this.cardIDOffset?0:1:0:0'
)
card.setXpos(int(lastXY[0] + gridWidth))
card.setYpos(int(lastXY[1] + gridHeight * 70))
cardList.append(card)
# make the transform geo
transformGeo = nuke.createNode('TransformGeo', inpanel=False)
transformGeo.setXpos(int(lastXY[0] + gridWidth))
transformGeo.setYpos(int(lookDot['ypos'].value()))
transformGeo.setInput(0, card)
transformGeo.setInput(2, lookDot)
transformGeo['translate'].setExpression('random(%s+%s,1)*parent.positionOffset(0)' \
'-parent.positionOffset(0)/2+%s' % ('parent.positionOffsetXZseed',str(i+0),point[0]),0)
transformGeo['translate'].setExpression('random(%s+%s,1)*parent.positionOffset(1)' \
'-parent.positionOffset(1)/2+%s' % ('parent.positionOffsetYseed',str(i+1),point[1]),1)
transformGeo['translate'].setExpression('random(%s+%s,1)*parent.positionOffset(2)' \
' -parent.positionOffset(2)/2+%s' % ('parent.positionOffsetXZseed',str(i+2),point[2]),2)
transformGeo['pivot'].setExpression('parent.pivotOffset', 1)
transformGeo['uniform_scale'].setExpression('parent.scale+random(%s+%s,1)*' \
'(scaleVariation*parent.scale)-(scaleVariation*parent.scale)/2' % ('parent.scaleSeed', str(i)))
transformGeo['look_axis'].setExpression('parent.look_axis')
transformGeo['look_rotate_x'].setExpression('parent.look_rotate_x')
transformGeo['look_rotate_y'].setExpression('parent.look_rotate_y')
transformGeo['look_rotate_z'].setExpression('parent.look_rotate_z')
transformGeo['look_strength'].setExpression('parent.look_strength')
transformGeo['look_use_quaternions'].setExpression(
'parent.look_use_quaternions')
transformGeoList.append(transformGeo)
lastXY = [lastXY[0] + gridWidth, lastXY[1]]
# pipe up all the transform geos into the output scene
scene = nuke.toNode('scene')
for i in range(len(transformGeoList)):
scene.setInput(i, transformGeoList[i])
scene.setYpos(int(lookDot['ypos'].value() + gridHeight * 10))
nuke.toNode('Output').setYpos(
int(lookDot['ypos'].value() + gridHeight * 20))
# set up the cards so that they can be culled by a percentage in the gui
random.seed(int(group['vertexStep'].value()))
random.shuffle(cardList)
for i in range(0, len(cardList)):
cardID = float(i) * 100 / len(cardList)
cardList[i]['cardID'].setValue(cardID)
# change the group label and let artist know how many cards were created
group['label'].setValue('%s Cards' % (len(transformGeoList)))
def MultiChannelCombine():
images = nuke.selectedNodes()
passes = []
passesRename = []
lastPass = ""
pipe2 = ""
i = 0
noread = 0
inputReads = []
if len(images) > 1:
#check if all selected nodes are read nodes
imageIn = ""
for img in images:
if img.Class() != "Read":
noread += 1
if noread == 0:
for img in images:
#get file path
readPath = img["file"].value()
#split by "/" to get the image name
readPathArr = readPath.split("/")
#image name is last item of arr
imageName = readPathArr[len(readPathArr) - 1]
#cut ending (.jpg, .png, .exr, etc...)
imageRawArr = imageName.split(".")
imageRawArr.pop()
imageRaw = "".join(imageRawArr)
#cut padding %05d etc...
if "%" in imageRaw:
temp = imageRaw.split("%")
imageRaw = temp[0]
#cut "_" , "." and "-" if that is the last character
if imageRaw != "":
if imageRaw[(len(imageRaw) - 1)] == "_" or imageRaw[(
len(imageRaw) -
1)] == "." or imageRaw[(len(imageRaw) - 1)] == "-":
imageRaw = imageRaw[:-1]
inputReads.append(imageRaw)
p = createPanel(inputReads)
renamed = setLayerList(inputReads)
if p.show():
channelNames = []
temp = 0
for cn in inputReads:
channelNames.append(p.value(inputReads[temp]))
temp += 1
#check if all channels have a name
isEmpty = 0
allUnder30Char = 0
for c in channelNames:
if c == "":
isEmpty += 1
if len(c) > 30:
allUnder30Char += 1
if isEmpty > 0:
nuke.message("you haven't named all channels.")
MultiChannelCombine()
else:
if allUnder30Char == 0:
for img in images:
#autoplace selected nodes
nuke.autoplace(img)
#get all the filenames to use them as pass name
imagePath = img.knob("file").value()
imageSplit = imagePath.split("/")
lastVal = imageSplit.pop()
#cutouts
lastVal = lastVal.split(".")
passName = lastVal[0]
#frame padding %
lastVal = passName.split("%")
passName = lastVal[0]
passes.append(passName)
#creating channels
r_temp = channelNames[i] + ".red"
g_temp = channelNames[i] + ".green"
b_temp = channelNames[i] + ".blue"
a_temp = channelNames[i] + ".alpha"
newLayer = nuke.Layer(
channelNames[i],
[r_temp, g_temp, b_temp, a_temp])
if i == 0:
shuffle1 = nuke.nodes.Shuffle()
shuffle1.setName("shuffle_%s" %
channelNames[i])
shuffle1.setInput(0, images[0])
#setting up the shuffle nodes inputs and outputs
shuffle1.knob("out").setValue(channelNames[i])
if i > 0:
if i == 1:
#initialize pipe2 for first round
pipe2 = shuffle1
#creating shuffle
shuffle = nuke.nodes.ShuffleCopy()
shuffle.setName("shuffle_%s" % channelNames[i])
shuffle.setInput(0, pipe2)
shuffle.setInput(1, images[i])
#setting up the shuffle nodes inputs and outputs
shuffle.knob("out2").setValue(channelNames[i])
shuffle['red'].setValue('red2')
shuffle['green'].setValue('green2')
shuffle['blue'].setValue('blue2')
shuffle['alpha'].setValue('alpha2')
shuffle['black'].setValue('red')
shuffle['white'].setValue('green')
shuffle['red2'].setValue('blue')
shuffle['green2'].setValue('alpha')
#this was a reported bug;
#it's right that red2 is actually called black, green2 is actually called white, blue2 is actually called red2 and alpha2 is actually called green2
#pretty strange but it is like that
#look here:
#http://forums.thefoundry.co.uk/phpBB2/viewtopic.php?t=5954&sid=5eba0be48c454bf34bc7bdf301983a21
#safe last shuffle for next round to pipe it in in shuffleknob pipe2
pipe2 = shuffle
i += 1
#create metadata-tag when comment was set
lastShuffle = nuke.toNode(
"shuffle_" + channelNames[len(channelNames) - 1])
commentVal = ""
commentVal = p.value("comment (optional): ")
if commentVal != "":
md = nuke.nodes.ModifyMetaData()
md.knob("metadata").fromScript(
"{set comment %s}" %
commentVal.replace(" ", "_"))
md.setName("comment")
md.setInput(0, lastShuffle)
#create write node
write = nuke.nodes.Write()
write.knob("file_type").setValue("exr")
write.knob("compression").setValue(
"Zip (16 scanlines)")
write.knob("channels").setValue("all")
if commentVal != "":
write.setInput(0, md)
write.knob("metadata").setValue("all metadata")
else:
write.setInput(0, lastShuffle)
else:
nuke.message(
"Wait, the channel names are too long. Pleae make sure, that each channel name is under 30 characters long. Otherwise the exr does not work properly."
)
else:
nuke.message("Please make sure to select READ nodes only")
else:
nuke.message("Please select at least 2 Read Nodes")
def createGroup(node):
# Create group
group = nuke.createNode('Group', inpanel=False)
group.setName('TPD_UpdateDIP')
# Set group input and connect parent node's dependents
group.setInput(0, node)
if node.dependent() > 0:
for dependent in node.dependent():
dependent.setInput(0, group)
# Set group position
group.knob('xpos').setValue(node.xpos())
group.knob('ypos').setValue(node.ypos() + 85)
# Create text knob with title and version info; create divider knob
text = nuke.Text_Knob(
'title', ' ',
'<b><i>{} {}</i></b> by {}<br><br>'.format(title, version, author))
div = nuke.Text_Knob('div', ' ')
group.addKnob(text)
group.addKnob(div)
satCtrl = nuke.Double_Knob('satCtrl', 'saturation')
satCtrl.setRange(0, 4)
satCtrl.setValue(2.5)
group.addKnob(satCtrl)
# Inside the group
with group:
# Create input
input = nuke.nodes.Input()
input.knob('name').setValue('Input')
# Create Colorspace node converting all channels from sRGB to Linear
colorspace = nuke.nodes.Colorspace(xpos=input.xpos(),
ypos=input.ypos() + 25,
colorspace_in='sRGB',
inputs=[input],
channels='all')
# Create DIP layer if it doesn't exist
if 'DIP' not in nuke.layers():
nuke.Layer('DIP',
['DIP.red', 'DIP.green', 'DIP.blue', 'DIP.alpha'])
# Create Shuffle; shuffle rgba into DIP
shuffle = nuke.nodes.Shuffle(xpos=input.xpos(),
ypos=input.ypos() + 75,
inputs=[colorspace],
out='DIP')
# Creates the main dot for the incremantal horizontal pipe
dot = nuke.nodes.Dot(xpos=input.xpos() + 34,
ypos=input.ypos() + 150,
inputs=[shuffle])
# Create empty global variables
disjoint, disjoint1 = None, None
stencil, stencil1 = None, None
grade, grade1 = None, None
over, over1 = None, None
for layer in m_layers:
dot1 = nuke.nodes.Dot(xpos=dot.xpos() + 200,
ypos=dot.ypos(),
inputs=[dot])
dot = dot1
shuffle = nuke.nodes.Shuffle(xpos=dot.xpos() - 34,
ypos=dot.ypos() + 50,
inputs=[dot])
shuffle.knob('in').setValue(layer)
shuffle.knob('label').setValue('[value in]')
if m_layers.index(layer) < 1:
dot2 = nuke.nodes.Dot(xpos=shuffle.xpos() + 34,
ypos=shuffle.ypos() + 100,
inputs=[shuffle])
shuffleA = nuke.nodes.Shuffle(xpos=shuffle.xpos(),
ypos=shuffle.ypos() + 250,
inputs=[dot2],
red='alpha',
green='alpha',
blue='alpha',
label='[value in]')
grade1 = nuke.nodes.Grade(xpos=shuffle.xpos(),
ypos=shuffle.ypos() + 300,
inputs=[shuffleA])
r, g, b = (float(random.randint(30, 100))) / 100, (float(
random.randint(30, 100))) / 100, (float(
random.randint(30, 100))) / 100
grade1.knob('white').setValue([r, g, b, 1])
grade1.knob('multiply').setValue(
(float(random.randint(30, 100))) / 100)
grade1.knob('unpremult').setValue('rgba.alpha')
elif m_layers.index(layer) == 1:
disjoint = nuke.nodes.Merge2(xpos=shuffle.xpos() + 100,
ypos=shuffle.ypos() + 100,
inputs=[dot2, shuffle],
operation='disjoint-over')
stencil = nuke.nodes.Merge2(xpos=shuffle.xpos(),
ypos=shuffle.ypos() + 200,
inputs=[shuffle, dot2],
operation='stencil')
shuffleA = nuke.nodes.Shuffle(xpos=shuffle.xpos(),
ypos=shuffle.ypos() + 250,
inputs=[stencil],
red='alpha',
green='alpha',
blue='alpha',
label='[value in]')
grade = nuke.nodes.Grade(xpos=shuffle.xpos(),
ypos=shuffle.ypos() + 300,
inputs=[shuffleA])
over = nuke.nodes.Merge2(xpos=shuffle.xpos(),
ypos=shuffle.ypos() + 400,
inputs=[grade1, grade],
operation='disjoint-over')
r, g, b = (float(random.randint(30, 100))) / 100, (float(
random.randint(30, 100))) / 100, (float(
random.randint(30, 100))) / 100
grade.knob('white').setValue([r, g, b, 1])
grade1.knob('multiply').setValue(
(float(random.randint(30, 100))) / 100)
grade.knob('unpremult').setValue('rgba.alpha')
elif m_layers.index(layer) > 1:
disjoint = nuke.nodes.Merge2(xpos=shuffle.xpos() + 100,
ypos=shuffle.ypos() + 100,
inputs=[disjoint1, shuffle],
operation='disjoint-over')
stencil = nuke.nodes.Merge2(xpos=shuffle.xpos(),
ypos=shuffle.ypos() + 200,
inputs=[shuffle, disjoint1],
operation='stencil')
shuffleA = nuke.nodes.Shuffle(xpos=shuffle.xpos(),
ypos=shuffle.ypos() + 250,
inputs=[stencil],
red='alpha',
green='alpha',
blue='alpha',
label='[value in]')
grade = nuke.nodes.Grade(xpos=shuffle.xpos(),
ypos=shuffle.ypos() + 300,
inputs=[shuffleA])
over = nuke.nodes.Merge2(xpos=shuffle.xpos(),
ypos=shuffle.ypos() + 400,
inputs=[over1, grade],
operation='disjoint-over')
r, g, b = (float(random.randint(30, 100))) / 100, (float(
random.randint(30, 100))) / 100, (float(
random.randint(30, 100))) / 100
grade.knob('white').setValue([r, g, b, 1])
grade1.knob('multiply').setValue(
(float(random.randint(30, 100))) / 100)
grade.knob('unpremult').setValue('rgba.alpha')
shuffle1 = shuffle
disjoint1 = disjoint
stencil1 = stencil
over1 = over
if m_layers.index(layer) == len(m_layers) - 1:
if 'tpd_colormatte' not in nuke.layers():
nuke.Layer('tpd_colormatte', [
'tpd_colormatte.red', 'tpd_colormatte.green',
'tpd_colormatte.blue', 'tpd_colormatte.alpha'
])
saturation = nuke.nodes.Saturation(xpos=shuffle.xpos(),
ypos=shuffle.ypos() + 450,
inputs=[over])
clamp = nuke.nodes.Clamp(xpos=shuffle.xpos(),
ypos=shuffle.ypos() + 500,
inputs=[saturation],
channels='rgba')
shuffle1 = nuke.nodes.Shuffle(xpos=shuffle.xpos(),
ypos=shuffle.ypos() + 550,
inputs=[clamp],
in2='DIP',
out='tpd_colormatte',
out2='rgba',
black='red2',
white='green2',
red2='blue2',
green2='alpha2')
remove = nuke.nodes.Remove(xpos=shuffle.xpos(),
ypos=shuffle.ypos() + 600,
inputs=[shuffle1],
operation='keep',
channels='rgba',
channels2='tpd_colormatte')
output = nuke.nodes.Output(xpos=shuffle.xpos(),
ypos=shuffle.ypos() + 700,
inputs=[remove])
saturation.knob('saturation').setExpression('satCtrl')
