Maya: Render Creator has configurable options.

openpype/hosts/maya/api/lib_renderproducts.py

@@ -82,6 +82,14 @@
 
 RENDERMAN_IMAGE_DIR = "maya/<scene>/<layer>"
 
+
+def has_tokens(string, tokens):
+ """Return whether any of tokens is in input string (case-insensitive)"""
+ pattern = "({})".format("|".join(re.escape(token) for token in tokens))
+ match = re.search(pattern, string, re.IGNORECASE)
+ return bool(match)
+
+
 @attr.s
 class LayerMetadata(object):
  """Data class for Render Layer metadata."""
@@ -99,6 +107,12 @@ class LayerMetadata(object):
  # Render Products
  products = attr.ib(init=False, default=attr.Factory(list))
 
+ # The AOV separator token. Note that not all renderers define an explicit
+ # render separator but allow to put the AOV/RenderPass token anywhere in
+ # the file path prefix. For those renderers we'll fall back to whatever
+ # is between the last occurrences of <RenderLayer> and <RenderPass> tokens.
+ aov_separator = attr.ib(default="_")
+
 
 @attr.s
 class RenderProduct(object):
@@ -183,7 +197,6 @@ def __init__(self, layer, render_instance):
  self.layer = layer
  self.render_instance = render_instance
  self.multipart = False
- self.aov_separator = render_instance.data.get("aovSeparator", "_")
 
  # Initialize
  self.layer_data = self._get_layer_data()
@@ -319,6 +332,31 @@ def _get_layer_data(self):
  # defaultRenderLayer renders as masterLayer
  layer_name = "masterLayer"
 
+ # AOV separator - default behavior extracts the part between
+ # last occurences of <RenderLayer> and <RenderPass>
+ # todo: This code also triggers for V-Ray which overrides it explicitly
+ # so this code will invalidly debug log it couldn't extract the
+ # aov separator even though it does set it in RenderProductsVray
+ layer_tokens = ["<renderlayer>", "<layer>"]
+ aov_tokens = ["<aov>", "<renderpass>"]
+
+ def match_last(tokens, text):
+ """regex match the last occurence from a list of tokens"""
+ pattern = "(?:.*)({})".format("|".join(tokens))
+ return re.search(pattern, text, re.IGNORECASE)
+
+ layer_match = match_last(layer_tokens, file_prefix)
+ aov_match = match_last(aov_tokens, file_prefix)
+ kwargs = {}
+ if layer_match and aov_match:
+ matches = sorted((layer_match, aov_match),
+ key=lambda match: match.end(1))
+ separator = file_prefix[matches[0].end(1):matches[1].start(1)]
+ kwargs["aov_separator"] = separator
+ else:
+ log.debug("Couldn't extract aov separator from "
+ "file prefix: {}".format(file_prefix))
+
  # todo: Support Custom Frames sequences 0,5-10,100-120
  # Deadline allows submitting renders with a custom frame list
  # to support those cases we might want to allow 'custom frames'
@@ -335,7 +373,8 @@ def _get_layer_data(self):
  layerName=layer_name,
  renderer=self.renderer,
  defaultExt=self._get_attr("defaultRenderGlobals.imfPluginKey"),
- filePrefix=file_prefix
+ filePrefix=file_prefix,
+ **kwargs
  )
 
  def _generate_file_sequence(
@@ -680,9 +719,17 @@ def get_renderer_prefix(self):
 
  """
  prefix = super(RenderProductsVray, self).get_renderer_prefix()
- prefix = "{}{}<aov>".format(prefix, self.aov_separator)
+ aov_separator = self._get_aov_separator()
+ prefix = "{}{}<aov>".format(prefix, aov_separator)
  return prefix
 
+ def _get_aov_separator(self):
+ # type: () -> str
+ """Return the V-Ray AOV/Render Elements separator"""
+ return self._get_attr(
+ "vraySettings.fileNameRenderElementSeparator"
+ )
+
  def _get_layer_data(self):
  # type: () -> LayerMetadata
  """Override to get vray specific extension."""
@@ -694,6 +741,8 @@ def _get_layer_data(self):
  layer_data.defaultExt = default_ext
  layer_data.padding = self._get_attr("vraySettings.fileNamePadding")
 
+ layer_data.aov_separator = self._get_aov_separator()
+
  return layer_data
 
  def get_render_products(self):

openpype/hosts/maya/api/lib_rendersettings.py

@@ -0,0 +1,216 @@
+# -*- coding: utf-8 -*-
+"""Class for handling Render Settings."""
+from maya import cmds # noqa
+import maya.mel as mel
+import six
+import sys
+
+from openpype.api import (
+ get_project_settings,
+ get_current_project_settings
+)
+
+from openpype.pipeline import legacy_io
+from openpype.pipeline import CreatorError
+from openpype.pipeline.context_tools import get_current_project_asset
+from openpype.hosts.maya.api.commands import reset_frame_range
+
+
+class RenderSettings(object):
+
+ _image_prefix_nodes = {
+ 'vray': 'vraySettings.fileNamePrefix',
+ 'arnold': 'defaultRenderGlobals.imageFilePrefix',
+ 'renderman': 'defaultRenderGlobals.imageFilePrefix',
+ 'redshift': 'defaultRenderGlobals.imageFilePrefix'
+ }
+
+ _image_prefixes = {
+ 'vray': get_current_project_settings()["maya"]["RenderSettings"]["vray_renderer"]["image_prefix"], # noqa
+ 'arnold': get_current_project_settings()["maya"]["RenderSettings"]["arnold_renderer"]["image_prefix"], # noqa
+ 'renderman': 'maya/<Scene>/<layer>/<layer>{aov_separator}<aov>',
+ 'redshift': get_current_project_settings()["maya"]["RenderSettings"]["redshift_renderer"]["image_prefix"] # noqa
+ }
+
+ _aov_chars = {
+ "dot": ".",
+ "dash": "-",
+ "underscore": "_"
+ }
+
+ @classmethod
+ def get_image_prefix_attr(cls, renderer):
+ return cls._image_prefix_nodes[renderer]
+
+ def __init__(self, project_settings=None):
+ self._project_settings = project_settings
+ if not self._project_settings:
+ self._project_settings = get_project_settings(
+ legacy_io.Session["AVALON_PROJECT"]
+ )
+
+ def set_default_renderer_settings(self, renderer=None):
+ """Set basic settings based on renderer."""
+ if not renderer:
+ renderer = cmds.getAttr(
+ 'defaultRenderGlobals.currentRenderer').lower()
+
+ asset_doc = get_current_project_asset()
+ # project_settings/maya/create/CreateRender/aov_separator
+ try:
+ aov_separator = self._aov_chars[(
+ self._project_settings["maya"]
+ ["create"]
+ ["CreateRender"]
+ ["aov_separator"]
+ )]
+ except KeyError:
+ aov_separator = "_"
+ reset_frame = self._project_settings["maya"]["RenderSettings"]["reset_current_frame"] # noqa
+
+ if reset_frame:
+ start_frame = cmds.getAttr("defaultRenderGlobals.startFrame")
+ cmds.currentTime(start_frame, edit=True)
+
+ if renderer in self._image_prefix_nodes:
+ prefix = self._image_prefixes[renderer]
+ prefix = prefix.replace("{aov_separator}", aov_separator)
+ cmds.setAttr(self._image_prefix_nodes[renderer],
+ prefix, type="string") # noqa
+ else:
+ print("{0} isn't a supported renderer to autoset settings.".format(renderer)) # noqa
+
+ # TODO: handle not having res values in the doc
+ width = asset_doc["data"].get("resolutionWidth")
+ height = asset_doc["data"].get("resolutionHeight")
+
+ if renderer == "arnold":
+ # set renderer settings for Arnold from project settings
+ self._set_arnold_settings(width, height)
+
+ if renderer == "vray":
+ self._set_vray_settings(aov_separator, width, height)
+
+ if renderer == "redshift":
+ self._set_redshift_settings(width, height)
+
+ def _set_arnold_settings(self, width, height):
+ """Sets settings for Arnold."""
+ from mtoa.core import createOptions # noqa
+ from mtoa.aovs import AOVInterface # noqa
+ createOptions()
+ arnold_render_presets = self._project_settings["maya"]["RenderSettings"]["arnold_renderer"] # noqa
+ # Force resetting settings and AOV list to avoid having to deal with
+ # AOV checking logic, for now.
+ # This is a work around because the standard
+ # function to revert render settings does not reset AOVs list in MtoA
+ # Fetch current aovs in case there's any.
+ current_aovs = AOVInterface().getAOVs()
+ # Remove fetched AOVs
+ AOVInterface().removeAOVs(current_aovs)
+ mel.eval("unifiedRenderGlobalsRevertToDefault")
+ img_ext = arnold_render_presets["image_format"]
+ img_prefix = arnold_render_presets["image_prefix"]
+ aovs = arnold_render_presets["aov_list"]
+ img_tiled = arnold_render_presets["tiled"]
+ multi_exr = arnold_render_presets["multilayer_exr"]
+ additional_options = arnold_render_presets["additional_options"]
+ for aov in aovs:
+ AOVInterface('defaultArnoldRenderOptions').addAOV(aov)
+
+ cmds.setAttr("defaultResolution.width", width)
+ cmds.setAttr("defaultResolution.height", height)
+
+ self._set_global_output_settings()
+
+ cmds.setAttr(
+ "defaultRenderGlobals.imageFilePrefix", img_prefix, type="string")
+
+ cmds.setAttr(
+ "defaultArnoldDriver.ai_translator", img_ext, type="string")
+
+ cmds.setAttr(
+ "defaultArnoldDriver.exrTiled", img_tiled)
+
+ cmds.setAttr(
+ "defaultArnoldDriver.mergeAOVs", multi_exr)
+ # Passes additional options in from the schema as a list
+ # but converts it to a dictionary because ftrack doesn't
+ # allow fullstops in custom attributes. Then checks for
+ # type of MtoA attribute passed to adjust the `setAttr`
+ # command accordingly.
+ for item in additional_options:
+ attribute, value = item
+ if (cmds.getAttr(str(attribute), type=True)) == "long":
+ cmds.setAttr(str(attribute), int(value))
+ elif (cmds.getAttr(str(attribute), type=True)) == "bool":
+ cmds.setAttr(str(attribute), int(value), type = "Boolean") # noqa
+ elif (cmds.getAttr(str(attribute), type=True)) == "string":
+ cmds.setAttr(str(attribute), str(value), type = "string") # noqa
+ reset_frame_range()
+
+ def _set_redshift_settings(self, width, height):
+ """Sets settings for Redshift."""
+ redshift_render_presets = (
+ self._project_settings
+ ["maya"]
+ ["RenderSettings"]
+ ["redshift_renderer"]
+ )
+ img_ext = redshift_render_presets.get("image_format")
+ self._set_global_output_settings()
+ cmds.setAttr("redshiftOptions.imageFormat", img_ext)
+ cmds.setAttr("defaultResolution.width", width)
+ cmds.setAttr("defaultResolution.height", height)
+
+ def _set_vray_settings(self, aov_separator, width, height):
+ # type: (str, int, int) -> None
+ """Sets important settings for Vray."""
+ settings = cmds.ls(type="VRaySettingsNode")
+ node = settings[0] if settings else cmds.createNode("VRaySettingsNode")
+
+ # Set aov separator
+ # First we need to explicitly set the UI items in Render Settings
+ # because that is also what V-Ray updates to when that Render Settings
+ # UI did initialize before and refreshes again.
+ MENU = "vrayRenderElementSeparator"
+ if cmds.optionMenuGrp(MENU, query=True, exists=True):
+ items = cmds.optionMenuGrp(MENU, query=True, ill=True)
+ separators = [cmds.menuItem(i, query=True, label=True) for i in items] # noqa: E501
+ try:
+ sep_idx = separators.index(aov_separator)
+ except ValueError as e:
+ six.reraise(
+ CreatorError,
+ CreatorError(
+ "AOV character {} not in {}".format(
+ aov_separator, separators)),
+ sys.exc_info()[2])
+
+ cmds.optionMenuGrp(MENU, edit=True, select=sep_idx + 1)
+
+ # Set the render element attribute as string. This is also what V-Ray
+ # sets whenever the `vrayRenderElementSeparator` menu items switch
+ cmds.setAttr(
+ "{}.fileNameRenderElementSeparator".format(node),
+ aov_separator,
+ type="string"
+ )
+
+ # Set render file format to exr
+ cmds.setAttr("{}.imageFormatStr".format(node), "exr", type="string")
+
+ # animType
+ cmds.setAttr("{}.animType".format(node), 1)
+
+ # resolution
+ cmds.setAttr("{}.width".format(node), width)
+ cmds.setAttr("{}.height".format(node), height)
+
+ @staticmethod
+ def _set_global_output_settings():
+ # enable animation
+ cmds.setAttr("defaultRenderGlobals.outFormatControl", 0)
+ cmds.setAttr("defaultRenderGlobals.animation", 1)
+ cmds.setAttr("defaultRenderGlobals.putFrameBeforeExt", 1)
+ cmds.setAttr("defaultRenderGlobals.extensionPadding", 4)

openpype/hosts/maya/api/menu.py

@@ -10,7 +10,7 @@
 from openpype.settings import get_project_settings
 from openpype.pipeline import legacy_io
 from openpype.tools.utils import host_tools
-from openpype.hosts.maya.api import lib
+from openpype.hosts.maya.api import lib, lib_rendersettings
 from .lib import get_main_window, IS_HEADLESS
 from .commands import reset_frame_range
 
@@ -44,6 +44,7 @@ def deferred():
  parent="MayaWindow"
  )
 
+ renderer = cmds.getAttr('defaultRenderGlobals.currentRenderer').lower()
  # Create context menu
  context_label = "{}, {}".format(
  legacy_io.Session["AVALON_ASSET"],
@@ -98,6 +99,13 @@ def deferred():
 
  cmds.menuItem(divider=True)
 
+ cmds.menuItem(
+ "Set Render Settings",
+ command=lambda *args: lib_rendersettings.RenderSettings().set_default_renderer_settings() # noqa
+ )
+
+ cmds.menuItem(divider=True)
+
  cmds.menuItem(
  "Work Files...",
  command=lambda *args: host_tools.show_workfiles(