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'))