def _nuke_execute(self, operation, file_path, context, parent_action,
                      file_version, read_only, **kwargs):
        if file_path:
            file_path = file_path.replace("/", os.path.sep)

        if operation == "current_path":
            # return the current script path
            return nuke.root().name().replace("/", os.path.sep)
        elif operation == "open":
            # open the specified script
            nuke.scriptOpen(file_path)

            # reset any write node render paths:
            if self._reset_write_node_render_paths():
                # something changed so make sure to save the script again:
                nuke.scriptSave()
        elif operation == "save":
            # save the current script:
            nuke.scriptSave()
        elif operation == "save_as":
            old_path = nuke.root()["name"].value()
            try:
                # rename script:
                nuke.root()["name"].setValue(file_path)

                # reset all write nodes:
                self._reset_write_node_render_paths()

                # save script:
                nuke.scriptSaveAs(file_path, -1)
            except Exception, e:
                # something went wrong so reset to old path:
                nuke.root()["name"].setValue(old_path)
                raise TankError("Failed to save scene %s", e)
示例#2
0
def advancedSubmission():
    nuke.scriptSave()
    DeadlineNukeClient.main()
    createArtifact()
    if nuke.ask('Do you want to version up your script?'):
        incrementalSave()
    return
def restartNuke():

    if nuke.ask('Are you sure you want to restart Nuke?'):

        scriptName = nuke.root().knob('name').getValue()

        subprocess_options = {"shell": True}

        separate_terminal_options = {
            "close_fds": True,
            "preexec_fn": os.setsid
        }

        if nuke.env['nukex'] == True:
            session = '--nukex'
        else:
            session = '--nuke'

        if 'REZ_VOLT_SESSION_ROOT' in os.environ:
            subprocess_options.update(separate_terminal_options)

        if os.path.isfile(scriptName):
            nuke.scriptSave()
            launch_cmd = '{} {} {}'.format(sys.executable, session, scriptName)
            subprocess.Popen(launch_cmd, **subprocess_options)
            nuke.modified(False)
            nuke.scriptExit()
        else:
            nuke.scriptNew('')
            nuke.modified(False)
            nuke.scriptExit()
示例#4
0
文件: open.py 项目: tws0002/jeeves
def run(found_file):
    #check if scene is modified
    if nuke.Root().modified() == True:
        #prompt user to save
        if nuke.ask('Unsaved script\n\nWould you like to save?'):
            if nuke.Root().name() == 'Root':
                #run up the save_as module as this script hasnt been saved yet, then clear and open
                import jnuke.pipeline.save_as
                jnuke.pipeline.save_as.run()

                nuke.scriptClear()
                nuke.scriptOpen(found_file)
            else:
                #save the script, clear and open selected script
                nuke.scriptSave("")
                nuke.scriptClear()
                nuke.scriptOpen(found_file)
        else:
            #they dont want to save, so just clear the script and open the selected script
            nuke.scriptClear()
            nuke.scriptOpen(found_file)

    else:
        #not modified, simply clear and open
        nuke.scriptClear()
        nuke.scriptOpen(found_file)
示例#5
0
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 execute(self, operation, file_path, **kwargs):
     """
     Main hook entry point
     
     :operation: String
                 Scene operation to perform
     
     :file_path: String
                 File path to use if the operation
                 requires it (e.g. open)
                 
     :returns:   Depends on operation:
                 'current_path' - Return the current scene
                                  file path as a String
                 all others     - None
     """
     if file_path:
         file_path = file_path.replace("/", os.path.sep)        
     
     if operation == "current_path":
         # return the current script path
         return nuke.root().name().replace("/", os.path.sep)
     elif operation == "open":
         # open the specified script into the current window
         if nuke.root().modified():
             raise TankError("Script is modified!")
         nuke.scriptClear()
         nuke.scriptOpen(file_path)
     elif operation == "save":
         # save the current script:
         nuke.scriptSave()
示例#7
0
    def process(self, context):
        # capture selection state
        with maintained_selection():
            active_node = [
                node for inst in context[:] for node in inst[:]
                if "ak:family" in node.knobs()
            ]

            if active_node:
                self.log.info(active_node)
                active_node = active_node[0]
                self.log.info(active_node)
                active_node['selected'].setValue(True)

            # select only instance render node
            output_node = nuke.createNode("Output")

            # deselect all and select the original selection
            output_node['selected'].setValue(False)

            # save script
            nuke.scriptSave()

            # add node to instance node list
            context.data["outputNode"] = output_node
示例#8
0
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)
示例#9
0
def BatScriptRenderFull():
    # Save Script
    nuke.scriptSave()
    # Variables of Script
    nukescript = nuke.value("root.name")
    start = nuke.knob("first_frame")
    end = nuke.knob("last_frame")
    path = nukescript + ".bat"
    # Cmd Message
    nuke.tprint("\nBatScriptRender\nSave Script " + nukescript)
    # Bat File Panel
    swt = ['-x', '-X']
    nfr = ['""', ',2', ',5', ',10', ',15', ',20']
    myPanel = nuke.Panel("BatScriptRender - Parameters", 338)
    myPanel.addSingleLineInput("nuke version: ", "nuke5.1")
    myPanel.addEnumerationPulldown("switches: ", ' '.join(swt))
    myPanel.addSingleLineInput("node: ", "")
    myPanel.addSingleLineInput("script: ", nukescript)
    myPanel.addSingleLineInput("start frame: ", start)
    myPanel.addSingleLineInput("end frame: ", end)
    myPanel.addEnumerationPulldown("every n frame: ", ' '.join(nfr))
    myPanel.addSingleLineInput("file path: ", path)
    myPanel.addButton("Quit")
    myPanel.addButton("Create")
    myPanel.addButton("Execute")
    result = myPanel.show()
    # Add Button's action & Cmd Message
    if result == 0:
        nuke.tprint("Bat File don't Create")
    elif result == 1:
        # Create Bat File
        curVersion = myPanel.value("nuke version: ")
        curSwitches = myPanel.value("switches: ")
        curNode = myPanel.value("node: ")
        curScript = myPanel.value("script: ")
        curStart = myPanel.value("start frame: ")
        curEnd = myPanel.value("end frame: ")
        curEvery = myPanel.value("every n frame: ")
        cmdLine = curVersion + " " + curSwitches + " " + curNode + " " + '"' + curScript + '"' + " " + curStart + "," + curEnd + curEvery
        cmdFile = myPanel.value("file path: ")
        file = open(cmdFile, 'w')
        file.write(cmdLine)
        file.close()
        nuke.tprint("Create Bat File " + cmdFile)
    elif result == 2:
        # Execute Bat File
        curVersion = myPanel.value("nuke version: ")
        curSwitches = myPanel.value("switches: ")
        curNode = myPanel.value("node: ")
        curScript = myPanel.value("script: ")
        curStart = myPanel.value("start frame: ")
        curEnd = myPanel.value("end frame: ")
        curEvery = myPanel.value("every n frame: ")
        cmdLine = curVersion + " " + curSwitches + " " + curNode + " " + '"' + curScript + '"' + " " + curStart + "," + curEnd + curEvery
        cmdFile = myPanel.value("file path: ")
        file = open(cmdFile, 'w')
        file.write(cmdLine)
        file.close()
        os.startfile(cmdFile)
        nuke.tprint("Execute Bat File " + cmdFile)
示例#10
0
def createNukeFile(seq = 's0060',shName=True,outFile = '/tmp/tmp.tif',task = 'compo_comp'):
    nbShots = len(findShotsInSequence(seq,False))
    intNb = nbShots/5
    floatNb = nbShots/5.0
    if floatNb-intNb > 0:
        intNb += 1
    sequenceGroupNode = sequenceGroup.create()
    sequenceGroupNode['sequence'].setValue(seq)
    sequenceGroupNode['task'].setValue(task)
    sequenceGroupNode['outputMode'].setValue('contactSheet')
    sequenceGroupNode['Rebuild'].execute()
    # a.knob('Rebuild').execute()
    sequenceGroupNode['RowCol'].setValue([intNb, 5])
    sequenceGroupNode['Resolution'].setValue([5*2048,intNb*858])
    if shName:
        sequenceGroupNode['showName'].setValue(True)
    else:
        sequenceGroupNode['showName'].setValue(False)

    colorConvertNode = nuke.nodes.OCIOColorSpace(in_colorspace="Linear", out_colorspace="Lut")
    #colorConvertNode = nuke.nodes.OCIOColorSpace( out_colorspace="Lut")
    colorConvertNode.setInput(0,sequenceGroupNode)

    writeNode = nuke.nodes.Write(name = seq + "WriteLutBurn", colorspace = "linear", file_type = "tiff",file =outFile+'/'+seq+'.tif')
    writeNode['datatype'].setValue('16 bit')
    #writeNode['views'].setValue('left left')
    writeNode.setInput(0,colorConvertNode)
    nuke.scriptSave('/tmp/tmp.nk')
    print 'done'
    nuke.execute(writeNode, 1, 1)
示例#11
0
def nk_multithreadedRender():
    """
	Multithreaded Render
	"""
    threads = nuke.env["threads"] - 2
    c = nuke.getInput("Number of threads (default %i)" % threads)
    if c:
        threads = int(c)
    THREADCOUNT = threads
    nuke.scriptSave()
    renderNode = nuke.selectedNode()
    use_limit = renderNode["use_limit"].value()
    first = renderNode["first"].value() if use_limit else nuke.root().firstFrame()
    last = renderNode["last"].value() if use_limit else nuke.root().lastFrame()
    frames = [i for i in range(first, last + 1)]
    threads = [[] for i in range(0, THREADCOUNT)]
    [threads[i % THREADCOUNT].append(frame) for (i, frame) in enumerate(frames)]

    THREAD_FRAMES = {}

    def render(frameList):
        _maxCache = str(max(nuke.memory("max_usage") / 1097152, 16) * 4) + "M"
        try:
            t = nuke.executeBackgroundNuke(
                nuke.EXE_PATH,
                [renderNode],
                nuke.FrameRanges(frameList),
                nuke.views(),
                {"maxThreads": 1, "maxCache": _maxCache},
            )
            THREAD_FRAMES[t] = frameList
        except Exception as e:
            print e

    [render(frameList) for frameList in threads]
示例#12
0
    def BlackSailRender():
        nuke.scriptSave()
        try:
            g = nuke.selectedNode()
            f = nuke.allNodes("Write") + nuke.allNodes("DeepWrite")
            for a in f:
                sel = a['selected'].value()
                names = ""
                if sel == 1:
                    a['disable'].setValue(0)
                    name = a['name'].value()
                    names = names + name + "\n"
                    #nuke.toNode("Review")['senttorender'].setValue(names)
                else:
                    a['disable'].setValue(1)

            BlackSailSubmit.BlackSailSubmit()
        except:
            BlackSailSubmit.BlackSailSubmit()

        try:
            n = nuke.selectedNodes()
            for n in n:
                x = n['xpos'].value()
                y = n['ypos'].value()
                b = nuke.allNodes("BackdropNode")
                for ba in b:
                    xb = ba['xpos'].value()
                    yb = ba['ypos'].value()
                    if xb < x and yb < y and xb > x - 300 and yb > y - 400 and ba[
                            'label'].value() == "Precomp":
                        ba['tile_color'].setValue(52479)
        except:
            BlackSailSubmit.BlackSailSubmit()
 def _nuke_execute(self, operation, file_path, context, parent_action, file_version, read_only, **kwargs):
     if file_path:
         file_path = file_path.replace("/", os.path.sep)
     
     if operation == "current_path":
         # return the current script path
         return nuke.root().name().replace("/", os.path.sep)
     elif operation == "open":
         # open the specified script
         nuke.scriptOpen(file_path)
         
         # reset any write node render paths:
         if self._reset_write_node_render_paths():
             # something changed so make sure to save the script again:
             nuke.scriptSave()
     elif operation == "save":
         # save the current script:
         nuke.scriptSave()
     elif operation == "save_as":
         old_path = nuke.root()["name"].value()
         try:
             # rename script:
             nuke.root()["name"].setValue(file_path)
             
             # reset all write nodes:
             self._reset_write_node_render_paths()
                     
             # save script:
             nuke.scriptSaveAs(file_path, -1)    
         except Exception, e:
             # something went wrong so reset to old path:
             nuke.root()["name"].setValue(old_path)
             raise TankError("Failed to save scene %s", e)
示例#14
0
def prep():
    nuke.scriptSave()
    node = nuke.thisNode()
    ffpy = __file__
    ffpy = ffpy.replace('pyc', 'py')
    node_framerange = node['framerange'].getValue()

    nk_cmd = "{0} -t {1} {2} --write {3} --output {4}".format(
        nuke.EXE_PATH,
        ffpy,
        nuke.root().knob("name").value(),
        node.fullName(),
        node['file'].getValue())
    print("RENDER COMMAND:\n\t{0}".format(nk_cmd))
    if _platform == "win":
        nuke.message("Windows not supported.")
        return
    if _platform == "osx":
        cmd = '''osascript 2>/dev/null <<EOF
                tell application "Terminal"
                  if not (exists window 1) then reopen
                  activate
                  do script "{0}"
                end tell
                EOF'''.format(nk_cmd)
    elif _platform == "linux":
        # cmd = 'xterm -e "bash {0}"'.format(nk_cmd)
        cmd = 'gnome-terminal -e "bash -c \\"{0}; exec bash\\""'.format(nk_cmd)
        #cmd = 'gnome-terminal -e "bash -c \\"{0}\\""'.format(nk_cmd)
    subprocess.Popen(cmd, shell=True)
示例#15
0
    def render( self ):
        
        frame_range  = self.panel.value("Frame Range")
        thread_count = self.panel.value("Num Threads")
        chunk_size     = self.panel.value("Frames per Chunk")
        force_fullsize   = self.panel.value("Force Fullsize")
        quiet_mode    = self.panel.value("Quiet Mode")
        render_name = self.panel.value("Render Name")
        
        if chunk_size == "None":
                chunk_size = 0

        username = getpass.getuser()
        timestamp = int( time.time() )        
        
        if render_name is None: 
            render_name = "Nuke Render for %s" % username
        
        filename = "/tmp/nuke-%s-%s-%s.nk" % ( frame_range, username, timestamp )
        
        try:
            nuke.scriptSave( filename )
            print filename
        except:
            nuke.message("ERR-001 Unable to save spool file")
            
        nuke_args   = {  "type":"Nuke", "threads":thread_count, "fullsize":force_fullsize, "quiet":quiet_mode, "file":filename, "nodes":self.writeNodes}    
        render_args = { "range":frame_range,  "chunksize":chunk_size, "timestamp":timestamp, "name":render_name,  "user":username,}
        
        print render_args
        print nuke_args
        
        rr = tractor.Render( render_args, nuke_args )
        rr.build()
        rr.spool()
示例#16
0
    def run(self):
        result = nukescripts.PythonPanel.showModalDialog(self)
        if result:
            self.farm.parms['queue']       = str(self.queueKnob.value())
            self.farm.parms['group']       = str(self.group_list.value())
            self.farm.parms['start_frame'] = int(self.start_frame.getValue())
            self.farm.parms['end_frame']   = int(self.end_frame.getValue())
            self.farm.parms['frame_range_arg'] = ["-F %s-%sx%s", 'start_frame', 'end_frame', int(self.every_of_Knob.getValue())]
            self.farm.parms['target_list'] = self.write_name.value().split()
            # First Write node selected will be passed as output_picture varible to render manager
            # It is used mostly for debuging, previewing etc. 
            write_node = self.farm.parms['target_list'][0]
            self.farm.parms['output_picture']   = str(nuke.root().node(write_node).knob("file").getEvaluatedValue())
            self.farm.parms['job_on_hold'] = bool(self.hold_Knob.value())
            self.farm.parms['priority']    = int(self.priorityKnob.value())

            if self.email_Knob.value():
                self.farm.parms['email_list']  = [utils.get_email_address()]
                self.farm.parms['email_opt']   = "eas"

            # Request slots exclusively:
            if self.requestSlots_Knob.value():
                self.farm.parms['req_resources'] = 'procslots=%s' % int(self.slotsKnob.value())
            nuke.scriptSave()
            print self.farm.render()
            return True
        return
示例#17
0
 def submitRender(self):
     filename = str(self.fileTextBox.text())
     nuke.scriptSave()
     if filename.endswith('.autosave'):
         nuke.message('Cannot submit .autosave file for render! Please save and try again.')
         return
     if filename is '' or not os.path.exists(filename):
         nuke.message('Please select a valid file to render!')
         return
     fileDir, fname = os.path.split(filename)
     jobName = 'Nuke - %s' % fname
     renderer = self.jobWidget.getRenderer('Nuke')
     splitMode = self.jobWidget.getSplitMode()
     local = self.jobWidget.localCheckbox.isChecked()
     pool = self.jobWidget.getClientPools()
     if pool == 'Linux Farm':
         pool = ''
     slackUser = self.jobWidget.getSlackUser()
     rendererParams = self.getRendererParams()
     priority = self.jobWidget.getPriority()
     dependent = self.jobWidget.getDependentJob()
     cmd = '%s %s %s' % (renderer, rendererParams, filename)
     hq_server = self.jobWidget.getHQProxy()
     if local:
         newCmd = cmd.split(';')[-1]
         self.submitLocalRender(newCmd)
         nuke.message('Local render started. \nCommand: %s' % newCmd)
     else:
         jobIds = self.jobWidget.submitNoChunk(hq_server, jobName, cmd, priority, 0,
                                               pool, False, slackUser, dependent)
         nuke.message('Job Submission Successful. Job Ids = {0}'.format(jobIds))
示例#18
0
def createThreads(frameStart, frameEnd, numThreads, writeNodes=None):
	nuke.scriptSave()

	if not writeNodes:
		writeNodes = getWriteNodes()

	# Create Folders
	for writeNode in writeNodes:
		try:
			createOutfolder(writeNode)
		except:
			pass



	os.environ["DCC"]			= "nuke"
	os.environ["EXE"]			= nuke.EXE_PATH
	os.environ["SCENE"]			= nuke.root().name()
	os.environ["WRITENODES"]	= str(writeNodes)

	os.environ["frameStart"] 	= str(frameStart)
	os.environ["frameEnd"]		= str(frameEnd)
	os.environ["numThreads"]	= str(numThreads)

	os.environ["FN_NUKE_DISABLE_GPU_ACCELERATION"] = str(1)

	# Start
	setEnvoriment()
	os.chdir(ROOT_RT)

	if sys.platform == "win32":
		print os.startfile("main.bat")
	else:
		opener ="open" if sys.platform == "darwin" else "xdg-open"
		subprocess.call(["bash", "main.sh"])
示例#19
0
def create_snapshot_script(scriptPath=None,
                           snapScriptName=None,
                           upversion=None):
    """
    Writes snapshot .nk script
    :param scriptPath: Path to the snapshot directory where .nk is stored
    :param snapScriptName: Absolute path to the .nk
    :param upversion: if True, minor version +1 (e.g v01.00 --> v01.01)
    """
    try:
        tmpScriptPath = scriptPath
        if upversion:
            up_minor_version = int(
                scriptPath.split("/")[-1].split(".")[-2]) + 1
            up_script_name = ".".join(tmpScriptPath.split("/")[-1].split(".")[:-2]) + "." \
                             + str(up_minor_version).zfill(2) + ".nk"
            tmpScriptPath = "/".join(
                tmpScriptPath.split("/")[:-1]) + "/" + up_script_name
        print "\n~ Writing script: " + str(snapScriptName)
        nuke.scriptSaveAs(str(snapScriptName))
        os.chmod(snapScriptName, 0444)
        rootNode = nuke.toNode('root')
        rootNode.knob('name').setValue(tmpScriptPath)
        nuke.scriptSave()
    except:
        nuke.message("\n! Can't save the script, no snapshot created")
        raise BaseException
    def execute(self, operation, file_path, **kwargs):
        """
        Main hook entry point
        
        :operation: String
                    Scene operation to perform
        
        :file_path: String
                    File path to use if the operation
                    requires it (e.g. open)
                    
        :returns:   Depends on operation:
                    'current_path' - Return the current scene
                                     file path as a String
                    all others     - None
        """
        if file_path:
            file_path = file_path.replace("/", os.path.sep)

        if operation == "current_path":
            # return the current script path
            return nuke.root().name().replace("/", os.path.sep)
        elif operation == "open":
            # open the specified script into the current window
            if nuke.root().modified():
                raise TankError("Script is modified!")
            nuke.scriptClear()
            nuke.scriptOpen(file_path)
        elif operation == "save":
            # save the current script:
            nuke.scriptSave()
示例#21
0
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))
示例#22
0
def createArtifact():

    nuke.scriptSave()
    script = nuke.value("root.name")
    filename, file_extension = os.path.splitext(script)
    artef = '{}_artifact.{}'.format(filename, file_extension)
    shutil.copyfile(script, artef)
示例#23
0
def asd():
    nuke.scriptSave()
    sp.call([
        "shutdown", "-f", "-s", "-t", "30", "-c",
        "\"This is Autoshutdown for Nuke by Mohan pugaz\""
    ])
    return
示例#24
0
def SCrendLinux():
    import nuke
    panel = nuke.Panel("Priority")
    panel.addEnumerationPulldown("priority:", "medium low high")
    if panel.show():
        priority = panel.value("priority:")
    try:
        f = nuke.allNodes()
        for a in f:
            if a.Class() == "comp_layers_core" or a.Class() == "Write":
                sel = a['selected'].value()
                if sel == 1:
                    a['disable'].setValue(0)
                else:
                    a['disable'].setValue(1)

        n = nuke.selectedNodes()
        for n in n:
            x = n['xpos'].value()
            y = n['ypos'].value()
            b = nuke.allNodes("BackdropNode")
            for ba in b:
                xb = ba['xpos'].value()
                yb = ba['ypos'].value()
                if xb < x and yb < y and xb > x - 300 and yb > y - 400 and ba[
                        'label'].value() == "Precomp":
                    ba['tile_color'].setValue(52479)

        ScanlineCoreSubmitRendering(priority, True, True)
    except:
        nuke.scriptSave()
        ScanlineCoreSubmitRendering(priority, True, True)
def dutchdevscripts():
    global  globalprogress
    global  only_enabled_nodes
    global  backup_project_dir
    global  backup_root_dir
    global  handlesize
    global  plemke_version

    dpan = nuke.Panel( "Where to save?");
    dpan.setWidth( 300 );
    dpan.setTitle( "plemkes consolidator  "+plemke_version );
    dpan.addBooleanCheckBox( "backup enabled nodes only" , False );
    dpan.addSingleLineInput( "Handle size" , str( handlesize ) );
    dpan.addFilenameSearch( "Folder Path" , "Select backup folder" );
    dpan.addSingleLineInput( "Backup name" , "NKBK_0001" );


    if dpan.show() == 1 :
        backup_root_dir  	= dpan.value('Folder Path' )
        backup_project_dir  	= dpan.value('Backup name' )
    else:
	nuke.message('You have to select a backup directory ')
	return 0

    only_enabled_nodes = dpan.value('backup enabled nodes only' )
    handlesize = dpan.value('Handle size' )

    prepare_current_project()

    backup_project_name = 'backup_'+ os.path.basename( project_file_name ) 

    open_log_file( backup_project_name  )


    for items in nuke.allNodes():
	bla = items.Class()

	read_node( bla , items )


#### for some strange reasons it skipped reads


    new_project_directory = backup_root_dir+'/'+backup_project_dir

    setting_proj_dir = nuke.root()['project_directory']
    setting_proj_dir.setValue( new_project_directory )


    out_name = backup_root_dir + '/'+ backup_project_dir + '/' + backup_project_name

    nuke.scriptSave( out_name )

    node_dir = backup_root_dir + '/' + backup_project_dir + '/backup_info.txt'
    nuke.message( "Backup Done\nThere are "+ str( errorcnt ) + " Errors \nErrors are mostly missing source files\nOpen "+node_dir + " to check the errors ")

    del globalprogress

    return 1
示例#26
0
def saveBackup(writeName):
	
	scriptLocation = nuke.root().name()
	scriptName = os.path.basename(scriptLocation)
	fileValue = nuke.toNode(writeName)['file'].getValue()
	renderPath = os.path.dirname(fileValue)
	
	nuke.scriptSave(renderPath + "/backup_" + scriptName)	
示例#27
0
文件: save.py 项目: tws0002/jeeves
def run():
    if nuke.Root().name() == 'Root':
        import jnuke.pipeline.save_as
        jnuke.pipeline.save_as.run()
    else:
        nuke.scriptSave("")

    return nuke.Root().name()
示例#28
0
def quickSubmit(*a):
    nuke.scriptSave()
    frame_range = '{0}-{1}'.format(nuke.root().firstFrame(),
                                   nuke.root().lastFrame())
    scene_name = basename(nuke.root().name())
    submit.singleNode(scene_name,
                      nuke.root().name(), frame_range, '5000', '8',
                      'MASTER_WRITE')
示例#29
0
def saveBackup(writeName):

    scriptLocation = nuke.root().name()
    scriptName = os.path.basename(scriptLocation)
    fileValue = nuke.toNode(writeName)['file'].getValue()
    renderPath = os.path.dirname(fileValue)

    nuke.scriptSave(renderPath + "/backup_" + scriptName)
示例#30
0
 def modify_nodes_path(self):
     nuke.scriptSaveAs('{}/{}'.format(self.dest_root,
                                      os.path.basename(nuke.Root().name())),
                       1)
     for node in self.nodes:
         modify_path(node)
     nuke.scriptSave()
     nuke.scriptClear()
     nuke.scriptOpen(self.original_nk)
    def _do_nuke_publish(self, task, work_template, comment, thumbnail_path,
                         sg_task, progress_cb):
        """
        Publish the main Nuke script

        :param task:            The primary task to publish
        :param work_template:   The primary work template to use
        :param comment:         The publish description/comment
        :param thumbnail_path:  The path to the thumbnail to associate with the published file
        :param sg_task:         The Shotgun task that this publish should be associated with
        :param progress_cb:     A callback to use when reporting any progress
                                to the UI
        :returns:               The path to the file that has been published        
        """
        import nuke

        progress_cb(0.0, "Finding dependencies", task)
        dependencies = self._nuke_find_script_dependencies()

        # get scene path
        script_path = nuke.root().name().replace("/", os.path.sep)
        if script_path == "Root":
            script_path = ""
        script_path = os.path.abspath(script_path)

        if not work_template.validate(script_path):
            raise TankError(
                "File '%s' is not a valid work path, unable to publish!" %
                script_path)

        # use templates to convert to publish path:
        output = task["output"]
        fields = work_template.get_fields(script_path)
        fields["TankType"] = output["tank_type"]
        publish_template = output["publish_template"]
        publish_path = publish_template.apply_fields(fields)

        if os.path.exists(publish_path):
            raise TankError("The published file named '%s' already exists!" %
                            publish_path)

        # save the scene:
        progress_cb(25.0, "Saving the script")
        self.parent.log_debug("Saving the Script...")
        nuke.scriptSave()

        # copy the file:
        progress_cb(50.0, "Copying the file")
        try:
            publish_folder = os.path.dirname(publish_path)
            self.parent.ensure_folder_exists(publish_folder)
            self.parent.log_debug("Copying %s --> %s..." %
                                  (script_path, publish_path))
            self.parent.copy_file(script_path, publish_path, task)
        except Exception, e:
            raise TankError("Failed to copy file from %s to %s - %s" %
                            (script_path, publish_path, e))
示例#32
0
def saveInitNkScript(nkFile):
    folder = os.path.dirname(nkFile)
    if not os.path.exists(folder):
        os.makedirs(folder)

    baseNkFile = re.sub(r'(.*)(_v\d{1,5})(\..*$)',
                        '\\1_v{}\\3'.format(baseVer), nkFile)
    nuke.scriptSave(baseNkFile)
    nuke.scriptSave(nkFile)
示例#33
0
    def createScript(self, nukeFile, fileOutNode):
        FlixNuke().clearScript()

        cbNode = nuke.createNode("CheckerBoard2")
        writeNode = nuke.createNode("Write")
        writeNode["name"].setValue(fileOutNode)
        writeNode["file"].setValue("/Users/brice/Desktop/testNuke/test.####.jpeg")
        writeNode.setInput(0, cbNode)
        nuke.scriptSave(nukeFile)
示例#34
0
    def file_save(self):
        """ Save the current file.
			If saving for first time take over and show custom dialog.
		"""
        if self.get_current_name() == 'Root':  # Is current file unsaved?
            self.file_save_dialog()

        else:
            nuke.scriptSave()
示例#35
0
def render_node(node):
    '''launch render'''
    out_path = node['file'].value()
    out_scriptcopy = node['tx_scriptcopy'].value()
    startFrame = int(nuke.Root()['first_frame'].value())
    endFrame = int(nuke.Root()['last_frame'].value())

    def _soloWrite(sel_node, all_enabled_write, mode='solo'):
        if mode == 'solo':
            for s in all_enabled_write:
                if s != sel_node.name():
                    print('node disabled---' + s)
                    nuke.toNode(s)['disable'].setValue(True)
        elif mode == 'reverse':
            for s in all_enabled_write:
                nuke.toNode(s)['disable'].setValue(False)
                print('node enabled---' + s)

    askMessage = "Render Node: %s\nFile: %s\nFramerage: %s-%s\n" % (
        node.name(), os.path.basename(
            node['file'].value()), startFrame, endFrame)
    c = nuke.ask(askMessage)
    if c:
        if not os.path.exists(os.path.dirname(out_path)):
            p = os.path.dirname(out_path)
            os.makedirs(p)
            print("out path created --- %s" % p)
        if not os.path.exists(os.path.dirname(out_scriptcopy)):
            s = os.path.dirname(out_scriptcopy)
            os.makedirs(s)
            print("out scriptcopy created --- %s" % s)

        all_enabled_write = [
            n.name() for n in nuke.allNodes('Write')
            if n['disable'].value() == False
        ]
        _soloWrite(node, all_enabled_write, mode='solo')
        nuke.scriptSave()
        thisScript_path = nuke.scriptName()
        shutil.copy2(thisScript_path, out_scriptcopy)

        # nuke.render(node, startFrame, endFrame)

        exe = joinPath(nuke.EXE_PATH).replace('/', '\\')

        cmd_str = """start cmd /k "{exe}" -t -m 22 -xi {script} {start}-{end}""".format(
            exe=exe,
            node=node.name(),
            script=thisScript_path,
            start=startFrame,
            end=endFrame)

        subprocess.Popen(cmd_str, shell=True)
        _soloWrite(node, all_enabled_write, mode='reverse')
    else:
        print("user cancelled")
示例#36
0
def buildCompScript(layerOrderFile, compScriptFile, isRunningFromScript):

    #imported nuke here as importing it outside was breaking argparse
    if not isRunningFromScript:
        import nuke

    #kept here if script is run from the comp itself
    if not os.path.isfile(layerOrderFile):
        print "Could not find layer_order.yml in " + shotDir
        sys.exit()

    if isRunningFromScript:
        # get nuke script to build
        nuke.scriptOpen(compScriptFile)

    # arrange templates in the given nuke script in vertical order
    templates = getTemplateList(layerOrderFile)

    for i, template in enumerate(templates):
        nuke.scriptReadFile(template)
        nuke.selectAll()
        node = nuke.selectedNodes("BackdropNode")[0]
        dotNode = nuke.selectedNodes('Dot')[0]
        if i > 0:
            bdNodes = node.getNodes()
            nodePrevX = node.xpos()
            nodePrevY = node.ypos()
            node.setYpos(previousNode.ypos() + 500)
            node.setXpos(previousNode.xpos())

            for n in bdNodes:
                if n.ypos() > nodePrevY:
                    n.setYpos(node.ypos() + (n.ypos() - nodePrevY))
                else:
                    n.setYpos(node.ypos() + (n.ypos() + nodePrevY))
                if n.xpos() > nodePrevX:
                    n.setXpos(node.xpos() + (n.xpos() - nodePrevX))
                else:
                    n.setXpos(node.xpos() + (n.xpos() + nodePrevX))

            if i > 1:
                dotNode.setInput(0, previousDotNode.dependent()[0])
            else:
                dotNode.setInput(0, previousDotNode)

        previousNode = node
        previousDotNode = dotNode

        if isRunningFromScript:
            #save nuke script
            nuke.scriptSave(compScriptFile)

        # remove temp files
        for template in templates:
            if "temp" in template:
                os.remove(template)
示例#37
0
文件: Save.py 项目: hdd/ue
def ueSave():
    root = nuke.root()

    if root.name() == "Root":
        ueSaveAs()
        return

#    if not ueNuke.ueScriptSanityCheck():
#        return

    nuke.scriptSave(root.knob("name").value())
示例#38
0
    def _do_nuke_publish(self, task, work_template, comment, thumbnail_path, sg_task, progress_cb):
        """
        Publish the main Nuke script

        :param task:            The primary task to publish
        :param work_template:   The primary work template to use
        :param comment:         The publish description/comment
        :param thumbnail_path:  The path to the thumbnail to associate with the published file
        :param sg_task:         The Shotgun task that this publish should be associated with
        :param progress_cb:     A callback to use when reporting any progress
                                to the UI
        :returns:               The path to the file that has been published        
        """
        import nuke
        
        progress_cb(0.0, "Finding dependencies", task)
        dependencies = self._nuke_find_script_dependencies()
        
        # get scene path
        script_path = nuke.root().name().replace("/", os.path.sep)
        if script_path == "Root":
            script_path = ""
        script_path = os.path.abspath(script_path)
        
        if not work_template.validate(script_path):
            raise TankError("File '%s' is not a valid work path, unable to publish!" % script_path)
        
        # use templates to convert to publish path:
        output = task["output"]
        fields = work_template.get_fields(script_path)
        fields["TankType"] = output["tank_type"]
        publish_template = output["publish_template"]
        publish_path = publish_template.apply_fields(fields)
        
        if os.path.exists(publish_path):
            raise TankError("The published file named '%s' already exists!" % publish_path)
        
        # save the scene:
        progress_cb(25.0, "Saving the script")
        self.parent.log_debug("Saving the Script...")
        nuke.scriptSave()
        
        # copy the file:
        progress_cb(50.0, "Copying the file")
        try:
            publish_folder = os.path.dirname(publish_path)
            self.parent.ensure_folder_exists(publish_folder)
            self.parent.log_debug("Copying %s --> %s..." % (script_path, publish_path))
            self.parent.copy_file(script_path, publish_path, task)
        except Exception, e:
            raise TankError("Failed to copy file from %s to %s - %s" % (script_path, publish_path, e))
def main():
    def change_file_knob_to_abs_path(node, knob_name):
        try:
            if not node[knob_name] == "":
                node[knob_name].setValue(get_abs_path(node[knob_name].value()))
        finally:
            return

    def make_collect_folder():
        split = os.path.splitext(nuke.scriptName())
        dst_path = os.path.join(nuke.script_directory(), split[0] + "_Collected")
        return make_folder(dst_path)

    # noinspection PyArgumentList
    def get_node_tuples_to_collect_by_all():
        node_list = []
        for dic in node_file_knob_dictionary:
            for node in nuke.allNodes(dic[0]):
                node_list.append((node, dic[1]))
        return node_list

    collect_folder_path = make_collect_folder()
    target_node_tuples = get_node_tuples_to_collect_by_all()
    # fileKnobがあるノードをすべてフルパスに変更
    for node_tuple in target_node_tuples:
        change_file_knob_to_abs_path(node_tuple[0], node_tuple[1])

    # collectFolderPathにnkを新規保存
    split_script_name = os.path.splitext(os.path.split(nuke.Root()["name"].getValue())[1])
    new_script_name = split_script_name[0] + "_collected" + split_script_name[1]
    new_script_path = os.path.join(collect_folder_path, new_script_name)
    nuke.scriptSaveAs(new_script_path)

    # project_directoryを設定
    nuke.Root()["project_directory"].setValue("[python {nuke.script_directory()}]")
    # ファイルコピー&パス書き換え
    progress_bar = nuke.ProgressTask("collecting...")
    for node_tuple in target_node_tuples:
        progress_bar.setProgress(
            get_int_percent((target_node_tuples.index(node_tuple) + 1.0) / len(target_node_tuples))
        )
        if progress_bar.isCancelled():
            break
        collect_node(node_tuple, collect_folder_path)

    # nkを保存
    nuke.scriptSave()
    del progress_bar
    nuke.message("complete. \n\n( ´ー`)y-~~")
    return
示例#40
0
    def alfredRender(self):
        
        self.node.end()
        
        for node in nuke.allNodes():
            node.knob('selected').setValue(0)
            
        for write in nuke.allNodes('Write'):
            write.knob('disable').setValue(1)
        
        self.node.begin()
        
        writeRender = nuke.toNode('WriteShot')
        writeRender.knob('selected').setValue(1)
        #nuke.show(writeRender)
        
        # alfred render luncher

        currTime = str(time.strftime('%d%m%y_%H%M%S'))
        nuke.scriptSave('')
        nukeScene = nuke.toNode('root').name()
        fileDir = os.path.dirname(nukeScene)+'/'

        panel = nuke.Panel('Alfred batch render')
        panel.addSingleLineInput('frame range', str(int(nuke.root()['first_frame'].getValue()))+','+str(int(nuke.root()['last_frame'].getValue())))
        val = panel.show()
        if val ==1:
            frameRange = panel.value('frame range')
            
            for write in nuke.allNodes('Write'):
                write.knob('disable').setValue(1)
            
            writeRender.knob('disable').setValue(0)

            renderScene = fileDir+'.'+os.path.basename(nukeScene).split('.')[0]+'_alfredrender_'+writeRender.name()+'_'+currTime+'.nk'
            nuke.scriptSaveAs(renderScene, overwrite = 1)
            
            print 'sending '+renderScene+' to Alfred ...'
            #nuke.tcl('exec rnuke "'+renderScene+'" '+frameRange+' &;')
            os.popen('rnuke '+renderScene+' '+frameRange+' &')
            
            for write in nuke.allNodes('Write'):
                write.knob('disable').setValue(0)
            
            nuke.scriptSaveAs(nukeScene, overwrite = 1)
            
        else:
            print 'abort...'
示例#41
0
def rrSubmit_Nuke_Node(node):
    nuke.scriptSave()
    CompName = nuke.root().name()
    if (CompName == None) or (len(CompName) == 0):
        writeError("Nuke comp not saved!")
        return
    jobList = []
    noLocalSceneCopy = [False]
    rrSubmit_CreateSingleJobs_Node(jobList, noLocalSceneCopy, node)
    submitOptions = ""
    if noLocalSceneCopy[0]:
        submitOptions = submitOptions + "AllowLocalSceneCopy=0~0 "
    if rrSubmit_NukeXRequired():
        submitOptions = submitOptions + " CONukeX=1~1 "
    rrSubmit_addPluginLicenses(jobList)
    submitJobsToRR(jobList, submitOptions)
示例#42
0
def rrSubmit_Nuke_Shotgun():
    #writeInfo ("rrSubmit v 7.0.24")
    nuke.scriptSave()
    CompName = nuke.root().name()
    if ((CompName==None) or (len(CompName)==0)):
        writeError("Nuke comp not saved!")
        return
    jobList= []
    noLocalSceneCopy= [False]
    rrSubmit_CreateSingleJobs_shotgun(jobList)
    submitOptions=""
    #if (noLocalSceneCopy[0]):
    #    submitOptions=submitOptions+"AllowLocalSceneCopy=0~0 "
    if (rrSubmit_NukeXRequired()):
        submitOptions=submitOptions+" CONukeX=1~1 "
    rrSubmit_addPluginLicenses(jobList)
    submitJobsToRR(jobList,submitOptions)
示例#43
0
 def replacePath(self):
   for n in nuke.allNodes():
     if n.Class() in ['ReadGeo2','Camera2','Axis2','WriteGeo']:
       a = n.knob('file').value()
       a = a.replace( os.path.dirname(a) , self.scriptRoot+'/FBX')
       n.knob('file').setValue(a)
   for n in nuke.allNodes('Read'):
     a = n.knob('file').value()
     a = a.replace( '/'.join(os.path.dirname(a).split('/')[0:-1]) , self.scriptRoot+'/LAYERS')
     n.knob('file').setValue(a)
   for n in nuke.allNodes('Write'):
     a = n.knob('file').value()
     a = a.replace( '/'.join(os.path.dirname(a).split('/')[0:-1]) , self.scriptRoot+'/WRITE')
     n.knob('file').setValue(a)
   nuke.scriptSave("")
   if self.log.value():
     self.generateLog()
 def _nuke_execute(self, operation, file_path, **kwargs):
     """
     The Nuke specific scene operations.
     """
     if file_path:
         file_path = file_path.replace("/", os.path.sep)        
     
     if operation == "current_path":
         # return the current script path
         return nuke.root().name().replace("/", os.path.sep)
     elif operation == "open":
         # open the specified script into the current window
         if nuke.root().modified():
             raise TankError("Script is modified!")
         nuke.scriptClear()
         nuke.scriptOpen(file_path)
     elif operation == "save":
         # save the current script:
         nuke.scriptSave()
示例#45
0
def batchReset(src,out):
    print src
    errFlg = 0
    nuke.scriptOpen(src)
    for node in nuke.allNodes('Read'):
        if os.path.dirname(node.knob('file').getValue()) != r'S:/LSC/CGI/Asset/lightset/asset_checklight/nukeimages':
            print os.path.dirname(node.knob('file').getValue())           
            filelist = scanForFiles(os.path.dirname(node.knob('file').getValue()))
            print filelist
            node.knob('file').setValue(os.path.dirname(node.knob('file').getValue())+'/'+filelist[0][0])
            node.knob('first').setValue(filelist[0][1])
            node.knob('last').setValue(filelist[0][2])
            node.knob('origfirst').setValue(filelist[0][1])
            node.knob('origlast').setValue(filelist[0][2])
    if not errFlg:
        print 'All selected Read nodes were reset.'
    nuke.scriptSave(out)
    for allnode in nuke.allNodes():
        nuke.delete(allnode)
示例#46
0
def post_publish():
    element = nuke_publish_dialog.result

    if nuke_publish_dialog.published:
        #save the file
        nuke.scriptSave()

        #Publish
        user = nuke_publish_dialog.user
        src = nuke_publish_dialog.src
        comment = nuke_publish_dialog.comment
        dst = element.publish(user, src, comment)
        #Ensure file has correct permissions
        try:
            os.chmod(dst, 0660)
        except:
            pass

        print "TODO: export playblast"
        print nuke_publish_dialog.result.get_name()
示例#47
0
def checkin():
    filePath = nuke.callbacks.filenameFilter( nuke.root().name() )
    save = nuke.scriptSave()
    if save==True:
        toCheckin = os.path.join(amu.getUserCheckoutDir(), os.path.basename(os.path.dirname(filePath)))
        if amu.canCheckin(toCheckin):
            dest = amu.checkin(toCheckin, False)
            nuke.message('Checkin Successful!')
            nuke.scriptClose()
        else:
            nuke.message('Can not check in')
示例#48
0
def checkin():
	save = nuke.scriptSave()
	if save==True:
		toCheckin = get_checkin_path()
		if can_checkin():
			amu.setComment(toCheckin, 'comment')
			dest = amu.checkin(toCheckin)
			nuke.message('Checkin Successful!')
			nuke.scriptClose()
		else:
			nuke.message('Can not check in')
示例#49
0
文件: rvNuke.py 项目: hradec/pipeVFX
    def prepForRender (self, node, renderType) :

        log ("prepForRender %s %s" % (node.name(), renderType))

        baseDir = self.sessionDir + "/" + renderType

        dateString = time.strftime("%b %d %H:%M:%S")
        if (renderType == "checkpoint") :
            dateStringForName = "_" + re.sub (" ", "_", re.sub (":", "_", dateString))
        else :
            dateStringForName = ""

        nodeDir = baseDir + "/" + node.name() + dateStringForName;

        if (not os.path.exists (nodeDir)) :
            log ("making directory '%s'" % nodeDir)
            os.makedirs (nodeDir)

        nuke.scriptSave (nodeDir + "/" + renderType + ".nk")

        return dateString
示例#50
0
def createThreads(frameStart, frameEnd, numThreads, writeNodes=None):
	nuke.scriptSave()

	if not writeNodes:
		writeNodes = getWriteNodes()


	os.environ["DCC"]			= "nuke"
	os.environ["EXE"]			= nuke.EXE_PATH
	os.environ["SCENE"]			= nuke.root().name()
	os.environ["WRITENODES"]	= str(writeNodes)

	os.environ["frameStart"] 	= str(frameStart)
	os.environ["frameEnd"]		= str(frameEnd)
	os.environ["numThreads"]	= str(numThreads)


	# Start
	setEnvoriment()
	os.chdir(ROOT_RT)
	print os.startfile("main.bat")
示例#51
0
def nk_backburner():
	"""
	Background render
	Note: this assumes that the nuke executable is in PATH
	"""
	nuke.scriptSave()
	op = nuke.root()['name'].value()
	name = nuke.selectedNode().name()
	np = op+"_%s.bburn"%name
	shutil.copy2(op,np)
	ranges = "%s-%s" % (nuke.root().firstFrame(),nuke.root().lastFrame())
	cmd = """ "%s" -m %i -F %s -X %s -ix %s""" % (nuke.EXE_PATH, int(nuke.env['numCPUs']/2), ranges, name, np)
	print cmd

	def render():
		print "Background rendering %s" % name
		try:
			Popen(cmd).wait()
		except WindowsError: # TODO: WTF is up with this?
			os.popen(cmd).read()
		nuke.message("%s Background render finished!" % name)
		nuke.executeInMainThread(nuke.toNode(name)['reading'].setValue,True)
		os.remove(np)

	def changeNodeColor(thisName):
		if nuke.thisNode().name() == thisName:
			nuke.executeInMainThread(nuke.toNode(thisName)['tile_color'].setValue,552079871)
			nuke.executeInMainThread(nuke.toNode(thisName)['postage_stamp'].setValue,True)
			nuke.removeKnobChanged(changeNodeColor,thisName,{},"Write")

	this = nuke.toNode(name)
	this['tile_color'].setValue(943405567)
	this['postage_stamp'].setValue(False)
	this['reading'].setValue(False)

	nuke.addKnobChanged(changeNodeColor,name,{},"Write")

	T = threading.Thread(target=render)
	T.start()
示例#52
0
def custom_execute_panel(_list, exceptOnError = True):
	"""
	Override the default way Nuke executes multiple Write nodes to allow
	each Write node's addBeforeRender and addBeforeFrameRender to execute
	code *specific to that node* before they are rendered.
	"""
	_list = nuke.allNodes("Write") if _list[0]	== nuke.root() else _list
	_list = [n for n in _list if not (n['disable'].value() or n['reading'].value())]
	if len(_list) == 0:
		nuke.message("No renderable Write nodes!")
		return
	else:
		_list = sorted(_list,key=lambda x: x['render_order'].value())
		nuke.scriptSave("")
		for n in _list:
			if n['use_limit'].value():
				first,last = n['first'].value(),n['last'].value()
			else:
				first,last = nuke.root().firstFrame(),nuke.root().lastFrame()
			print "Render started: %s" % n.name()
			nuke.execute(n.name(),int(first),int(last))
			print "Render completed: %s" % n.name()
    def execute(self, **kwargs):
                
        items = []
        
        # get the main scene:
        scene_name = nuke.root()['name'].value()
        if not scene_name:
            raise TankError("Please Save your file before Rendering")
                 
        items.append({"type": "work_file", "value": scene_name})
        
        #scan scene for starting information
        items.append({'type':'start','value': nuke.root()['first_frame'].value()})
        items.append({'type':'end','value': nuke.root()['last_frame'].value()})
        items.append({'type':'limit','value':'nuke_render'})
        
        jobname = '.'.join(os.path.basename(scene_name).split('.')[0:-1])
        items.append({'type':'jobname','value':jobname})
        
        #saving scene before dialog
        nuke.scriptSave()

        return items
示例#54
0
文件: pathmap.py 项目: Spudster3/cgru
def pmSaveToServer():
   print 'Saving scene to server paths...'
   pm = PathMap( UnixSeparators = True, Verbose = True)
   nuke.scriptSave()

   # Get server scene name:
   scenename = nuke.root().name()
   scenename_server = scenename + '.' + SERVER_PATHS_SUFFIX + '.nk'

   # Map paths from client to server:
   error_msg = ''
   if pm.initialized:
      pm.toServerFile( scenename, scenename_server, SearchStrings, Verbose = True)
   else:
      print 'No paths map preset. Just copying scene to:'
      print scenename_server
      try:
         shutil.copy( scenename, scenename_server)
      except:
         error_msg = str(sys.exc_info()[1])
         print 'File copied with error:'
         print error_msg

   if error_msg != '': nuke.message('Server scene copy error:\n' + error_msg)
    def execute(self, **kwargs):

        scene_name = nuke.root()["name"].value()
        if not scene_name:
            raise TankError("Please Save your file before Rendering")

        jobname = os.path.splitext(os.path.basename(scene_name))[0]

        start = nuke.root()["first_frame"].value()
        end = nuke.root()["last_frame"].value()

        attrs = [
            {"name": "submit_file", "value": str(scene_name), "title": "Submit File", "hidden": True},
            {"name": "start", "value": int(start), "title": "Start Frame"},
            {"name": "end", "value": int(end), "title": "End Frame"},
            {"name": "by", "value": 1, "title": "By Frame"},
            {"name": "jobname", "value": str(jobname), "title": "Job Name"},
            {"name": "queue", "value": ["high", "mid", "low"], "title": "Queue"},
            {"name": "submit", "value": True, "title": "Submit Job"},
        ]

        nuke.scriptSave()

        return attrs
示例#56
0
def save_script():
    """
    Save the current script under the
    same name. Return True or False depending on
    wether or not the operation was successful.
    """

    try:
        
        result = nuke.scriptSave()
        return result
    
    except:

        # log
        logger.info('Error saving file.')
        
        return False
示例#57
0
def _collect(localPath):
	n = nuke.allNodes()
	seqPads = ['%01d', '%02d', '%03d', '%04d', '%05d', '%06d', '%07d', '%08d', '%d', '%1d']

	# Get script name
	scriptName = os.path.basename(nuke.Root().name())

	# Save script to archive path
	newScriptPath = localPath + scriptName
	nuke.scriptSaveAs(newScriptPath)

	# Build lists of nodes (also remove duplicate Read nodes)
	if nuke.allNodes("Read"):
		readNodes = _dupReadDestroy(False)
		readPaths = [nukescripts.replaceHashes(node['file'].value()) for node in readNodes]
	else:
		readNodes = None
	readGeoNodes = nuke.allNodes("ReadGeo2") + nuke.allNodes("ReadGeo")
	readGeoPaths = [nukescripts.replaceHashes(node['file'].value()) for node in readGeoNodes]
	fbxNodes = [node for node in nuke.allNodes("Axis2") + nuke.allNodes("Camera2") if node['read_from_file'].value()]
	
	# Check to make sure there is something to archive
	if not readNodes and not readGeoNodes and not fbxNodes:
		return False

	# Create log file and write header info to it
	fOut = open(localPath + 'Archive Log.txt', 'w')
	fOut.write('Comp archived %s at %s\n\n\n' % (strftime("%m/%d/%Y"), strftime("%H:%M:%S")))   
	fOut.write('Comp Name: %s\n\n' % scriptName)
	fOut.write('Files archived to:\n\t%s\n\n\n' % localPath)

	# Archive Read nodes (if applicable)
	if readNodes:
		fOut.write('Read nodes and associated source files:\n')

		# Create footage directory
		os.makedirs(localPath + "Footage")
		footagePath = localPath + "Footage/"

		for node in readNodes:
			# Get Read node's footage path
			currentPath = node['file'].value()
			seqName = os.path.basename(currentPath)
			seqTuple = os.path.splitext(seqName)

			# Build local path to assign to Read node
			localReadFolder = footagePath + node.name()
			os.mkdir(localReadFolder)

			# Check for a sequence and copy if applicable
			if seqTuple[0].endswith(tuple(seqPads)):
				curFrame = node.firstFrame()
				while curFrame <= node.lastFrame():
					fileName = seqName % (curFrame, )
					shutil.copy2('%s/%s' % (os.path.dirname(currentPath), fileName), localReadFolder)
					curFrame += 1

			# Copy single file
			else:
				shutil.copy2(currentPath, localReadFolder)

			# Re-link Read node to local footage
			node['file'].setValue('%s/%s' % (localReadFolder, seqName))
			# Output Read node info to log file
			fOut.write('\t%s: %s\n' % (node.name(), seqName))

	# Archive Geometry nodes (if applicable)
	if readGeoNodes:
		fOut.write('\nReadGeo nodes and associated geometry files:\n')

		# Create geometry directory
		os.makedirs(localPath + "Geometry")
		geoPath = localPath + "Geometry/"

		for node in readGeoNodes:
			# Get Geo node's file path
			currentPath = node['file'].value()
			seqName = os.path.basename(currentPath)
			seqTuple = os.path.splitext(seqName)

			# Build local path to assign to Geo node
			localGeoFolder = geoPath + node.name()
			os.mkdir(localGeoFolder)

			# Check for a geo sequence and copy if applicable 
			# A little different than Read node since ReadGeo nodes have no explicit frame range
			if seqTuple[0].endswith(tuple(seqPads)):
				if seqTuple[0].endswith(('%d', '%1d')):
					padLength = 1
					if seqTuple[0].endswith('%d'):
						baseName = seqTuple[0][:-2]
					else:
						baseName = seqTuple[0][:-3]
				else:
					padLength = seqPads.index(seqTuple[0][-4:]) + 1
					baseName = seqTuple[0][:-4]
				extMatch = [i for i in os.listdir(os.path.dirname(currentPath)) if os.path.splitext(i)[1] == seqTuple[1]]
				fnPattern = baseName
				for i in range(0,padLength):
					fnPattern += '[0-9]'
				fnPattern += seqTuple[1]
				for f in extMatch:
					if fnmatch(f, fnPattern):
						shutil.copy2('%s/%s' % (os.path.dirname(currentPath), f), localGeoFolder)

			# Copy single file
			else:
				shutil.copy2(currentPath, localGeoFolder)

			# Re-link Geo node to local footage
			node['file'].setValue('%s/%s' % (localGeoFolder, seqName))
			# Output Geo node info to log file
			fOut.write('\t%s: %s\n' % (node.name(), seqName))

	# Archive FBX-dependent nodes (if applicable)
	if fbxNodes:
		fOut.write('\nFBX-dependent nodes and associated FBX files:\n')

		# Create FBX directory
		os.makedirs(localPath + "FBX")
		fbxPath = localPath + "FBX/"

		for node in fbxNodes:
			# Get FBX node's file path
			currentPath = node['file'].value()
			fileName = os.path.basename(currentPath)

			# Build local path to assign to FBX node
			localFBXFolder = fbxPath + node.name()
			os.mkdir(localFBXFolder)

			# Copy FBX file to local path
			shutil.copy2(currentPath, localFBXFolder)

			# Re-link FBX node to local footage
			node['file'].setValue('%s/%s' % (localFBXFolder, fileName))
			# Output FBX node info to log file
			fOut.write('\t%s: %s\n' % (node.name(), fileName))

	# Write total number of copied files to log file
	fOut.write('\n\n%d files total' % (sum((len(f) for _, _, f in os.walk(localPath)))-2, ))
	fOut.close()

	# Save script and return successfully
	nuke.scriptSave()
	return True
示例#58
0
def collectFiles():
    panelResult = collectPanel()

    #copy script to target directory
    script2Copy = nuke.root()['name'].value()
    scriptName = os.path.basename(nuke.Root().name())

    fileNames = []
    paddings = ['%01d', '%02d', '%03d', '%04d', '%05d', '%06d', '%07d', '%08d', '%d', '%1d']
    videoExtension = ['mov', 'avi', 'mpeg', 'mpg', 'mp4', 'R3D']
    cancelCollect = 0

    # hit OK
    if panelResult[0] == 1 and panelResult[1] != '':
        targetPath = panelResult[1]

        # Check to make sure a file path is not passed through
        if os.path.isfile(targetPath):
            targetPath = os.path.dirname(targetPath)

        # Make sure target path ends with a slash (for consistency)
        if not targetPath.endswith('/'):
            targetPath += '/'

        # Check if local directory already exists. Ask to create it if it doesn't
        if not os.path.exists(targetPath):
            if nuke.ask("Directory does not exist. Create now?"):
                try:
                    os.makedirs(targetPath)
                except:
                    raise Exception, "Something's not working!"
                    return False
            else:
                nuke.message("Cannot proceed without valid target directory.")
                return False
       
        # Get script name
        scriptName = os.path.basename(nuke.Root().name())
    
        footagePath = targetPath + 'footage/'
        if (os.path.exists(footagePath)):
            pass
        else:
            os.mkdir(footagePath)

        task = nuke.ProgressTask("Collect Files 1.2")
        count = 0

        for fileNode in nuke.allNodes():
            if task.isCancelled():
                cancelCollect = 1
                break
            count += 1
            task.setMessage("Collecting file:   " + str(fileNode))
            task.setProgress(count*100/len(nuke.allNodes()))


            if checkForKnob(fileNode, 'file'):
                if not checkForKnob(fileNode, 'Render'):
                    fileNodePath = fileNode['file'].value()
                    if (fileNodePath == ''):
                        continue
                    else:
                        readFilename = fileNodePath.split("/")[-1]
                        
                        if checkForKnob(fileNode, 'first'):

                            if (fileNodePath.endswith(tuple(videoExtension))):
                                newFilenamePath = footagePath + fileNodePath.split("/")[-1]
                                if (os.path.exists(newFilenamePath)):
                                    print (newFilenamePath + '     DUPLICATED')
                                else:
                                    if (os.path.exists(fileNodePath)):
                                        shutil.copy2(fileNodePath, newFilenamePath)
                                        print (newFilenamePath + '     COPIED')                                       
                                    else:
                                        print (newFilenamePath + '     MISSING')        

                            else:
                                # frame range
                                frameFirst = fileNode['first'].value()
                                frameLast = fileNode['last'].value()
                                framesDur = frameLast - frameFirst
                                
                                if (frameFirst == frameLast):
                                    newFilenamePath = footagePath + readFilename
                                    if (os.path.exists(newFilenamePath)):
                                        print (newFilenamePath + '     DUPLICATED')
                                    else:
                                        if (os.path.exists(fileNodePath)):
                                            shutil.copy2(fileNodePath, newFilenamePath)
                                            print (newFilenamePath + '     COPIED')                             
                                        else:
                                            print (newFilenamePath + '     MISSING')

                                else:
                                    dirSeq = fileNodePath.split("/")[-2] + '/'
                                    newFilenamePath = footagePath + dirSeq
                                    if (os.path.exists(newFilenamePath)):
                                        print (newFilenamePath + '     DUPLICATED')
                                    else:
                                        os.mkdir(newFilenamePath)
    
                                    # rename sequence
                                    for frame in range(framesDur + 1):
                                        for pad in paddings:
            
                                            # Copy sequence file
                                            if (re.search(pad, fileNodePath.split("/")[-1])):
                                                originalSeq = fileNodePath.replace(pad, str(pad % frameFirst))
                                                frameSeq = fileNodePath.split("/")[-1].replace(pad, str(pad % frameFirst))
                                                fileNames.append (frameSeq)
                                                newSeq = newFilenamePath + frameSeq
                                                frameFirst += 1
                                                task.setMessage("Collecting file:   " + frameSeq)
        
                                                if (os.path.exists(newSeq)):
                                                    print (newSeq + '     DUPLICATED')
                                                else:
                                                    if (os.path.exists(originalSeq)):
                                                        shutil.copy(originalSeq, newSeq)
                                                        print (newSeq + '     COPIED')                      
                                                    else:
                                                        print (newSeq + '     MISSING')

                                    print ('\n')
                            
                        # Copy single file
                        else:
                            newFilenamePath = footagePath + fileNodePath.split("/")[-1]
                            if (os.path.exists(newFilenamePath)):
                                print (newFilenamePath + '     DUPLICATED')
                            else:
                                if (os.path.exists(fileNodePath)):
                                    shutil.copy2(fileNodePath, newFilenamePath)
                                    print (newFilenamePath + '     COPIED')
                                else:
                                    print (newFilenamePath + '     MISSING')

            else:
                pass

        
        if (cancelCollect == 0):
            # Save script to archive path
            newScriptPath = targetPath + scriptName
            nuke.scriptSaveAs(newScriptPath)
    
            #link files to new path
            for fileNode in nuke.allNodes():
                if checkForKnob(fileNode, 'file'):
                    if not checkForKnob(fileNode, 'Render'):
                        fileNodePath = fileNode['file'].value()
                        if (fileNodePath == ''):
                            continue
                        else:
                            
                            if checkForKnob(fileNode, 'first'):                            
                                if (fileNodePath.endswith(tuple(videoExtension))):
                                    fileNodePath = fileNode['file'].value()
                                    readFilename = fileNodePath.split("/")[-1]
                                    reloadPath = '[file dirname [value root.name]]/footage/' + readFilename
                                    fileNode['file'].setValue(reloadPath)
                                else:
                                    # frame range
                                    frameFirst = fileNode['first'].value()
                                    frameLast = fileNode['last'].value()
        
                                    if (frameFirst == frameLast):
                                        fileNodePath = fileNode['file'].value()
                                        readFilename = fileNodePath.split("/")[-1]
                                        reloadPath = '[file dirname [value root.name]]/footage/' + readFilename
                                        fileNode['file'].setValue(reloadPath)
                                    else:
                                        fileNodePath = fileNode['file'].value()
                                        dirSeq = fileNodePath.split("/")[-2] + '/'
                                        readFilename = fileNodePath.split("/")[-1]
                                        reloadPath = '[file dirname [value root.name]]/footage/' + dirSeq + readFilename
                                        fileNode['file'].setValue(reloadPath)
                            
                            else:
                                fileNodePath = fileNode['file'].value()
                                readFilename = fileNodePath.split("/")[-1]
                                reloadPath = '[file dirname [value root.name]]/footage/' + readFilename
                                fileNode['file'].setValue(reloadPath)
                    else:
                        pass
                else:
                    pass
    
            nuke.scriptSave()
            del task        
            print ('COLLECT DONE!!')
            nuke.message('COLLECT DONE!!')

        else:
            del task
            print ('COLLECT CANCELLED - Toma Rojo Puto')
            nuke.message('COLLECT CANCELLED')

    # If they just hit OK on the default ellipsis...
    elif panelResult[0] == 1 and panelResult[1] == '':
        nuke.message("Select a path")
        return False

    # hit CANCEL
    else:
        print ('COLLECT CANCELLED')
    def execute(self, operation, file_path, context, parent_action, file_version, read_only, **kwargs):
        """
        Main hook entry point

        :param operation:       String
                                Scene operation to perform

        :param file_path:       String
                                File path to use if the operation
                                requires it (e.g. open)

        :param context:         Context
                                The context the file operation is being
                                performed in.

        :param parent_action:   This is the action that this scene operation is
                                being executed for.  This can be one of:
                                - open_file
                                - new_file
                                - save_file_as
                                - version_up

        :param file_version:    The version/revision of the file to be opened.  If this is 'None'
                                then the latest version should be opened.

        :param read_only:       Specifies if the file should be opened read-only or not

        :returns:               Depends on operation:
                                'current_path' - Return the current scene
                                                 file path as a String
                                'reset'        - True if scene was reset to an empty
                                                 state, otherwise False
                                all others     - None
        """

        # AARDMAN ADDITION
        # adds short cuts to file browser
        aaNukeUtils.aaSetupShortCuts()

        if file_path:
            file_path = file_path.replace("/", os.path.sep)

        if operation == "current_path":
            # return the current script path
            return nuke.root().name().replace("/", os.path.sep)

        elif operation == "open":
            # open the specified script
            nuke.scriptOpen(file_path)

            # reset any write node render paths:
            if self._reset_write_node_render_paths():
                # something changed so make sure to save the script again:
                nuke.scriptSave()

        elif operation == "save":
            # save the current script:
            nuke.scriptSave()

        elif operation == "save_as":
            old_path = nuke.root()["name"].value()
            try:
                # rename script:
                nuke.root()["name"].setValue(file_path)

                # reset all write nodes:
                self._reset_write_node_render_paths()

                # save script:
                nuke.scriptSaveAs(file_path, -1)
            except Exception, e:
                # something went wrong so reset to old path:
                nuke.root()["name"].setValue(old_path)
                raise TankError("Failed to save scene %s", e)