Schreiben Sie mit Python einen Render-Manager für Nuke

() translation by (you can also view the original English article)

Erfahren Sie, wie Sie mit Python einen benutzerdefinierten Render-Manager für Nuke schreiben, mit dem Sie ein oder mehrere Nuke-Projekte rendern können, ohne die Software öffnen zu müssen.

1. Einleitung

In diesem Lernprogramm wird erläutert, wie Sie eine Software schreiben, mit der Sie den Renderprozess in Nuke verwalten können. Möglicherweise müssen mehrere Nuke-Kompositionen gerendert werden. Wenn Sie also ein solches Programm verwenden, können Sie alle auf einmal rendern, ohne Nuke selbst zu öffnen. Dies bedeutet, dass das System die grafische Oberfläche von Nuke nicht lädt, sodass mehr Speicher für das Rendern reserviert werden kann Prozess. Hier sehen Sie ein Beispiel für das Programm, das Sie erstellen werden:

Das Programm verfügt über eine übersichtliche Benutzeroberfläche, mit der Sie so viele Renderings organisieren und in die Warteschlange stellen können, wie Sie benötigen.

Bedarf

In diesem Tutorial gehe ich davon aus, dass Sie ein grundlegendes Verständnis von Python und einigen dos-Befehlen haben. Diese Software soll unter dem Windows-Betriebssystem ausgeführt werden. Folgende Tools benötigen Sie:

Python 2.x installiert (https://www.python.org) Verwenden Sie die 3.x-Version nicht, da Nuke sie nicht unterstützt.

wxPython-Bibliothek (http://www.wxpython.org) Hiermit können Sie eine Benutzeroberfläche erstellen. Sie können auch Tkinter, Qt verwenden, dies wird jedoch in diesem Tutorial nicht behandelt.

Softwarestruktur

Wir werden diese Software NukeRenderManager nennen. Das Programm besteht aus drei Dateien:

NukeRenderingManager.py
exeNuke.bat
Rendering.py

NukeRenderingManager.py: Es enthält alles über die grafische Benutzeroberfläche sowie alle Informationen zum Speicherort der Nuke-Projekte und zu allen Frame-Bereichen.

exeNuke.bat: Es ist dafür verantwortlich, Nuke im Terminalmodus zu starten, indem alle Informationen aus der Datei NukeRenderingManager.py durchlaufen werden. Diese Datei wird für jedes Rendern aufgerufen. Wenn also drei Nuke-Comps gerendert werden müssen, wird diese Datei dreimal ausgeführt.

Rendering.py: Es ruft alle Informationen von exeNuke.bat ab und führt das Rendern durch. Diese Datei wird für jedes Nuke-Projekt ausgeführt.

2. Schreiben Sie die Datei NukeRenderingManager.py

Beschreibung

Die Datei NukeRenderingManager.py verwaltet die Benutzeroberfläche und organisiert die Liste der zu rendernden Projekte.

Die Benutzeroberfläche

Zum Erstellen unserer Benutzeroberfläche verwenden wir die wxPython-Bibliothek. Wie ich bereits sagte, können Sie eine andere Bibliothek verwenden, aber für den Zweck dieses Tutorials werde ich wxPython erklären. Um es zu installieren, müssen Sie nur das Installationsprogramm herunterladen, es starten und alles ist fertig (Sie finden den Link oben). Nach der Installation der Bibliothek müssen Sie Python 2.x IDLE starten. Dadurch erhalten Sie die Python-Shell. Wählen Sie im Menü Datei die Option Neue Datei. Jetzt haben Sie einen leeren Editor. Wenn Sie möchten, können Sie jeden anderen Editor verwenden, mit dem Sie sich möglicherweise wohl fühlen.

Speichern Sie die Datei als NukeRenderingManager.py und legen Sie sie in einem beliebigen Ordner ab.

Als erstes müssen Sie die benötigten Module importieren. Das erste ist ein Betriebssystem, mit dem wir die Funktionen des Betriebssystems verwenden können, das zweite ist das wx, das zum Erstellen einer grafischen Benutzeroberfläche hilfreich sein wird:

1	import os
2	import wx

Wir werden ein Fenster erstellen, das alles enthält, was wir brauchen. Um dieses Ziel zu erreichen, erstellen wir eine benutzerdefinierte Klasse, die von wx.Frame abgeleitet ist:

1	Class mainWindow(wx.Frame):

Dann implementieren wir den Konstruktor, indem wir den wx.Frame.__ init__ aufrufen:

1	def __init__(self):
2
3	#constructor
4	wx.Frame.__init__(self,None,title="Nuke Rendering Manager",size=(600,300),style=wx.SYSTEM_MENU\|wx.CAPTION\|wx.CLOSE_BOX)

Dann erstellen wir eine Statusleiste:

1	self.CreateStatusBar()

Wir fügen ein Textsteuerelement hinzu, um anzuzeigen, welche Nuke-Projekte verarbeitet werden sollen:

# prepare the Nuke scripts list on screen
self.NukeScriptsList=wx.TextCtrl(self, style=wx.TE_MULTILINE)
self.NukeScriptsList.SetEditable(False)
self.NukeScriptsList.SetBackgroundColour((120,120,120))
self.NukeScriptsList.SetForegroundColour((50,255,50))
self.NukeScriptsList.SetValue('Nuke scripts:\n')

Die wx.TextCtrl bietet uns einen Bereich, in dem wir die Liste schreiben können. Wir benötigen sie als mehrzeilig, damit wir wx.TE_MULTILINE deklarieren. Es muss nicht bearbeitet werden können, daher verwenden wir SetEditable(False). Dann definieren wir einige Farben und zeigen schließlich einen Text an.

Dann erstellen wir eine Render-Schaltfläche:

1	# it creates the render button
2	self.RenderButton=wx.Button(self,label="Render",pos=(8,200))

Eine sehr wichtige Sache ist der Sizer. Mit dem Sizer können wir ein Layout definieren. Wir verwenden den BoxSizer, der Elemente horizontal und vertikal platziert. Wir wählen eine vertikale Platzierung für das Textsteuerelement und die Schaltfläche:

1	self.layout=wx.BoxSizer(wx.VERTICAL)
2	self.layout.Add(self.NukeScriptsList,1,wx.EXPAND)
3	self.layout.Add(self.RenderButton,0,wx.EXPAND)
4	self.SetSizer(self.layout)

Der zweite Parameter in der Add-Methode ist eine Zahl, die beschreibt, wie viel Platz jedes Element einnimmt. 0 bedeutet, dass die Mindestgröße verwendet wird. 1 bedeutet, dass der verfügbare Platz belegt wird. In unserem Fall möchten wir, dass die Schaltfläche und der Text minimiert werden steuern, um den verbleibenden Platz zu haben.

Wir bereiten einige Variablen vor:

1	self.NukeScripts=[]
2	self.dirName=""
3	self.fileName=""

Dann bereiten wir das Menü vor. Wir erstellen zunächst eine Menüleiste als wx.MenuBar(), erstellen ein Menü mit dem Namen filemenu als wx.Menu(), fügen die Elemente Nuke-Skripte hinzufügen und Beenden hinzu und hängen sie an das Dateimenü an. Und schließlich hängen wir das Menü an menuBar an:

# it creates menu items
menuBar=wx.MenuBar()

filemenu=wx.Menu()
addNukeScript=filemenu.Append(wx.ID_ANY,"Add Nuke script","Add Nuke script")
ClearList=filemenu.Append(wx.ID_ANY,"Clear list","Clear list")
exitEvt=filemenu.Append(wx.ID_EXIT,"Exit","Exit")

menuBar.Append(filemenu,"File")
self.SetMenuBar(menuBar)

wx.ID_ANY wx.ID_EXIT werden verwendet, um den Elementen eine ID bereitzustellen. Im ersten Fall erhalten wir eine ID für das Element, im zweiten Fall haben wir eine ID_EXIT, die eine spezielle ID für die Exit-Aktion erstellt.

Der nächste Schritt besteht darin, diese Elemente eine Operation ausführen zu lassen. Dazu verwenden wir die Funktion wx.Bind, mit der wir das Element an eine bestimmte Funktion binden können:

1	self.Bind(wx.EVT_MENU,self.onAdd,addNukeScript)

Das erste Argument besagt, dass es sich um ein Menüereignis handelt, das zweite ruft die Funktion auf, die wir mit diesem Element verknüpfen möchten, und das dritte ist das Element selbst. In diesem Fall befindet sich das Element addNukeScript im Menü. Wir müssen noch die self.onAdd-Funktion implementieren, das werden wir später tun:

1	self.Bind(wx.EVT_MENU,self.onClearList,ClearList)

Die ClearList-Aktion ist an die onClearList-Methode gebunden:

1	self.Bind(wx.EVT_BUTTON,self.onRender,self.RenderButton)

Hier binden wir den self.RenderButton an die self.onRender-Funktion, die wir implementieren müssen:

1	self.Bind(wx.EVT_MENU, self.onExit,exitEvt)

Schließlich weisen wir dem exitEvt-Element die Funktion self.onExit zu.

Um den Konstruktor zu vervollständigen, zeigen wir das mainWindow:

1	# it shows the main window
2	self.Show(True)

Bisher haben wir unseren Konstruktor:

import os
import wx

class mainWindow(wx.Frame):

    def __init__(self):
        
        #constructor
        wx.Frame.__init__(self,None,title="Nuke Rendering Manager",size=(600,300),style=wx.SYSTEM_MENU|wx.CAPTION|wx.CLOSE_BOX)

        # it creates a status bar
        self.CreateStatusBar()

        # prepare the Nuke scripts list on screen
        self.NukeScriptsList=wx.TextCtrl(self, style=wx.TE_MULTILINE)
        self.NukeScriptsList.SetEditable(False)
        self.NukeScriptsList.SetBackgroundColour((120,120,120))
        self.NukeScriptsList.SetForegroundColour((50,255,50))
        self.NukeScriptsList.SetValue('Nuke scripts:\n')

        # it creates the render button
        self.RenderButton=wx.Button(self,label="Render",pos=(8,8))

        # layout
        self.layout=wx.BoxSizer(wx.VERTICAL)
        self.layout.Add(self.NukeScriptsList,1,wx.EXPAND)
        self.layout.Add(self.RenderButton,0,wx.EXPAND)
        self.SetSizer(self.layout)
        
        #variables
        self.NukeScripts=[]
        self.dirName=""
        self.fileName=""

        # it creates menu items
        menuBar=wx.MenuBar()

        filemenu=wx.Menu()
        addNukeScript=filemenu.Append(wx.ID_ANY,"Add Nuke script","Add Nuke script")
        ClearList=filemenu.Append(wx.ID_ANY,"Clear list","Clear list")
        exitEvt=filemenu.Append(wx.ID_EXIT,"Exit","Exit")

        menuBar.Append(filemenu,"File")
        self.SetMenuBar(menuBar)

        # it binds elements to events
        self.Bind(wx.EVT_MENU,self.onAdd,addNukeScript)
        self.Bind(wx.EVT_MENU,self.onClearList,ClearList)
        self.Bind(wx.EVT_BUTTON,self.onRender,self.RenderButton)
        self.Bind(wx.EVT_MENU, self.onExit,exitEvt)

        # it shows the main window
        self.Show(True)

Werfen wir einen Blick auf die Funktionen. Das erste, was ich erklären möchte, ist onAdd, das ausgeführt wird, wenn das Menüereignis addNukeScript aufgerufen wird. Ziel dieser Funktion ist es, die Nuke-Skriptinformationen zu einer Liste hinzuzufügen:

# it adds Nuke scripts on the list
    def onAdd(self,event):
        wildcard="Nuke scripts *.nk|*.nk"
        dlg=wx.FileDialog(self,message="Add Nuke script",wildcard=wildcard,style=wx.OPEN)
        if dlg.ShowModal()==wx.ID_OK:
            self.dirName=dlg.GetDirectory()
            self.fileName=dlg.GetFilename()
            self.NukeScripts.append(self.dirName+self.fileName)
            self.updateList()
        dlg.Destroy()

Da diese Funktion aufgerufen wird, wenn ein Ereignis auftritt, müssen wir, wie wir es definieren, einen zusätzlichen Parameter einfügen, den wir in diesem Fall Ereignis genannt haben. Wir definieren einen Platzhalter als Zeichenfolge, die hilfreich ist, um Benutzer zu der Erweiterung zu führen, nach der sie suchen müssen:

1	wildcard="Nuke scripts .nk\|.nk"

Ein Dialogfeld zum Öffnen von Dateien wird erstellt. Wenn der Benutzer auf OK klickt, speichern wir das Verzeichnis und den Dateinamen in unseren Variablen und rufen updateList auf, um den Bildschirm zu aktualisieren:

if dlg.ShowModal()==wx.ID_OK:
            self.dirName=dlg.GetDirectory()
            self.fileName=dlg.GetFilename()
            self.NukeScripts.append(self.dirName+self.fileName)
            self.updateList()

Die updateList-Methode löscht den Bildschirm, durchläuft die NukeScripts-Liste und schreibt erneut auf den Bildschirm:

#it updates the Nuke scripts list on screen
    def updateList(self):
        self.NukeScriptsList.Clear()
        for i in self.NukeScripts:
            self.NukeScriptsList.AppendText(i+"\n") 

Die Funktion onClearList löscht den Bildschirm und die NukeScripts-Liste:

1	def onClearList(self,event):
2	self.NukeScriptsList.Clear()
3	self.NukeScripts=[]

Wir haben onRender(), das im nächsten Abschnitt implementiert wird, und die onExit-Funktion, die die Anwendung schließt:

# it starts the rendering process
    def onRender(self,event):
        print "Rendering..."

    # it closes the program
    def onExit(self,event):
        self.Close(True)

Dies ist die mainWindow-Klassendefinition. Jetzt müssen wir eine Instanz davon erstellen, um sie zu sehen und zu verwenden. Zuerst müssen wir jedoch ein wx.App-Objekt erstellen:

1	app=wx.App(False)

Dann erstellen wir unsere mainWindow-Instanz:

1	mainWindow=mainWindow()

Schließlich müssen wir die MainLoop-Funktion aufrufen, um die Anwendung zu starten:

1	app.MainLoop()

Zu diesem Zeitpunkt haben wir also den Code NukeRenderingManager.py mit Ausnahme der onRender-Methode, die wir im nächsten Abschnitt implementieren werden.

Um unser Programm robuster zu machen, habe ich ein paar Zeilen hinzugefügt, um einige Überprüfungen durchzuführen. Wenn wir ein Nuke-Skript laden, ist es gut, wenn wir überprüfen, ob die Dateierweiterung .nk ist, auch wenn der Platzhalter unsere Auswahl filtert. Wir verwenden die Funktion os.path.splitext. Wenn die Erweiterung .nk lautet, gehen wir wie gewohnt vor:

#we check if we have a Nuke script
            self.extension=os.path.splitext(self.fileName)
            
            if self.extension[1]==".nk":    
                self.NukeScripts.append(self.dirName+self.fileName)
                self.updateList()

Die Datei os.path.splitext gibt eine Liste mit dem Namen und der Dateierweiterung an den Positionen [0] und [1] zurück. Da wir externe Dateien laden, ist es möglich, dass einige von ihnen beschädigt sind. Um die Qualität unserer Anwendung zu verbessern, werden wir die folgenden Ausnahmen behandeln:

# it adds Nuke scripts on the list
    def onAdd(self,event):
        wildcard="Nuke scripts *.nk|*.nk"
        dlg=wx.FileDialog(self,message="Add Nuke script",wildcard=wildcard,style=wx.OPEN)

        try:
            if dlg.ShowModal()==wx.ID_OK:
                self.dirName=dlg.GetDirectory()
                self.fileName=dlg.GetFilename()
            
                #we check if we have a Nuke script
                self.extension=os.path.splitext(self.fileName)
            
                if self.extension[1]==".nk":    
                    self.NukeScripts.append(self.dirName+”\\”+self.fileName)
                    self.updateList()
        except:
            print "unable to read this file"
                
        dlg.Destroy()

Wie Sie bemerkt haben, habe ich self.NukeScripts.append self.NukeScripts.append(self.dirName+”\\”+self.fileName) verwendet. Ich musste "\\" hinzufügen, da ich herausgefunden habe, dass sich in c:\ it ein Nuke-Skript befindet Gibt c:\ zurück, müssen Sie das \ manuell hinzufügen.

Vor dem Ende dieses Abschnitts möchte ich erwähnen, dass wir vermeiden sollten, die Nuke-Skripte, die exeNuke.bat- und die Rendering.py-Dateien in einem Ordner mit einem sehr langen Pfad abzulegen, damit das gesamte System funktioniert. Ich habe das Programm getestet und aus irgendeinem Grund, wenn dieser Pfad zu lang ist, funktioniert er möglicherweise nicht, weil die Eingabeaufforderung solche Zeichenfolgen nicht verarbeiten kann.

Unsere NukeRenderingManager.py lautet also wie folgt:

import os
import wx

class mainWindow(wx.Frame):

    def __init__(self):
        
        #constructor
        wx.Frame.__init__(self,None,title="Nuke Rendering Manager",size=(600,300),style=wx.SYSTEM_MENU|wx.CAPTION|wx.CLOSE_BOX)

        # it creates a status bar
        self.CreateStatusBar()

        # prepare the Nuke scripts list on screen
        self.NukeScriptsList=wx.TextCtrl(self, style=wx.TE_MULTILINE)
        self.NukeScriptsList.SetEditable(False)
        self.NukeScriptsList.SetBackgroundColour((120,120,120))
        self.NukeScriptsList.SetForegroundColour((50,255,50))
        self.NukeScriptsList.SetValue('Nuke scripts:\n')

        # it creates the render button
        self.RenderButton=wx.Button(self,label="Render",pos=(8,8))

        # layout
        self.layout=wx.BoxSizer(wx.VERTICAL)
        self.layout.Add(self.NukeScriptsList,1,wx.EXPAND)
        self.layout.Add(self.RenderButton,0,wx.EXPAND)
        self.SetSizer(self.layout)
        
        # variables
        self.NukeScripts=[]
        self.dirName=""
        self.fileName=""

        # it creates menu items
        menuBar=wx.MenuBar()

        filemenu=wx.Menu()
        addNukeScript=filemenu.Append(wx.ID_ANY,"Add Nuke script","Add Nuke script")
        ClearList=filemenu.Append(wx.ID_ANY,"Clear list","Clear list")
        exitEvt=filemenu.Append(wx.ID_EXIT,"Exit","Exit")

        menuBar.Append(filemenu,"File")
        self.SetMenuBar(menuBar)

        # it binds elements to events
        self.Bind(wx.EVT_MENU,self.onAdd,addNukeScript)
        self.Bind(wx.EVT_MENU,self.onClearList,ClearList)
        self.Bind(wx.EVT_BUTTON,self.onRender,self.RenderButton)
        self.Bind(wx.EVT_MENU, self.onExit,exitEvt)

        # it shows the main window
        self.Show(True)

    #it updates the Nuke scripts list on screen
    def updateList(self):
        self.NukeScriptsList.Clear()
        for i in self.NukeScripts:
            self.NukeScriptsList.AppendText(i+"\n")

    # it adds Nuke scripts on the list
    def onAdd(self,event):
        wildcard="Nuke scripts *.nk|*.nk"
        dlg=wx.FileDialog(self,message="Add Nuke script",wildcard=wildcard,style=wx.OPEN)

        try:
            if dlg.ShowModal()==wx.ID_OK:
                self.dirName=dlg.GetDirectory()
                self.fileName=dlg.GetFilename()
            
                #we check if we have a Nuke script
                self.extension=os.path.splitext(self.fileName)
            
                if self.extension[1]==".nk":
                    self.NukeScripts.append(self.dirName+"\\"+self.fileName)
                    self.updateList()
        except:
            print "unable to read this file"
                
        dlg.Destroy()

    def onClearList(self,event):
        self.NukeScriptsList.Clear()
        self.NukeScripts=[]

    # it starts the rendering process for each Nuke script
    def onRender(self,event):
            #to implement
	return

    # it closes the program
    def onExit(self,event):
        self.Close(True)
                        

app=wx.App(False)
mainWindow=mainWindow()
app.MainLoop()

3. Schreiben Sie die Datei exeNuke.bat

Beschreibung

Eine bat-Datei wird vom Windows-Betriebssystem als eine Sammlung von Befehlen erkannt. Sie können jede Art von Befehl schreiben, Sie können auch Programme starten, und das ist eine Funktion, die wir verwenden werden. Wenn Sie mit sofortigen Anweisungen vertraut sind, wird Ihnen dieser Vorgang leicht fallen.

Zunächst müssen Sie eine leere Textdatei öffnen (ich empfehle Notepad) und als exeNuke.bat speichern. Wie ich im vorherigen Abschnitt erwähnt habe, sollten wir vermeiden, diese Dateien an einem Ort zu platzieren, der einen sehr langen Pfad hat. Da die Eingabeaufforderung dies nicht verarbeiten kann, platzieren Sie alle drei Dateien, die wir schreiben, mit just auf Ihrem Laufwerk Einige Unterordner, z. B. c:\NukeRenderingManager oder c:\myProjects\NukeRenderingManager.

Diese Regel gilt auch für die Nuke-Skripte. Sie befinden sich möglicherweise an einer anderen Stelle. Stellen Sie jedoch sicher, dass der Pfad nicht zu lang ist.

Implementierung

Ich möchte kurz erklären, wie Nuke funktioniert. Normalerweise arbeiten wir in Nuke über die grafische Benutzeroberfläche, aber für bestimmte Aufgaben möchten wir es möglicherweise im Terminalmodus ausführen. Das heißt, wir schreiben nur Befehle, um einen normalen Vorgang auszuführen. Es sieht aus wie eine Windows-Eingabeaufforderung:

Die Art und Weise, wie wir im Terminalmodus Anweisungen an Nuke senden, besteht darin, Python-Code zu schreiben. Angenommen, Sie möchten einen Unschärfeknoten erstellen, geben Sie nuke.createNode(‘Blur’) usw. ein. Was wir tun werden, ist, die Bat-Datei Nuke im Terminal-Modus öffnen zu lassen und das Rendern eines Projekts zu starten. Dabei wird alles durch Senden von Befehlen und ohne grafische Benutzeroberfläche ausgeführt.

Die ersten Anweisungen sind:

1	C:\
2	C:

Dies soll sicherstellen, dass wir den Nuke-Pfad eingeben können, um ihn zu starten:

1	cd Programmi\Nuke6.2v6
2	Nuke6.2 –t

Natürlich können diese Zeilen unterschiedlich sein. Schreiben Sie den Standort Ihres Computers. Das –t bedeutet Terminalmodus. Wenn Sie auf Ihre exeNuke.bat-Datei doppelklicken, sollte Nuke im Terminalmodus angezeigt werden. Wenn Sie beenden möchten, geben Sie einfach quit() ein und drücken Sie die Eingabetaste. Um das Rendern durchzuführen, müssen wir auch die Datei Rendering.py ausführen, damit wir unseren Code aktualisieren können:

1	cd\
2	c:
3	cd Programmi\Nuke6.2v6
4	Nuke6.2 -t c:\NukeRenderingManager\Rendering.py

Durch Hinzufügen des Speicherorts der Datei Rendering.py bitten wir Sie, Nuke im Terminalmodus zu öffnen und die Datei Rendering.py auszuführen, die den gesamten Code für das Rendern enthält. Wie bereits erwähnt, erfordert der Terminalmodus die Python-Sprache, die wir verwenden den Rendering.py-Code. Wir benötigen jedoch noch eine Information: Die Datei Rendering.py muss wissen, wo sich die Nuke-Skripte befinden.

Denken Sie daran, dass exeNuke.bat und Rendering.py für jedes Nuke-Skript aufgerufen werden. Wenn wir also drei Projekte rendern müssen, werden sie dreimal gestartet. Aber jedes Mal, wenn sie als Rendering.py bezeichnet werden, muss bekannt sein, wo sich das Scrritp befindet. Um diese Aufgabe zu erfüllen, müssen wir diese Informationen aus dem obigen NukeRenderingManager.py abrufen.

Schließen Sie NukeRenderingManagerFile.py ab

Die einzige Methode, die wir implementieren müssen, ist onRender(). Wir durchlaufen NukeScripts und rufen jedes Mal die bat-Datei auf:

1	# it starts the rendering process for each Nuke script
2	def onRender(self,event):
3	for i in self.NukeScripts:
4	os.system("C:/exeNuke.bat"+ " "+i)

Wir verwenden die Funktion os.system, um die Datei auszuführen. Wie Sie bemerkt haben, übergeben wir i auch als Argument nach einem Leerzeichen. Grundsätzlich senden wir den NukeScript-Pfad an die Batch-Datei. Die Tatsache, dass wir diese Informationen problemlos an die Batch-Datei senden können, gibt uns eine große Flexibilität.

Vervollständigen Sie die Datei exeNuke.bat

Die Art und Weise, wie eine Batchdatei Argumente erhält, besteht darin, das Symbol % gefolgt von einer Zahl zu verwenden, da wir eine Information übergeben haben, die wir %1 schreiben werden. Hier der komplette Code:

1	cd\
2	c:
3	cd Programmi\Nuke6.2v6
4	Nuke6.2 -t c:\Rendering.py %1

Wir starten Nuke und rufen die Datei Rendering.py auf, indem wir den Pfad des Skripts als Argument angeben.

Bevor ich diesen Abschnitt abschließe, möchte ich den bisher beschriebenen Prozess zusammenfassen. NukeRenderingManager.py stellt uns die grafische Benutzeroberfläche zur Verfügung und organisiert die Liste der zu rendernden Nuke-Skripte. Für jedes der Skripte werden exeNuke.bat und Rendering.py aufgerufen. Der erste ist dafür verantwortlich, Nuke im Terminalmodus auszuführen, den Pfad des zu verarbeitenden Skripts zu ermitteln und an die Datei Rendering.py zu übergeben, die das Rendern selbst ausführt. Jetzt müssen wir Rendering.py implementieren.

4. Schreiben Sie die Datei Rendering.py

Implementierung

Als erstes müssen wir den Pfad des Skripts abrufen, das wir an die Batchdatei übergeben haben. Um dies zu erreichen, verwenden wir einfach die folgende Anweisung sys.argv[1]. Dann transformieren wir diese Informationen in einen String:

1	prj=str(sys.argv[1])

Die Anweisung zum Öffnen eines Nuke-Projekts lautet wie folgt:

1	nuke.scriptOpen(prj)

Jetzt haben wir das Skript einsatzbereit. Was wir jetzt tun müssen, ist nach dem gewünschten Schreibknoten zu suchen und zu rendern. In meinem Beispiel heißt der von mir benötigte Schreibknoten Write1, Sie können jedoch einen beliebigen Namen verwenden. Hier ist der vollständige Code:

prj=str(sys.argv[1])

nuke.scriptOpen(prj)

for i in nuke.allNodes():
    if i.Class()=="Write":
        if i['name'].getValue()=="Write1":
            first_frame=nuke.Root().knob('first_frame').value()
            last_frame=nuke.Root().knob('last_frame').value()
            nuke.execute(i,first_frame,last_frame)

Wir durchlaufen alle Knoten im Skript, prüfen, ob es sich um einen Schreibknoten handelt, steuern, ob der Name Write1 lautet, erhalten den ersten und den letzten Frame des Projekts und verwenden die Funktion nuke.execute um das Rendern auszuführen.

Abschluss

Um das Programm zu starten, doppelklicken Sie einfach auf NukeRenderingManager.py. Genießen!

1	import os
2	import wx
3
4	class mainWindow(wx.Frame):
5
6	def __init__(self):
7
8	#constructor
9	wx.Frame.__init__(self,None,title="Nuke Rendering Manager",size=(600,300),style=wx.SYSTEM_MENU\|wx.CAPTION\|wx.CLOSE_BOX)
10
11	# it creates a status bar
12	self.CreateStatusBar()
13
14	# prepare the Nuke scripts list on screen
15	self.NukeScriptsList=wx.TextCtrl(self, style=wx.TE_MULTILINE)
16	self.NukeScriptsList.SetEditable(False)
17	self.NukeScriptsList.SetBackgroundColour((120,120,120))
18	self.NukeScriptsList.SetForegroundColour((50,255,50))
19	self.NukeScriptsList.SetValue('Nuke scripts:\n')
20
21	# it creates the render button
22	self.RenderButton=wx.Button(self,label="Render",pos=(8,8))
23
24	# layout
25	self.layout=wx.BoxSizer(wx.VERTICAL)
26	self.layout.Add(self.NukeScriptsList,1,wx.EXPAND)
27	self.layout.Add(self.RenderButton,0,wx.EXPAND)
28	self.SetSizer(self.layout)
29
30	# variables
31	self.NukeScripts=[]
32	self.dirName=""
33	self.fileName=""
34
35	# it creates menu items
36	menuBar=wx.MenuBar()
37
38	filemenu=wx.Menu()
39	addNukeScript=filemenu.Append(wx.ID_ANY,"Add Nuke script","Add Nuke script")
40	ClearList=filemenu.Append(wx.ID_ANY,"Clear list","Clear list")
41	exitEvt=filemenu.Append(wx.ID_EXIT,"Exit","Exit")
42
43	menuBar.Append(filemenu,"File")
44	self.SetMenuBar(menuBar)
45
46	# it binds elements to events
47	self.Bind(wx.EVT_MENU,self.onAdd,addNukeScript)
48	self.Bind(wx.EVT_MENU,self.onClearList,ClearList)
49	self.Bind(wx.EVT_BUTTON,self.onRender,self.RenderButton)
50	self.Bind(wx.EVT_MENU, self.onExit,exitEvt)
51
52	# it shows the main window
53	self.Show(True)
54
55	#it updates the Nuke scripts list on screen
56	def updateList(self):
57	self.NukeScriptsList.Clear()
58	for i in self.NukeScripts:
59	self.NukeScriptsList.AppendText(i+"\n")
60
61	# it adds Nuke scripts on the list
62	def onAdd(self,event):
63	wildcard="Nuke scripts .nk\|.nk"
64	dlg=wx.FileDialog(self,message="Add Nuke script",wildcard=wildcard,style=wx.OPEN)
65
66	try:
67	if dlg.ShowModal()==wx.ID_OK:
68	self.dirName=dlg.GetDirectory()
69	self.fileName=dlg.GetFilename()
70
71	#we check if we have a Nuke script
72	self.extension=os.path.splitext(self.fileName)
73
74	if self.extension[1]==".nk":
75	self.NukeScripts.append(self.dirName+"\\"+self.fileName)
76	self.updateList()
77	except:
78	print "unable to read this file"
79
80	dlg.Destroy()
81
82	def onClearList(self,event):
83	self.NukeScriptsList.Clear()
84	self.NukeScripts=[]
85
86	# it starts the rendering process for each Nuke script
87	def onRender(self,event):
88	#to implement
89	return
90
91	# it closes the program
92	def onExit(self,event):
93	self.Close(True)
94
95
96	app=wx.App(False)
97	mainWindow=mainWindow()
98	app.MainLoop()