def ReplaceFileRootPathUI():
allreadfiles = nuke.selectedNodes('Read')
if len(allreadfiles) == 0:
allreadfiles = nuke.allNodes('Read')
if not len(allreadfiles):
nuke.message('no Read file ')
return
else:
a = nukescripts.PythonPanel('ReplaceFileRootPath')
a.addKnob(nuke.File_Knob('OldRootPath:'))
#a.knobs()['OldRootPath:'].setValue('aa')
a.addKnob(nuke.File_Knob('NewRootPath:'))
reslut = a.showModalDialog()
if reslut:
oldfilepath = a.knobs()['OldRootPath:'].getValue()
newfilepath = a.knobs()['NewRootPath:'].getValue()
if len(oldfilepath) and len(newfilepath):
oldfilepath = invertpath(oldfilepath)
newfilepath = invertpath(newfilepath)
for singleread in allreadfiles:
oldfile = singleread['file'].value()
if oldfilepath in oldfile:
file = oldfile.replace(oldfilepath, newfilepath)
singleread['file'].setValue(file)
else:
nuke.message(
'!!!no something path in OldRootPath:and NewRootPath:!!!')
return
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 __init__(self):
nukescripts.PythonPanel.__init__(self, "error report", "error report")
if nuke.errors_lenErrors == 0:
col = "green"
else:
col = "red"
countErrors = '<span style="color:{col}">{countErr}</span>'.format(
col=col, countErr=nuke.errors_lenErrors)
#create elements
self.errorCount = nuke.Text_Knob('', 'errors found: ',
'%s' % countErrors)
self.div = nuke.Text_Knob("", "", "")
self.errorCount.setFlag(nuke.STARTLINE)
self.outputPath = nuke.File_Knob('output to: ', '')
self.write = nuke.PyScript_Knob('write', 'write')
self.update = nuke.PyScript_Knob('update', 'update')
self.outputPath = nuke.File_Knob('', 'outputPath')
#add elements
self.addKnob(self.errorCount)
self.addKnob(self.outputPath)
self.addKnob(self.write)
self.addKnob(self.update)
self.addKnob(self.div)
#error node knobs
for errorNode in nuke.errors_nodes:
self.en = nuke.PyScript_Knob(errorNode.name(), errorNode.name())
self.addKnob(self.en)
nuke.errors_footageBtn.append(self.en)
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 __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 ReplaceFilePathUI(self):
a = nukescripts.PythonPanel('ReplaceFileRootPath')
a.addKnob(nuke.File_Knob('OldRootPath:'))
a.addKnob(nuke.File_Knob('NewRootPath:'))
reslut = a.showModalDialog()
if reslut:
oldfilepath = a.knobs()['OldRootPath:'].getValue()
newfilepath = a.knobs()['NewRootPath:'].getValue()
if len(oldfilepath) and len(newfilepath):
oldfilepath = self.invertpath(oldfilepath)
newfilepath = self.invertpath(newfilepath)
self.Bulk_Samples_Conversion(oldfilepath,newfilepath)
else:
nuke.message('!!!no something path in OldRootPath:and NewRootPath:!!!')
return
def __init__(self):
super(DailiesSettingPanel, self).__init__('Dailies Setting')
self.file_knob = nuke.File_Knob('source', 'image')
self.source_list = nuke.Multiline_Eval_String_Knob(
'source_list', 'sources')
self.source_list.setEnabled(False)
self.remove_first = nuke.Int_Knob('remove_first', 'remove first line:')
self.remove_last = nuke.Int_Knob('remove_last', 'remove last line:')
self.remove_first.setValue(1)
self.remove_last.setValue(1)
self.remove_last.clearFlag(nuke.STARTLINE)
self.remove_button = nuke.PyScript_Knob('remove', 'remove')
self.message = nuke.Text_Knob('message', '', ' ')
self.create_button = nuke.PyScript_Knob('create', 'create node tree')
self.render_button = nuke.PyScript_Knob('render', 'render dailies')
self.create_button.setFlag(nuke.STARTLINE)
self.addKnob(self.file_knob)
self.addKnob(self.source_list)
self.addKnob(self.remove_first)
self.addKnob(self.remove_last)
self.addKnob(self.remove_button)
self.addKnob(self.create_button)
self.addKnob(self.render_button)
self.addKnob(self.message)
self.sources = {}
self.render_infos = {}
self.control_funcs = {}
self.bypass_callback = False
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):
'''
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 nukeSetup():
'''
Set up Nuke knobs to keep track of the settings file.
Aborts and returns False if Nuke script hasn't been saved.
'''
import nuke
try:
root = nuke.root()
rootKnobs = root.knobs()
rootName = root.name()
except ValueError as e:
if str(e) == 'A PythonObject is not attached to a node':
raise NukeError
# we should never get this far so let's raise an error in case we do
raise e
if 'To Do List' not in rootKnobs:
scriptPath = rootName
if scriptPath == 'Root':
return False
logger.info('adding user knobs in script settings')
tab = nuke.Tab_Knob('To Do List')
settingsKnob = nuke.File_Knob('todoSettingsFile', 'Settings file')
root.addKnob(tab)
root.addKnob(settingsKnob)
settingsKnob.setValue(settingsPathFromProject(scriptPath))
return True
else:
return True
def importImagesPanel():
n = nuke.createNode("PanelNode")
k1 = nuke.File_Knob("dirPath", "Path")
k2 = nuke.PyScript_Knob(
"importImages", "importImages",
"importImages(nuke.thisNode()['dirPath'].value())")
n.addKnob(k1)
n.addKnob(k2)
def L_newProject():
p = nuke.Panel('KLXR NEW PROJECT')
p.addSingleLineInput('Root', 'K:/_VFX/')
p.addSingleLineInput('Project', 'L')
p.addSingleLineInput('Shot', 'sh0100')
p.addSingleLineInput('Task', 'comp')
p.show()
proot = p.value('Root')
pproject = p.value('Project')
pshot = p.value('Shot')
ptask = p.value('Task')
if proot == '':
nuke.message('No Root')
return
if pproject == '':
nuke.message('No Project')
return
if pshot == '':
nuke.message('No Shot')
return
if ptask == '':
nuke.message('No Task')
return
pfolder = proot + pproject + '/' + pshot + '/'
pscripts = pfolder + 'scripts/'
pscriptname = pscripts + pproject + '_' + pshot + '_' + ptask + '_v001.nk'
if not os.path.isdir(pscripts):
os.makedirs(pscripts)
nuke.scriptSaveAs(pscriptname)
write = nuke.createNode('Write', inpanel=False)
pnode = nuke.nodes.NoOp(name="L_PROJECT")
pnode.setXpos(write.xpos() + 300)
pnode.setYpos(write.ypos() + 200)
k = nuke.File_Knob("proot", "Root")
k.setValue(proot)
pnode.addKnob(k)
k = nuke.String_Knob("pproject", "Project")
k.setValue(pproject)
pnode.addKnob(k)
k = nuke.String_Knob("pshot", "Shot")
k.setValue(pshot)
pnode.addKnob(k)
k = nuke.String_Knob("ptask", "Task")
k.setValue(ptask)
pnode.addKnob(k)
def updatePreferences():
'''
Check whether the hotbox was updated since the last launch. If so refresh the preferences.
'''
allKnobs = preferencesNode.knobs().keys()
#Older versions of the hotbox had a knob called 'iconLocation'.
#This was a mistake and the knob was supposed to be called
#'hotboxIconLocation', similar to the rest of the knobs.
forceUpdate = False
if 'iconLocation' in allKnobs and 'hotboxIconLocation' not in allKnobs:
currentSetting = preferencesNode.knob('iconLocation').value()
#delete 'iconLocation'
preferencesNode.removeKnob(preferencesNode.knob('iconLocation'))
#re-add 'hotboxIconLocation'
iconLocationKnob = nuke.File_Knob('hotboxIconLocation','Icons location')
iconLocationKnob.setValue(currentSetting)
addToPreferences(iconLocationKnob)
forceUpdate = True
allKnobs = preferencesNode.knobs().keys()
proceedUpdate = True
if 'hotboxVersion' in allKnobs or forceUpdate:
if not forceUpdate:
try:
if float(version) == float(preferencesNode.knob('hotboxVersion').value()):
proceedUpdate = False
except:
proceedUpdate = True
if proceedUpdate:
currentSettings = {knob:preferencesNode.knob(knob).value() for knob in allKnobs if knob.startswith('hotbox') and knob != 'hotboxVersion'}
#delete all the preferences
deletePreferences()
#re-add all the knobs
addPreferences()
#Restore
for knob in currentSettings.keys():
try:
preferencesNode.knob(knob).setValue(currentSettings[knob])
except:
pass
#save to file
savePreferencesToFile()
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):
PythonPanel.__init__(self, 'C1 Preferences')
# C1 Preferences
self.email = None
self.localDir = None
self.projectDir = None
# custom regex definitions for validation engine
self.regex = {}
self.projectStructure = {'root': {}}
self.scriptDir = {
'root':
os.path.join(os.path.join(os.path.realpath(__file__), os.pardir),
os.pardir),
'c1_tools':
os.path.join(os.path.realpath(__file__), os.pardir)
}
# define knobs
self.inp_email = nuke.String_Knob('email', 'C1 Initials: ')
self.inp_localDir = nuke.String_Knob('localDir',
'Local Working Directory: ')
self.btn_localDir = nuke.PyScript_Knob("Set Working Dir")
self.loginButton = nuke.PyScript_Knob("Login")
self.cancelButton = nuke.PyScript_Knob("Cancel")
# Project Map Tab
self.projectMapTab = nuke.Tab_Knob("Project Map")
self.setProjectButton = nuke.File_Knob('projectDir',
'Project Location')
self.inp_projectLocation = nuke.String_Knob(
'projectDir',
'<b><font size="3" color="red">Remote Project Directory</font></b>'
)
self.inp_projectName = nuke.String_Knob('projectName', 'Project Name')
self.inp_projectNum = nuke.Int_Knob('projectNum')
# self.inp_projectNum.clearFlag( nuke.STARTLINE )
self.inp_projectCode = nuke.String_Knob('projectCode', 'Project Code')
self.inp_projectCode.clearFlag(nuke.STARTLINE)
# add knobs
self.addKnob(self.inp_localDir)
self.addKnob(self.btn_localDir)
self.addKnob(self.inp_email)
self.addKnob(self.loginButton)
self.addKnob(self.cancelButton)
# Project Map Tab
self.addKnob(self.projectMapTab)
self.addKnob(self.setProjectButton)
self.addKnob(self.inp_projectName)
self.addKnob(self.inp_projectNum)
self.addKnob(self.inp_projectCode)
# retrieve previous login from login.txt
self.retrieveLogin()
return
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 __init__(self):
'''
RV Preferences UI
'''
self._constructing = True
nukescripts.PythonPanel.__init__(
self, "Rv Preferences", "com.tweaksoftware.RvPreferencesPanel")
self.rvPrefs = RvPreferences()
self.rvExecPath = nuke.File_Knob("rvExecPath", "RV Executable Path")
self.rvExecPath.setTooltip("Path to RV executable.")
self.rvExecPath.setValue(self.rvPrefs.prefs["rvExecPath"])
self.addKnob(self.rvExecPath)
self.extraArgs = nuke.String_Knob('extraArgs',
'Default Command Line Args')
self.extraArgs.setTooltip(
"Additional arguments to be added to the command line when RV is run."
)
self.extraArgs.setValue(self.rvPrefs.prefs["extraArgs"])
self.addKnob(self.extraArgs)
self.sessionDirBase = nuke.File_Knob("sessionDirBase",
"Default Session Dir Base")
self.sessionDirBase.setTooltip(
"Path to base directory from which to form sessionDirectories. $NUKE_TEMP_DIR will be used if this is not set."
)
self.sessionDirBase.setValue(self.rvPrefs.prefs["sessionDirBase"])
self.addKnob(self.sessionDirBase)
# self.knobs()['OK'].setLabel('Save')
log("knobs %s" % self.knobs())
self._constructing = False
self.show()
def __init__(self, dialogState, groupContext, node):
# init super
FlipbookDialog.__init__(self, dialogState, groupContext, node, True)
self._bgRender.setVisible(False)
self._useProxy.setVisible(False)
self._continueOnError.setVisible(False)
self._viewerForSettings.setVisible(False)
self._defaultValues.setVisible(False)
self._useRoi.setVisible(False)
self._roi.setVisible(False)
self._channels.setVisible(False)
self._luts.setVisible(False)
self._audioSource.setVisible(False)
self._burnInLUT.setVisible(False)
try:
## this may not exist, just ignore if not present
self._viewSelection.setVisible(False)
except:
pass
customWriteActive = node['file'].getValue(
) != self._getIntermediatePath() and node['file'].getValue() != ''
self._customWrite = nuke.Boolean_Knob('custom', 'Customise write path')
self._customWrite.setValue(customWriteActive)
self.addKnob(self._customWrite)
self._noFlipbook = nuke.Boolean_Knob('write', 'No flipbook')
self._noFlipbook.setFlag(nuke.STARTLINE)
self._noFlipbook.setVisible(customWriteActive)
self._noFlipbook.setValue(self._state.get(self._noFlipbook, False))
self.addKnob(self._noFlipbook)
self._file = nuke.File_Knob('file', 'Write path')
defaultPath = self._node['file'].value()
if defaultPath == self._getIntermediatePath():
defaultPath = ''
self._file.setValue(self._state.get(self._file, defaultPath))
self._file.setVisible(customWriteActive)
self.addKnob(self._file)
def __init__(self):
'''
init values
'''
enableBackup = blackboxHelper.getBackupSettings(
"@enableBackup", backupSettings)
backupPath = blackboxHelper.getBackupSettings("@backupPath",
backupSettings)
operation = blackboxHelper.getBackupSettings("@operation",
backupSettings)
numberOfBackups = int(
blackboxHelper.getBackupSettings("@numberOfBackups",
backupSettings))
if enableBackup == "1.0":
enableBackup = True
else:
enableBackup = False
nukescripts.PythonPanel.__init__(self, "Blackbox Settings",
"Blackbox Settings")
self.setMinimumSize(450, 160)
self.enableBackup = nuke.Boolean_Knob("enableBackup", "enable backup",
enableBackup)
self.backupDirOp = nuke.Enumeration_Knob("operation", "operation", [
"backup directory on global place", "backup directory per script"
])
self.backupDirOp.setValue(str(operation))
self.backupDirOp.resize(300, 30)
self.backupPath = nuke.File_Knob('backupPath', 'backupPath')
self.backupPath.setValue(backupPath)
if operation == "0.0":
self.backupPath.setVisible(True)
else:
self.backupPath.setVisible(False)
self.numberOfBackups = nuke.String_Knob('numberOfBackups',
'number of backups')
self.numberOfBackups.setValue(str(numberOfBackups))
self.addKnob(self.enableBackup)
self.addKnob(self.backupDirOp)
self.addKnob(self.backupPath)
self.addKnob(self.numberOfBackups)
def FromNuke2MayaExporter():
allSelectedNodes = nuke.selectedNodes()
firstFrame = nuke.root().knob('first_frame').getValue()
lastFrame = nuke.root().knob('last_frame').getValue()
if len(allSelectedNodes) == 1:
selectedNode = allSelectedNodes[0]
selectedNodeType = selectedNode.Class()
channelMatch = {'transform.tx':'translate:0', 'transform.ty':'translate:1', 'transform.tz':'translate:2', 'transform.rx':'rotate:0', 'transform.ry':'rotate:1', 'transform.rz':'rotate:2', 'transform.sx':'scaling:0', 'transform.sy':'scaling:1', 'transform.sz':'scaling:2', 'transform.rotateOrder':'rot_order', 'camera.fl':'focal', 'camera.horizontalFilmAperture':'haperture', 'camera.verticalFilmAperture':'vaperture'}
objectTypeOk = ['Camera', 'Camera2']
cameraName = selectedNode.name()
if selectedNodeType in objectTypeOk:
exportPath = os.environ["HOME"].replace('\\', '/') + '/Desktop/'
a = nukescripts.PythonPanel('File to Export')
a.addKnob(nuke.Int_Knob('Start-Frame:'))
a.knobs()['Start-Frame:'].setValue(int(firstFrame))
a.addKnob(nuke.Int_Knob('End-Frame:'))
a.knobs()['End-Frame:'].setValue(int(lastFrame))
a.addKnob(nuke.File_Knob('Export-File:'))
a.knobs()['Export-File:'].setValue(exportPath+cameraName + '.fm2n')
finishedDialog = a.showModalDialog()
startFrame = int(a.knobs()['Start-Frame:'].getValue())
lastFrame = int(a.knobs()['End-Frame:'].getValue())
filename = a.knobs()['Export-File:'].getValue()
filename = filename.replace('\\', '/')
filenameParts = filename.split('.')
if filenameParts[len(filenameParts)-1] != 'fm2n':
filename = filename + ".fm2n"
exportData(selectedNode, channelMatch, firstFrame, lastFrame, filename)
else:
nuke.message("ERROR: The Node you have selected is not a Camera.")
else:
nuke.message("ERROR: You have more then one Node selected")
def KuWrite():
'''Adding inputs for auto generate output path'''
RENDER_TYPE = ['comp', 'precomp', 'lookdev']
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_projDir = nuke.File_Knob('fp_proj', 'proj dir')
k_scene = nuke.String_Knob(
'tx_scene', 'scene',
os.path.basename(nuke.scriptName()).split('_v')[0])
k_type = nuke.Enumeration_Knob('mu_type', 'type', RENDER_TYPE)
k_precomp = nuke.String_Knob('tx_precomp', '_', 'NewPass')
k_ver = nuke.Int_Knob('nm_ver', 'version', 1)
k_div = nuke.Text_Knob('divider', '')
k_set = nuke.PyScript_Knob('bt_set', '<b>Set Write</b>',
'mod_KuWrite.set_settings(nuke.thisNode())')
k_render = nuke.PyScript_Knob('bt_render', '<b>Render</b>',
'mod_KuWrite.render_node(nuke.thisNode())')
path_proj = os.path.dirname(os.path.dirname(nuke.script_directory()))
k_projDir.setValue(path_proj)
k_precomp.clearFlag(nuke.STARTLINE)
k_precomp.setVisible(False)
k_ver.setValue(1)
k_render.clearFlag(nuke.STARTLINE)
k_pipeline.setVisible(False)
for k in [
k_tab, k_pipeline, k_projDir, k_scene, k_type, k_precomp, k_ver,
k_div, k_set, k_render
]:
node.addKnob(k)
set_settings(node)
def interface(self):
# set up the new script name
scriptName = os.path.basename(nuke.value('root.name'))
date = datetime.date.today()
formattedDate = '%s%02d%02d' % (date.year, int(date.month), int(date.day))
archivePath = 'z:/job/after_earth/prod/io/archive/%s/%s/' % (formattedDate, scriptName.replace('.nk',''))
self.panel = nukescripts.PythonPanel('Archive script 1.01')
self.file = nuke.File_Knob('Output','Output folder:')
self.file.setValue(archivePath)
self.panel.addKnob(self.file)
self.scriptName = nuke.String_Knob('name','Script name:',scriptName)
self.panel.addKnob(self.scriptName)
self.log = nuke.Boolean_Knob('log','Generate log:',True)
self.panel.addKnob(self.log)
self.comment = nuke.Multiline_Eval_String_Knob('comment','Comments:')
self.panel.addKnob(self.comment)
result = self.panel.showModalDialog()
self.scriptInfo = nukescripts.get_script_data()
if result:
self.convertGizmosToGroups()
self.action()
def __init__(self):
nukescripts.PythonPanel.__init__(self, 'Create Shot Directories')
num = 1
self.jobKnobName = nuke.Text_Knob('folder to create shots')
self.jobKnob = nuke.File_Knob('jobdrive', '')
self.create1 = nuke.PyScript_Knob('create', 'Create')
self.cancel1 = nuke.PyScript_Knob('cancel', 'Cancel')
self.addKnob(self.jobKnobName)
self.addKnob(self.jobKnob)
while num <= self.numshots:
shotNameKnobs.append(num)
shotPathKnobs.append(num)
shotNameKnobs[num] = nuke.String_Knob('shot'+str(num)+'name', 'shot name', 'Shot '+str(num))
shotPathKnobs[num] = nuke.Text_Knob('shot'+str(num)+'path', 'shot path', self.jobKnob.value()+shotNameKnobs[num].value()+'/')
self.addKnob(shotNameKnobs[num])
self.addKnob(shotPathKnobs[num])
num = num+1
self.addKnob(self.create1)
self.addKnob(self.cancel1)
def __init__(self, n):
nukescripts.PythonPanel.__init__(self, 'Auto Write Path')
self.setMinimumSize(550, 160)
self.rootname = n #n is current nuke script saving path
self.projectKnob = nuke.String_Knob('proj', 'Project:')
self.sequenceKnob = nuke.String_Knob('seq', 'Sequence:')
self.sequenceKnob.clearFlag(nuke.STARTLINE)
self.shotKnob = nuke.String_Knob('shot', 'Shot:')
self.shotKnob.clearFlag(nuke.STARTLINE)
self.taskKnob = nuke.String_Knob('task', 'Task Type:')
self.versionKnob = nuke.String_Knob('version', 'Version:')
self.versionKnob.clearFlag(nuke.STARTLINE)
self.formatKnob = nuke.Enumeration_Knob('format', 'File Type:',
['exr', 'jpg', 'mov'])
self.formatKnob.clearFlag(nuke.STARTLINE)
self.nameKnob = nuke.String_Knob('name', 'File Name:')
self.pathKnob = nuke.File_Knob('path', 'Write Path:')
self.formatKnob.setValue('exr')
self.addKnob(self.projectKnob)
self.addKnob(self.sequenceKnob)
self.addKnob(self.shotKnob)
self.addKnob(self.taskKnob)
self.addKnob(self.versionKnob)
self.addKnob(self.formatKnob)
self.addKnob(self.nameKnob)
self.addKnob(self.pathKnob)
self.projectKnob.setEnabled(False)
self.sequenceKnob.setEnabled(False)
self.shotKnob.setEnabled(False)
self.taskKnob.setEnabled(False)
self.versionKnob.setEnabled(False)
self.info = {}
self.parseParameters()
if self.match:
self.knobChanged(self.formatKnob)
def __init__(self, root_path):
super(AutoWritePath, self).__init__()
self.root_path = root_path
self.setMinimumSize(550, 160)
self.show_knob = nuke.String_Knob('show', 'Show:')
self.episode_knob = nuke.String_Knob('episode', 'Episode:')
self.episode_knob.clearFlag(nuke.STARTLINE)
self.sequence_knob = nuke.String_Knob('seq', 'Sequence:')
self.sequence_knob.clearFlag(nuke.STARTLINE)
self.shot_knob = nuke.String_Knob('shot', 'Shot:')
self.shot_knob.clearFlag(nuke.STARTLINE)
self.step_knob = nuke.String_Knob('step', 'Step:')
self.task_knob = nuke.Enumeration_Knob('task', 'Task:', [])
self.task_knob.clearFlag(nuke.STARTLINE)
self.version_knob = nuke.Enumeration_Knob('version', 'Version', [])
self.version_knob.clearFlag(nuke.STARTLINE)
self.format_knob = nuke.Enumeration_Knob(
'format', 'File Type:', ['exr', 'dpx', 'jpg', 'tiff', 'mov'])
self.format_knob.clearFlag(nuke.STARTLINE)
self.name_knob = nuke.String_Knob('name', 'File Name:')
self.path_knob = nuke.File_Knob('path', 'Write Path:')
self.addKnob(self.show_knob)
self.addKnob(self.episode_knob)
self.addKnob(self.sequence_knob)
self.addKnob(self.shot_knob)
self.addKnob(self.step_knob)
self.addKnob(self.task_knob)
self.addKnob(self.version_knob)
self.addKnob(self.format_knob)
self.addKnob(self.name_knob)
self.addKnob(self.path_knob)
self.episode_knob.setVisible(False)
self.path_pattern = None
self.write_path_pattern = None
self.task_names = {}
def addPreferences():
'''
Add knobs to the preferences needed for this module to work properly.
'''
homeFolder = os.getenv('HOME').replace('\\','/') + '/.nuke'
addToPreferences(nuke.Tab_Knob('hotboxLabel','W_hotbox'))
addToPreferences(nuke.Text_Knob('hotboxGeneralLabel','<b>General</b>'))
#version knob to check whether the hotbox was updated
versionKnob = nuke.String_Knob('hotboxVersion','version')
versionKnob.setValue(version)
addToPreferences(versionKnob)
preferencesNode.knob('hotboxVersion').setVisible(False)
#location knob
locationKnob = nuke.File_Knob('hotboxLocation','Hotbox location')
tooltip = "The folder on disk the Hotbox uses to store the Hotbox buttons. Make sure this path links to the folder containing the 'All','Single' and 'Multiple' folders."
locationKnobAdded = addToPreferences(locationKnob, tooltip)
if locationKnobAdded != None:
locationKnob.setValue(homeFolder + '/W_hotbox')
#icons knob
iconLocationKnob = nuke.File_Knob('hotboxIconLocation','Icons location')
iconLocationKnob.setValue(homeFolder +'/icons/W_hotbox')
tooltip = "The folder on disk the where the Hotbox related icons are stored. Make sure this path links to the folder containing the PNG files."
addToPreferences(iconLocationKnob, tooltip)
#open manager button
openManagerKnob = nuke.PyScript_Knob('hotboxOpenManager','open hotbox manager','W_hotboxManager.showHotboxManager()')
openManagerKnob.setFlag(nuke.STARTLINE)
tooltip = "Open the Hotbox Manager."
addToPreferences(openManagerKnob, tooltip)
#open in file system button knob
openFolderKnob = nuke.PyScript_Knob('hotboxOpenFolder','open hotbox folder','W_hotbox.revealInBrowser(True)')
tooltip = "Open the folder containing the files that store the Hotbox buttons. It's advised not to mess around in this folder unless you understand what you're doing."
addToPreferences(openFolderKnob, tooltip)
#delete preferences button knob
deletePreferencesKnob = nuke.PyScript_Knob('hotboxDeletePreferences','delete preferences','W_hotbox.deletePreferences()')
tooltip = "Delete all the Hotbox related knobs from the Preferences Panel. After clicking this button the Preferences Panel should be closed by clicking the 'cancel' button."
addToPreferences(deletePreferencesKnob, tooltip)
#Launch Label knob
addToPreferences(nuke.Text_Knob('hotboxLaunchLabel','<b>Launch</b>'))
#shortcut knob
shortcutKnob = nuke.String_Knob('hotboxShortcut','Shortcut')
shortcutKnob.setValue('`')
tooltip = "The key that triggers the Hotbox. Should be set to a single key without any modifier keys. Spacebar can be defined as 'space'. A restart is required in order for the changes to take effect."
addToPreferences(shortcutKnob, tooltip)
global shortcut
shortcut = preferencesNode.knob('hotboxShortcut').value()
#trigger mode knob
triggerDropdownKnob = nuke.Enumeration_Knob('hotboxTriggerDropdown', 'Launch mode',['Press and Hold','Single Tap'])
tooltip = "The way the hotbox is launched. When set to 'Press and Hold' the Hotbox will appear whenever the shortcut is pressed and disappear as soon as the user releases the key. When set to 'Single Tap' the shortcut will toggle the Hotbox on and off."
addToPreferences(triggerDropdownKnob, tooltip)
#close on click
closeAfterClickKnob = nuke.Boolean_Knob('hotboxCloseOnClick','Close on button click')
closeAfterClickKnob.setValue(False)
closeAfterClickKnob.clearFlag(nuke.STARTLINE)
tooltip = "Close the Hotbox whenever a button is clicked (excluding submenus obviously). This option will only take effect when the launch mode is set to 'Single Tap'."
addToPreferences(closeAfterClickKnob, tooltip)
#Appearence knob
addToPreferences(nuke.Text_Knob('hotboxAppearanceLabel','<b>Appearance</b>'))
#color dropdown knob
colorDropdownKnob = nuke.Enumeration_Knob('hotboxColorDropdown', 'Color scheme',['Maya','Nuke','Custom'])
tooltip = "The color of the buttons when selected. Options are 'Maya' (Autodesk Maya's muted blue), 'Nuke' (Nuke's bright orange) or 'Custom' (which lets the user pick a color)."
addToPreferences(colorDropdownKnob, tooltip)
#custom color knob
colorCustomKnob = nuke.ColorChip_Knob('hotboxColorCustom','')
colorCustomKnob.clearFlag(nuke.STARTLINE)
tooltip = "The color of the buttons when selected, when the color dropdown is set to 'Custom'."
addToPreferences(colorCustomKnob, tooltip)
#hotbox center knob
colorHotboxCenterKnob = nuke.Boolean_Knob('hotboxColorCenter','Colorize hotbox center')
colorHotboxCenterKnob.setValue(True)
colorHotboxCenterKnob.clearFlag(nuke.STARTLINE)
tooltip = "Color the center button of the hotbox depending on the current selection. When unticked the center button will be coloured a lighter tone of grey."
addToPreferences(colorHotboxCenterKnob, tooltip)
#fontsize knob
fontSizeKnob = nuke.Int_Knob('hotboxFontSize','Font size')
fontSizeKnob.setValue(9)
tooltip = "The font size of the text that appears in the hotbox buttons, unless defined differently on a per-button level."
addToPreferences(fontSizeKnob, tooltip)
#transparency knob
opaqueKnob = nuke.Boolean_Knob('hotboxOpaqueBackground', 'Disable transparancy')
opaqueKnob.setValue(False)
opaqueKnob.setFlag(nuke.STARTLINE)
tooltip = "This option was introduced because the Hotbox might have some trouble displaying correctly on Linux running a KDE environment.\n\nIt's recommanded to fix this problem by changing the KDE system settings. Alternatively the transparency can be disabled completely. This option is also available on Windows and Mac OSX."
addToPreferences(opaqueKnob, tooltip)
#Check if the compositing manager is running. If thats not the case, disable the transparancy.
if not preferencesNode.knob('hotboxOpaqueBackground').value():
try:
if not QtGui.QX11Info.isCompositingManagerRunning():
preferencesNode.knob('hotBoxOpaqueBackground').setValue(True)
except:
pass
addToPreferences(nuke.Text_Knob('hotboxItemsLabel','<b>Items per Row</b>'))
#row amount selection knob
rowAmountSelectionKnob = nuke.Int_Knob('hotboxRowAmountSelection', 'Selection specific')
rowAmountSelectionKnob.setValue(3)
tooltip = "The maximum amount of buttons a row in the upper half of the Hotbox can contain. When the row's maximum capacity is reached a new row will be started. This new row's maximum capacity will be incremented by the step size."
addToPreferences(rowAmountSelectionKnob, tooltip)
#row amount all knob
rowAmountSelectionAll = nuke.Int_Knob('hotboxRowAmountAll','All')
rowAmountSelectionAll.setValue(3)
tooltip = "The maximum amount of buttons a row in the lower half of the Hotbox can contain. When the row's maximum capacity is reached a new row will be started.This new row's maximum capacity will be incremented by the step size."
addToPreferences(rowAmountSelectionAll, tooltip)
#stepsize knob
stepSizeKnob = nuke.Int_Knob('hotboxRowStepSize','Step size')
stepSizeKnob.setValue(1)
tooltip = "The amount a buttons every new row's maximum capacity will be increased by. Having a number unequal to zero will result in a triangular shape when having multiple rows of buttons."
addToPreferences(stepSizeKnob, tooltip)
#spawnmode knob
spawnModeKnob = nuke.Boolean_Knob('hotboxButtonSpawnMode','Add new buttons to the sides')
spawnModeKnob.setValue(True)
spawnModeKnob.setFlag(nuke.STARTLINE)
tooltip = "Add new buttons left and right of the row alternately, instead of to the right, in order to preserve muscle memory."
addToPreferences(spawnModeKnob, tooltip)
#hide the iconLocation knob if environment varible called 'W_HOTBOX_HIDE_ICON_LOC' is set to 'true' or '1'
preferencesNode.knob('hotboxIconLocation').setVisible(True)
if 'W_HOTBOX_HIDE_ICON_LOC' in os.environ.keys():
if os.environ['W_HOTBOX_HIDE_ICON_LOC'].lower() in ['true','1']:
preferencesNode.knob('hotboxIconLocation').setVisible(False)
savePreferencesToFile()
def rebuildSettingsKnobs(self, r):
log("rebuilding settings knobs")
#
# Delete all rv settings knobs
#
knobList = ["rvSettings_" + k for k in self.settings.keys()]
knobList += [
"rvSettings_syncOptionsStart", "rvSettings_syncOptionsEnd",
"rvSettings_RVstart"
]
for k in knobList:
try:
r.removeKnob(r.knob(k))
except:
pass
#
# Add rv settings knobs
#
r.addKnob(nuke.Tab_Knob("rvSettings_RVstart", "RV"))
#r.addKnob(nuke.Tab_Knob ("rvSettings_RVstart", "RV", nuke.TABBEGINGROUP))
n = "rvSettings_"
k = nuke.File_Knob(n + "sessionDir", "Session Directory")
k.setTooltip(
"Root directory of RV session data. Should be unique to this Nuke script"
)
k.setValue(self.settings["sessionDir"])
r.addKnob(k)
k = nuke.Enumeration_Knob(n + "outputFileFormat", "Render File Format",
["rgb", "exr", "dpx", "jpg"])
k.setTooltip("File format for renders, usual 'rgb' or 'exr'.")
k.setValue(self.settings["outputFileFormat"])
r.addKnob(k)
#r.addKnob (nuke.BeginTabGroup_Knob ("rvSettings_syncOptionsBegin", "Sync Options"))
r.addKnob(
nuke.Tab_Knob("rvSettings_syncOptionsStart", "Sync Options",
nuke.TABBEGINGROUP))
k = nuke.Boolean_Knob(n + "syncSelection",
"Nuke Node Selection -> RV Current View")
k.setTooltip("Sync RV current view to Nuke node selection.")
k.setValue(self.settings["syncSelection"])
k.setFlag(nuke.STARTLINE)
r.addKnob(k)
k = nuke.Boolean_Knob(n + "syncFrameChange",
"Nuke Frame -> RV Frame")
k.setTooltip("Sync RV frame to Nuke's frame.")
k.setValue(self.settings["syncFrameChange"])
k.setFlag(nuke.STARTLINE)
r.addKnob(k)
k = nuke.Boolean_Knob(n + "syncReadChanges",
"Nuke Read/Write Node Changes -> RV Sources")
k.setTooltip(
"Sync creation/deletion/modification of Read and Write nodes to corresponding sources in RV."
)
k.setValue(self.settings["syncReadChanges"])
k.setFlag(nuke.STARTLINE)
r.addKnob(k)
r.addKnob(
nuke.Tab_Knob("rvSettings_syncOptionsEnd", "Sync Options",
nuke.TABENDGROUP))
def addPreferences():
'''
Add knobs to the preferences needed for this module to work properly.
'''
homeFolder = os.getenv('HOME').replace('\\', '/') + '/.nuke'
addToPreferences(nuke.Tab_Knob('hotboxLabel', 'W_hotbox'))
addToPreferences(nuke.Text_Knob('hotboxGeneralLabel', '<b>General</b>'))
locationKnob = nuke.File_Knob('hotboxLocation', 'Hotbox location')
locationKnobAdded = addToPreferences(locationKnob)
if locationKnobAdded != None:
location = homeFolder + '/W_hotbox'
for i in ['', 'All', 'Single', 'Multiple', 'Single/No Selection']:
try:
os.mkdir(location + '/' + i)
except:
pass
locationKnob.setValue(location)
iconLocationKnob = nuke.File_Knob('iconLocation', 'Icons location')
iconLocationKnob.setValue(homeFolder + '/icons/W_hotbox')
addToPreferences(iconLocationKnob)
shortcutKnob = nuke.String_Knob('hotboxShortcut', 'shortcut')
shortcutKnob.setValue('`')
addToPreferences(shortcutKnob)
global shortcut
shortcut = preferencesNode.knob('hotboxShortcut').value()
opaqueKnob = nuke.Boolean_Knob('hotboxOpaqueBackground',
'Disable transparancy')
opaqueKnob.setValue(False)
opaqueKnob.setFlag(nuke.STARTLINE)
addToPreferences(opaqueKnob)
openManagerKnob = nuke.PyScript_Knob(
'hotboxOpenManager', 'open hotbox manager',
'W_hotboxManager.showHotboxManager()')
openManagerKnob.setFlag(nuke.STARTLINE)
addToPreferences(openManagerKnob)
openFolderKnob = nuke.PyScript_Knob('hotboxOpenFolder',
'open hotbox folder',
'W_hotbox.revealInBrowser(True)')
addToPreferences(openFolderKnob)
deletePreferencesKnob = nuke.PyScript_Knob('hotboxDeletePreferences',
'delete preferences',
'W_hotbox.deletePreferences()')
addToPreferences(deletePreferencesKnob)
addToPreferences(
nuke.Text_Knob('hotboxAppearanceLabel', '<b>Appearance</b>'))
colorDropdownKnob = nuke.Enumeration_Knob('hotboxColorDropdown',
'Color scheme',
['Maya', 'Nuke', 'Custom'])
addToPreferences(colorDropdownKnob)
colorCustomKnob = nuke.ColorChip_Knob('hotboxColorCustom', '')
colorCustomKnob.clearFlag(nuke.STARTLINE)
addToPreferences(colorCustomKnob)
colorHotboxCenterKnob = nuke.Boolean_Knob('hotboxColorCenter',
'Colorize hotbox center')
colorHotboxCenterKnob.setValue(True)
colorHotboxCenterKnob.clearFlag(nuke.STARTLINE)
addToPreferences(colorHotboxCenterKnob)
addToPreferences(nuke.Text_Knob('hotboxItemsLabel',
'<b>Items per Row</b>'))
rowAmountSelectionKnob = nuke.Int_Knob('hotboxRowAmountSelection',
'Selection specific')
rowAmountSelectionAll = nuke.Int_Knob('hotboxRowAmountAll', 'All')
for knob in [rowAmountSelectionKnob, rowAmountSelectionAll]:
knob.setValue(3)
addToPreferences(knob)
stepSizeKnob = nuke.Int_Knob('hotboxRowStepSize', 'Step size')
stepSizeKnob.setValue(1)
addToPreferences(stepSizeKnob)
spawnModeKnob = nuke.Boolean_Knob('hotboxButtonSpawnMode',
'Add new buttons to the sides')
spawnModeKnob.setValue(True)
spawnModeKnob.setFlag(nuke.STARTLINE)
addToPreferences(spawnModeKnob)
#Check if the compositing manager is running. If thats not the case, disable the transparancy.
if not preferencesNode.knob('hotboxOpaqueBackground').value():
try:
if not QtGui.QX11Info.isCompositingManagerRunning():
preferencesNode.knob('hotBoxOpaqueBackground').setValue(True)
except:
pass
def autoFillWrite():
dir, name, show, scene, shot, version, valid, format = getFileInfos()
# standard values for creation
numberformat = "%04d"
extension = "sgi"
if valid:
selection = nuke.selectedNodes('Write')
for node in selection:
try:
try:
# try to set standard values
node['show'].setValue(show)
node['applyShow'].setValue("Filename")
node['scene'].setValue(scene)
node['applyScene'].setValue("Filename")
node['shot'].setValue(shot)
node['applyShot'].setValue("Filename")
node['custom'].setValue("")
node['applyCustom'].setValue("None")
node['path'].setValue(dir)
node['number'].setValue(numberformat)
node['file_type'].setValue(extension)
# node is no autoFillWrite yet, so create user knobs
except:
# show
user_show = nuke.String_Knob("show", "show: ", show)
node.addKnob(user_show)
node['show'].setFlag(nuke.STARTLINE)
if not format == "short":
user_applyShow = nuke.Enumeration_Knob(
'applyShow', '',
['None', 'Folder', 'Filename', 'Both'])
node.addKnob(user_applyShow)
node['applyShow'].clearFlag(nuke.STARTLINE)
node['applyShow'].setValue("Filename")
else:
node['show'].setFlag(nuke.INVISIBLE)
# scene
user_scene = nuke.String_Knob("scene", "scene: ", scene)
node.addKnob(user_scene)
node['scene'].setFlag(nuke.STARTLINE)
if format == "long":
user_applyScene = nuke.Enumeration_Knob(
'applyScene', '',
['None', 'Folder', 'Filename', 'Both'])
node.addKnob(user_applyScene)
node['applyScene'].clearFlag(nuke.STARTLINE)
node['applyScene'].setValue("Filename")
else:
node['scene'].setFlag(nuke.INVISIBLE)
# shot
user_shot = nuke.String_Knob("shot", "shot: ", shot)
node.addKnob(user_shot)
node['shot'].setFlag(nuke.STARTLINE)
user_applyShot = nuke.Enumeration_Knob(
'applyShot', '',
['None', 'Folder', 'Filename', 'Both'])
node.addKnob(user_applyShot)
node['applyShot'].clearFlag(nuke.STARTLINE)
node['applyShot'].setValue("Filename")
# custom
user_custom = nuke.String_Knob("custom",
"custom postfix: ", "")
node.addKnob(user_custom)
node['custom'].setFlag(nuke.STARTLINE)
user_applyCustom = nuke.Enumeration_Knob(
'applyCustom', '',
['None', 'Folder', 'Filename', 'Both'])
node.addKnob(user_applyCustom)
node['applyCustom'].clearFlag(nuke.STARTLINE)
node['applyCustom'].setValue("None")
# path
user_path = nuke.File_Knob("path", "path: ")
node.addKnob(user_path)
node['path'].setValue(dir)
node['path'].setFlag(nuke.STARTLINE)
# number format
user_number = nuke.Enumeration_Knob(
'number', 'numberformat: ',
['%01d', '%02d', '%03d', '%04d', '%05d', 'custom'])
node.addKnob(user_number)
node['number'].setFlag(nuke.STARTLINE)
node['number'].setValue("%04d")
user_number_custom = nuke.String_Knob(
"number_custom", "", "custom format")
node.addKnob(user_number_custom)
node['number_custom'].clearFlag(nuke.STARTLINE)
node['number_custom'].setEnabled(False)
# file type
node.addKnob(node['file_type'])
node['file_type'].setValue(extension)
# set write settings
node.knob('file').setValue(dir + version + "/" + name +
"_" + numberformat + "." +
extension)
node.knob('proxy').setValue(dir + version + "/" + name +
"_proxy_" + numberformat +
"." + extension)
node.knob('datatype').setValue("16 Bit")
node.knob('label').setValue("autoFillWrite")
except:
# something went terribly wrong and we all gonna die ...
nuke.message("Couldn't change Settings for Write Node")
def create_AutoWrite():
try:
# this just test the file
test = os.path.basename(
nuke.root().name()).split('_v')[1].split('.nk')[0]
#creates a unique write node name
AutoWrite = nuke.createNode('Write', inpanel=True)
count = 1
while nuke.exists('AutoWrite_' + str(count)):
count += 1
AutoWrite.knob('name').setValue('AutoWrite_' + str(count))
AutoWrite.addKnob(nuke.Text_Knob('AutoWrite_test', '', "AutoWrite"))
# Create AutoWrite Tab for settings
AW_Settings = nuke.Tab_Knob('Auto Write Settings')
AutoWrite.addKnob(AW_Settings)
# Create AutoWrite UI
AutoWrite.addKnob(nuke.File_Knob(
'AW_userCompPath',
'Render Dir : ',
))
AutoWrite['AW_userCompPath'].setValue("SET YOUR RENDER FOLDER HERE")
# Show Output
AutoWrite.addKnob(
nuke.EvalString_Knob('AW_show_output', 'OUTPUT: ', ''))
AutoWrite['AW_show_output'].setEnabled(False)
# Script name
AutoWrite.addKnob(
nuke.EvalString_Knob('AW_autoScriptName', 'Script name : ', ''))
AutoWrite['AW_autoScriptName'].setEnabled(False)
# Version number
AutoWrite.addKnob(
nuke.EvalString_Knob('AW_autoVersion', 'Version : ', ''))
AutoWrite['AW_autoVersion'].setEnabled(False)
# Additional Information
AutoWrite.addKnob(nuke.EvalString_Knob('AW_userInfo', 'Info : ', ''))
AutoWrite['AW_userInfo'].setValue("Info")
# Auto Padding
AutoWrite.addKnob(nuke.Int_Knob('AW_userPadding', 'Padding # :'))
AutoWrite['AW_userPadding'].setValue(4)
# Auto Naming
AutoWrite.addKnob(nuke.Boolean_Knob('AW_autoName', 'Auto Name?'))
AutoWrite['AW_autoName'].setEnabled(False)
AutoWrite.addKnob(nuke.Text_Knob('auto_divider01', '', ''))
# Formating Options
AutoWrite.addKnob(
nuke.EvalString_Knob('AW_userFormat', 'Format : ', ''))
AutoWrite['AW_userFormat'].setValue(
'Path/Script/Version/Script_Info_Version')
AutoWrite['AW_userFormat'].setFlag(nuke.ENDLINE)
AutoWrite.addKnob(nuke.Text_Knob('auto_divider02', '', ''))
AutoWrite_FormatOptions = [
"/", "_", "Path", "Script", "Version", "Info", "Date"
]
for Options in AutoWrite_FormatOptions:
AutoWrite.addKnob(
nuke.PyScript_Knob(
"Options_" + Options, Options,
'MOTools.updateformat_AutoWrite("' + Options + '")'))
AutoWrite.addKnob(nuke.Text_Knob('auto_divider03', '', ''))
# Add user info
AutoWrite.addKnob(
nuke.Text_Knob(
'data', '',
infoScript + " | " + infoContact + " | " + __version__))
AutoWrite.addKnob(
nuke.PyScript_Knob(
"help", "?",
'nukescripts.start ("https://www.mikeoakley.com/wiki/motools-for-nuke/")'
))
# Auto set file_type
AutoWrite['file_type'].setValue('exr')
return
except IndexError:
nuke.message(
"ERROR: Version naming\nex: myfile_v001.nk\n Node will be deleted")
nuke.delete(AutoWrite)
return
except:
return
