Share
Erfahren Sie, wie Sie mit Python einen benutzerdefinierten Render-Manager für Nuke erstellen, mit dem Sie ein oder mehrere Nuke-Projekte rendern können, ohne die Software öffnen zu müssen.
In diesem Lernprogramm wird erläutert, wie Sie eine Software schreiben, mit der Sie den Rendering-Prozess in Nuke verwalten können. Möglicherweise gibt es mehrere Nuke-Comps, die gerendert werden müssen. Wenn Sie also ein solches Programm verwenden, können Sie alle auf einmal rendern, ohne Nuke selbst zu öffnen. Das bedeutet, dass das System die grafische Benutzeroberfläche von Nuke nicht lädt, sodass mehr Speicher für das Rendern reserviert werden kann verarbeiten. Hier sehen Sie ein Beispiel für das Programm, das Sie erstellen werden:
Grafische Benutzeroberfläche.
Das Programm rendert drei Projekte.Das Programm verfügt über eine übersichtliche Benutzeroberfläche, mit der Sie beliebig viele Renderings organisieren und in eine Warteschlange stellen können.
Ich gehe davon aus, dass Sie in diesem Tutorial ein grundlegendes Verständnis von Python und einige DOS-Befehle haben. Diese Software soll auf dem Windows-Betriebssystem ausgeführt werden. Die Werkzeuge, die Sie benötigen, sind folgende:
Python 2.x installiert (https://www.python.org) Verwenden Sie nicht die 3.x-Version, da Nuke dies nicht unterstützt.
wxPython-Bibliothek (http://www.wxpython.org) Hier können Sie eine Benutzeroberfläche erstellen. Sie können auch Tkinter, Qt verwenden, dies wird jedoch in diesem Lernprogramm nicht behandelt.
Wir nennen diese Software NukeRenderManager. Das Programm besteht aus drei Dateien:
NukeRenderingManager.py
exeNuke.bat
Wiedergabe.py
NukeRenderingManager.py: Es enthält alles über die grafische Benutzeroberfläche und alle Informationen zum Standort der Nuke-Projekte und zu allen Frame-Bereichen.
exeNuke.bat: Es ist dafür verantwortlich, Nuke im Terminalmodus zu starten, indem alle Informationen aus der Datei NukeRenderingManager.py weitergeleitet werden. Diese Datei wird für jedes Rendering aufgerufen. Wenn also drei Nuke-Comps gerendert werden müssen, wird diese Datei dreimal ausgeführt.
Rendering.py: Es holt alle Informationen von exeNuke.bat und führt das Rendern aus. Diese Datei wird für jedes Nuke-Projekt ausgeführt.
NukeRenderingManager.py verwaltet die Benutzeroberfläche und organisiert die Liste der zu rendernden Projekte.
Um unsere Benutzeroberfläche zu erstellen, verwenden wir die wxPython-Bibliothek. Wie ich bereits gesagt habe, können Sie eine andere Bibliothek verwenden, aber für dieses Tutorial werde ich wxPython erklären. Um es zu installieren, müssen Sie nur das Installationsprogramm herunterladen, starten und alles ist fertig (Sie können den Link oben finden). Nach der Installation der Bibliothek müssen Sie Python 2.x IDLE starten. Dadurch erhalten Sie die Python-Shell. Von dem Datei Menü auswählen Neue Datei, Jetzt hast du einen leeren Editor. Wenn Sie möchten, können Sie einen anderen Editor verwenden, mit dem Sie sich vielleicht wohl fühlen.
Leerer Python-Editor.Speichern Sie die Datei als NukeRenderingManager.py und legen Sie es in einem beliebigen Ordner.
Als erstes müssen Sie die benötigten Module importieren. Die erste ist os, mit der wir die Betriebssystemfunktionen verwenden können, die zweite ist die wx, die nützlich sein wird, um eine grafische Benutzeroberfläche zu erstellen:
import os import wx
Wir werden ein Fenster erstellen, das alles enthält, was wir brauchen. Wir erreichen dieses Ziel, indem wir eine benutzerdefinierte Klasse erstellen, die von wx.Frame abgeleitet ist:
Klasse mainWindow (wx.Frame):
Dann implementieren wir den Konstruktor durch Aufruf des wx.Frame .__ init__:
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)
Dann erstellen wir eine Statusleiste:
self.CreateStatusBar ()
Wir fügen ein Textsteuerelement hinzu, um zu zeigen, welche Nuke-Projekte verarbeitet werden:
Accentsconagua
# Bereiten Sie die Liste der Nuke-Skripts auf dem Bildschirm self.NukeScriptsList = wx.TextCtrl (self, style = wx.TE_MULTILINE) vor. self.NukeScriptsList.SetEditable (False) self.NukeScriptsList.SetBackgroundColour ((120,120,120)) , 50)) self.NukeScriptsList.SetValue ('Nuke scripts: \ n')Das wx.TextCtrl Geben Sie uns einen Bereich, in dem wir die Liste schreiben können. Wir brauchen sie als mehrzeilig, so dass wir sie erklären wx.TE_MULTILINE. Wir brauchen es nicht bearbeitbar zu sein, also benutzen wir es SetEditable (False), Dann definieren wir einige Farben und zeigen schließlich einen Text.
Dann erstellen wir eine Render-Schaltfläche:
# erstellt die Render-Schaltfläche self.RenderButton = wx.Button (self, label = "Render", pos = (8.200))
Eine sehr wichtige Sache ist der Sizer. Mit dem Sizer können wir ein Layout definieren. Wir verwenden BoxSizer, der Elemente horizontal und vertikal platziert. Wir wählen eine vertikale Position für das Textsteuerelement und die Schaltfläche:
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)
Der zweite Parameter in der Hinzufügen method ist eine Zahl, die beschreibt, wie viel Platz jedes Element einnimmt, 0 bedeutet, dass die Mindestgröße verwendet wird, 1 bedeutet, dass der verfügbare Platz belegt wird. In unserem Fall möchten wir, dass die Schaltfläche minimiert wird und das Textsteuerelement den verbleibenden Speicherplatz hat.
Wir bereiten einige Variablen vor:
self.NukeScripts = [] self.dirName = "" self.fileName = ""
Dann bereiten wir das Menü vor. Wir beginnen mit der Erstellung einer Menüleiste als wx.MenuBar (), Wir erstellen ein Menü namens Datei wx.Menu (), wir fügen das hinzu Nuke-Skripte hinzufügen und Ausgang Elemente und hängen sie an das Dateimenü an. Und zum Schluss fügen wir noch ein Menü zu menuBar hinzu:
# es erstellt Menüelemente menuBar = wx.MenuBar () filemenu = wx.Menu () addNukeScript = filemenu.Append (wx.ID_ANY, "Nuke-Skript hinzufügen", "Nuke-Skript hinzufügen") ClearList = filemenu.Append (wx.ID_ANY) , "Liste löschen", "Liste löschen") exitEvt = filemenu.Append (wx.ID_EXIT, "Exit", "Exit") menuBar.Append (fileemenu, "File") self.SetMenuBar (menuBar)
wx.ID_ANY wx.ID_EXIT werden verwendet, um eine ICH WÜRDE Zu den Elementen erhalten wir im ersten Fall eine ID für den Artikel, im zweiten Fall jedoch eine ID_EXIT Dadurch wird eine spezielle ID für die Beendigungsaktion erstellt.
Der nächste Schritt besteht darin, diese Elemente einige Operationen ausführen zu lassen. Dazu verwenden wir die wx.Bind Funktion, die es uns ermöglicht, das Element an eine bestimmte Funktion zu binden:
self.Bind (wx.EVT_MENU, self.onAdd, addNukeScript)
Das erste Argument besagt, dass es sich um ein Menüereignis handelt, das zweite ruft die Funktion auf, die wir mit diesem Element verknüpfen möchten, und das dritte ist das Element selbst. In diesem Fall ist das addNukeScritp Menüpunkt. Wir müssen das noch umsetzen self.onAdd Funktion, das machen wir später:
self.Bind (wx.EVT_MENU, self.onClearList, ClearList)
Das Liste leeren Aktion ist an die gebunden onClearList Methode:
self.Bind (wx.EVT_BUTTON, self.onRender, self.RenderButton)
Hier binden wir das self.RenderButton zum self.onRender Funktion, die wir implementieren müssen:
self.Bind (wx.EVT_MENU, self.onExit, exitEvt)
Zum Schluss vergeben wir die self.onExit Funktion zum exitEvt Element.
Um den Konstruktor abzuschließen, zeigen wir die Hauptfenster:
# zeigt das Hauptfenster 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", Größe = (600,300), style = wx.SYSTEM_MENU | wx.CAPTION | wx.CLOSE_BOX) # erstellt eine Statusleiste self.CreateStatusBar () # erstellt die Liste der Nuke-Scripts auf dem Bildschirm 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') # erstellt den Render-Button self.RenderButach (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) #Variable self.NukeScripts = [] self.dirName = "" self.fileName = "" # erstellt Menüpunkte menuBar = wx. MenuBar () filemenu = wx.Menu () addNukeScript = filemenu.Append (wx.ID_ANY, "Nuke-Skript hinzufügen", " Nuke-Skript hinzufügen ") ClearList = filemenu.Append (wx.ID_ANY," Liste löschen "," Liste löschen ") exitEvt = filemenu.Append (wx.ID_EXIT," Exit "," Exit ") menuBar.Append (filemenu," Datei ") self.SetMenuBar (menuBar) # es bindet Elemente an Ereignisse 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) # zeigt das Hauptfenster self.Show (True)
Momentaufnahme des Editors.Schauen wir uns die Funktionen an. Das erste, was ich erklären möchte, ist onAdd Das wird ausgeführt, wenn das Menüereignis ausgeführt wird addNukeScript wird genannt. Das Ziel dieser Funktion ist es, die Informationen zu den Nuke-Skripten einer Liste hinzuzufügen:
# es fügt Nuke-Skripte der Liste hinzu. def onAdd (self, event): wildcard = "Nuke-Skripte * .nk | * .nk" dlg = wx.FileDialog (self, message = "Nuke-Skript hinzufügen", 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 beim Auftreten eines Ereignisses aufgerufen wird, müssen wir bei der Definition einen zusätzlichen Parameter angeben, den wir in diesem Fall event genannt haben. Wir definieren einen Platzhalter als eine Zeichenfolge, die nützlich ist, um Benutzer dahin zu führen, nach welcher Erweiterung sie suchen müssen:
wildcard = "Nuke-Skripte * .nk | * .nk"
Ein Datei-Öffnen-Dialog wird erstellt, und wenn der Benutzer auf OK klickt, speichern wir das Verzeichnis und den Dateinamen in unsere Variablen und rufen diese auf Aktualisierungsliste So aktualisieren Sie den Bildschirm:
if dlg.ShowModal () == wx.ID_OK: self.dirName = dlg.GetDirectory () self.fileName = dlg.GetFilename () self.NukeScripts.append (self.dirName + self.fileName) self.updateList ()
Das Aktualisierungsliste Methode löscht den Bildschirm, durchläuft die NukeScripts liste und schreibe wieder auf den Bildschirm:
#it aktualisiert die Nuke-Skriptliste auf dem Bildschirm def updateList (selbst): self.NukeScriptsList.Clear () für i in self.NukeScripts: self.NukeScriptsList.AppendText (i + "\ n")
Das onClearList Funktion löscht den Bildschirm und die NukeScripts Liste:
def onClearList (self, event): self.NukeScriptsList.Clear () self.NukeScripts = []
Wir haben onRender () , das wird im nächsten Abschnitt implementiert, und die onExit Funktion, die die Anwendung schließt:
# es startet den Rendering-Prozess def onRender (self, event): print "Rendering…" # schließt das Programm def onExit (self, event): self.Close (True)
Dies ist die Definition der mainWindow-Klasse. Jetzt müssen wir eine Instanz davon erstellen, um sie zu sehen und zu verwenden, aber zuerst müssen wir eine wx.App Objekt:
app = wx.App (False)
Dann schaffen wir unsere Hauptfenster Beispiel:
mainWindow = mainWindow ()
Zum Schluss müssen wir die anrufen Hauptschleife Funktion zum Starten der Anwendung:
app.MainLoop ()
Zu diesem Zeitpunkt haben wir also den NukeRenderingManager.py-Code, mit Ausnahme der onRender-Methode, die wir im nächsten Abschnitt implementieren werden.
Um unser Programm robuster zu machen, habe ich ein paar Zeilen hinzugefügt, um einige Überprüfungen durchzuführen. Wenn wir ein Nuke-Skript laden, wäre es gut, wenn wir prüfen, ob die Dateierweiterung ist .nk, Auch wenn der Platzhalter unsere Wahl filtert. Wir benutzen das os.path.splitext Funktion, dann, wenn die Erweiterung ist .nk wir gehen normal weiter:
#Wir prüfen, ob wir ein Nuke-Skript besitzen. self.extension = os.path.splitext (self.fileName), wenn self.extension [1] == ". nk": self.NukeScripts.append (self.dirName + self.fileName) ) self.updateList ()
Das os.path.splitext gibt eine Liste mit dem Namen und der Dateierweiterung am zurück [0] und [1] Position. Da wir externe Dateien laden, kann es vorkommen, dass einige von ihnen beschädigt sind. Um die Qualität unserer Anwendung zu erhöhen, behandeln wir die Ausnahmen:
# es fügt Nuke-Skripte der Liste hinzu. def onAdd (self, event): wildcard = "Nuke-Skripte * .nk | * .nk" dlg = wx.FileDialog (self, message = "Nuke-Skript hinzufügen", wildcard = wildcard, style = wx.OPEN) try: if dlg.ShowModal () == wx.ID_OK: self.dirName = dlg.GetDirectory () self.fileName = dlg.GetFilename () # wir prüfen, ob wir ein Nuke-Skript self.extension = haben os.path.splitext (self.fileName) wenn self.extension [1] == ". nk": self.NukeScripts.append (self.dirName + "\\" + self.fileName) self.updateList () mit Ausnahme von print "Kann diese Datei nicht lesen" dlg.Destroy ()
Wie Sie bemerkt haben, habe ich verwendet self.NukeScripts.append (self.dirName + "\\" + self.fileName), Ich musste hinzufügen "\\" weil ich herausgefunden habe, ob sich ein Nuke-Skript in befindet c: \ es kehrt zurück c: \, Sie müssen das hinzufügen \ manuell.
Ich möchte vor dem Ende dieses Abschnitts erwähnen, dass wir das Nuke-Skript, das exeNuke.bat und das Wiedergabe.py Dateien in einem Ordner, der einen sehr langen Pfad hat. Ich habe das Programm getestet. Wenn dieser Pfad zu lang ist, funktioniert er nicht. Möglicherweise ist die Eingabeaufforderung nicht in der Lage, solche Zeichenfolgen zu verarbeiten.
Unser NukeRenderingManager.py ist also folgendes:
import os import wx class mainWindow (wx.Frame): def __init __ (selbst): #constructor wx.Frame .__ init __ (selbst, keiner, title = "Nuke Rendering Manager"), size = (600,300), style = wx.SYSTEM_MENU | wx.CAPTION | wx.CLOSE_BOX) # erstellt eine Statusleiste self.CreateStatusBar () # erstellt die Liste der Nuke-Scripts auf dem Bildschirm self.NukeScriptsList = wx.TextCtrl (self, style = wx.TE_MULTILINE) ) self.NukeScriptsList.SetBackgroundColour ((120,120,120)) self.NukeScriptsList.SetForegroundColour ((50,255,50)) (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 = "" # erstellt Menüpunkte menuBar = wx. MenuBar () filemenu = wx.Menu () addNukeScript = filemenu.Append (wx.ID_ANY, "Nuke-Skript hinzufügen"), "Nuke-Skript hinzufügen") ClearList = filemenu.Append (wx.ID_ANY, "Liste löschen", "Liste löschen") exitEvt = filemenu.Append (wx.ID_EXIT, "Exit", "Exit") menuBar.Append (Filemenu, "Datei") self.SetMenuBar (menuBar) # es bindet Elemente an Ereignisse 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) # zeigt das Hauptfenster self.Show (True) #it aktualisiert die Liste der Nuke-Skripts auf dem Bildschirm def updateList (self) : self.NukeScriptsList.Clear () für i in self.NukeScripts: self.NukeScriptsList.AppendText (i + "\ n") # fügt Nuke-Scripts in der Liste hinzu. def onAdd (self, event): wildcard = "Nuke-Scripts *. nk | * .nk "dlg = wx.FileDialog (self, message =" Nuke-Skript hinzufügen ", Wildcard = Wildcard, style = wx.OPEN) try: if dlg.ShowModal () == wx.ID_OK: self.dirName = dlg.GetDirectory () self.fileName = dlg.GetFilename () #Wir prüfen, ob ein Nuke-Skript self.extension = os.path.splitext (self.fileName) vorhanden ist, wenn self.extension [1] == ".nk": self.NukeScripts.append (self.dirName + "\\" + self.fileName) self.updateList () außer: print "Kann diese Datei nicht lesen" dlg.Destroy () def onClearList (self, event) : self.NukeScriptsList.Clear () self.NukeScripts = [] # Startet den Rendering-Prozess für jedes Nuke-Skript def onRender (self, event): #, um return # zu implementieren. Es schließt das Programm def onExit (self, event): self .Close (True) app = wx.App (False) mainWindow = mainWindow () app.MainLoop ()
Noch eine Momentaufnahme des Editors.Eine Bat-Datei wird vom Windows-Betriebssystem als eine Sammlung von Befehlen erkannt. Sie können alle Befehle schreiben, die Sie möchten, Sie können auch Programme starten. Diese Funktion verwenden wir. Wenn Sie mit prompten Anweisungen vertraut sind, werden Sie diesen Vorgang leicht durchführen können.
Zunächst müssen Sie eine leere Textdatei öffnen (ich empfehle den Editor) und diese als speichern exeNuke.bat. Wie ich bereits im vorherigen Abschnitt erwähnt habe, sollten wir vermeiden, diese Dateien an einem Ort zu platzieren, an dem es einen sehr langen Pfad gibt, da die Eingabeaufforderung nicht verarbeitet werden kann. Platzieren Sie also alle drei Dateien, die wir gerade schreiben, einfach mit Ihrem Laufwerk einige Unterordner, etwa c: \ NukeRenderingManager oder c: \ myProjects \ NukeRenderingManager.
Diese Regel gilt auch für die Nuke-Skripte. Sie befinden sich möglicherweise an einem anderen Ort. Stellen Sie jedoch sicher, dass der Pfad nicht zu lang ist.
Ich möchte kurz erklären, wie Nuke funktioniert. Wir arbeiten normalerweise in Nuke über seine grafische Benutzeroberfläche, aber für bestimmte Aufgaben möchten wir es vielleicht im Terminal-Modus ausführen. Das bedeutet, dass wir nur Befehle schreiben, um eine normale Operation auszuführen, es sieht aus wie eine Windows-Eingabeaufforderung:
Im Terminal-Modus senden wir Anweisungen an Nuke, indem Sie etwas Python-Code schreiben. Angenommen, Sie möchten einen Unschärfeknoten erstellen, den Sie eingeben können nuke.createNode ('Blur') und so weiter. Was wir tun werden, ist, die Bat-Datei Nuke im Terminal-Modus zu öffnen und das Rendern eines Projekts zu starten. Alles durch Senden von Befehlen und ohne grafische Benutzeroberfläche zu tun.
Die ersten Anweisungen sind:
C: \ C:
So stellen Sie sicher, dass wir den Nuke-Pfad eingeben können, um ihn zu starten:
cd Programmi \ Nuke6.2v6 Nuke6.2 -t
Natürlich unterscheiden sich diese Zeilen möglicherweise, schreiben Sie den Standort Ihres Computers. Das -t bedeutet Terminalmodus. Wenn Sie auf Ihre exeNuke.bat-Datei doppelklicken, sollten Sie Nuke im Terminal-Modus sehen. Wenn Sie den Vorgang beenden möchten, geben Sie einfach ein Verlassen() und schlagen Eingeben. Um das Rendern durchzuführen, müssen wir auch das ausführen Wiedergabe.py Datei, damit wir unseren Code aktualisieren können:
cd \ c: cd Programmi \ Nuke6.2v6 Nuke6.2 -t c: \ NukeRenderingManager \ Rendering.py
Durch Hinzufügen der Position des Wiedergabe.py Datei, wir bitten, Nuke im Terminalmodus zu öffnen und die Wiedergabe.py das enthält den gesamten Code, um das Rendering durchzuführen, und wie gesagt, bevor der Terminal-Modus die Python-Sprache erfordert, verwenden wir die Wiedergabe.py Code. Aber wir benötigen immer noch eine Information, die Rendering.py-Datei muss wissen, wo sich die Nuke-Skripts befinden.
Denken Sie daran, dass die exeNuke.bat und Wiedergabe.py wird für jedes Nuke-Skript aufgerufen. Wenn wir drei Projekte rendern müssen, werden sie dreimal gestartet. Aber jedes Mal werden sie das genannt Wiedergabe.py Um zu wissen, wo sich die Scritp befindet, benötigen wir diese Informationen, um diese Aufgabe zu lösen NukeRenderingManager.py.
Momentaufnahme des Stapeldatei-Editors .Die einzige Methode, die wir implementieren müssen, ist onRender (). Was wir tun, ist NukeScripts zu durchlaufen und jedes Mal die bat-Datei aufzurufen:
# es startet den Rendering-Prozess für jedes Nuke-Skript def onRender (self, event): für i in self.NukeScripts: os.system ("C: /exeNuke.bat" + "" + i)Wir nehmen das os.system Funktion zum Ausführen der Datei. Wie Sie bemerkt haben, passieren wir auch ich als das Argument nach einem Leerzeichen. Wir senden grundsätzlich den NukeScript-Pfad an die Batch-Datei. Die Tatsache, dass wir diese Informationen problemlos an die Batch-Datei senden können, gibt uns eine große Flexibilität.
Die Art und Weise, wie eine Batchdatei Argumente erhält, ist das Symbol % gefolgt von einer Nummer, weil wir eine Information übergeben haben, die wir schreiben werden % 1. Hier der vollständige Code:
cd \ c: cd Programmi \ Nuke6.2v6 Nuke6.2 -t c: \ Rendering.py% 1
Wir starten Nuke und rufen die an Wiedergabe.py indem Sie den Pfad des Skripts als Argument angeben.
Bevor ich diesen Abschnitt abschließe, möchte ich den bisher beschriebenen Prozess zusammenfassen. NukeRenderingManager.py stellt uns die grafische Benutzeroberfläche zur Verfügung und organisiert die Liste der zu rendernden Nuke-Skripte. Für jedes der Skripte exeNuke.bat und Wiedergabe.py wird angerufen werden. Die erste ist dafür zuständig, Nuke im Terminal-Modus auszuführen, den Pfad des zu bearbeitenden Skripts zu ermitteln und an das Skript zu übergeben Wiedergabe.py das wird das Rendern selbst durchführen. Jetzt müssen wir Rendering.py implementieren.
Das erste, was wir tun müssen, ist den Pfad des Skripts zu packen, das wir in die Batch-Datei übergeben haben. Um dies zu erreichen, verwenden wir einfach die folgende Anweisung sys.argv [1]. Dann transformieren wir diese Informationen in einen String:
prj = str (sys.argv [1])
Die Anweisungen zum Öffnen eines Nuke-Projekts lauten wie folgt:
nuke.scriptOpen (prj)
Jetzt haben wir das Skript fertig. Jetzt müssen wir den gewünschten Schreibknoten suchen und rendern. In meinem Beispiel wird der Schreibknoten aufgerufen, den ich brauche Write1, Sie können jedoch einen beliebigen Namen verwenden. Hier ist der vollständige Code:
prj = str (sys.argv [1]) nuke.scriptOpen (prj) für i in nuke.allNodes (): wenn i.Class () == "Write": Wenn i ['name']. getValue () = = "Write1": first_frame = nuke.Root (). Regler ('first_frame'). Value () last_frame = nuke.Root (). Regler ('last_frame'). Value () nuke.execute (i, erster_Frame, letzter_Frame) )Was wir tun, ist eine Schleife durch alle Knoten im Skript. Wir prüfen, ob der Knoten ein Schreibknoten ist, und wir kontrollieren, dass es sich um einen Namen handelt Write1, Wir bekommen den ersten und den letzten Frame des Projekts und verwenden die nuke.execute Funktion, um den Render auszuführen.
Momentaufnahme der Datei rendering.py.Um das Programm zu starten, doppelklicken Sie auf NukeRenderingManager.py. Genießen!
