def do_backup():
"""
Saves script into BACKUP_DIR folder after each save.
If more then KEEP_VERSIONS files are present, deletes them
Returns: None
"""
if not os.path.isdir(BACKUP_DIR):
try:
os.mkdir(BACKUP_DIR)
except:
nuke.message("Cannot create backup folder {}".format(BACKUP_DIR))
current_time_str = time.strftime("%Y%m%d_%H%M")
backup_file_url = "{}/bckp_{}_{}.nknc".format(BACKUP_DIR, get_script_name(), current_time_str)
try:
import shutil
nuke.removeOnScriptSave(do_backup) #remove call on save to limit recursion
nuke.scriptSave(backup_file_url)
nuke.addOnScriptSave(do_backup)
delete_old_version()
except IOError as e:
nuke.message("Cannot write file {}, {}".format(backup_file_url,e))
def registerNukePanel():
'''Register widget as a Nuke panel and add callback for saveing scripts'''
import nuke
import nukescripts
nukescripts.registerWidgetAsPanel('ToDoList.MainWindow', 'To Do List', MainWindow.appName)
nuke.addOnScriptSave(findAndReload)
nuke.addOnScriptLoad(findAndReload)
def standard_setup():
"""Non-standalone user setup."""
import traceback
import os
import nuke
import metatools.imports
import sgfs.nuke.menu
def callback():
try:
metatools.imports.autoreload(sgfs.nuke.menu)
sgfs.nuke.menu.build_for_path(nuke.root().name())
except Exception:
traceback.print_exc()
nuke.addOnScriptSave(callback)
nuke.addOnScriptLoad(callback)
try:
sgfs.nuke.menu.build_for_path(os.getcwd())
except Exception:
traceback.print_exc()
def standard_setup():
"""Non-standalone user setup."""
import traceback
import os
import nuke
import metatools.imports
import sgfs.nuke.menu
def callback():
try:
metatools.imports.autoreload(sgfs.nuke.menu)
sgfs.nuke.menu.build_for_path(nuke.root().name())
except Exception:
traceback.print_exc()
nuke.addOnScriptSave(callback)
nuke.addOnScriptLoad(callback)
try:
sgfs.nuke.menu.build_for_path(os.getcwd())
except Exception:
traceback.print_exc()
def makeBackup():
'''
make backup of script
'''
#get script name and make folder if not exist
script = nuke.root().name()
scriptName = (nuke.root().name().split("/")[-1]).replace(".nk","")
operation=blackboxHelper.getBackupSettings("@operation", backupSettings)
backupPath=blackboxHelper.getBackupSettings("@backupPath", backupSettings)
numberOfBackups=int(blackboxHelper.getBackupSettings("@numberOfBackups", backupSettings))
if backupMinute == True:
t = time.strftime("%y%m%d-%H%M")
else:
t = time.strftime("%y%m%d-%H%M%S")
# global dir
if operation=="0.0":
if not os.path.isdir(backupPath+"/"+scriptName):
os.makedirs(backupPath+"/"+scriptName)
try:
nuke.removeOnScriptSave(makeBackup)
nuke.scriptSave(backupPath+"/"+scriptName+"/bckp_"+t+"_"+scriptName+".nk")
nuke.addOnScriptSave(makeBackup)
except Exception, e:
nuke.message("couldn't write a backup file")
deleteOlderBackupVersions(backupPath+"/"+scriptName)
def makeBackup():
'''
make backup of script
'''
#get script name and make folder if not exist
script = nuke.root().name()
scriptName = (nuke.root().name().split("/")[-1]).replace(".nk", "")
operation = blackboxHelper.getBackupSettings("@operation", backupSettings)
backupPath = blackboxHelper.getBackupSettings("@backupPath",
backupSettings)
numberOfBackups = int(
blackboxHelper.getBackupSettings("@numberOfBackups", backupSettings))
if backupMinute == True:
t = time.strftime("%y%m%d-%H%M")
else:
t = time.strftime("%y%m%d-%H%M%S")
# global dir
if operation == "0.0":
if not os.path.isdir(backupPath + "/" + scriptName):
os.makedirs(backupPath + "/" + scriptName)
try:
nuke.removeOnScriptSave(makeBackup)
nuke.scriptSave(backupPath + "/" + scriptName + "/bckp_" + t +
"_" + scriptName + ".nk")
nuke.addOnScriptSave(makeBackup)
except Exception, e:
nuke.message("couldn't write a backup file")
deleteOlderBackupVersions(backupPath + "/" + scriptName)
def init_app(self):
"""
Called as the application is being initialized
"""
# first, we use the special import_module command to access the app module
# that resides inside the python folder in the app. This is where the actual UI
# and business logic of the app is kept. By using the import_module command,
# toolkit's code reload mechanism will work properly.
#app_payload = self.import_module("app")
# now register a *command*, which is normally a menu entry of some kind on a Shotgun
# menu (but it depends on the engine). The engine will manage this command and
# whenever the user requests the command, it will call out to the callback.
# Get Current Shotgun Toolkit path
#tk = sgtk.sgtk_from_entity(context.project["type"], context.project["id"])
#sgtk_path = str(tk).split(" ")[-1]
sgtk_python_path = sgtk.get_sgtk_module_path()
sgtk_config_path = os.path.join(
sgtk_python_path.split("install")[0], "config")
# Check if hook folder exists, this app will not work without making a bespoke lut gizmo and script.
app_hook_path = os.path.join(sgtk_config_path, "hooks", "tk-nuke",
"tk-nuke-lut-app")
if not os.path.exists(app_hook_path):
os.makedirs(app_hook_path)
self.logger.info("Created Hooks folder: tk-nuke/tk-nuke-lut-app")
# # Copy over the update_lut.py
# callback_script = "update_lut.py"
# src = os.path.join(os.path.dirname(__file__), "resources", callback_script)
# dst = os.path.join(app_hook_path, callback_script)
# if not os.path.exists(dst):
# shutil.copy2(src, dst)
# self.logger.info("Copied "+callback_script+" script to hooks folder because it did not exist yet.")
# # Copy over the example init.py
# resource = "init.py"
# src = os.path.join(os.path.dirname(__file__), "resources", resource)
# dst = os.path.join(app_hook_path, resource)
# if not os.path.exists(dst):
# shutil.copy2(src, dst)
# self.logger.info("Copied "+resource+" script to hooks folder because it did not exist yet.")
# Adding hook folder to Nuke Path so the custom gizmo and script can be picked up
nuke.pluginAddPath(app_hook_path)
self.logger.error("Adding " + app_hook_path + " to nuke plugin path")
# first, set up our callback, calling out to a method inside the app module contained
# in the python folder of the app
menu_callback = lambda: loadLut()
# now register the command with the engine
self.engine.register_command("Load Viewer LUT...", menu_callback)
# Callbacks
nuke.addOnScriptSave(loadLut())
nuke.addOnScriptLoad(loadLut())
def registerNukePanel():
'''Register widget as a Nuke panel and add callback for saveing scripts'''
import nuke
import nukescripts
nukescripts.registerWidgetAsPanel('ToDoList.MainWindow', 'To Do List',
MainWindow.appName)
nuke.addOnScriptSave(findAndReload)
nuke.addOnScriptLoad(findAndReload)
def registerNukePanel():
"""Register widget as a Nuke panel and add callback for saveing scripts"""
import nuke
import nukescripts
nukescripts.registerWidgetAsPanel("ToDoList.MainWindow", "To Do List", MainWindow.appName)
nuke.addOnScriptSave(findAndReload)
nuke.addOnScriptLoad(findAndReload)
def set_open_file_callback(self, func=None):
"""
set_open_file_callback will set a callback function for
when a file is opened
"""
if func:
nuke.addOnScriptSave(func)
nuke.addOnScriptLoad(func)
def tank_ensure_callbacks_registered():
"""
Make sure that we have callbacks tracking context state changes.
"""
global g_tank_callbacks_registered
if not g_tank_callbacks_registered:
nuke.addOnCreate(__tank_startup_node_callback)
nuke.addOnScriptSave(__tank_on_save_callback)
g_tank_callbacks_registered = True
def addCallbackOnScriptSave(self, func, nodeClass=None, group=None):
"""Executed when the user tries to save a script."""
self._addNukeCallbackGroup(group)
self.windowInstance()['callback'][group]['onScriptSave'][func].add(nodeClass)
if not self.__windowHidden:
if nodeClass is None:
nuke.addOnScriptSave(func)
else:
nuke.addOnScriptSave(func, nodeClass=nodeClass)
def tank_ensure_callbacks_registered():
"""
Make sure that we have callbacks tracking context state changes.
"""
global g_tank_callbacks_registered
if not g_tank_callbacks_registered:
nuke.addOnCreate(__tank_startup_node_callback)
nuke.addOnScriptSave(__tank_on_save_callback)
g_tank_callbacks_registered = True
def savebackup():
save = backupfolder() + '/' + time.strftime(
'%Y_%m_%d_%H_%M', time.localtime(
time.time())) + '_' + os.path.basename(
nuke.root().name()).split('.')[0] + '.nk'
try:
nuke.removeOnScriptSave(savebackup)
nuke.scriptSave(save)
nuke.addOnScriptSave(savebackup)
except:
nuke.message('Backup failed!(Pr_ToolKit)')
def setup():
nuke.addBeforeRender(CALLBACKS_BEFORE_RENDER.execute)
nuke.addOnScriptLoad(CALLBACKS_ON_SCRIPT_LOAD.execute)
nuke.addOnScriptSave(CALLBACKS_ON_SCRIPT_SAVE.execute)
nuke.addOnScriptClose(CALLBACKS_ON_SCRIPT_CLOSE.execute)
nuke.addOnCreate(CALLBACKS_ON_CREATE.execute)
nuke.addUpdateUI(CALLBACKS_UPDATE_UI.execute)
if nuke.GUI:
import nukescripts
nukescripts.addDropDataCallback(CALLBACKS_ON_DROP_DATA.execute)
def toggleBackupProcess():
'''
enable/disable blackbox - set by value in blackbox.set
'''
#reload settings
enableBackup=blackboxHelper.getBackupSettings("@enableBackup", backupSettings)
backupPath=blackboxHelper.getBackupSettings("@backupPath", backupSettings)
operation=blackboxHelper.getBackupSettings("@operation", backupSettings)
numberOfBackups=blackboxHelper.getBackupSettings("@numberOfBackups", backupSettings)
if enableBackup == "1.0":
nuke.addOnScriptSave(makeBackup)
else:
nuke.removeOnScriptSave(makeBackup)
def tank_ensure_callbacks_registered():
"""
Make sure that we have callbacks tracking context state changes.
"""
import sgtk
engine = sgtk.platform.current_engine()
# Register only if we're missing an engine (to allow going from disabled to something else)
# or if the engine specifically requests for it.
if not engine or engine.get_setting("automatic_context_switch"):
global g_tank_callbacks_registered
if not g_tank_callbacks_registered:
nuke.addOnScriptLoad(tank_startup_node_callback)
nuke.addOnScriptSave(__tank_on_save_callback)
g_tank_callbacks_registered = True
def make_backup():
script_name = get_script_name()
script_backup_dir = "{}/{}".format(backup_dir, script_name)
current_time = time.strftime("%y%m%d-%H%M")
if not os.path.isdir(script_backup_dir):
os.makedirs(script_backup_dir)
try:
nuke.removeOnScriptSave(make_backup)
nuke.scriptSave("{}/backup_{}_{}.nk".format(script_backup_dir, current_time, script_name))
nuke.addOnScriptSave(make_backup)
except:
nuke.message("Could't write a backup file!!")
delete_older_backup_versions(script_backup_dir)
def toggleBackupProcess():
'''
enable/disable blackbox - set by value in blackbox.set
'''
#reload settings
enableBackup = blackboxHelper.getBackupSettings("@enableBackup",
backupSettings)
backupPath = blackboxHelper.getBackupSettings("@backupPath",
backupSettings)
operation = blackboxHelper.getBackupSettings("@operation", backupSettings)
numberOfBackups = blackboxHelper.getBackupSettings("@numberOfBackups",
backupSettings)
if enableBackup == "1.0":
nuke.addOnScriptSave(makeBackup)
else:
nuke.removeOnScriptSave(makeBackup)
def make_save():
"""
保存备份文件
"""
script_name = get_script_name()
project_name = script_name.split("_")[0]
shot_name = "_".join(script_name.split("_")[1:-3])
script_backup_dir = "{}/{}/{}".format(backup_dir, project_name, shot_name)
current_time = time.strftime("%m%d_%H%M")
if not os.path.isdir(script_backup_dir):
os.makedirs(script_backup_dir)
try:
nuke.removeOnScriptSave(make_save)
nuke.scriptSave("{}/{}_{}.nk".format(script_backup_dir, script_name, current_time))
nuke.addOnScriptSave(make_save)
except:
nuke.message(u"没有需要备份的文件")
del_older_backup_version(script_backup_dir)
def make_backup():
"""
make backup of script
:returns: none
"""
script_name = get_current_script_name()
script_backup_dir = "{}/{}".format(BACKUP_DIR, script_name)
current_time = time.strftime("%Y%m%d-%H%M")
if not os.path.isdir(script_backup_dir):
os.makedirs(script_backup_dir)
try:
nuke.removeOnScriptSave(make_backup)
nuke.scriptSave("{}/bckp_{}_{}.nk".format(script_backup_dir,
current_time,
script_name))
nuke.addOnScriptSave(make_backup)
except:
nuke.message("Couldn't write a backup file")
delete_older_backup_versions(script_backup_dir)
def tank_ensure_callbacks_registered(engine=None):
"""
Make sure that we have callbacks tracking context state changes.
The OnScriptLoad callback really only comes into play when you're opening a file or creating a new script, when
there is no current script open in your Nuke session. If there is a script currently open then this will spawn a
new Nuke instance and the callback won't be called.
"""
global g_tank_callbacks_registered
# Register only if we're missing an engine (to allow going from disabled to something else)
# or if the engine specifically requests for it.
if not engine or engine.get_setting("automatic_context_switch"):
if not g_tank_callbacks_registered:
nuke.addOnScriptLoad(sgtk_on_load_callback)
nuke.addOnScriptSave(__sgtk_on_save_callback)
g_tank_callbacks_registered = True
elif engine and not engine.get_setting("automatic_context_switch"):
# we have an engine but the automatic context switching has been disabled, we should ensure the callbacks
# are removed.
if g_tank_callbacks_registered:
nuke.removeOnScriptLoad(sgtk_on_load_callback)
nuke.removeOnScriptSave(__sgtk_on_save_callback)
g_tank_callbacks_registered = False
def tank_ensure_callbacks_registered(engine=None):
"""
Make sure that we have callbacks tracking context state changes.
The OnScriptLoad callback really only comes into play when you're opening a file or creating a new script, when
there is no current script open in your Nuke session. If there is a script currently open then this will spawn a
new Nuke instance and the callback won't be called.
"""
# Register only if we're missing an engine (to allow going from disabled to something else)
# or if the engine specifically requests for it.
if not engine or engine.get_setting("automatic_context_switch"):
global g_tank_callbacks_registered
if not g_tank_callbacks_registered:
nuke.addOnScriptLoad(sgtk_on_load_callback)
nuke.addOnScriptSave(__sgtk_on_save_callback)
g_tank_callbacks_registered = True
elif engine and not engine.get_setting("automatic_context_switch"):
# we have an engine but the automatic context switching has been disabled, we should ensure the callbacks
# are removed.
global g_tank_callbacks_registered
if g_tank_callbacks_registered:
nuke.removeOnScriptLoad(sgtk_on_load_callback)
nuke.removeOnScriptSave(__sgtk_on_save_callback)
g_tank_callbacks_registered = False
shot_folder + custom_folder +
version + "/" + show_filename +
scene_filename + shot_filename +
custom_filename + version + number +
"." + extension)
node['proxy'].setValue(path + show_folder + scene_folder +
shot_folder + custom_folder +
version + "/" + show_filename +
scene_filename + shot_filename +
custom_filename + version +
"_proxy" + number + "." + extension)
if extension == "sgi":
node['datatype'].setValue("16 Bit")
except:
print("No AutoFillWrites found.")
def createOutputDir():
file = nuke.filename(nuke.thisNode())
dir = os.path.dirname(file)
osdir = nuke.callbacks.filenameFilter(dir)
if not os.path.isdir(osdir):
os.makedirs(osdir)
# register functions
nuke.addOnScriptSave(updateAutoFillWrite)
nuke.addUpdateUI(updateAutoFillWrite, nodeClass='Write')
nuke.addBeforeRender(createOutputDir)
try:
import re
regex = re.compile("v[0-9]{3}")
fileVers = regex.findall(nuke.root().name())[0]
for w in nuke.allNodes('Write'):
renderPath = w['file'].value()
renderVers = regex.findall(renderPath)
if len(renderVers) > 0:
for v in renderVers:
renderPath = renderPath.replace(v, fileVers)
w['file'].setValue(renderPath)
except:
pass
nuke.addOnScriptSave(matchWriteVersionToFilename)
def setLightingStatusComplete():
import tank
PROJECT_ID = tank.platform.current_engine().context.project['id']
import shotgun_api3 as shotgun
SERVER_PATH = "https://psyop.shotgunstudio.com"
SCRIPT_USER = "******"
SCRIPT_KEY = "e0078c0e80f09ee7a76de2c25afce6bd34a5bc601f598d446daf6a8e848d9089"
sg = shotgun.Shotgun(SERVER_PATH, SCRIPT_USER, SCRIPT_KEY)
try:
shotName = nuke.root().name().split('/')[-1].split('_')[0]
#get shot
fields = ['id', 'code', 'sg_status_list']
#THIS LINE WILL ADD THE NEW ENTRY TO THE PANE MENU
nuke.menu('Pane').addCommand('SearchReplace', addSRPanel)
# CREATE A READ NODE AND OPEN THE "DB" TAB
def customRead():
n = nuke.createNode( 'Read' )
n['PipeL'].setFlag( 0 )
return n
nuke.menu( 'Nodes' ).addCommand( 'Image/ReadPipel', customRead, 'Shift+r' )
nuke.addOnUserCreate( nuk.general.read.createVersionKnobs, nodeClass='Read' )
nuke.addKnobChanged( nuk.general.read.updateVersionKnob, nodeClass='Read' )
nuke.addOnScriptLoad( nuk.general.read.checkVersions )
nuke.addOnScriptSave( nuk.general.read.checkVersions )
"""
import nuk.general.read
import nuke
nuke.removeOnScriptLoad(nuk.general.read.checkVersions)
nuke.removeOnScriptSave(nuk.general.read.checkVersions)
"""
def mergeColor():
n = nuke.thisNode()
k = nuke.thisKnob()
if k.name() == "mix":
v = k.value()
green = v
red = 1 - int(v)
r = red
import os
import sys
import KnobScripter
from pype.nuke.lib import (writes_version_sync, on_script_load,
check_inventory_versions)
import nuke
from pypeapp import Logger
log = Logger().get_logger(__name__, "nuke")
# nuke.addOnScriptSave(writes_version_sync)
nuke.addOnScriptSave(on_script_load)
nuke.addOnScriptLoad(check_inventory_versions)
nuke.addOnScriptSave(check_inventory_versions)
# nuke.addOnScriptSave(writes_version_sync)
log.info('Automatic syncing of write file knob to script version')
def start():
nuke.addOnScriptSave(backup_autosave_file)
nuke.removeOnScriptSave(makeBackup)
nuke.scriptSave(backupPath+"/"+scriptName+"/bckp_"+t+"_"+scriptName+".nk")
nuke.addOnScriptSave(makeBackup)
except Exception, e:
nuke.message("couldn't write a backup file")
deleteOlderBackupVersions(backupPath+"/"+scriptName)
# per script
else:
backupPath = "/".join(nuke.root().name().split("/")[:-1])+"/_backups_%s" % scriptName
if not os.path.isdir(backupPath):
os.makedirs(backupPath)
try:
nuke.removeOnScriptSave(makeBackup)
nuke.scriptSave(backupPath+"/bckp_"+t+"_"+scriptName+".nk")
nuke.addOnScriptSave(makeBackup)
except Exception, e:
nuke.message("couldn't write a backup file")
deleteOlderBackupVersions(backupPath)
def toggleBackupProcess():
'''
enable/disable blackbox - set by value in blackbox.set
'''
#reload settings
enableBackup=blackboxHelper.getBackupSettings("@enableBackup", backupSettings)
backupPath=blackboxHelper.getBackupSettings("@backupPath", backupSettings)
operation=blackboxHelper.getBackupSettings("@operation", backupSettings)
numberOfBackups=blackboxHelper.getBackupSettings("@numberOfBackups", backupSettings)
# Animation Menu
animation = nuke.menu("Animation")
# Viewer Menu
viewer = nuke.menu("Viewer")
# Preferences Condition
if os.path.exists(platform_pref_path()): # Preferences Available
import Bc_ToolSet_preferences as pref
gizmoColor = pref.gizmo_color
if pref.save_log is True:
from PrPy.SaveLog import save_log, lock_save_log
nuke.addOnScriptSave(save_log)
nuke.addOnScriptLoad(lock_save_log)
# Gizmos - Nodes Menu
if pref.Bc_ShuffleMatte is True:
Bc_ShuffleMatte = "nuke.createNode('Bc_ShuffleMatte', 'tile_color %d')" % gizmoColor
nodes.addCommand("Bc_ShuffleMatte",
Bc_ShuffleMatte,
"",
icon="Bc_ShuffleMatte_v01.png")
if pref.Bc_LBGrain is True:
Bc_LBGrain = "nuke.createNode('Bc_LBGrain', 'tile_color %d')" % gizmoColor
nodes.addCommand("Bc_LBGrain",
Bc_LBGrain,
"",
icon="Bc_LBGrain_v01.png")
# -*- coding:utf-8 -*-
__date__ = '2017/3/10 16:00'
__author__ = 'liaokong'
import nuke
import AutoSave
nuke.menu("Nuke").addCommand("pipeline/open backup dir",
"AutoSave.open_backup_dir()")
nuke.addOnScriptSave(autoSave.make_save)
(pName, pExt) = os.path.splitext(os.path.basename(root['name'].value()))
pData = etree.fromstring(root['tri_project_xml_formats'].value())
for group in nuke.allNodes("Group", nuke.root()):
if 'triwrite_gizmo' not in group.knobs():
continue
resultNode = group.node('result')
dailiesNode = group.node('dailies')
#--- update results params
filename = pName + pData.find('result').find('file').get('numbers') + pData.find('result').find('file').get('file_type')
filename = nukenormpath(filename)
oldfilename = os.path.basename(resultNode['file'].value())
resultNode['file'].setValue(resultNode['file'].value().replace(oldfilename, filename))
#--- update dailies params
filename = pName + pData.find('dailies').find('file').get('numbers') + pData.find('dailies').find('file').get('file_type')
filename = nukenormpath(filename)
oldfilename = os.path.basename(dailiesNode['file'].value())
dailiesNode['file'].setValue(dailiesNode['file'].value().replace(oldfilename, filename))
pData = None
nuke.addOnUserCreate(tri_project_init, nodeClass="Root")
nuke.addOnUserCreate(tri_writeGizmo_init, nodeClass="Group")
nuke.addOnScriptSave(tri_writeGizmo_update, nodeClass="Root")
nuke.addOnScriptLoad(tri_project_init, nodeClass="Root")
import os
import sys
import KnobScripter
from pype.nuke.lib import (writes_version_sync, onScriptLoad,
checkInventoryVersions)
import nuke
from pypeapp import Logger
log = Logger().get_logger(__name__, "nuke")
# nuke.addOnScriptSave(writes_version_sync)
nuke.addOnScriptSave(onScriptLoad)
nuke.addOnScriptLoad(checkInventoryVersions)
nuke.addOnScriptSave(checkInventoryVersions)
# nuke.addOnScriptSave(writes_version_sync)
log.info('Automatic syncing of write file knob to script version')
nkScripts = assetManager.getNukeScripts()
if not nkScripts:
# IF THERE ARE NONE DON'T DO ANYTHING
return
# CREATE PANEL
p = assetManager.NkPanel( nkScripts )
# ADJUST SIZE
p.setMinimumSize( 200, 200 )
# IF PANEL WAS CONFIRMED AND A NUKE SCRIPT WAS SELECTED, OPEN IT
if p.showModalDialog():
if p.selectedScript:
nuke.scriptOpen( p.selectedScript )
# ADD CALLBACKS
nuke.addOnScriptSave( assetManager.checkScriptName )
nuke.addOnUserCreate( nkPanelHelper, nodeClass='Root')
nuke.addOnUserCreate( assetManager.createVersionKnobs, nodeClass='Read' )
nuke.addKnobChanged( assetManager.updateVersionKnob, nodeClass='Read' )
nuke.addBeforeRender( assetManager.createOutDirs, nodeClass='Write' )
nuke.knobDefault( 'Write.beforeRender', 'assetManager.createOutDirs()')
### END ASSET MANAGEMENT SETUP ###
### BEGIN RENDER SETUP ###
m = menubar.addMenu("Render")
m.addCommand("Create Paths", "createPaths()")
#m.addCommand("Fix Paths", "fixPath.fixPath()")
## Uncomment this if RUSH is used
#m.addCommand("Send2Rush", "s2r.Nuke2Rush()")
menu = nuke.menu("Nuke")
menu.addCommand(
"Tools/Ada/Remove Ada Tab",
"__import__('ada.nuke.utils', "
"fromlist=['remove_ada_tab']).remove_ada_tab(nuke.selectedNodes())",
shortcut="Shift+Alt+t",
)
menu.addCommand(
"Tools/Ada/Bake Selected",
"__import__('ada.nuke.context', "
"fromlist=['Engine']).Engine.run(nodes=nuke.selectedNodes())",
shortcut="Shift+b",
)
menu.addCommand(
"Tools/Ada/Add Knobs To Bake",
"__import__('ada.nuke.node', "
"fromlist=['add_knob_to_bake']).add_knob_to_bake(nuke.selectedNode())",
shortcut="Shift+t",
)
# add ada file loader
nuke.addOnScriptLoad(load_ada_context_from_file)
# add ada file loader
nuke.addOnScriptSave(save_ada_context_to_file)
# add on destroy callback to remove any context information that nodes are associated with.
#/Pr_Tools/Python/autobackup/menu.py, v1.0.1, 2020.01.08 import nuke import autoback nuke.addOnScriptSave(autoback.savebackup)
1] + "_" + fileNameSplit[2]
projectName = path
fileVersion = fileNameSplit[3].replace(".nk", "")
print dirname
print projectPath
nuke.addFavoriteDir("Project", projectPath)
nuke.addFavoriteDir("Inputs", projectPath + "\\input\\" + dirname + "\\")
nuke.addFavoriteDir("Write",
writeRootDir + "\\" + projectName + "\\" + dirname)
def scriptSaved():
loadScriptVars()
checkWriteNodes()
#checkInputNodes()
def scriptLoaded():
loadScriptVars()
checkWriteNodes()
#checkInputNodes()
nuke.addOnScriptLoad(scriptLoaded)
nuke.addOnScriptSave(scriptSaved)
import nuke
import script_backup
nuke.menu('Nuke').addCommand("utilities/auto_backup/open backup dir",
"script_backup.open_backup_dir()")
nuke.addOnScriptSave(script_backup.do_backup)
nuke.addOnScriptSave(makeBackup)
except Exception, e:
nuke.message("couldn't write a backup file")
deleteOlderBackupVersions(backupPath + "/" + scriptName)
# per script
else:
backupPath = "/".join(
nuke.root().name().split("/")[:-1]) + "/_backups_%s" % scriptName
if not os.path.isdir(backupPath):
os.makedirs(backupPath)
try:
nuke.removeOnScriptSave(makeBackup)
nuke.scriptSave(backupPath + "/bckp_" + t + "_" + scriptName +
".nk")
nuke.addOnScriptSave(makeBackup)
except Exception, e:
nuke.message("couldn't write a backup file")
deleteOlderBackupVersions(backupPath)
def toggleBackupProcess():
'''
enable/disable blackbox - set by value in blackbox.set
'''
#reload settings
enableBackup = blackboxHelper.getBackupSettings("@enableBackup",
backupSettings)
backupPath = blackboxHelper.getBackupSettings("@backupPath",
backupSettings)
import atom_server
from pype.nuke.lib import (writes_version_sync, onScriptLoad,
checkInventoryVersions)
import nuke
from pypeapp import Logger
log = Logger().get_logger(__name__, "nuke")
# nuke.addOnScriptSave(writes_version_sync)
nuke.addOnScriptSave(onScriptLoad)
nuke.addOnScriptLoad(checkInventoryVersions)
nuke.addOnScriptSave(checkInventoryVersions)
nuke.addOnScriptSave(writes_version_sync)
log.info('Automatic syncing of write file knob to script version')
continue
# SAVE NUKE SCRIPT
nuke.scriptSaveAs( nkPath )
fileSaved = True
return nkPath
# ADD EASY SAVE TO SHOT MENU
shotMenu = '%s - %s' % ( os.getenv('SCENE'), os.getenv('SHOT') )
nuke.menu( 'Nuke' ).addCommand( shotMenu+'/Easy Save', easySave, 'Ctrl+S' )
nuke.menu('Nuke').addCommand( shotMenu+'/Write Assets', 'nuke.createNode("WriteAssets")', 'W', icon='Write.png')
# REQUIRE VERSIONING IN SCRIPT NAME
def checkScriptName():
if not re.search( r'[vV]\d+', nuke.root().name() ):
raise NameError, 'Please include a version number and save script again.'
nuke.addOnScriptSave( checkScriptName )
# GET ALL NUKE SCRIPTS FOR CURRENT SHOT
def getNukeScripts():
nkFiles = glob( os.path.join( nukeDir(), '*.nk' ) )
return nkFiles
# PANEL TO SHOW NUKE SCRIPTS FOR CURRENT SHOT
class NkPanel( nukescripts.PythonPanel ):
def __init__( self, nkScripts ):
nukescripts.PythonPanel.__init__( self, 'Open NUKE Script' )
self.checkboxes = []
self.nkScripts = nkScripts
self.selectedScript = ''
for i, n in enumerate( self.nkScripts ):
moduleName = os.path.basename(
os.path.normpath(os.path.join(currentFile, "..", "..", "..")))
if not main_folder in sys.path:
sys.path.append(main_folder)
### Registering Callback ###
exec("from {0} import config as wsconfig".format(moduleName))
def store_recent():
wsconfig.add_recent(nuke.Root().knob("name").value())
nuke.addOnScriptLoad(store_recent)
nuke.addOnScriptSave(store_recent)
if nuke.env['NukeVersionMajor'] < 11:
execfile(os.path.join(main_folder, moduleName, "main.py"))
### Import Required Modules ###
def WelcomeScreen_start():
ws = WelcomeScreen()
ws.start()
### Registering Menu ###
menu = nuke.menu('Nuke')
menu.addCommand('General/Welcome Screen',
lambda f=WelcomeScreen_start: nuke.executeInMainThread(f),
'ctrl+shift+w')
