Merge branch 'develop' into enhancement/OP-7630_DCC-connection-timeout

client/ayon_core/hosts/blender/api/render_lib.py

@@ -47,6 +47,22 @@ def get_multilayer(settings):
                     ["multilayer_exr"])
 
 
+def get_renderer(settings):
+    """Get renderer from blender settings."""
+
+    return (settings["blender"]
+                    ["RenderSettings"]
+                    ["renderer"])
+
+
+def get_compositing(settings):
+    """Get compositing from blender settings."""
+
+    return (settings["blender"]
+                    ["RenderSettings"]
+                    ["compositing"])
+
+
 def get_render_product(output_path, name, aov_sep):
     """
     Generate the path to the render product. Blender interprets the `#`
@@ -91,66 +107,120 @@ def set_render_format(ext, multilayer):
         image_settings.file_format = "TIFF"
 
 
-def set_render_passes(settings):
-    aov_list = (settings["blender"]
-                        ["RenderSettings"]
-                        ["aov_list"])
-
-    custom_passes = (settings["blender"]
-                             ["RenderSettings"]
-                             ["custom_passes"])
+def set_render_passes(settings, renderer):
+    aov_list = set(settings["blender"]["RenderSettings"]["aov_list"])
+    custom_passes = settings["blender"]["RenderSettings"]["custom_passes"]
 
+    # Common passes for both renderers
     vl = bpy.context.view_layer
 
+    # Data Passes
     vl.use_pass_combined = "combined" in aov_list
     vl.use_pass_z = "z" in aov_list
     vl.use_pass_mist = "mist" in aov_list
     vl.use_pass_normal = "normal" in aov_list
+
+    # Light Passes
     vl.use_pass_diffuse_direct = "diffuse_light" in aov_list
     vl.use_pass_diffuse_color = "diffuse_color" in aov_list
     vl.use_pass_glossy_direct = "specular_light" in aov_list
     vl.use_pass_glossy_color = "specular_color" in aov_list
-    vl.eevee.use_pass_volume_direct = "volume_light" in aov_list
     vl.use_pass_emit = "emission" in aov_list
     vl.use_pass_environment = "environment" in aov_list
-    vl.use_pass_shadow = "shadow" in aov_list
     vl.use_pass_ambient_occlusion = "ao" in aov_list
 
-    cycles = vl.cycles
+    # Cryptomatte Passes
+    vl.use_pass_cryptomatte_object = "cryptomatte_object" in aov_list
+    vl.use_pass_cryptomatte_material = "cryptomatte_material" in aov_list
+    vl.use_pass_cryptomatte_asset = "cryptomatte_asset" in aov_list
 
-    cycles.denoising_store_passes = "denoising" in aov_list
-    cycles.use_pass_volume_direct = "volume_direct" in aov_list
-    cycles.use_pass_volume_indirect = "volume_indirect" in aov_list
+    if renderer == "BLENDER_EEVEE":
+        # Eevee exclusive passes
+        eevee = vl.eevee
+
+        # Light Passes
+        vl.use_pass_shadow = "shadow" in aov_list
+        eevee.use_pass_volume_direct = "volume_light" in aov_list
+
+        # Effects Passes
+        eevee.use_pass_bloom = "bloom" in aov_list
+        eevee.use_pass_transparent = "transparent" in aov_list
+
+        # Cryptomatte Passes
+        vl.use_pass_cryptomatte_accurate = "cryptomatte_accurate" in aov_list
+    elif renderer == "CYCLES":
+        # Cycles exclusive passes
+        cycles = vl.cycles
+
+        # Data Passes
+        vl.use_pass_position = "position" in aov_list
+        vl.use_pass_vector = "vector" in aov_list
+        vl.use_pass_uv = "uv" in aov_list
+        cycles.denoising_store_passes = "denoising" in aov_list
+        vl.use_pass_object_index = "object_index" in aov_list
+        vl.use_pass_material_index = "material_index" in aov_list
+        cycles.pass_debug_sample_count = "sample_count" in aov_list
+
+        # Light Passes
+        vl.use_pass_diffuse_indirect = "diffuse_indirect" in aov_list
+        vl.use_pass_glossy_indirect = "specular_indirect" in aov_list
+        vl.use_pass_transmission_direct = "transmission_direct" in aov_list
+        vl.use_pass_transmission_indirect = "transmission_indirect" in aov_list
+        vl.use_pass_transmission_color = "transmission_color" in aov_list
+        cycles.use_pass_volume_direct = "volume_light" in aov_list
+        cycles.use_pass_volume_indirect = "volume_indirect" in aov_list
+        cycles.use_pass_shadow_catcher = "shadow" in aov_list
 
     aovs_names = [aov.name for aov in vl.aovs]
     for cp in custom_passes:
-        cp_name = cp[0]
+        cp_name = cp["attribute"]
         if cp_name not in aovs_names:
             aov = vl.aovs.add()
             aov.name = cp_name
         else:
             aov = vl.aovs[cp_name]
-        aov.type = cp[1].get("type", "VALUE")
+        aov.type = cp["value"]
 
-    return aov_list, custom_passes
+    return list(aov_list), custom_passes
 
 
-def set_node_tree(output_path, name, aov_sep, ext, multilayer):
+def _create_aov_slot(name, aov_sep, slots, rpass_name, multi_exr, output_path):
+    filename = f"{name}{aov_sep}{rpass_name}.####"
+    slot = slots.new(rpass_name if multi_exr else filename)
+    filepath = str(output_path / filename.lstrip("/"))
+
+    return slot, filepath
+
+
+def set_node_tree(
+    output_path, render_product, name, aov_sep, ext, multilayer, compositing
+):
     # Set the scene to use the compositor node tree to render
     bpy.context.scene.use_nodes = True
 
     tree = bpy.context.scene.node_tree
 
-    # Get the Render Layers node
-    rl_node = None
+    comp_layer_type = "CompositorNodeRLayers"
+    output_type = "CompositorNodeOutputFile"
+    compositor_type = "CompositorNodeComposite"
+
+    # Get the Render Layer, Composite and the previous output nodes
+    render_layer_node = None
+    composite_node = None
+    old_output_node = None
     for node in tree.nodes:
-        if node.bl_idname == "CompositorNodeRLayers":
-            rl_node = node
+        if node.bl_idname == comp_layer_type:
+            render_layer_node = node
+        elif node.bl_idname == compositor_type:
+            composite_node = node
+        elif node.bl_idname == output_type and "AYON" in node.name:
+            old_output_node = node
+        if render_layer_node and composite_node and old_output_node:
             break
 
     # If there's not a Render Layers node, we create it
-    if not rl_node:
-        rl_node = tree.nodes.new("CompositorNodeRLayers")
+    if not render_layer_node:
+        render_layer_node = tree.nodes.new(comp_layer_type)
 
     # Get the enabled output sockets, that are the active passes for the
     # render.
@@ -158,48 +228,81 @@ def set_node_tree(output_path, name, aov_sep, ext, multilayer):
     exclude_sockets = ["Image", "Alpha", "Noisy Image"]
     passes = [
         socket
-        for socket in rl_node.outputs
+        for socket in render_layer_node.outputs
         if socket.enabled and socket.name not in exclude_sockets
     ]
 
-    # Remove all output nodes
-    for node in tree.nodes:
-        if node.bl_idname == "CompositorNodeOutputFile":
-            tree.nodes.remove(node)
-
     # Create a new output node
-    output = tree.nodes.new("CompositorNodeOutputFile")
+    output = tree.nodes.new(output_type)
 
     image_settings = bpy.context.scene.render.image_settings
     output.format.file_format = image_settings.file_format
 
+    slots = None
+
     # In case of a multilayer exr, we don't need to use the output node,
     # because the blender render already outputs a multilayer exr.
-    if ext == "exr" and multilayer:
-        output.layer_slots.clear()
-        return []
+    multi_exr = ext == "exr" and multilayer
+    slots = output.layer_slots if multi_exr else output.file_slots
+    output.base_path = render_product if multi_exr else str(output_path)
 
-    output.file_slots.clear()
-    output.base_path = str(output_path)
+    slots.clear()
 
     aov_file_products = []
 
+    old_links = {
+        link.from_socket.name: link for link in tree.links
+        if link.to_node == old_output_node}
+
+    # Create a new socket for the beauty output
+    pass_name = "rgba" if multi_exr else "beauty"
+    slot, _ = _create_aov_slot(
+        name, aov_sep, slots, pass_name, multi_exr, output_path)
+    tree.links.new(render_layer_node.outputs["Image"], slot)
+
+    if compositing:
+        # Create a new socket for the composite output
+        pass_name = "composite"
+        comp_socket, filepath = _create_aov_slot(
+            name, aov_sep, slots, pass_name, multi_exr, output_path)
+        aov_file_products.append(("Composite", filepath))
+
     # For each active render pass, we add a new socket to the output node
     # and link it
-    for render_pass in passes:
-        filepath = f"{name}{aov_sep}{render_pass.name}.####"
+    for rpass in passes:
+        slot, filepath = _create_aov_slot(
+            name, aov_sep, slots, rpass.name, multi_exr, output_path)
+        aov_file_products.append((rpass.name, filepath))
 
-        output.file_slots.new(filepath)
+        # If the rpass was not connected with the old output node, we connect
+        # it with the new one.
+        if not old_links.get(rpass.name):
+            tree.links.new(rpass, slot)
 
-        filename = str(output_path / filepath.lstrip("/"))
+    for link in list(old_links.values()):
+        # Check if the socket is still available in the new output node.
+        socket = output.inputs.get(link.to_socket.name)
+        # If it is, we connect it with the new output node.
+        if socket:
+            tree.links.new(link.from_socket, socket)
+        # Then, we remove the old link.
+        tree.links.remove(link)
 
-        aov_file_products.append((render_pass.name, filename))
+    # If there's a composite node, we connect its input with the new output
+    if compositing and composite_node:
+        for link in tree.links:
+            if link.to_node == composite_node:
+                tree.links.new(link.from_socket, comp_socket)
+                break
 
-        node_input = output.inputs[-1]
+    if old_output_node:
+        output.location = old_output_node.location
+        tree.nodes.remove(old_output_node)
 
-        tree.links.new(render_pass, node_input)
+    output.name = "AYON File Output"
+    output.label = "AYON File Output"
 
-    return aov_file_products
+    return [] if multi_exr else aov_file_products
 
 
 def imprint_render_settings(node, data):
@@ -228,17 +331,23 @@ def prepare_rendering(asset_group):
     aov_sep = get_aov_separator(settings)
     ext = get_image_format(settings)
     multilayer = get_multilayer(settings)
+    renderer = get_renderer(settings)
+    compositing = get_compositing(settings)
 
     set_render_format(ext, multilayer)
-    aov_list, custom_passes = set_render_passes(settings)
+    bpy.context.scene.render.engine = renderer
+    aov_list, custom_passes = set_render_passes(settings, renderer)
 
     output_path = Path.joinpath(dirpath, render_folder, file_name)
 
     render_product = get_render_product(output_path, name, aov_sep)
     aov_file_product = set_node_tree(
-        output_path, name, aov_sep, ext, multilayer)
+        output_path, render_product, name, aov_sep,
+        ext, multilayer, compositing)
 
-    bpy.context.scene.render.filepath = render_product
+    # Clear the render filepath, so that the output is handled only by the
+    # output node in the compositor.
+    bpy.context.scene.render.filepath = ""
 
     render_settings = {
         "render_folder": render_folder,

client/ayon_core/hosts/blender/plugins/create/create_render.py

@@ -1,8 +1,10 @@
 """Create render."""
 import bpy
 
+from ayon_core.lib import version_up
 from ayon_core.hosts.blender.api import plugin
 from ayon_core.hosts.blender.api.render_lib import prepare_rendering
+from ayon_core.hosts.blender.api.workio import save_file
 
 
 class CreateRenderlayer(plugin.BaseCreator):
@@ -37,6 +39,7 @@ class CreateRenderlayer(plugin.BaseCreator):
         # settings. Even the validator to check that the file is saved will
         # detect the file as saved, even if it isn't. The only solution for
         # now it is to force the file to be saved.
-        bpy.ops.wm.save_as_mainfile(filepath=bpy.data.filepath)
+        filepath = version_up(bpy.data.filepath)
+        save_file(filepath, copy=False)
 
         return collection

client/ayon_core/hosts/blender/plugins/publish/validate_deadline_publish.py

@@ -28,15 +28,27 @@ class ValidateDeadlinePublish(pyblish.api.InstancePlugin,
     def process(self, instance):
         if not self.is_active(instance.data):
             return
+
+        tree = bpy.context.scene.node_tree
+        output_type = "CompositorNodeOutputFile"
+        output_node = None
+        # Remove all output nodes that inlcude "AYON" in the name.
+        # There should be only one.
+        for node in tree.nodes:
+            if node.bl_idname == output_type and "AYON" in node.name:
+                output_node = node
+                break
+        if not output_node:
+            raise PublishValidationError(
+                "No output node found in the compositor tree."
+            )
         filepath = bpy.data.filepath
         file = os.path.basename(filepath)
         filename, ext = os.path.splitext(file)
-        if filename not in bpy.context.scene.render.filepath:
+        if filename not in output_node.base_path:
             raise PublishValidationError(
-                "Render output folder "
-                "doesn't match the blender scene name! "
-                "Use Repair action to "
-                "fix the folder file path."
+                "Render output folder doesn't match the blender scene name! "
+                "Use Repair action to fix the folder file path."
             )
 
     @classmethod

client/ayon_core/hosts/houdini/plugins/publish/collect_instances_usd_layered.py

@@ -2,7 +2,7 @@ import hou
 import pyblish.api
 from ayon_core.hosts.houdini.api import lib
 import ayon_core.hosts.houdini.api.usd as hou_usdlib
-import ayon_core.lib.usdlib as usdlib
+from ayon_core.pipeline import usdlib
 
 
 class CollectInstancesUsdLayered(pyblish.api.ContextPlugin):

client/ayon_core/hosts/houdini/plugins/publish/collect_usd_bootstrap.py

@@ -5,7 +5,7 @@ from ayon_core.client import (
     get_asset_by_name,
     get_asset_name_identifier,
 )
-import ayon_core.lib.usdlib as usdlib
+from ayon_core.pipeline import usdlib
 
 
 class CollectUsdBootstrap(pyblish.api.InstancePlugin):

client/ayon_core/hosts/max/plugins/create/create_workfile.py

@@ -0,0 +1,109 @@
+# -*- coding: utf-8 -*-
+"""Creator plugin for creating workfiles."""
+from ayon_core.pipeline import CreatedInstance, AutoCreator
+from ayon_core.client import get_asset_by_name, get_asset_name_identifier
+from ayon_core.hosts.max.api import plugin
+from ayon_core.hosts.max.api.lib import read, imprint
+from pymxs import runtime as rt
+
+
+class CreateWorkfile(plugin.MaxCreatorBase, AutoCreator):
+    """Workfile auto-creator."""
+    identifier = "io.ayon.creators.max.workfile"
+    label = "Workfile"
+    family = "workfile"
+    icon = "fa5.file"
+
+    default_variant = "Main"
+
+    def create(self):
+        variant = self.default_variant
+        current_instance = next(
+            (
+                instance for instance in self.create_context.instances
+                if instance.creator_identifier == self.identifier
+            ), None)
+        project_name = self.project_name
+        asset_name = self.create_context.get_current_asset_name()
+        task_name = self.create_context.get_current_task_name()
+        host_name = self.create_context.host_name
+
+        if current_instance is None:
+            asset_doc = get_asset_by_name(project_name, asset_name)
+            subset_name = self.get_subset_name(
+                variant, task_name, asset_doc, project_name, host_name
+            )
+            data = {
+                "folderPath": asset_name,
+                "task": task_name,
+                "variant": variant
+            }
+
+            data.update(
+                self.get_dynamic_data(
+                    variant, task_name, asset_doc,
+                    project_name, host_name, current_instance)
+            )
+            self.log.info("Auto-creating workfile instance...")
+            instance_node = self.create_node(subset_name)
+            data["instance_node"] = instance_node.name
+            current_instance = CreatedInstance(
+                self.family, subset_name, data, self
+            )
+            self._add_instance_to_context(current_instance)
+            imprint(instance_node.name, current_instance.data)
+        elif (
+            current_instance["folderPath"] != asset_name
+            or current_instance["task"] != task_name
+        ):
+            # Update instance context if is not the same
+            asset_doc = get_asset_by_name(project_name, asset_name)
+            subset_name = self.get_subset_name(
+                variant, task_name, asset_doc, project_name, host_name
+            )
+            asset_name = get_asset_name_identifier(asset_doc)
+
+            current_instance["folderPath"] = asset_name
+            current_instance["task"] = task_name
+            current_instance["subset"] = subset_name
+
+    def collect_instances(self):
+        self.cache_subsets(self.collection_shared_data)
+        for instance in self.collection_shared_data["max_cached_subsets"].get(self.identifier, []):  # noqa
+            if not rt.getNodeByName(instance):
+                continue
+            created_instance = CreatedInstance.from_existing(
+                read(rt.GetNodeByName(instance)), self
+            )
+            self._add_instance_to_context(created_instance)
+
+    def update_instances(self, update_list):
+        for created_inst, _ in update_list:
+            instance_node = created_inst.get("instance_node")
+            imprint(
+                instance_node,
+                created_inst.data_to_store()
+            )
+
+    def remove_instances(self, instances):
+        """Remove specified instance from the scene.
+
+        This is only removing `id` parameter so instance is no longer
+        instance, because it might contain valuable data for artist.
+
+        """
+        for instance in instances:
+            instance_node = rt.GetNodeByName(
+                instance.data.get("instance_node"))
+            if instance_node:
+                rt.Delete(instance_node)
+
+            self._remove_instance_from_context(instance)
+
+    def create_node(self, subset_name):
+        if rt.getNodeByName(subset_name):
+            node = rt.getNodeByName(subset_name)
+            return node
+        node = rt.Container(name=subset_name)
+        node.isHidden = True
+        return node

client/ayon_core/hosts/max/plugins/publish/collect_current_file.py

@@ -0,0 +1,23 @@
+import os
+import pyblish.api
+
+from pymxs import runtime as rt
+
+
+class CollectCurrentFile(pyblish.api.ContextPlugin):
+    """Inject the current working file."""
+
+    order = pyblish.api.CollectorOrder - 0.5
+    label = "Max Current File"
+    hosts = ['max']
+
+    def process(self, context):
+        """Inject the current working file"""
+        folder = rt.maxFilePath
+        file = rt.maxFileName
+        if not folder or not file:
+            self.log.error("Scene is not saved.")
+        current_file = os.path.join(folder, file)
+
+        context.data["currentFile"] = current_file
+        self.log.debug("Scene path: {}".format(current_file))

client/ayon_core/hosts/max/plugins/publish/collect_members.py

@@ -12,7 +12,9 @@ class CollectMembers(pyblish.api.InstancePlugin):
     hosts = ['max']
 
     def process(self, instance):
-
+        if instance.data["family"] == "workfile":
+            self.log.debug("Skipping Collecting Members for workfile family.")
+            return
         if instance.data.get("instance_node"):
             container = rt.GetNodeByName(instance.data["instance_node"])
             instance.data["members"] = [

client/ayon_core/hosts/max/plugins/publish/collect_workfile.py

@@ -6,57 +6,41 @@ import pyblish.api
 from pymxs import runtime as rt
 
 
-class CollectWorkfile(pyblish.api.ContextPlugin):
+class CollectWorkfile(pyblish.api.InstancePlugin):
     """Inject the current working file into context"""
 
     order = pyblish.api.CollectorOrder - 0.01
     label = "Collect 3dsmax Workfile"
     hosts = ['max']
+    families = ["workfile"]
 
-    def process(self, context):
+    def process(self, instance):
         """Inject the current working file."""
+        context = instance.context
         folder = rt.maxFilePath
         file = rt.maxFileName
         if not folder or not file:
             self.log.error("Scene is not saved.")
-        current_file = os.path.join(folder, file)
-
-        context.data['currentFile'] = current_file
-
-        filename, ext = os.path.splitext(file)
-
-        task = context.data["task"]
+        ext = os.path.splitext(file)[-1].lstrip(".")
 
         data = {}
 
-        # create instance
-        instance = context.create_instance(name=filename)
-        subset = 'workfile' + task.capitalize()
-
         data.update({
-            "subset": subset,
-            "asset": context.data["asset"],
-            "label": subset,
-            "publish": True,
-            "family": 'workfile',
-            "families": ['workfile'],
-            "setMembers": [current_file],
-            "frameStart": context.data['frameStart'],
-            "frameEnd": context.data['frameEnd'],
-            "handleStart": context.data['handleStart'],
-            "handleEnd": context.data['handleEnd']
+            "setMembers": context.data["currentFile"],
+            "frameStart": context.data["frameStart"],
+            "frameEnd": context.data["frameEnd"],
+            "handleStart": context.data["handleStart"],
+            "handleEnd": context.data["handleEnd"]
         })
 
-        data['representations'] = [{
-            'name': ext.lstrip("."),
-            'ext': ext.lstrip("."),
-            'files': file,
+        data["representations"] = [{
+            "name": ext,
+            "ext": ext,
+            "files": file,
             "stagingDir": folder,
         }]
 
         instance.data.update(data)
-
-        self.log.info('Collected instance: {}'.format(file))
-        self.log.info('Scene path: {}'.format(current_file))
-        self.log.info('staging Dir: {}'.format(folder))
-        self.log.info('subset: {}'.format(subset))
+        self.log.debug("Collected data: {}".format(data))
+        self.log.debug("Collected instance: {}".format(file))
+        self.log.debug("staging Dir: {}".format(folder))

client/ayon_core/modules/deadline/plugins/publish/submit_houdini_render_deadline.py

@@ -44,7 +44,10 @@ class VrayRenderPluginInfo():
 @attr.s
 class RedshiftRenderPluginInfo():
     SceneFile = attr.ib(default=None)
-    Version = attr.ib(default=None)
+    # Use "1" as the default Redshift version just because it
+    # default fallback version in Deadline's Redshift plugin
+    # if no version was specified
+    Version = attr.ib(default="1")
 
 
 class HoudiniSubmitDeadline(

client/ayon_core/settings/defaults/project_settings/blender.json

@@ -22,7 +22,8 @@
         "aov_separator": "underscore",
         "image_format": "exr",
         "multilayer_exr": true,
-        "aov_list": [],
+        "renderer": "CYCLES",
+        "aov_list": ["combined"],
         "custom_passes": []
     },
     "workfile_builder": {

server_addon/blender/server/settings/render_settings.py

@@ -23,6 +23,13 @@ def image_format_enum():
     ]
 
 
+def renderers_enum():
+    return [
+        {"value": "CYCLES", "label": "Cycles"},
+        {"value": "BLENDER_EEVEE", "label": "Eevee"},
+    ]
+
+
 def aov_list_enum():
     return [
         {"value": "empty", "label": "< none >"},
@@ -30,18 +37,52 @@ def aov_list_enum():
         {"value": "z", "label": "Z"},
         {"value": "mist", "label": "Mist"},
         {"value": "normal", "label": "Normal"},
-        {"value": "diffuse_light", "label": "Diffuse Light"},
+        {"value": "position", "label": "Position (Cycles Only)"},
+        {"value": "vector", "label": "Vector (Cycles Only)"},
+        {"value": "uv", "label": "UV (Cycles Only)"},
+        {"value": "denoising", "label": "Denoising Data (Cycles Only)"},
+        {"value": "object_index", "label": "Object Index (Cycles Only)"},
+        {"value": "material_index", "label": "Material Index (Cycles Only)"},
+        {"value": "sample_count", "label": "Sample Count (Cycles Only)"},
+        {"value": "diffuse_light", "label": "Diffuse Light/Direct"},
+        {
+            "value": "diffuse_indirect",
+            "label": "Diffuse Indirect (Cycles Only)"
+        },
         {"value": "diffuse_color", "label": "Diffuse Color"},
-        {"value": "specular_light", "label": "Specular Light"},
-        {"value": "specular_color", "label": "Specular Color"},
-        {"value": "volume_light", "label": "Volume Light"},
+        {"value": "specular_light", "label": "Specular (Glossy) Light/Direct"},
+        {
+            "value": "specular_indirect",
+            "label": "Specular (Glossy) Indirect (Cycles Only)"
+        },
+        {"value": "specular_color", "label": "Specular (Glossy) Color"},
+        {
+            "value": "transmission_light",
+            "label": "Transmission Light/Direct (Cycles Only)"
+        },
+        {
+            "value": "transmission_indirect",
+            "label": "Transmission Indirect (Cycles Only)"
+        },
+        {
+            "value": "transmission_color",
+            "label": "Transmission Color (Cycles Only)"
+        },
+        {"value": "volume_light", "label": "Volume Light/Direct"},
+        {"value": "volume_indirect", "label": "Volume Indirect (Cycles Only)"},
         {"value": "emission", "label": "Emission"},
         {"value": "environment", "label": "Environment"},
-        {"value": "shadow", "label": "Shadow"},
+        {"value": "shadow", "label": "Shadow/Shadow Catcher"},
         {"value": "ao", "label": "Ambient Occlusion"},
-        {"value": "denoising", "label": "Denoising"},
-        {"value": "volume_direct", "label": "Direct Volumetric Scattering"},
-        {"value": "volume_indirect", "label": "Indirect Volumetric Scattering"}
+        {"value": "bloom", "label": "Bloom (Eevee Only)"},
+        {"value": "transparent", "label": "Transparent (Eevee Only)"},
+        {"value": "cryptomatte_object", "label": "Cryptomatte Object"},
+        {"value": "cryptomatte_material", "label": "Cryptomatte Material"},
+        {"value": "cryptomatte_asset", "label": "Cryptomatte Asset"},
+        {
+            "value": "cryptomatte_accurate",
+            "label": "Cryptomatte Accurate Mode (Eevee Only)"
+        },
     ]
 
 
@@ -81,6 +122,14 @@ class RenderSettingsModel(BaseSettingsModel):
     multilayer_exr: bool = SettingsField(
         title="Multilayer (EXR)"
     )
+    renderer: str = SettingsField(
+        "CYCLES",
+        title="Renderer",
+        enum_resolver=renderers_enum
+    )
+    compositing: bool = SettingsField(
+        title="Enable Compositing"
+    )
     aov_list: list[str] = SettingsField(
         default_factory=list,
         enum_resolver=aov_list_enum,
@@ -102,6 +151,8 @@ DEFAULT_RENDER_SETTINGS = {
     "aov_separator": "underscore",
     "image_format": "exr",
     "multilayer_exr": True,
-    "aov_list": [],
+    "renderer": "CYCLES",
+    "compositing": True,
+    "aov_list": ["combined"],
     "custom_passes": []
 }

server_addon/blender/server/version.py

@@ -1 +1 @@
-__version__ = "0.1.5"
+__version__ = "0.1.6"