def add_knobs(self, mode):
self.remove_knobs()
custom_knob_names = []
if mode == 'sync':
for node in self.all_nodes:
name_knob = nuke.Boolean_Knob(node.name())
name_knob.setValue(1)
if not custom_knob_names:
name_knob.setFlag(nuke.STARTLINE)
self.editor.addKnob(name_knob)
custom_knob_names.append(name_knob.name())
name_knob.setFlag(nuke.ENDLINE)
for knob in self.knobs:
self.editor.addKnob(knob)
custom_knob_names.append(knob.name())
update_knob = nuke.PyScript_Knob('update', 'set all values')
update_knob.setFlag(nuke.STARTLINE)
update_knob.setCommand('MultiNodeEditor.set_all_values()')
self.editor.addKnob(update_knob)
custom_knob_names.append(update_knob.name())
elif mode == 'non sync':
for i in range(len(self.all_nodes)):
name_knob = nuke.Boolean_Knob(self.all_nodes[i].name())
name_knob.setValue(1)
name_knob.setFlag(nuke.STARTLINE)
self.editor.addKnob(name_knob)
custom_knob_names.append(name_knob.name())
for knob in self.knobs[i]:
self.editor.addKnob(knob)
custom_knob_names.append(knob.name())
self.editor['custom_knobs'].setValues(custom_knob_names)
def preferencesCreatedCallback():
p = nuke.toNode('preferences')
#Setup J_Ops prefs knobs if they don't exist.
try:
jopsKnobsPresent = p["J_Ops"]
except (SyntaxError, NameError):
k = nuke.Tab_Knob("J_Ops")
k.setFlag(nuke.ALWAYS_SAVE)
p.addKnob(k)
v = nuke.Double_Knob("j_ops_ver", "j_ops_ver")
v.setFlag(nuke.ALWAYS_SAVE)
v.setFlag(nuke.INVISIBLE)
v.setValue(2.0101)
p.addKnob(v)
k = nuke.Boolean_Knob("j_ops_enable_drop", "Improved drag and drop")
k.setFlag(nuke.ALWAYS_SAVE)
k.setFlag(nuke.STARTLINE)
k.setValue(1.0)
k.setTooltip("Enable/disable a somewhat improved drag and drop behaviour. Requires Nuke restart to take effect. Adds creation of geo, camera, light and vectorfield nodes based on incoming file extensions, as well as support for sequences when dropping folders onto DAG.")
p.addKnob(k)
k = nuke.Boolean_Knob("j_ops_enable_bookmark", "DAG bookmarks")
k.setFlag(nuke.ALWAYS_SAVE)
k.setFlag(nuke.STARTLINE)
k.setValue(1.0)
k.setTooltip("Enable/disable DAG bookmarks, allowing storing and recalling of particular DAG locations and zoom settings, for easy navigation around a script. Requires Nuke restart to take effect. Adds Python-DAG Bookmarks menu to J_Ops toolbar, offering access via mouse, tab menu, or hotkeys.")
p.addKnob(k)
k = nuke.Text_Knob("j_ops_dropdivider_label", "Drag And Drop")
k.setFlag(nuke.ALWAYS_SAVE)
p.addKnob(k)
k = nuke.Boolean_Knob("j_ops_drop_recurse", "Recurse directories")
k.setFlag(nuke.ALWAYS_SAVE)
k.setValue(1.0)
k.setTooltip("Enable/disable recursion into directories dropped on DAG. When enabled will result in entire directory structure being imported into DAG, when disabled only the directory dropped will be imported (ie none of its sub directories)")
p.addKnob(k)
#Check for preference setting, and if drop enabled add its callback/
dropEnabled = False
try:
dropEnabled = nuke.toNode('preferences')["j_ops_enable_drop"].getValue()
except (SyntaxError, NameError):
pass
if dropEnabled == True:
nukescripts.drop.addDropDataCallback(jopsDropHandler)
#Check for preference setting, and if drop enabled add its callback/
bookmarkEnabled = False
try:
bookmarkEnabled = nuke.toNode('preferences')["j_ops_enable_bookmark"].getValue()
except (SyntaxError, NameError):
pass
if bookmarkEnabled == True:
jopsBookmarkAddMenus()
def __init__(self):
nukescripts.PythonPanel.__init__(self, 'Merge Transforms')
# 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.forceCP = nuke.Boolean_Knob('force_cp',
'Force Merge as CornerPin')
self.forceCP.setFlag(nuke.STARTLINE)
self.forceCP.setTooltip(
'Tool will merge transforms a a new Transform if possible, or Cornerpin if necessary.'
'\nChecking this box will force a corner pin output')
self.forceMatrix = nuke.Boolean_Knob('force_matrix',
'CornerPin as extra_matrix')
self.forceMatrix.setTooltip(
"Uses the cornerpin's extra_matrix to recreate the transform rather than the corners"
)
self.forceMatrix.setEnabled(False)
self.forceMatrix.setFlag(nuke.STARTLINE)
# ADD KNOBS
for k in (self.first, self.last, self.forceCP, self.forceMatrix):
self.addKnob(k)
def create_projector_panel():
if not ensure_camera_selected(nuke.selectedNode()):
return
p = nukescripts.panels.PythonPanel("Create a projector")
k = nuke.Boolean_Knob("link", "Link the projector camera to the original")
k.setFlag(nuke.STARTLINE)
k.setTooltip(
"This will create a live setup that will update when the camera keyframes change"
)
p.addKnob(k)
k = nuke.Boolean_Knob("create_shader_tree",
"Create shader tree (FrameHold + project3d)")
k.setFlag(nuke.STARTLINE)
k.setTooltip(
"will also create a FrameHold and a Project3D to spare even more clicks"
)
p.addKnob(k)
result = p.showModalDialog()
if result == 0:
return # Canceled
# The API called "get value of the field by providing it's UI label" earns the
# mark of the most f****d up disgusting crap engineering ever (tm)
do_link = p.knobs()["link"].value()
do_tree = p.knobs()["create_shader_tree"].value()
if do_tree:
create_camera_at_and_shader(nuke.selectedNode(), nuke.frame(), do_link)
else:
create_camera_at(nuke.selectedNode(), nuke.frame(), do_link)
def __init__(self):
nukescripts.PythonPanel.__init__(self, 'Estimator',
'uk.co.thefoundry.estimatorPanel')
self.runBtn = nuke.PyScript_Knob('Run')
self.precisionValue = nuke.Int_Knob('Frames to calculate: ')
self.divider = nuke.Text_Knob('')
self.pathBool = nuke.Boolean_Knob('Show full path')
self.disabledBool = nuke.Boolean_Knob('Estimate disabled nodes')
self.sortedBool = nuke.Boolean_Knob('Sort by size')
self.addKnob(self.precisionValue)
self.addKnob(self.runBtn)
self.addKnob(self.divider)
self.addKnob(self.pathBool)
self.addKnob(self.disabledBool)
self.addKnob(self.sortedBool)
self.precisionValue.setValue(10)
self.disabledBool.setValue(1)
self.prj_first_frame = int(
nuke.toNode('root').knob('first_frame').value())
self.prj_last_frame = int(
nuke.toNode('root').knob('last_frame').value())
self.prj_length = abs(self.prj_last_frame - self.prj_first_frame)
global DEV
DEV = 0
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 preferencesCreatedCallback():
p = nuke.toNode('preferences')
#Setup J_Ops prefs knobs if they don't exist.
try:
jopsKnobsPresent = p["J_Ops"]
except (SyntaxError, NameError):
k = nuke.Tab_Knob("J_Ops")
k.setFlag(nuke.ALWAYS_SAVE)
p.addKnob(k)
v = nuke.Double_Knob("j_ops_ver", "j_ops_ver")
v.setFlag(nuke.ALWAYS_SAVE)
v.setFlag(nuke.INVISIBLE)
v.setValue(2.0101)
p.addKnob(v)
k = nuke.Boolean_Knob("j_ops_enable_drop", "Improved drag and drop")
k.setFlag(nuke.ALWAYS_SAVE)
k.setFlag(nuke.STARTLINE)
k.setValue(1.0)
k.setTooltip(
"Enable/disable a somewhat improved drag and drop behaviour. Requires Nuke restart to take effect. Adds creation of geo, camera, light and vectorfield nodes based on incoming file extensions, as well as support for sequences when dropping folders onto DAG. Warning: does not observe hash vs regex file path expression, due to Nuke python functions ignoring it."
)
p.addKnob(k)
k = nuke.Text_Knob("j_ops_dropdivider_label", "Drag And Drop")
k.setFlag(nuke.ALWAYS_SAVE)
p.addKnob(k)
k = nuke.Boolean_Knob("j_ops_drop_recurse", "Recurse directories")
k.setFlag(nuke.ALWAYS_SAVE)
k.setValue(1.0)
k.setTooltip(
"Enable/disable recursion into directories dropped on DAG. When enabled will result in entire directory structure being imported into DAG, when disabled only the directory dropped will be imported (ie none of its sub directories)"
)
p.addKnob(k)
#Knobs created. Hide obselete ones, update ver
#2.1
try:
p["j_ops_ver"].setValue(2.0201)
try:
p["j_ops_enable_bookmark"].setFlag(nuke.INVISIBLE)
except Exception:
pass
except Exception:
pass
#Check for preference setting, and if drop enabled add its callback/
dropEnabled = False
try:
dropEnabled = nuke.toNode(
'preferences')["j_ops_enable_drop"].getValue()
except (SyntaxError, NameError):
pass
if dropEnabled == True:
nukescripts.drop.addDropDataCallback(jopsDropHandler)
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 __init__(self,
dialogState,
groupContext,
nodeSelection=[],
exceptOnError=True):
self._state = dialogState
self._nodeSelection = nodeSelection
self._exceptOnError = exceptOnError
nukescripts.PythonPanel.__init__(self, self._titleString(),
self._idString(), False)
self._viewers = {}
for n in nuke.allNodes("Viewer", groupContext):
self._viewers[n.name()] = n
self._specialRanges = ["input", "global", "custom"]
self._addPreKnobs()
# Frame range knobs
self._rangeEnum = nuke.Enumeration_Knob(
"frame_range", "Frame range",
self._specialRanges + self._viewers.keys())
self._state.setKnob(self._rangeEnum, "input")
self.addKnob(self._rangeEnum)
self._frameRange = nuke.String_Knob("frame_range_string", "")
self._frameRange.clearFlag(nuke.STARTLINE)
if self._rangeEnum.value() == "custom":
self._state.setKnob(self._frameRange,
str(nuke.root().frameRange()))
else:
self._setFrameRangeFromSource(self._rangeEnum.value())
self.addKnob(self._frameRange)
# Proxy
self._useProxy = nuke.Boolean_Knob("use_proxy", "Use proxy")
self._useProxy.setFlag(nuke.STARTLINE)
self._state.setKnob(self._useProxy, nuke.root().proxy())
self.addKnob(self._useProxy)
self._addPostKnobs()
self._continueOnError = nuke.Boolean_Knob("continue",
"Continue on error")
self._state.setKnob(self._continueOnError, True)
self._continueOnError.setFlag(nuke.STARTLINE)
self.addKnob(self._continueOnError)
self._addViewKnob()
self._addTrailingKnobs()
def __init__(self):
'''
init values
'''
global uniqueLayers
global layerCheckboxes
global panelHeight
panelHeight = 160
nukescripts.PythonPanel.__init__(self, "MultichannelSplit",
"MultiChannelSplit")
self.setMinimumSize(450, panelHeight)
self.autoCrop = nuke.Boolean_Knob("autoCrop", "autocrop", 0.0)
self.autoCrop.setFlag(nuke.STARTLINE)
self.prepareForOutput = nuke.Boolean_Knob("prepareForOutput",
"prepare for output", 0.0)
self.prepareForOutput.setFlag(nuke.STARTLINE)
self.outputPath = nuke.File_Knob('outputPath', 'output path')
self.outputPath.setVisible(False)
self.div = nuke.Text_Knob("", "", "")
self.which = nuke.Enumeration_Knob("which", "",
["all AOVs", "individual AOVs"])
self.addKnob(self.autoCrop)
self.addKnob(self.prepareForOutput)
self.addKnob(self.outputPath)
self.addKnob(self.div)
self.addKnob(self.which)
# Layer checkboxes
uniqueLayers = getUniqueChannelLayerList(nuke.selectedNode())
layerCheckboxes = []
self.allLayer = nuke.Script_Knob("allLayer", "select all")
self.allLayer.setVisible(False)
self.noLayer = nuke.Script_Knob("noLayer", "deselect all")
self.noLayer.setVisible(False)
self.div2 = nuke.Text_Knob("", "available AOVs", "")
self.div2.setVisible(False)
self.addKnob(self.div2)
self.addKnob(self.allLayer)
self.addKnob(self.noLayer)
for layer in uniqueLayers:
self.layer = nuke.Boolean_Knob(layer, layer, 0)
self.layer.setFlag(nuke.STARTLINE)
self.layer.setVisible(False)
self.addKnob(self.layer)
layerCheckboxes.append(self.layer)
self.div3 = nuke.Text_Knob("", "", "")
self.addKnob(self.div3)
def selectNodesPanel():
p = nukescripts.PythonPanel('Conform file paths to Project Directory')
p.nodesSelection = newUserKnob(
nuke.Enumeration_Knob(
'nodesSel', 'Nodes selections',
['All nodes', 'Selected nodes only', 'Exclude selected nodes']), 2)
p.checkReadGeo = newUserKnob(
nuke.Boolean_Knob('checkReadGeo', 'Exclude ReadGeo nodes', '0'), 0)
p.readGeoText = nuke.Text_Knob(
'readGeoText', '', 'Will affect configured alembic scenegraph')
p.div1 = nuke.Text_Knob('div1', '')
p.recurseGroups = newUserKnob(
nuke.Boolean_Knob('checkRecurse', 'Exclude groups/gizmos', '0'), 1)
p.tclPath = newUserKnob(
nuke.Boolean_Knob('checkTCL', 'Exclude TCL knobs', '0'), 1)
for k in (p.checkReadGeo, p.readGeoText, p.div1, p.recurseGroups):
k.setFlag(0x1000)
for k in (p.nodesSelection, p.checkReadGeo, p.readGeoText, p.div1,
p.recurseGroups, p.tclPath):
p.addKnob(k)
if p.showModalDialog():
# check if recurseGroups is true
if p.recurseGroups.value():
allNodes = nodeWithFile(False)
else:
allNodes = nodeWithFile(True)
# check if selectedNodes
if p.nodesSelection.value() == 'Selected nodes only':
for node in allNodes:
if node not in nuke.selectedNodes():
allNodes.remove(node)
elif p.nodesSelection.value() == 'Exclude selected nodes':
for node in allNodes:
if node in nuke.selectedNodes():
allNodes.remove(node)
# remove nodes with TCL
if p.tclPath.value():
for node in allNodes:
hasTCL = bool(re.search(r'\[*\]', node['file'].value()))
if hasTCL:
allNodes.remove(node)
# remove readGeos node if necessary
if p.checkReadGeo.value():
for n in allNodes:
if n.Class() == 'ReadGeo2':
allNodes.remove(n)
return allNodes
def __create_knobs(viewer_node):
# lock knobs dosn't exist, create one and use default action
tab = nuke.Tab_Knob('Lock')
lock_all = nuke.Boolean_Knob('lock_all_buffers', 'lock all buffers')
viewer_node.addKnob(tab)
viewer_node.addKnob(lock_all)
for i in xrange(1, 10):
k = nuke.Boolean_Knob('lock_buffer_{}'.format(i),
'lock buffer {}'.format(i))
k.setFlag(nuke.STARTLINE)
viewer_node.addKnob(k)
k = nuke.Boolean_Knob('lock_buffer_0', 'lock buffer 0')
k.setFlag(nuke.STARTLINE)
viewer_node.addKnob(k)
def __init__(self):
"""
Adding knobs to UI panel.
"""
nukescripts.PythonPanel.__init__(self, "Shuffle EXR Passes", "com.parimalvfx.ShufflePassesPanel")
self.node = nuke.selectedNode()
self.nodeLayers = find_node_layers(self.node)
self.layerKnobs = []
for layer in self.nodeLayers:
self.layer = nuke.Boolean_Knob(layer, layer, True)
self.layer.setFlag(nuke.STARTLINE)
self.addKnob(self.layer)
self.layerKnobs.append(self.layer)
if layer == "rgba":
self.layer.setValue(False)
self.div1 = nuke.Text_Knob("div1", " ", "")
self.all = nuke.PyScript_Knob("select_all", " Select All ")
self.invert = nuke.PyScript_Knob("invert_selection", " Invert Selection ")
self.clear = nuke.PyScript_Knob("clear_selection", " Clear Selection ")
self.div2 = nuke.Text_Knob("div2", " ", "")
height = 125 + len(self.layerKnobs) * 20
width = 330
if height > 700:
width = 350
height = 700
self.setMinimumSize(width, height)
self.setMaximumSize(500, 900)
for each in (self.div1, self.all, self.invert, self.clear, self.div2):
self.addKnob(each)
def __init__(self):
nukescripts.PythonPanel.__init__(self, 'Snapshotr',
'uk.co.thefoundry.ssPanel')
if self.DEV > 0:
print "\n* Debug mode ON"
print "* rootDir inside ssPanel __init__ = " + self.rootDir
print "* snapsDir inside ssPanel __init__ = " + self.snapsDir
self.btn_snap_fullres = nuke.PyScript_Knob('Full')
self.btn_snap_instant = nuke.PyScript_Knob('Instant')
self.btn_open_webview = nuke.PyScript_Knob('Open')
self.commentField = nuke.String_Knob('Comment:')
self.divider = nuke.Text_Knob('')
self.markNode = nuke.Boolean_Knob('Mark node ')
self.timerValue = nuke.Int_Knob('Autosnap: ')
self.addKnob(self.commentField)
self.addKnob(self.btn_snap_instant)
self.addKnob(self.btn_snap_fullres)
self.addKnob(self.btn_open_webview)
self.addKnob(self.timerValue)
self.addKnob(self.divider)
self.addKnob(self.markNode)
self.timerValue.setValue(60) # 60 minutes by default
scriptPath = nuke.toNode('root').knob('name').value()
scriptName = scriptPath.split("/")[-1]
if cmn.check_script(name=scriptName) is None:
nuke.message(
"Please save your script in the following format:\nshot.task.artist.v00.00.nk"
)
raise BaseException
def snapAutosave():
"""
Create auto snapshot, start timer to trigger this (every 60min by default)
"""
try:
c_var = cmn.init_common_vars(snapsDir=self.snapsDir)
print "\n~ autosaving snapshot..."
cmn.create_snapshot_dirs(rootDir=self.rootDir,
snapsDir=self.snapsDir,
snapPath=c_var["snapPath"],
markNode=self.markNode)
cmn.create_snapshot_script(
scriptPath=c_var["scriptPath"],
snapScriptName=c_var["snapScriptName"],
upversion=False)
cmn.create_snapshot_comment(
snapCommentFile=c_var["snapCommentFile"],
commentText="#autosnap")
cmn.create_snapshot_screenshot(
DEV=self.DEV, snapImageFile=c_var["snapImageFile"])
finally:
timer = int(self.timerValue.value()) * 60000
QtCore.QTimer.singleShot(timer, snapAutosave)
snapAutosave()
def _addPreKnobs(self):
if self.isTimelineWrite():
self._frameServerRender = nuke.Boolean_Knob(
"frameserver_render", "Render to timeline")
self._state.setKnob(self._frameServerRender, True)
self._frameServerRender.setFlag(nuke.STARTLINE)
self.addKnob(self._frameServerRender)
def process(self, context):
formats = ["cache", "camera", "geometry"]
for item in context.data["instances"]:
families = [item.data["family"]] + item.data.get("families", [])
# Skip any instances that is not valid.
valid_families = set(formats)
if len(valid_families & set(families)) != 1:
continue
fmt = list(valid_families & set(families))[0]
instance = context.create_instance(item.data["name"])
for key, value in item.data.iteritems():
instance.data[key] = value
instance.data["label"] += " - writegeo - local"
instance.data["families"] = ["writegeo", "local"]
for node in item:
instance.add(node)
# Adding/Checking publish attribute
if "{0}_local".format(fmt) not in node.knobs():
knob = nuke.Boolean_Knob("{0}_local".format(fmt),
"{0} Local".format(fmt.title()))
knob.setValue(False)
node.addKnob(knob)
value = bool(node["{0}_local".format(fmt)].getValue())
# Compare against selection
selection = instance.context.data.get("selection", [])
if selection:
if list(set(instance) & set(selection)):
value = True
else:
value = False
instance.data["publish"] = value
if fmt == "cache":
def instanceToggled(instance, value):
instance[0]["cache_local"].setValue(value)
instance.data["instanceToggled"] = instanceToggled
if fmt == "camera":
def instanceToggled(instance, value):
instance[0]["camera_local"].setValue(value)
instance.data["instanceToggled"] = instanceToggled
if fmt == "geometry":
def instanceToggled(instance, value):
instance[0]["geometry_local"].setValue(value)
instance.data["instanceToggled"] = instanceToggled
def instanceToggled(instance, value):
# Removing and adding the knob to support NukeAssist, where
# you can't modify the knob value directly.
instance[0].removeKnob(instance[0]["publish"])
knob = nuke.Boolean_Knob("publish", "Publish")
knob.setValue(value)
instance[0].addKnob(knob)
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):
'''
init panel and knobs
'''
nukescripts.PythonPanel.__init__(self, 'breakdown',
'com.ohufx.breakdown')
# CREATE KNOBS
self.home = nuke.PyScript_Knob(
'www.leafpictures.de',
'<img src="%s" width = "450" height = "50">' % imgPath)
self.div = nuke.Text_Knob("", "", "")
self.writeEachStep = nuke.Boolean_Knob('writeEachStep',
'create writes for each step')
self.writeEachStep.setFlag(nuke.STARTLINE)
self.renderPath = nuke.File_Knob('renderTo', '')
self.renderPath.setVisible(False)
self.addToList = nuke.Script_Knob("addToList", "add selection")
self.execute = nuke.Script_Knob("execute", "make breakdown")
self.removeSelected = nuke.Script_Knob("removeUnchecked",
"remove unchecked")
#add knobs
self.addKnob(self.home)
self.addKnob(self.writeEachStep)
self.addKnob(self.renderPath)
self.addKnob(self.addToList)
self.addKnob(self.removeSelected)
self.addKnob(self.execute)
self.addKnob(self.div)
def fps_init():
"""
Sets the frame rate on first launch.
Extracting a "fps" custom attribute on the parent entity of the task.
Adds a "ftrackFPSSet" knob to the root node in Nuke,
which indicates whether to set the FPS on startup.
"""
node = nuke.root()
# Adding/Checking ftrack fps attribute
fps_set = False
if "ftrackFPSSet" in node.knobs():
fps_set = node["ftrackFPSSet"].getValue()
else:
node.addKnob(nuke.Tab_Knob("Ftrack"))
knob = nuke.Boolean_Knob("ftrackFPSSet", "Set FPS on startup.")
node.addKnob(knob)
node["ftrackFPSSet"].setValue(True)
if not fps_set:
session = ftrack_api.Session()
task = session.get("Task", os.environ["FTRACK_TASKID"])
if "fps" in task["parent"]["custom_attributes"]:
fps = task["parent"]["custom_attributes"]["fps"]
msg = "{0}: Setting FPS to {1}."
print msg.format(__file__, fps)
nuke.root()["fps"].setValue(fps)
def plusWrite():
This = nuke.thisNode()
tab = nuke.Tab_Knob('plus', 'plus')
line1 = nuke.Text_Knob("PlusControl", "Plus Control")
OPNbutton = nuke.PyScript_Knob("OPN", "Open Directory")
OPNbutton.setFlag(nuke.STARTLINE)
rfwbutton = nuke.PyScript_Knob("rfw", "Read from write")
rfwbutton.setFlag(nuke.STARTLINE)
linkCheck = nuke.Boolean_Knob("lnk", "Link")
linkCheck.clearFlag(nuke.STARTLINE)
This.addKnob(tab)
This.addKnob(line1)
This.addKnob(OPNbutton)
This.addKnob(rfwbutton)
This.addKnob(linkCheck)
This['OPN'].setCommand('plusOpen()')
def lnkv():
if This['lnk'].value() == False:
This['rfw'].setCommand('PlusRFW()')
else:
This['rfw'].setCommand('PlusRFWLink()')
nuke.addKnobChanged(lnkv, nodeClass="Write")
def write_addKnobs():
node = nuke.thisNode()
# tab
batch = nuke.Tab_Knob("noid", "NOID")
node.addKnob(batch)
# auto
lock = nuke.Boolean_Knob("lock", "Lock Filename")
lock.setFlag(nuke.STARTLINE)
node.addKnob(lock)
# suffix
suffix = nuke.String_Knob("suffix", "Suffix")
suffix.setFlag(nuke.STARTLINE)
node.addKnob(suffix)
node.addKnob(nuke.Text_Knob("", ""))
# batch
batch = nuke.PyScript_Knob("batch", "Batch", "batch.batch()")
batch.setFlag(nuke.STARTLINE)
node.addKnob(batch)
node['file'].setEnabled(False)
node['lock'].setValue(1)
def __init__(self, data):
nukescripts.PythonPanel.__init__(self, 'Submit Shot')
self.gladiator = data.gladiator
self.dialogueText = data.dialogueText
self.validated = data.validated
self.user = c1_user
# filename fragments
self.filepath = data.filepath
self.filename = data.filename
self.showCode = data.showCode
self.shotName = data.shotName
self.fileversion = data.fileversion
# folders
self.versionFolder = data.versionFolder
self.shotFolder = data.shotFolder
self.showFolder = data.showFolder
# knobs
self.emailBool = nuke.Boolean_Knob('emailBool', 'Send Email to VFX')
# self.addKnob(self.emailBool)
self.emailBool.setValue(False)
self.emailMsg = nuke.Multiline_Eval_String_Knob(
'Type your shot notes here(if enabled).', '')
# self.addKnob(self.emailMsg)
self.emailMsg.setEnabled(False)
self.sep = nuke.Text_Knob('', '')
# self.addKnob(self.sep)
self.cancelButton = nuke.PyScript_Knob("Cancel")
self.addKnob(self.dialogueText)
self.button1 = nuke.PyScript_Knob(
"submit", self.shotName + '_v' +
str(self.versionFolder.ver.remote + 1).zfill(3))
self.button2 = nuke.PyScript_Knob(
"submit", self.shotName + '_v' + str(self.fileversion).zfill(3))
def process(self, instance):
node = instance[0]
if "review" not in node.knobs():
knob = nuke.Boolean_Knob("review", "Review")
knob.setValue(True)
node.addKnob(knob)
if not node["review"].value():
return
# Add audio to instance if it exists.
try:
version = pype.api.get_latest_version(
instance.context.data["assetEntity"]["name"], "audioMain")
representation = io.find_one({
"type": "representation",
"parent": version["_id"]
})
instance.data["audio"] = [{
"offset":
0,
"filename":
api.get_representation_path(representation)
}]
except AssertionError:
pass
instance.data["families"].append("review")
instance.data['families'].append('ftrack')
self.log.info("Review collected: `{}`".format(instance))
self.log.debug("__ instance.data: `{}`".format(instance.data))
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 setDotNode(d, node_sel_cam):
d['label'].setValue("\n%s" % (node_sel_cam))
d['note_font'].setValue('bold')
d['note_font_size'].setValue(24)
d['note_font_color'].setValue(color_white)
d['tile_color'].setValue(color_red)
d['hide_input'].setValue(True)
d.setInput(0, nuke.toNode(node_sel_cam))
# Add Show Panel Knob
cmd_ppanel = "n=nuke.thisNode()\ntry:\n\tn.input(0).showControlPanel(forceFloat=n.knob('isFloat').value())\nexcept:\n\tpass"
cmd_orig = "origNode = nuke.thisNode().input(0);\
origXpos = origNode.xpos();\
origYpos = origNode.ypos();\
nuke.zoom(2, [origXpos,origYpos]);\
nuke.thisNode()['selected'].setValue(False);\
origNode['selected'].setValue(True);\
nuke.show(origNode)"
t_tab = nuke.Tab_Knob('t_user', "DotCamConnect")
k_showPanel = nuke.PyScript_Knob('ppanel', "Show Input Property Panel",
cmd_ppanel)
k_float = nuke.Boolean_Knob('isFloat', "Floating Panel", True)
k_showCam = nuke.PyScript_Knob('orig', "Show Camera Node", cmd_orig)
k_float.clearFlag(nuke.STARTLINE)
k_float.setFlag(nuke.STARTLINE)
d.addKnob(t_tab)
d.addKnob(k_showPanel)
d.addKnob(k_float)
d.addKnob(k_showCam)
print "%s -> %s" % (d.name(), node_sel_cam)
def __init__(self):
nukescripts.PythonPanel.__init__(self, 'Spinel Review Submission')
self.cvn_knob = nuke.Multiline_Eval_String_Knob(
'cvn_', 'current version notes', 'For review')
self.addKnob(self.cvn_knob)
self.cc_knob = nuke.Boolean_Knob('cc_', 'CC', True)
self.cc_knob.setFlag(nuke.STARTLINE)
self.addKnob(self.cc_knob)
self.avidqt_knob = nuke.Boolean_Knob('avidqt_', 'Avid QT', True)
self.addKnob(self.avidqt_knob)
self.vfxqt_knob = nuke.Boolean_Knob('vfxqt_', 'VFX QT', False)
self.addKnob(self.vfxqt_knob)
self.exr_knob = nuke.Boolean_Knob('exr_', 'EXR', True)
self.addKnob(self.exr_knob)
self.matte_knob = nuke.Boolean_Knob('matte_', 'Matte', False)
self.addKnob(self.matte_knob)
def process(self, context):
for item in context.data["write_instances"]:
instance = context.create_instance(item.data["name"])
for key, value in item.data.iteritems():
instance.data[key] = value
instance.data["label"] += " - write - local"
instance.data["families"] = ["write", "local"]
for node in item:
instance.add(node)
# Adding/Checking publish attribute
if "process_local" not in node.knobs():
knob = nuke.Boolean_Knob("process_local", "Process Local")
knob.setValue(False)
node.addKnob(knob)
value = bool(node["process_local"].getValue())
# Compare against selection
selection = instance.context.data.get("selection", [])
if selection:
if list(set(instance) & set(selection)):
value = True
else:
value = False
instance.data["publish"] = value
def instanceToggled(instance, value):
instance[0]["process_local"].setValue(value)
instance.data["instanceToggled"] = instanceToggled
def instanceToggled(instance, value):
try:
import nuke
# Removing and adding the knob to support NukeAssist, where
# you can't modify the knob value directly.
if "review" in instance[0].knobs():
instance[0].removeKnob(instance[0]["review"])
knob = nuke.Boolean_Knob("review", "Review")
knob.setValue(value)
instance[0].addKnob(knob)
except ImportError:
pass
try:
if not hasattr(instance[0].getTransform(), "review"):
pymel.core.addAttr(instance[0].getTransform(),
longName="review",
defaultValue=False,
attributeType="bool")
attr = pymel.core.Attribute(
instance[0].getTransform().name() + ".review")
pymel.core.setAttr(attr, channelBox=True)
instance[0].getTransform().review.set(value)
except AttributeError:
pass
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'))
