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)