def __init__(self):
nukescripts.PythonPanel.__init__(self, 'Watermark Utility',
'dushyant.info.WatermarkUtility')
# CREATE PANEL KNOBS
self.nodesChoice = nuke.Enumeration_Knob('nodes', 'Source Nodes',
['selected', 'all'])
self.optChoice = nuke.Enumeration_Knob('opt_knob', 'Watermark type',
['text', 'image'])
self.STRING_Knob = nuke.String_Knob('text', 'text')
self.FILE_Knob = nuke.File_Knob('file', 'watermark file')
self.Divider_Knob = nuke.Text_Knob("divName", "", "")
self.Divider_Knob2 = nuke.Text_Knob("divName2", "", "")
self.FILE_Knob2 = nuke.File_Knob('out_file', 'Output path')
self.FILE_Knob2.setTooltip(
'If this field is left blank, output path will be filled with source Read node\'s path with a directory named watermark on the same level, else this path will be used as the ROOT path for all outputs.'
)
self.run = nuke.PyScript_Knob('run', 'Run')
# ADD PANEL KNOBS
self.addKnob(self.nodesChoice)
self.addKnob(self.optChoice)
self.addKnob(self.STRING_Knob)
self.addKnob(self.FILE_Knob)
self.addKnob(self.Divider_Knob)
self.addKnob(self.FILE_Knob2)
self.addKnob(self.Divider_Knob2)
self.addKnob(self.run)
self.FILE_Knob.setEnabled(False)
def _addPostKnobs(self):
super(FlipbookDialog, self)._addPostKnobs()
# Misc knobs
self._cleanup = nuke.Boolean_Knob("cleanup",
"Delete existing temporary files")
self._cleanup.setFlag(nuke.STARTLINE)
self._state.setKnob(self._cleanup, True)
self.addKnob(self._cleanup)
# LUT knobs
self._luts = nuke.Enumeration_Knob(
"lut", "LUT", nuke.ViewerProcess.registeredNames())
if self._takeNodeSettings:
self._state.setKnob(
self._luts,
self._lutFromViewer(self._viewerForSettings.value()))
else:
self._state.setKnob(self._luts, self._lutFromViewer())
self.addKnob(self._luts)
self._burnInLUT = nuke.Boolean_Knob("burnin", "Burn in the LUT")
self._state.setKnob(self._burnInLUT, False)
self.addKnob(self._burnInLUT)
# Audio knobs
audioList = []
audioList.append("None")
for node in nuke.allNodes("AudioRead"):
audioList.append(node.name())
self._audioSource = nuke.Enumeration_Knob("audio", "Audio", audioList)
self.addKnob(self._audioSource)
def __init__(self):
super(WatermarkControlPanel, self).__init__('Watermark Control')
self.setMinimumSize(600, 260)
self.sourceKnob = nuke.File_Knob('file', 'Open:')
self.formatKnob = nuke.Format_Knob('format', 'Format:')
self.outputKnob = nuke.File_Knob('file', 'Save:')
self.addKnob(self.sourceKnob)
self.addKnob(self.formatKnob)
self.addKnob(self.outputKnob)
self.formatKnob.setValue('HD_720')
self.addSourceKnob = nuke.PyScript_Knob('add', 'Add')
self.addKnob(self.addSourceKnob)
self.watermarkType = nuke.Enumeration_Knob('type', 'Type:',
['Text', 'Image'])
self.watermarkText = nuke.String_Knob('text', 'Text:')
self.watermarkImage = nuke.File_Knob('image', 'Image:')
self.watermarkNum = nuke.Enumeration_Knob(
'num', 'Number:', ['1 ', '2 ', '3 ', '4 ', '6 ', '9 '])
self.watermarkCreate = nuke.PyScript_Knob('create', 'Create')
self.watermarkRotate = nuke.Double_Knob('rotate', 'Rotate:')
self.watermarkScale = nuke.Double_Knob('scale', 'Scale:')
self.watermarkOpacity = nuke.Double_Knob('opacity', 'Opacity:')
self.watermarkRotate.setRange(-180, 180)
self.watermarkOpacity.setDefaultValue([1, 1])
self.watermarkScale.setRange(0.3, 1.5)
self.watermarkScale.setDefaultValue([1, 1])
self.addKnob(self.watermarkType)
self.addKnob(self.watermarkText)
self.addKnob(self.watermarkImage)
self.addKnob(self.watermarkNum)
self.addKnob(self.watermarkCreate)
self.addKnob(self.watermarkRotate)
self.addKnob(self.watermarkScale)
self.addKnob(self.watermarkOpacity)
self.controller = WatermarkController(self)
def createVersionKnobs():
'''
Add as callback to add user knobs in Read nodes.
In menu.py or init.py:
nuke.addOnUserCreate( assetManager.createVersionKnobs, nodeClass='Read' )
'''
# CREATE USER KNOBS
node = nuke.thisNode()
tabKnob = nuke.Tab_Knob('DB', 'DB')
typeKnob = nuke.Enumeration_Knob('versionType', 'type',
['plates', 'cg', 'roto'])
updateKnob = nuke.PyScript_Knob('update', 'update')
updateKnob.setValue('assetManager.updateVersionKnob()')
versionKnob = nuke.Enumeration_Knob(
'_version', 'version', []
) # DO NOT USE "VERSION" AS THE KNOB NAME AS THE READ NODE ALREADY HAS A "VERSION" KNOB
loadKnob = nuke.PyScript_Knob('load', 'load')
# ASSIGN PYTHON SCRIPT AS ONE LARGE STRING
loadScript = '''#THIS ASSUMES NO WHITE SPACES IN FILE PATH
node = nuke.thisNode()
path, range = node['_version'].value().split()
first, last = range.split('-')
node['file'].setValue( path )
node['first'].setValue( int(first) )
node['last'].setValue( int(last) )'''
loadKnob.setValue(loadScript)
# ADD NEW KNOBS TO NODE
for k in (tabKnob, typeKnob, updateKnob, versionKnob, loadKnob):
node.addKnob(k)
# UPDATE THE VERSION KNOB SO IT SHOWS WHAT'S ON DISK / IN THE DATABASE
updateVersionKnob()
def _addPreKnobs(self):
self._flipbookEnum = nuke.Enumeration_Knob(
"flipbook", "Flipbook", flipbooking.gFlipbookFactory.getNames())
self._state.setKnob(self._flipbookEnum, "FrameCycler")
self.addKnob(self._flipbookEnum)
self._viewerForSettings = nuke.Enumeration_Knob(
"viewer_settings", "Take settings from",
["-"] + self._viewers.keys())
if not self._takeNodeSettings:
self._viewerForSettings.setValue("-")
self.addKnob(self._viewerForSettings)
self._defaultValues = nuke.PyScript_Knob("default", "Defaults")
self.addKnob(self._defaultValues)
# Region of Interest knobs
self._useRoi = nuke.Boolean_Knob("use_roi", "Enable ROI")
self._useRoi.setFlag(nuke.STARTLINE)
self._state.setKnob(self._useRoi, False)
self.addKnob(self._useRoi)
self._roi = nuke.BBox_Knob("roi", "Region of Interest")
self._state.setKnob(self._roi, (0, 0, 0, 0))
self.addKnob(self._roi)
self._roi.setVisible(self._useRoi.value())
# Channel knobs
self._channels = nuke.Channel_Knob("channels_knob", "Channels")
if self._node.Class() == "Write":
self._channels.setValue(self._node.knob("channels").value())
else:
self._state.setKnob(self._channels, "rgba")
self._channels.setFlag(nuke.STARTLINE | nuke.NO_CHECKMARKS)
self.addKnob(self._channels)
def __init__(self):
nukescripts.PythonPanel.__init__(self,"b_procedural_backdrop")
#CREATE KNOBS
self.note_size = nuke.Int_Knob("Note Size:")
self.note_size.clearFlag(nuke.STARTLINE)
self.frame_display = nuke.String_Knob("Label:")
self.frame_display.clearFlag(nuke.STARTLINE)
self.align = nuke.Enumeration_Knob("Align", "Align", ["left","center","right"])
self.color = nuke.Enumeration_Knob("Color", "Color", ["green","pink","dark","yellow","grey","random"])
self.color.clearFlag(nuke.STARTLINE)
self.axis = nuke.Enumeration_Knob("Axis", "Axis", ["horizontal","vertical"])
self.multi = nuke.Text_Knob("Multi")
self.axis.clearFlag(nuke.STARTLINE)
self.amount = nuke.Int_Knob("Amount:")
self.note_size.clearFlag(nuke.STARTLINE)
self.spacing = nuke.Int_Knob("Spacing:")
self.spacing.clearFlag(nuke.STARTLINE)
self.author = nuke.Text_Knob("by Boris Martinez")
#SET DEFAULTS
self.set_note_size_default_value()
self.spacing_default_value()
#ADD KNOBS
for i in (self.note_size , self.frame_display,self.align,self.color,self.multi,self.amount,self.axis,self.spacing,self.author):
self.addKnob(i)
def __init__(self):
nukescripts.PythonPanel.__init__(self, "GQ_Tools")
## KNOBS ##
# Node Disable #
self.classInput = nuke.String_Knob("classInput", "Type")
self.classSelect = nuke.PyScript_Knob('classSelect', 'Select Type')
self.enableAll = nuke.PyScript_Knob("enableAll", "Enable All")
self.enableAll.setFlag(nuke.STARTLINE)
self.disableHeavy = nuke.PyScript_Knob("disableHeavy", "Disable Heavy")
self.disableDivider = nuke.Text_Knob("")
# Read Properties #
self.readBefore = nuke.Enumeration_Knob(
'readBefore', "Before", ['hold', "loop", "bounce", "black"])
self.readAfter = nuke.Enumeration_Knob(
'readAfter', "Before", ['hold', "loop", "bounce", "black"])
self.readAfter.clearFlag(nuke.STARTLINE)
self.setBeforeAfter = nuke.PyScript_Knob("setBeforeAfter",
"Set Before + After")
self.readStart = nuke.Int_Knob('readStart', "Start", 100)
self.readEnd = nuke.Int_Knob('readEnd', "End", 200)
self.readEnd.clearFlag(nuke.STARTLINE)
self.setStartEnd = nuke.PyScript_Knob("setStartEnd", "Set Start + End")
self.startAt = nuke.Int_Knob('startAt', "Start At")
self.setStartAt = nuke.PyScript_Knob("setStartAt", "Set Start At")
self.readDivider = nuke.Text_Knob("")
## LAYOUT ##
# Node Disable #
self.addKnob(self.classInput)
self.addKnob(self.classSelect)
self.addKnob(self.enableAll)
self.addKnob(self.disableHeavy)
self.addKnob(self.disableDivider)
# Read Properties #
self.addKnob(self.readBefore)
self.addKnob(self.readAfter)
self.addKnob(self.setBeforeAfter)
self.addKnob(self.readStart)
self.addKnob(self.readEnd)
self.addKnob(self.setStartEnd)
self.addKnob(self.startAt)
self.addKnob(self.setStartAt)
self.readStart.setValue(int(nuke.Root()['first_frame'].getValue()))
self.readEnd.setValue(int(nuke.Root()['last_frame'].getValue()))
def __init__(self):
nukescripts.PythonPanel.__init__(self, 'ZGrade')
layer_list = ["depth", "depth_extra", "rgba"]
self.layers = nuke.Enumeration_Knob("layer", "Layers", layer_list)
self.addKnob(self.layers)
self.channels_ = ['red', 'green', 'blue', 'alpha']
self.channel_list = nuke.Enumeration_Knob("channel", "",
self.channels_)
self.channel_list.clearFlag(nuke.STARTLINE)
self.channel_list.setVisible(False)
self.addKnob(self.channel_list)
self._viewers = {}
for n in nuke.allNodes("Viewer", nuke.Root()):
self._viewers[n.name()] = n
self._specialRanges = ["input", "global", "custom"]
self._rangeEnum = nuke.Enumeration_Knob(
"frame_range", "Frame range",
self._specialRanges + self._viewers.keys())
self.addKnob(self._rangeEnum)
self._frameRange = nuke.String_Knob('frame_range_sting', "",
str(nuke.root().frameRange()))
self._frameRange.clearFlag(nuke.STARTLINE)
if self._rangeEnum.value() == "custom":
self._frameRange.setValue(str(nuke.root().frameRange()))
else:
self._setFrameRangeFromSource(self._rangeEnum.value())
self.addKnob(self._frameRange)
self.depth_clamp = nuke.String_Knob('number,"inf"or"nan"',
'Depth clamp', '1000000')
self.addKnob(self.depth_clamp)
self.warning = nuke.Text_Knob(
'waring', '<span style="color:red">Not Numbers</span>')
self.warning.clearFlag(nuke.STARTLINE)
self.warning.setVisible(False)
self.addKnob(self.warning)
self.channels_name = ''
self.channel_names()
self.channel_num = 1
self.frameranges = ''
self.firstframe = ''
self.lastframe = ''
self.frame_ranges()
self.depth_clamp_value = self.depth_clamp.value()
self.warning_bool = True
self.mark = False
def __init__(self):
nukescripts.PythonPanel.__init__(self, 'Corner Pin To Matrix')
# ANALYZE NUKE SCRIPT TO GATHER VALUES
camera_nodes = []
nodes_with_matrix = []
for node in nuke.allNodes():
if 'Camera' in node.Class():
camera_nodes.append(node.name())
elif node.Class() in ['Transform', 'CornerPin2D', 'Tracker4', 'Card2', 'Card3D']:
nodes_with_matrix.append(node.name())
camera_nodes.sort()
nodes_with_matrix.sort()
try:
node = nuke.selectedNode()
except ValueError:
node = None
# CREATE KNOBS
self.first = nuke.Int_Knob('first', 'First Frame')
self.first.setValue(int(nuke.root()['first_frame'].value()))
self.last = nuke.Int_Knob('last', 'Last Frame')
self.last.setValue(int(nuke.root()['last_frame'].value()))
self.last.clearFlag(nuke.STARTLINE)
self.node = nuke.Enumeration_Knob('original_node', 'Node to Convert', nodes_with_matrix)
if node and node.name() in nodes_with_matrix:
self.node.setValue(node.name())
self.camera = nuke.Enumeration_Knob('camera_node', 'Camera', camera_nodes)
# In cases where no node was selected in the first place, the current node is the first entry in the list
node = nuke.toNode(self.node.value())
if not node or node.Class() not in ['Card2', 'Card3D']:
self.camera.setVisible(False)
options = ['Roto',
'RotoPaint',
'CornerPin',
'CornerPin (Matrix only)',
'Transform (No Perspective)',
'Tracker',
'SplineWarp']
self.destination = nuke.Enumeration_Knob('target', 'Convert to', options)
self.force_ref = nuke.Boolean_Knob('force_reference', '')
self.force_ref.setTooltip("Forces the resulting node to leave the reference frame untouched")
self.force_ref.setFlag(nuke.STARTLINE)
self.reference = nuke.Int_Knob('reference', 'Reference Frame')
self.reference.clearFlag(nuke.STARTLINE)
self.reference.setEnabled(False)
self.reference.setValue(nuke.frame())
self.invert = nuke.Boolean_Knob('invert', 'Invert Matrix')
# ADD KNOBS
for k in (self.first, self.last, self.node, self.camera, self.destination, self.force_ref, self.reference,
self.invert):
self.addKnob(k)
def showModalDialog(self, parser):
"""Called to display the dialogue to the user."""
self.parser = parser
self.cdlcorrectionid = nuke.Enumeration_Knob(
"cdlcorrectionid", "ID",
sorted(self.parser.cdlcorrectionvalues.keys()))
self.addKnob(self.cdlcorrectionid)
self.dividerone = nuke.Text_Knob("dividerone", "")
self.addKnob(self.dividerone)
self.cdlcorrectiondesc = nuke.Multiline_Eval_String_Knob(
"cdlcorrectiondesc", "Description", "")
self.addKnob(self.cdlcorrectiondesc)
self.cdlcorrectiondesc.setFlag(nuke.DISABLED)
self.dividertwo = nuke.Text_Knob("dividertwo", "")
self.addKnob(self.dividertwo)
self.extrefsearchpath = nuke.Enumeration_Knob("extrefsearchpath", "Ref Search", \
["Same Name, Same Dir", "Any Name, Same Dir", "Specified"])
self.addKnob(self.extrefsearchpath)
self.extrefpath = nuke.File_Knob("extrefpath", "Ref Path")
self.addKnob(self.extrefpath)
self.dividerthree = nuke.Text_Knob("dividerthree", "")
self.addKnob(self.dividerthree)
self.cdloffset = nuke.Color_Knob("cdloffset", "Offset")
self.addKnob(self.cdloffset)
self.cdloffset.setFlag(nuke.DISABLED)
self.cdlslope = nuke.Color_Knob("cdlslope", "Slope")
self.addKnob(self.cdlslope)
self.cdlslope.setFlag(nuke.DISABLED)
self.cdlpower = nuke.Color_Knob("cdlpower", "Power")
self.addKnob(self.cdlpower)
self.cdlpower.setFlag(nuke.DISABLED)
self.cdlsaturation = nuke.Double_Knob("cdlsaturation", "Saturation")
self.addKnob(self.cdlsaturation)
self.cdlsaturation.setFlag(nuke.DISABLED)
self.dividerfour = nuke.Text_Knob("dividerfour", "")
self.addKnob(self.dividerfour)
self.updateDesc()
return nukescripts.PythonPanel.showModalDialog(
self), self.cdlcorrectionid.value()
def __init__(self, historyFile='~/.nuke/srhistory.xml', maxSteps=10):
'''
Search and Replace panel
args:
historyFile - file to manage recent search&replace actions
maxSteps - amount of steps to keep in history file
'''
nukescripts.PythonPanel.__init__(self, 'Search and Replace',
'com.ohufx.SearchReplace')
# VARS
self.historyFile = os.path.expandvars(os.path.expanduser(historyFile))
self.maxSteps = maxSteps
self.delimiter = ' |>>| '
# CREATE KNOBS
self.nodesChoice = nuke.Enumeration_Knob('nodes', 'Source Nodes',
['all', 'selected'])
self.nodesChoice.setTooltip(
'Chose to perform action on all nodes with file knobs or only selected ones'
)
self.history = nuke.Enumeration_Knob('history', 'Recent Searches',
self.loadHistory())
self.history.setTooltip(
'Use the history to quicky access previous search&replace actions.\n By default the history file is stored as "~/.nuke/srhistory.xml" but this can be changed via the "historyFile" argument when creating the panel object. It is also possible to change the size of the history via the "maxSteps" argument to the panel object. Default is 10'
)
self.case = nuke.Boolean_Knob('case', 'case sensitive')
self.case.setFlag(nuke.STARTLINE)
self.case.setValue(True)
self.case.setTooltip(
'Set whether or not the search should be case sensitive')
self.searchStr = nuke.String_Knob('searchStr', 'Search for:')
self.searchStr.setTooltip('The text to search for')
self.update = nuke.PyScript_Knob('update', 'Update')
self.update.setTooltip(
'update the search result and preview. This is automaticaly performed and usually should only be required when the node selection has canged'
)
self.replaceStr = nuke.String_Knob('replaceStr', 'Replace with:')
self.replaceStr.setTooltip('Text to replace the found text with')
self.replace = nuke.PyScript_Knob('replace', 'Replace')
self.replace.setTooltip(
'Perform replace action. The preview will update afterwards and the action is added to the history'
)
self.info = nuke.Multiline_Eval_String_Knob('info', 'Found')
self.info.setEnabled(False)
self.info.setTooltip(
'See the search results and a preview of the replace action before it is performed'
)
# ADD KNOBS
for k in (self.nodesChoice, self.history, self.case, self.searchStr,
self.update, self.replaceStr, self.replace, self.info):
self.addKnob(k)
self.matches = None
def __init__(self):
"""
Adding knobs to UI panel.
"""
nukescripts.PythonPanel.__init__(self, "Select Roto & Bezier")
roto_list = []
for each in nuke.allNodes("Roto"):
roto_list.append(each["name"].value())
roto_list.sort()
self.roto = nuke.Enumeration_Knob("roto_list", "Select Roto Node", roto_list)
self.bezier = nuke.Enumeration_Knob("bezier_list", "Select Bezier Shape", [])
for add in (self.roto, self.bezier):
self.addKnob(add)
def __init__( self ):
panels.PythonPanel.__init__( self, "Precomp Nodes", "uk.co.thefoundry.PrecompOptionsDialog" )
self.scriptPath = nuke.File_Knob( "script", "Precomp script path " )
self.renderPath = nuke.File_Knob( "render", "Precomp render path " )
self.channels = nuke.Channel_Knob( "channels", "Channels " )
self.origNodes = nuke.Enumeration_Knob( "orig", "Original nodes ", ["add backdrop", "delete", "no change" ] )
self.addKnob ( self.scriptPath )
self.addKnob ( self.renderPath )
self.addKnob ( self.channels )
self.addKnob ( self.origNodes )
self.channels.setValue('all')
defaultDir = nuke.Root()['name'].value()
if defaultDir and defaultDir != "":
defaultDir = os.path.dirname( defaultDir )
if not defaultDir.endswith("/"):
defaultDir += "/"
else:
defaultDir = ""
basename = findNextName("Precomp")
self.scriptPath.setValue( defaultDir + basename + "_v01.nk" )
self.renderPath.setValue( defaultDir + basename + ".####.exr" )
self.setMinimumSize( 420, 50 )
def createKnobsFromParameter(knobHolder, parameter, knobName="parm"):
if knobName:
knobLabel = IECore.CamelCase.toSpaced(parameter.name)
if parameter.presetsOnly:
knob = nuke.Enumeration_Knob(knobName, knobLabel, [])
knob.setValues(parameter.presetNames())
knob.setValue(parameter.getCurrentPresetName())
knobHolder.addKnob(knob)
else:
for (paramClass, knobCreator, toKnobConverter,
fromKnobConverter) in __parameterKnobConverters:
if isinstance(parameter, paramClass):
knob = knobCreator(knobHolder, parameter, knobName, knobLabel)
if knob:
knobHolder.addKnob(knob)
toKnobConverter(knobHolder, parameter, knobName)
break
else:
knob = nuke.Text_Knob(knobName, "Not implemented!")
knobHolder.addKnob(knob)
def onCreateReadNode():
"""
Triggered when a read node is created.
"""
node = nuke.thisNode()
# in case the umedia knob is already there we don't do anything
# this happens when a read node is duplicated (ctrl+c & ctrl+v)
if 'umedia' in node.knobs():
return
# creating tab umedia knob
umediaTab = nuke.Tab_Knob('umedia', 'UMedia')
node.addKnob(umediaTab)
# creating variation knob
variation = nuke.Enumeration_Knob('uVariation', 'Variation', [])
node.addKnob(variation)
node['label'].setValue('[value uVariation]')
# forcing to update the list of variations
onReadNodeUpdate(node, node['file'])
# setting default uVariation value
setDefaultVariation(node)
def __init__(self, node):
self.n = node
if not self.n.Class() in ('Tracker4', 'Tracker3','CornerPin2D'):
nuke.message('The selected node is neither a Tracker or a Cornerpin.')
return
self._trackNames = self.getTrackNames(self.n)
if not self._trackNames:
nuke.message('No Tracks found in %s' %self.n.name())
return
nukescripts.PythonPanel.__init__(self, 'Export Tracks from %s' %self.n.name())
self.fRange = nuke.String_Knob('fRange', 'Framerange: ', '%s-%s' %(nuke.root().firstFrame(), nuke.root().lastFrame()))
self.trackEnum = []
self.trackXY = []
for i in range(len(self._trackNames)):
if i > 3:
break
self.trackEnum.append(nuke.Enumeration_Knob('track%d' %i, 'Track %d' %(i + 1), self._trackNames))
self.trackEnum[i].setValue(i)
self.trackXY.append(nuke.XY_Knob('trackpos%d', ''))
self.trackXY[i].setExpression('root.%s.tracks.%d.track_x' %(self.n.name(), i + 1), 0)
self.trackXY[i].setExpression('root.%s.tracks.%d.track_y' %(self.n.name(), i + 1), 1)
self.addKnob(self.fRange)
for j, k in enumerate(self.trackEnum):
self.addKnob(k)
self.addKnob(self.trackXY[j])
def __init__(self):
import nuke.rotopaint
super(RotoViewsPanel,
self).__init__('Change views on RotoPaint Nodes...')
self.changeKnob = nuke.Enumeration_Knob(
'change', 'change',
['all RotoPaint nodes', 'selected RotoPaint nodes'])
self.addKnob(self.changeKnob)
self.viewsKnob = nuke.MultiView_Knob('views')
self.addKnob(self.viewsKnob)
self.viewsKnob.setValue((' ').join(nuke.views()))
self.okButton = nuke.Script_Knob("Change Views")
self.addKnob(self.okButton)
self.okButton.setFlag(nuke.STARTLINE)
self.cancelButton = nuke.Script_Knob("Cancel")
self.addKnob(self.cancelButton)
def __init__(self):
nukescripts.PythonPanel.__init__(self, "Show properties of")
nodes = []
for node in nuke.allNodes(group=nuke.selectedNode()):
nodes.append(node.name())
self.nodeList = nuke.Enumeration_Knob('showNode', "Show node", nodes)
self.addKnob(self.nodeList)
def write_create():
""" Create a custom GPS Write node.
"""
if not getWorkingScriptName(): # re-write this function
nuke.message('Please save your script first')
return
writeNode = nuke.createNode('Write', 'name GPS_Write')
presetLs = [
'Comp', 'CG_Comp', 'Precomp', 'Roto', 'Elements', 'Plate_Raw',
'Plate_Graded', 'Plate_CG'
]
gps_presets_tab = nuke.Tab_Knob('gps_presets', 'GPS_Write_Presets')
gps_write_presets = nuke.Enumeration_Knob('write_presets', 'Write Preset',
presetLs)
writeNode.addKnob(gps_presets_tab)
writeNode.addKnob(gps_write_presets)
writeNode['knobChanged'].setValue('gpsNodes.w_presets_callback()')
writeNode.knob('write_presets').setValue('Precomp')
try:
writeNode.knob('create_directories').setValue('True')
# Create directories option added in Nuke 10.5x makes this redundant...
except:
writeNode.knob('beforeRender').setValue('gpsNodes.w_create_dir()')
# writeNode.knob('afterRender').setValue('gpsNodes.w_openPermissions()')
renderSubmit_button = nuke.PyScript_Knob('renderSubmit_button',
'Submit to Render Queue',
'gpsNodes.w_render_submit()')
renderSubmit_button.setFlag(nuke.STARTLINE)
writeNode.addKnob(renderSubmit_button)
return writeNode
def addFrameioroottab():
"""Adds frame.io settings tab to the nukescript"""
nukeroot = nuke.root()
if not 'frameio' in nukeroot.knobs():
nukeroot.addKnob( nuke.Tab_Knob('frameio' , 'frame.io') )
nukeroot.addKnob( nuke.String_Knob('frameiousername' , 'Username') )
nukeroot.addKnob( nuke.Enumeration_Knob('frameioproject' , 'Project' , [] ) )
def __init__(self, labelChoices, title):
self.title = title
self.labelChoices = labelChoices
nukescripts.PythonPanel.__init__(self, self.title)
self.typeKnob = nuke.Enumeration_Knob('select', 'Select release',
self.labelChoices)
self.addKnob(self.typeKnob)
def __setup_knobs(self):
self.__output_path_knob = nuke.File_Knob('output_path', 'Output Path')
self.addKnob(self.__output_path_knob)
self.__file_formats_knob = nuke.Enumeration_Knob('format', 'Format', ['png', 'jpg'])
self.addKnob(self.__file_formats_knob)
self.__start_frame_knob = nuke.Int_Knob('start_frame', 'Start Frame')
self.addKnob(self.__start_frame_knob)
self.__end_frame_knob = nuke.Int_Knob('end_frame', 'End Frame')
self.addKnob(self.__end_frame_knob)
self.__output_channels_knob = nuke.Channel_Knob('output_channels', 'Output Channels')
self.__output_channels_knob.setFlag(nuke.ENDLINE)
self.__output_channels_knob.setValue('rgba')
self.addKnob(self.__output_channels_knob)
self.__use_proxy_knob = nuke.Boolean_Knob('use_proxy', 'Use Proxy')
self.__use_proxy_knob.setFlag(nuke.ENDLINE)
self.addKnob(self.__use_proxy_knob)
self.__render_button_knob = nuke.PyScript_Knob('render', 'Render')
self.__render_button_knob.setFlag(nuke.STARTLINE)
self.addKnob(self.__render_button_knob)
self.addKnob(nuke.Text_Knob('copyright', 'www.ngreen.org'))
def __init__(self):
"""
Adding knobs to UI panel.
"""
nukescripts.PythonPanel.__init__(self, "Smart Floating Notepad", "com.parimalvfx.SmartFloatingNotepadPanel")
self.notepadOne = nuke.Multiline_Eval_String_Knob("first_notepad", "")
self.notepadOne.setTooltip("Take your notes here...")
self.notepadTwo = nuke.Multiline_Eval_String_Knob("second_notepad", "")
self.notepadTwo.setTooltip("Compare notes with first notepad")
self.notepadTwo.clearFlag(nuke.STARTLINE)
self.notepadTwo.setVisible(False)
self.options = nuke.Boolean_Knob("options", "Options", True)
self.options.setTooltip("Toggle notepad options")
self.options.setFlag(nuke.STARTLINE)
self.compare = nuke.PyScript_Knob("compare", "Compare Notes")
self.compare.setTooltip("Toggle second notepad")
self.compare.setFlag(nuke.STARTLINE)
self.bookmark = nuke.PyScript_Knob("bookmark", "Bookmark")
self.bookmark.setTooltip("Bookmark first notepad's notes.")
self.bookmarkList = nuke.Enumeration_Knob("bookmark_list", "", [])
self.bookmarkList.setTooltip("Open bookmarked notes in second notepad.")
self.bookmarkList.clearFlag(nuke.STARTLINE)
self .clearBookmark = nuke.PyScript_Knob("clear_bookmark", "Clear Bookmark")
self.addKnob(self.notepadOne)
self.addKnob(self.notepadTwo)
self.addKnob(self.options)
self.addKnob(self.compare)
self.addKnob(self.bookmark)
self.addKnob(self.bookmarkList)
self.addKnob(self.clearBookmark)
def KuWrite():
'''Adding inputs for auto generate output path'''
node = nuke.createNode('Write')
node.setName('KuWrite')
node.knob('file').setEnabled(False)
k_pipeline = nuke.Text_Knob('kupipeline', 'kuWrite',
'kuWrite') # Ku Pipeline Identifier
k_tab = nuke.Tab_Knob('tb_KuWrite', 'KuWrite')
k_title = nuke.Text_Knob('tx_title', '', '<h1><br>KuWrite</h1>')
k_show = nuke.Text_Knob('tx_show', '<h3>show</h3>',
slate.SHOW_CONFIG['kp_show'])
k_shot = nuke.Text_Knob('tx_shot', '<h3>shot</h3>',
slate.SHOT_CONFIG['kp_shot'])
k_type = nuke.Enumeration_Knob('mu_type', '<h3>type</h3>', RENDER_TYPE)
k_elements = nuke.String_Knob('tx_passname', '_', 'NewPass')
k_ver = nuke.Enumeration_Knob('mu_ver', '<h3>version</h3>', [' '])
k_latest = nuke.Text_Knob('tx_versionLabel', '',
VERSION_LABEL['new_version'])
k_div_title = nuke.Text_Knob('divider', '')
k_div = nuke.Text_Knob('divider', ' ')
k_set = nuke.PyScript_Knob('bt_set', '<b>⭮ Check Versions</b>',
'mod_KuWrite.set_write(nuke.thisNode())')
k_render = nuke.PyScript_Knob('bt_render', '<b>Render</b>',
'mod_KuWrite.render_node(nuke.thisNode())')
k_scriptcopy = nuke.String_Knob('tx_scriptcopy', 'scriptcopy dir', '')
k_elements.clearFlag(nuke.STARTLINE)
k_elements.setVisible(False)
k_set.setFlag(nuke.STARTLINE)
k_latest.clearFlag(nuke.STARTLINE)
k_render.clearFlag(nuke.STARTLINE)
k_pipeline.setVisible(False)
k_scriptcopy.setVisible(False)
for k in [
k_tab, k_pipeline, k_title, k_div_title, k_show, k_shot, k_type,
k_elements, k_ver, k_latest, k_div, k_set, k_render, k_scriptcopy
]:
node.addKnob(k)
mod = os.path.basename(__file__).split('.')[0]
node['knobChanged'].setValue('%s.onChange()' % mod)
set_write(node)
def __init__(self):
super(Core_PickTranslate, self).__init__('PickTranslate')
self.k_pick = nuke.Color_Knob('pick', "pick translate")
self.k_node = nuke.Enumeration_Knob('geo', "pick geo node", [])
self.addKnob(self.k_pick)
self.addKnob(self.k_node)
def __init__(self, node):
'''List all roto paint nodes and the name of their respective shapes and strokes'''
nukescripts.PythonPanel.__init__(self, 'RotoPaint Elements')
self.rpNode = node
# CREATE KNOBS
self.typeKnob = nuke.Enumeration_Knob('element', 'element / curve',
['Shapes', 'Strokes'])
self.elementKnob = nuke.Enumeration_Knob('curve', '', [])
self.elementKnob.clearFlag(nuke.STARTLINE)
# ADD KNOBS
for k in (self.typeKnob, self.elementKnob):
self.addKnob(k)
# STORE DICTIONARY OF ELEMENTS PER TYPE
self.curveDict = {}
# FILL DICTIONARY
self.getData()
def create_read_sub_node():
node = nuke.createNode('Read', inpanel=True)
node_name = 'ReadSub'
node_inst = 1
while nuke.exists(node_name + str(node_inst)):
node_inst += 1
node_name += str(node_inst)
node.knob('name').setValue(node_name)
sub_tab = nuke.Tab_Knob("Sub")
# make sure the product reprs are cached
populate_sub_cache(refresh=False)
repr_str_list = [DEFAULT_REPR_STR]
repr_str_list.extend(sorted(PRODUCT_REPR_STR_TO_PATH.keys()))
product_repr_select = nuke.Enumeration_Knob(
'product_repr_select',
'subscription',
repr_str_list,
)
product_seq_select = nuke.Enumeration_Knob(
'product_seq_select',
'files',
[],
)
nuke.callbacks.addKnobChanged(read_sub_knob_changed,
nodeClass='Read',
node=node)
node.addKnob(sub_tab)
node.addKnob(product_repr_select)
node.addKnob(product_seq_select)
# make the tab pop to front
node['Sub'].setFlag(0)
read_sub_knob_changed(node=node, knob=node.knob('product_repr_select'))
def forEach():
forbidden = ['RotoPaint', 'Roto']
for n in nuke.selectedNodes():
feMsg = 'Nodes from type ' + n.Class(
) + ' are not supported yet. Please remove them from the selection before creating the ForEach node.'
if n.Class() in forbidden:
nuke.message(feMsg)
return False
feGroup = nuke.collapseToGroup()
feGroup.setName("forEach")
for n in feGroup.nodes():
n.setSelected(False)
nuke.allNodes("Input", feGroup)[0].setSelected(True)
feTab = feGroup.addKnob(nuke.Tab_Knob("forEach"))
feGroup.addKnob(nuke.Int_Knob("n_inputs", "number of inputs"))
feGroup.addKnob(nuke.Boolean_Knob("manual", "manual loop"))
feGroup.addKnob(nuke.Int_Knob("init", "from:"))
feGroup.addKnob(nuke.Int_Knob("end", "to:"))
feGroup['n_inputs'].setValue(1)
feGroup['n_inputs'].setTooltip(
"determines the number of inputs (arrows) the node has got.")
feGroup["manual"].setTooltip(
"If in manual mode forEach will run from init to end.")
feGroup["init"].setTooltip(
"The init value of the loop. In pseudocode, this would correspond to for(i=init; i<=end; i++)"
)
feGroup["end"].setTooltip(
"The end value of the loop. In pseudocode, this would correspond to for(i=init; i<=end; i++)"
)
feGroup["end"].setValue(10)
feGroup["manual"].setFlag(nuke.STARTLINE)
feGroup["init"].clearFlag(nuke.STARTLINE)
feGroup["init"].setEnabled(False)
feGroup["end"].clearFlag(nuke.STARTLINE)
feGroup["end"].setEnabled(False)
feGroup.knob("knobChanged").setValue(
"with nuke.thisNode():\n knob = nuke.thisKnob();\n if(knob.name() == 'n_inputs'):\n n_inps = len(nuke.allNodes('Input'));\n n_knob = int(float(knob.value()))-1;\n\n if n_knob != n_inps:\n for i in range(n_inps-1, n_knob, cmp(n_knob, n_inps)):\n if(n_inps < n_knob):\n nuke.nodes.Input();\n elif n_knob > -1:\n nuke.delete(nuke.allNodes('Input')[0]);\n elif(knob.name() == 'manual'):\n nuke.thisNode()['init'].setEnabled(knob.value());\n nuke.thisNode()['end'].setEnabled(knob.value());"
)
feGroup.addKnob(nuke.PyScript_Knob("run_btn", "explode loop"))
feGroup['run_btn'].setTooltip(
"transforms the forEach group into clones created by the loop.")
feGroup['run_btn'].setCommand(
"from types import *\n\ndef is_numeric(n):\n try: \n float(n);\n return True;\n except TypeError:\n return False;\n\nfeGroup = nuke.thisNode();\nfePadding = feGroup.knob('padd').getValue();\nfeCY = int(feGroup.ypos() + feGroup.screenHeight()/2);\nfeCX = int(feGroup.xpos() + feGroup.screenWidth()/2);\nfeW = 0; feH = 0;\nfe_horiz = (feGroup.knob('layout').value() == 'horizontal');\n\nfe_manual = feGroup['manual'].value();\n\nfeInputs_num = feGroup.inputs() if not fe_manual else (int(feGroup['end'].value()) - int(feGroup['init'].value()));\nfeInputs = feGroup.dependencies();\nfeInputs.sort(lambda a,b: cmp(a.xpos() if fe_horiz else a.ypos(), b.xpos() if fe_horiz else b.ypos()));\n\nif fe_manual: feInputs += [fakeInp for fakeInp in xrange(feInputs_num - len(feInputs))];\n\n#expand group:\nfeGroup = feGroup.expand();\n\n#create a clone for every input\nfor i, feInput in enumerate(feInputs):\n if i>0: nuke.cloneSelected();\n\n feGroup = nuke.selectedNodes();\n\n feEach = nuke.nodes.NoOp();\n feEach.setName('each');\n \n feI = nuke.String_Knob('i', 'instance #');\n feEach.addKnob(feI);\n feI.setValue(str(i));\n feI.setTooltip('Use [python {forEach_i()}] inside an expression of a node created by the forEach node to access the iterator of the for loop (i). For this to work you need to keep the each-nodes.');\n feI.setEnabled(False);\n \n # find first node:\n for feC in feGroup:\n if feC.isSelected():\n feClone = feC;\n else:\n break;\n \n if feClone.maxInputs > 0: feClone.setInput(0, feEach);\n\n if not fe_manual or not is_numeric(feInput): feEach.setInput(0, feInput);\n if fe_horiz: \n feEach.setYpos(feCY);\n else:\n feEach.setXpos(feCX);\n\n feEach.setSelected(True);\n feGroup = nuke.selectedNodes();\n \n for j,node in enumerate(feGroup): #walk thru all nodes within & position\n if fe_horiz:\n feW = max(feW, node.screenWidth() + fePadding);\n else:\n feH = max(feH, node.screenHeight() + fePadding);\n\n if fe_horiz: \n node.setXpos(int(feCX - feW * (feInputs_num/2) + feW * i));\n else: \n node.setYpos(int(feCY - feH * (feInputs_num/2) + feH * i));\n feEach.setYpos(feClone.ypos()-feClone.screenHeight()-feEach.screenHeight()-40);\n feEach.setSelected(False);\n\n#clean up\nnuke.selectAll();\nnuke.invertSelection();\n\n#i-function\ndef forEach_i():\n n = nuke.thisNode();\n if n.name() != 'Root':\n while (n.Class() != 'NoOp' or not n.name().startswith('each')) and len(n.dependencies()) > 0:\n n = n.dependencies()[0];\n return int(n['i'].value()) if n.knob('i') != None else -1;\n else:\n return -1;"
)
feGroup['run_btn'].setFlag(nuke.STARTLINE)
feGroup.addKnob(nuke.Tab_Knob("display", "display options"))
feGroup.addKnob(
nuke.Enumeration_Knob("layout", "preferred layout",
["horizontal", "vertical"]))
feGroup.addKnob(nuke.Double_Knob("padd", "padding"))
feGroup['padd'].setTooltip("determines the space between branches.")
feGroup['padd'].setValue(300)
return True
def __init__(self, rootDir='Q:\\Info5Film\\Heritage\\05_Render\\'):
super(ProjectManager, self).__init__('ProjectManager', 'id.ProjectManager')
self.rootDir = rootDir
self.seq = self.pl = None
self.write_path = ''
seqDirs = [x for x in os.listdir(rootDir)
if os.path.isdir(os.path.join(rootDir, x))]
self.seq = seqDirs[0]
self.seqEnum = nuke.Enumeration_Knob('SEQ', 'SEQ', seqDirs)
self.addKnob(self.seqEnum)
self.plEnum = nuke.Enumeration_Knob('PL', 'PL', [])
self.addKnob(self.plEnum)
self._seqChanged()
def __init__(self, node):
nukescripts.PythonPanel.__init__(self, 'Lock Knobs')
#CREATE KNOBS
self.AllKnobs = nuke.PyScript_Knob('AllKnobs', 'All Knobs')
self.Clear = nuke.PyScript_Knob('Clear', 'Clear')
self.Knobslist = nuke.Multiline_Eval_String_Knob('Knobs', 'Knobs')
self.Operation = nuke.Enumeration_Knob('Operation', 'Operation', ['Hide', 'Show', 'Lock', 'Unlock'])
#ADD KNOBS
for k in ( self.AllKnobs, self.Clear, self.Knobslist, self.Operation):
self.addKnob(k)
