code_gallery

Web News Blog Press Pricing

Learn

Training

Profiles

Executive Questions Harmony

Templates

Animation VFX

Code

Code Gallery Designer

v6.09

Maya

Nuke Submitter Render

12/09/2024

Tags

Nuke Submitter Render

Action v1

12/09/2024

Maya

Pseudo-Code

413	Main execution to open the UI.
89	Main class to launch the UI
131	Define the pyqt widgets in the UI
237	Signals assigned to the UI widgets
255	Callback when submit button is clicked. It collects the data and send it to function.
320	Prepares the render to be submitted. Set the frame range(from the UI), creates the new task "Render2D" and its new file wip, set the write output path. Finally upload the file wip and publish to generate the render.

Parameters

self.write_node	The write node of Nuke to submit render.
render_task	It represents the Render2D task that will save the render.
data	Data collected from the UI and the write node to generate the render

Talk with TD Support

Import to my Pipeline

Code

#########   Submit Render Template   ##################
## Date: 20/09/2024
##
## Notes: Save Current script wip and publish.
##		  
## Property of: PipelinePro
##
######################################################

import nuke
import os
import pipeline

from PySide2.QtWidgets import (QDialog, QApplication, QWidget, QLabel, QVBoxLayout, QHBoxLayout, QComboBox, QLineEdit,
                               QDoubleSpinBox, QRadioButton, QPushButton, QMessageBox, QCheckBox, QMainWindow, QFormLayout)
from PySide2.QtCore import Signal, Qt

# Functions Definition

def get_nuke_main_window():
    for widget in QApplication.topLevelWidgets():
        if isinstance(widget, QMainWindow):
            return widget
    return None

def create_new_task(shotKey, maintaskInitials):
    task_obj = pipeline.api(
        call_type='mutation',
        operation='newTask',
        fields='task { name key lastReviewFolder { key folderLocal name } }',
        shotKey=shotKey,
        maintaskInitials=maintaskInitials)
    return task_obj

def create_new_wip(folderKey):
    folder_obj = pipeline.api(
        call_type='mutation',
        operation='newWip',
        fields='file { fileName key fileLocal folder { name key folderLocal } }',
        folderKey=folderKey
    )
    return folder_obj

def create_new_file(folderKey):
    file_obj = pipeline.api(
        call_type='mutation',
        operation='newFile',
        fields='file { fileName fileLocal key }',
        folderKey=folderKey,
        pathToFile="D:/bin/pipelinepro/pipeline_actions/scenes/test.png"
    )
    return file_obj

def publish_folder(folderKey, type):
    folder_obj = pipeline.api(
        call_type='mutation',
        operation='publishFolder',
        fields='folder { key }',
        folderKey=folderKey,
        type=type)
    return folder_obj

def upload_folder(folderKey):
    folder_obj = pipeline.api(
        call_type='mutation',
        operation='uploadFolder',
        fields='folder { key }',
        folderKey=folderKey)
    return folder_obj

def download_folder(folderKey):
    folder_obj = pipeline.api(
        call_type='mutation',
        operation='downloadFolder',
        fields='message',
        folderKey=folderKey
    )
    return folder_obj

class SubmitRenderUI(QWidget):
    """Clase que contiene la UI para enviar el render."""
    submit_render = Signal(dict)

def __init__(self, write_node, title="Submit Render", parent=None):
        super(SubmitRenderUI, self).__init__(parent=parent)
        print("Submit render UI")
        self.write_node = write_node
        self.setWindowTitle("Render Settings Form")
        self.setWindowFlags(Qt.Window)

self.main_layout = QVBoxLayout()
        self.setLayout(self.main_layout)
        self.setMinimumHeight(350)
        # Write data
        self.get_write_data()

# Build the UI widget
        self.build_widget()

# Connect signals
        self.connect_signals()
        self._autocomplete()

def get_write_data(self):
        """Obtiene los datos de render del nodo write."""
        self.output_file = self.write_node.knob('file').value()
        self.render_type = self.write_node.knob('render_type').value()
        self.render_name = self.write_node.knob('name_1').value()
        self.render_version = self.write_node.knob('version_1').value()
        self.render_file_type = self.write_node.knob('file_type').value()
        self.render_colorspace = self.write_node.knob('colorspace').value()
        self.render_compression = ""
        self.render_codec = ""
        self.render_codec_profile = ""

if self.render_file_type == "exr":
            self.render_compression = self.write_node.knob("compression").value()
        elif self.render_file_type == "mov":
            self.render_codec = self.write_node.knob("mov64_codec").value()
            self.render_codec_profile = self.write_node.knob("mov_prores_codec_profile")

def build_widget(self):
        """Construye todos los componentes de la interfaz de usuario."""
        # Write Node input layout
        self.write_node_layout = QHBoxLayout()
        self.write_node_layout.setAlignment(Qt.AlignCenter)
        self.write_node_label = QLabel("Write Node:")
        self.write_node_label_name = QLabel(self.write_node.name())

self.write_node_layout.addWidget(self.write_node_label)
        self.write_node_layout.addWidget(self.write_node_label_name)

# Frame Range Layout
        self.start_end_layout = QHBoxLayout()

# First Frame input
        self.first_frame_label = QLabel("First Frame:")
        self.first_frame_input = QDoubleSpinBox()
        self.first_frame_input.setRange(-1000000.0, 1000000.0)  # Example range, adjust as needed

# Last Frame input
        self.last_frame_label = QLabel("Last Frame:")
        self.last_frame_input = QDoubleSpinBox()
        self.last_frame_input.setRange(-1000000.0, 1000000.0)  # Example range, adjust as needed

self.start_end_layout.addWidget(self.first_frame_label)
        self.start_end_layout.addWidget(self.first_frame_input)
        self.start_end_layout.addWidget(self.last_frame_label)
        self.start_end_layout.addWidget(self.last_frame_input)

# Pipeline Data (node Write)
        self.pipeline_data_layout = QFormLayout()

self.pipeline_data_layout.setAlignment(Qt.AlignCenter)

self.output_path_label = QLabel("Output Name:")
        self.output_path_input = QLineEdit()
        self.output_path_input.setEnabled(False)
        self.render_type_label = QLabel(f"Render Type:")
        self.render_type_value = QLineEdit(self.render_type)
        self.render_type_value.setEnabled(False)
        self.render_name_label = QLabel(f"Render name:")
        self.render_name_value = QLineEdit(self.render_name)
        self.render_name_value.setEnabled(False)
        self.render_version_label = QLabel(f"Version:")
        self.render_version_value = QLineEdit(self.render_version)
        self.render_version_value.setEnabled(False)

self.pipeline_data_layout.addRow(self.output_path_label, self.output_path_input)
        self.pipeline_data_layout.addRow(self.render_type_label, self.render_type_value)
        self.pipeline_data_layout.addRow(self.render_name_label, self.render_name_value)
        self.pipeline_data_layout.addRow(self.render_version_label, self.render_version_value)

# TD_TODO_PIPELINER: Set formato para EXR y MOV (el codec puede ser un knob)
        # Select Render Frame Range
        self.set_frame_range_layout = QVBoxLayout()

self.selected_option_label = QLabel("Selected Render Frame Range Option")
        self.selected_option_label.setAlignment(Qt.AlignCenter)
        self.frame_range_option_layout = QHBoxLayout()

self.write_radio_button = QRadioButton("Write Settings")
        self.project_settings_radio_button = QRadioButton("Project Settings")
        self.custom_radio_button = QRadioButton("Custom")

self.frame_range_option_layout.addWidget(self.write_radio_button)
        self.frame_range_option_layout.addWidget(self.project_settings_radio_button)
        self.frame_range_option_layout.addWidget(self.custom_radio_button)

self.set_frame_range_layout.addWidget(self.selected_option_label)
        self.set_frame_range_layout.addLayout(self.frame_range_option_layout)

# Proxy Output checkbox
        self.proxy_layout = QVBoxLayout()

self.proxy_checkbox = QCheckBox("Proxy Output")
        self.proxy_outpath = QLineEdit()
        self.proxy_outpath.setEnabled(False)
        self.proxy_outpath.hide()

self.proxy_layout.addWidget(self.proxy_checkbox)
        self.proxy_layout.addWidget(self.proxy_outpath)

# Send to Local/Farm option
        self.send_to_farm_check = QCheckBox("Send Render to Farm.")

# Buttons Submit/ Cancel
        self.buttons_layout = QHBoxLayout()
        self.submit_button = QPushButton("Submit Render")
        self.cancel_button = QPushButton("Cancel")

self.buttons_layout.addWidget(self.submit_button)
        self.buttons_layout.addWidget(self.cancel_button)

# Add widgets to main layout
        self.main_layout.addLayout(self.write_node_layout)
        self.main_layout.addLayout(self.pipeline_data_layout)
        self.main_layout.addStretch(0)
        self.main_layout.addLayout(self.set_frame_range_layout)
        self.main_layout.addLayout(self.start_end_layout)
        self.main_layout.addLayout(self.proxy_layout)
        self.main_layout.addWidget(self.send_to_farm_check)
        self.main_layout.addStretch(0)
        self.main_layout.addLayout(self.buttons_layout)

def connect_signals(self):
        """Registro de los signals de los elementos de la UI a las funciones."""
        self.submit_button.clicked.connect(self.on_submit_render)
        self.cancel_button.clicked.connect(self.on_cancel)
        self.write_radio_button.toggled.connect(self.on_frame_range_option_changed)
        self.project_settings_radio_button.toggled.connect(self.on_frame_range_option_changed)
        self.custom_radio_button.toggled.connect(self.on_frame_range_option_changed)
        self.proxy_checkbox.stateChanged.connect(self.on_proxy_checkbox)

def _autocomplete(self):
        """Autocompletar datos al iniciar la UI."""
        write_out_path = self.write_node.knob('file').value()
        version_name = os.path.basename(write_out_path)
        self.output_path_input.setText(version_name)

# Frame range por defecto: write node
        self.write_radio_button.setChecked(True)

def on_submit_render(self):
        """Al pulsar sobre Submit, recopila todos los datos necesarios para enviar Render."""
        version_name = self.output_path_input.text()
        first_frame = self.first_frame_input.value()
        last_frame = self.last_frame_input.value()
        proxy_path = self.proxy_outpath.text()
        send_to_farm = self.send_to_farm_check.isChecked()

# Collect Render data:

data = {
            'write_node': self.write_node,
            'output_path': self.output_file,
            'version_name': version_name,
            'first_frame': first_frame,
            'last_frame': last_frame,
            'proxy_path': proxy_path,
            'send_to_farm': send_to_farm,
            'file_type': self.render_file_type,
            'colorspace': self.render_colorspace,
            'compression': self.render_compression,
            'codec': self.render_codec,
            'codec_profile': self.render_codec_profile
        }
        print(f"data: \n {data}")
        self.submit_render.emit(data)
        self.close()

def on_cancel(self):
        """Al pulsar sobre Cancelar, cerramos la interfaz."""
        self.close()

def on_frame_range_option_changed(self):
        """Callback cuando las selección de la opción del frame range ha cambiado."""
        # Obtener el radio button seleccionado, y actualizar los labels de Frame range.
        self.first_frame_input.setEnabled(False)
        self.last_frame_input.setEnabled(False)
        if self.write_radio_button.isChecked():
            self.set_frame_range(
                self.write_node.knob('first').value(),
                self.write_node.knob('last').value()
            )
        elif self.project_settings_radio_button.isChecked():
            first = nuke.root().knob('first_frame').value()
            last = nuke.root().knob('last_frame').value()
            self.set_frame_range(first, last)
        elif self.custom_radio_button.isChecked():
            self.first_frame_input.setEnabled(True)
            self.last_frame_input.setEnabled(True)

def on_proxy_checkbox(self):
        """Callback cuando la opción de proxy ha cambiado."""
        if self.proxy_checkbox.isChecked():
            self.proxy_outpath.show()
            self.proxy_outpath.setText(self.write_node.knob('proxy').value())
        else:
            self.proxy_outpath.hide()
            self.proxy_outpath.clear()

def set_frame_range(self, start, end):
        """Setea el frame range con los datos proporcionados."""
        self.first_frame_input.setValue(start)
        self.last_frame_input.setValue(end)

def render(data):
    """Envia el render con los datos proporcionados. Crea la tarea de Render2D y renderiza (for Version).
    Info:
        data = {
            'write_node': obj:'nuke.write()',
            'output_path': 'D:/PROJECT/2D/EP/SQ/SHOT/OUT/render.%04.exr',
            'version_name': 'VFX_EP_SQ_SHOT_comp_v001',
            'first_frame': 1001,
            'last_frame': 1050,
            'proxy_path': 'D:/PROJECT/2D/EP/SQ/SHOT/PROXY/render.%04.exr'
            'send_to_farm': True
            'file_type': "exr",
            'colorspace': "sRGB",
            'compression': "",
            'codec': "",
            'codec_profile': ""
        }
    """
    # Datos de render
    write_node = data.get('write_node')
    output_path = data.get('output_path')
    first_frame = data.get('first_frame')
    last_frame = data.get('last_frame')
    proxy_output = data.get('proxy_path')
    send_to_farm = data.get('send_to_farm')
    file_type = data.get('file_type')
    colorspace = data.get('colorspace')
    compression = data.get('compression')
    codec = data.get('codec')
    codec_compression = data.get('codec_compression')

# Seteamos el write node con el rango de first/last frame a renderizar
    write_node.knob('first').setValue(first_frame)
    write_node.knob('last').setValue(last_frame)
    nk_version_name = write_node.knob('version_name').value()

# TODO_TD_PIPELINEPRO: Sanity Checks del render antes de enviarlo (estamos en el DCC).
    # TODO_TD_PIPELINEPRO: Revisar si damos opción de hacer un Render local o for Review.

# 0. Guardamos escena actual en la tarea de COMP (REVIEW?)

# Archivo actual
    file = pipeline.file()
    nuke_file = nuke.root().name()

# Carpeta local
    folder_local = file['folder']['folderLocal']
    file_name = file['folder']['name']
    folder_local_key = file['folder']['key']
    # Key del shot al que pertenece
    shot_key = file['folder']['relTaskFolder'][0]['relShotTask'][0]['key']
    # TODO_TD_PIPELINER: Publicar a Review o hacer New WIP.
    print(f"Saving script...")
    nuke.scriptSaveAs(nuke_file, overwrite=1)
    upload_folder(folder_local_key)
    # TODO_TD_PIPELINER: El publish no funciona. 
    # publish_folder(folder_local_key, 'wip')

# 2. Crear tarea Render2D
    render_task = create_new_task(shot_key, 'RD2D')
    print("Render Task Created")
    review_folder_key = render_task['task']['lastReviewFolder']['key']

# 2.1. Creamos el archivo de primer wip
    print("Create Render wip file!")
    wip_file_obj = create_new_wip(review_folder_key)
    wip_file_key = wip_file_obj['file']['key']
    wip_file = wip_file_obj['file']['fileLocal']
    wip_folder_local = wip_file_obj['file']['folder']['folderLocal']
    wip_folder_key = wip_file_obj['file']['folder']['key']

# 2.2 Seteamos la salida del Write de render
    # TODO_TD_PIPELINEPRO: Ahora añadimos como salida de render el path del archivo Wip.
    # TODO_TD_PIPELINEPRO: dar la opción de poder renderizar en un path de salida que quieran (fuera de pipe)
    file_path = os.path.join(wip_folder_local, f"{nk_version_name}.####.{file_type}")
    write_node.knob('file').setValue(file_path)
    print(f"Render File: {file_path}")

# 2.3 Guardamos el template actual de COMP en la tarea wip de Render2D
    if not os.path.exists(os.path.dirname(wip_file)):
        os.makedirs(os.path.dirname(wip_file))
    nuke.scriptSaveAs(wip_file, overwrite=1)

# 3. Actualizamos carpeta WIP
    print(f"Subir carpeta WIP: {wip_folder_key}")
    upload_folder(wip_folder_key)

# 4. Publicamos Tarea a for Review -> lanzará el render: exr y mp4
    message = publish_folder(wip_folder_key, 'rev')
    print(f"Render2D published to Review.")
    # TODO_TD_PIPELINEPRO: Ahora se usa la misma escena para renderizar, el artista no puede tocar nada, debe esperar.

def main():
    """Funcion principal para la apertura de la UI."""
    nuke_window = get_nuke_main_window()
    if nuke_window is None:
        print("Error on creating UI in Nuke")
        return

write_nodes = [node for node in nuke.selectedNodes() if node.Class() == "Write"]
    # Check write node type.
    msg = ""
    if write_nodes:
        if len(write_nodes) > 1:
            msg = f"More than 1 Write node selected. \nPlease select only one."
        else:
            try:
                nuke_submit_window = SubmitRenderUI(write_nodes[0], parent=nuke_window)
                nuke_submit_window.show()
                nuke_submit_window.submit_render.connect(render)
            except Exception as e:
                msg = f"Error on Submit Render: \n{e}"
                print(e)
    else:
        msg = "Please select a Write Node."
    if msg:
        print("Error on Submit render.")
        nuke.message(msg)

main()

Import Action

1. Copy Key

Copy

2. Go to your Action pannel

Go