Substance Painter: Support for exporting maps/layer stacks with specific channels

client/ayon_core/hosts/substancepainter/api/lib.py

@@ -3,6 +3,8 @@
 import json
 from collections import defaultdict
 
+import contextlib
+import substance_painter
 import substance_painter.project
 import substance_painter.resource
 import substance_painter.js
@@ -11,6 +13,43 @@
 from qtpy import QtGui, QtWidgets, QtCore
 
 
+def get_channel_map_enum():
+    """Function to get channel map items value.
+    For backward compatibility only. Will be removed after
+    client addon migration
+    """
+    return {
+            "BaseColor": "Base Color",
+            "Metallic": "Metallic",
+            "Roughness": "Roughness",
+            "SpecularEdgeColor": "Specular Edge Color",
+            "Emissive": "Emissive",
+            "Opacity": "Opacity",
+            "Displacement": "Displacement",
+            "Glossiness": "Glossiness",
+            "Anisotropylevel": "Anisotropy Level",
+            "AO": "Ambient Occulsion",
+            "Anisotropyangle": "Anisotropy Angle",
+            "Transmissive": "Transmissive",
+            "Reflection": "Reflection",
+            "Diffuse": "Diffuse",
+            "Ior": "Index of Refraction",
+            "Specularlevel": "Specular Level",
+            "BlendingMask": "Blending Mask",
+            "Translucency": "Translucency",
+            "Scattering": "Scattering",
+            "ScatterColor": "Scatter Color",
+            "SheenOpacity": "Sheen Opacity",
+            "SheenRoughness": "Sheen Roughness",
+            "SheenColor": "Sheen Color",
+            "CoatOpacity": "Coat Opacity",
+            "CoatColor": "Coat Color",
+            "CoatRoughness": "Coat Roughness",
+            "CoatSpecularLevel": "Coat Specular Level",
+            "CoatNormal": "Coat Normal",
+    }
+
+
 def get_export_presets():
     """Return Export Preset resource URLs for all available Export Presets.
 
@@ -640,3 +679,88 @@ def _setup_prompt():
         return
 
     return project_mesh
+
+
+def get_export_presets_by_filtering(export_preset_name, channel_type_names):
+    """Function to get export presets included with specific channels
+    requested by users.
+
+    Args:
+        export_preset_name (str): Name of export preset
+        channel_type_list (list): A list of channel type requested by users
+
+    Returns:
+        dict: export preset data
+    """
+
+    target_maps = []
+
+    export_presets = get_export_presets()
+    export_preset_nice_name = export_presets[export_preset_name]
+    resource_presets = substance_painter.export.list_resource_export_presets()
+    preset = next(
+        (
+            preset for preset in resource_presets
+            if preset.resource_id.name == export_preset_nice_name
+        ), None
+    )
+    if preset is None:
+        return {}
+
+    maps = preset.list_output_maps()
+    for channel_map in maps:
+        for channel_name in channel_type_names:
+            if not channel_map.get("fileName"):
+                continue
+
+            if channel_name in channel_map["fileName"]:
+                target_maps.append(channel_map)
+    # Create a new preset
+    return {
+        "exportPresets": [
+            {
+                "name": export_preset_name,
+                "maps": target_maps
+            }
+        ],
+    }
+
+
+@contextlib.contextmanager
+def set_layer_stack_opacity(node_ids, channel_types):
+    """Function to set the opacity of the layer stack during
+    context
+    Args:
+        node_ids (list): A list of substance painter node ids
+        channel_types (list): A list of channel types
+    """
+    # Do nothing
+    if not node_ids or not channel_types:
+        yield
+        return
+
+    stack = substance_painter.textureset.get_active_stack()
+    stack_root_layers = (
+        substance_painter.layerstack.get_root_layer_nodes(stack)
+    )
+    all_selected_nodes = []
+    for node_id in node_ids:
+        node = substance_painter.layerstack.get_node_by_uid(int(node_id))
+        all_selected_nodes.append(node)
+    excluded_nodes  = {node for node in stack_root_layers
+                       if node not in all_selected_nodes}
+
+    original_opacity_values = []
+    for node in excluded_nodes:
+        for channel in channel_types:
+            chan = getattr(substance_painter.textureset.ChannelType, channel)
+            original_opacity_values.append((chan, node.get_opacity(chan)))
+    try:
+        for node in excluded_nodes:
+            for channel, _ in original_opacity_values:
+                node.set_opacity(0.0, channel)
+        yield
+    finally:
+        for node in excluded_nodes:
+            for channel, opacity in original_opacity_values:
+                node.set_opacity(opacity, channel)

client/ayon_core/hosts/substancepainter/plugins/create/create_textures.py

@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
 """Creator plugin for creating textures."""
-
 from ayon_core.pipeline import CreatedInstance, Creator, CreatorError
 from ayon_core.lib import (
     EnumDef,
@@ -15,8 +14,12 @@
     set_instances,
     remove_instance
 )
-from ayon_core.hosts.substancepainter.api.lib import get_export_presets
+from ayon_core.hosts.substancepainter.api.lib import (
+    get_export_presets,
+    get_channel_map_enum
+)
 
+import substance_painter
 import substance_painter.project
 
 
@@ -28,9 +31,16 @@ class CreateTextures(Creator):
     icon = "picture-o"
 
     default_variant = "Main"
+    channel_mapping = []
 
-    def create(self, product_name, instance_data, pre_create_data):
+    def apply_settings(self, project_settings):
+        settings = project_settings["substancepainter"].get("create", [])  # noqa
+        if settings:
+            self.channel_mapping = settings["CreateTextures"].get(
+                "channel_mapping", [])
 
+
+    def create(self, product_name, instance_data, pre_create_data):
         if not substance_painter.project.is_open():
             raise CreatorError("Can't create a Texture Set instance without "
                                "an open project.")
@@ -42,11 +52,20 @@ def create(self, product_name, instance_data, pre_create_data):
             "exportFileFormat",
             "exportSize",
             "exportPadding",
-            "exportDilationDistance"
+            "exportDilationDistance",
+            "useCustomExportPreset",
+            "exportChannel"
         ]:
             if key in pre_create_data:
                 creator_attributes[key] = pre_create_data[key]
 
+        if pre_create_data.get("use_selection"):
+            stack = substance_painter.textureset.get_active_stack()
+
+            instance_data["selected_node_id"] = [
+                node_number.uid() for node_number in
+                substance_painter.layerstack.get_selected_nodes(stack)]
+
         instance = self.create_instance_in_context(product_name,
                                                    instance_data)
         set_instance(
@@ -88,8 +107,24 @@ def create_instance_in_context_from_existing(self, data):
         return instance
 
     def get_instance_attr_defs(self):
+        if self.channel_mapping:
+            export_channel_enum = {
+                item["value"]: item["name"]
+                for item in self.channel_mapping
+            }
+        else:
+            export_channel_enum = get_channel_map_enum()
 
         return [
+            EnumDef("exportChannel",
+                    items=export_channel_enum,
+                    multiselection=True,
+                    default=None,
+                    label="Export Channel(s)",
+                    tooltip="Choose the channel which you "
+                            "want to solely export. The value "
+                            "is 'None' by default which exports "
+                            "all channels"),
             EnumDef("exportPresetUrl",
                     items=get_export_presets(),
                     label="Output Template"),
@@ -149,7 +184,6 @@ def get_instance_attr_defs(self):
                     },
                     default=None,
                     label="Size"),
-
             EnumDef("exportPadding",
                     items={
                         "passthrough": "No padding (passthrough)",
@@ -172,4 +206,10 @@ def get_instance_attr_defs(self):
 
     def get_pre_create_attr_defs(self):
         # Use same attributes as for instance attributes
-        return self.get_instance_attr_defs()
+        attr_defs = []
+        if  substance_painter.application.version_info()[0] >= 10:
+            attr_defs.append(
+                BoolDef("use_selection", label="Use selection",
+                        tooltip="Select Layer Stack(s) for exporting")
+            )
+        return attr_defs + self.get_instance_attr_defs()

client/ayon_core/hosts/substancepainter/plugins/publish/collect_textureset_images.py

@@ -8,6 +8,7 @@
 from ayon_core.pipeline import publish
 from ayon_core.hosts.substancepainter.api.lib import (
     get_parsed_export_maps,
+    get_export_presets_by_filtering,
     strip_template
 )
 from ayon_core.pipeline.create import get_product_name
@@ -207,5 +208,8 @@ def get_export_config(self, instance):
             for key, value in dict(parameters).items():
                 if value is None:
                     parameters.pop(key)
-
+        channel_layer = creator_attrs.get("exportChannel", [])
+        if channel_layer:
+            maps = get_export_presets_by_filtering(preset_url, channel_layer)
+            config.update(maps)
         return config

client/ayon_core/hosts/substancepainter/plugins/publish/extract_textures.py

@@ -1,6 +1,6 @@
 import substance_painter.export
-
 from ayon_core.pipeline import KnownPublishError, publish
+from ayon_core.hosts.substancepainter.api.lib import set_layer_stack_opacity
 
 
 class ExtractTextures(publish.Extractor,
@@ -25,19 +25,24 @@ class ExtractTextures(publish.Extractor,
     def process(self, instance):
 
         config = instance.data["exportConfig"]
-        result = substance_painter.export.export_project_textures(config)
-
-        if result.status != substance_painter.export.ExportStatus.Success:
-            raise KnownPublishError(
-                "Failed to export texture set: {}".format(result.message)
-            )
-
-        # Log what files we generated
-        for (texture_set_name, stack_name), maps in result.textures.items():
-            # Log our texture outputs
-            self.log.info(f"Exported stack: {texture_set_name} {stack_name}")
-            for texture_map in maps:
-                self.log.info(f"Exported texture: {texture_map}")
+        creator_attrs = instance.data["creator_attributes"]
+        export_channel = creator_attrs.get("exportChannel", [])
+        node_ids = instance.data.get("selected_node_id", [])
+
+        with set_layer_stack_opacity(node_ids, export_channel):
+            result = substance_painter.export.export_project_textures(config)
+
+            if result.status != substance_painter.export.ExportStatus.Success:
+                raise KnownPublishError(
+                    "Failed to export texture set: {}".format(result.message)
+                )
+
+            # Log what files we generated
+            for (texture_set_name, stack_name), maps in result.textures.items():
+                # Log our texture outputs
+                self.log.info(f"Exported stack: {texture_set_name} {stack_name}")
+                for texture_map in maps:
+                    self.log.info(f"Exported texture: {texture_map}")
 
         # We'll insert the color space data for each image instance that we
         # added into this texture set. The collector couldn't do so because

server_addon/substancepainter/package.py

@@ -1,3 +1,3 @@
 name = "substancepainter"
 title = "Substance Painter"
-version = "0.1.1"
+version = "0.1.2"

server_addon/substancepainter/server/settings/creator_plugins.py

@@ -0,0 +1,56 @@
+from ayon_server.settings import BaseSettingsModel, SettingsField
+
+
+class ChannelMappingItemModel(BaseSettingsModel):
+    _layout = "compact"
+    name: str = SettingsField(title="Channel Type")
+    value: str = SettingsField(title="Channel Name")
+
+
+class CreateTextureModel(BaseSettingsModel):
+    channel_mapping: list[ChannelMappingItemModel] = SettingsField(
+        default_factory=list, title="Channel Mapping")
+
+
+class CreatorsModel(BaseSettingsModel):
+    CreateTextures: CreateTextureModel = SettingsField(
+        default_factory=CreateTextureModel,
+        title="Create Textures"
+    )
+
+
+DEFAULT_CREATOR_SETTINGS = {
+    "CreateTextures": {
+        "channel_mapping": [
+            {"name": "Base Color", "value": "BaseColor"},
+            {"name": "Metallic", "value": "Metallic"},
+            {"name": "Specular Edge Color",
+             "value": "SpecularEdgeColor"},
+            {"name": "Opacity", "value": "Opacity"},
+            {"name": "Displacement", "value": "Displacement"},
+            {"name": "Glossiness", "value": "Glossiness"},
+            {"name": "Anisotropy Level",
+             "value": "Anisotropylevel"},
+            {"name": "Ambient Occulsion", "value": "AO"},
+            {"name": "Anisotropy Angle",
+             "value": "Anisotropyangle"},
+            {"name": "Transmissive", "value": "Transmissive"},
+            {"name": "Reflection", "value": "Reflection"},
+            {"name": "Diffuse", "value": "Diffuse"},
+            {"name": "Index of Refraction", "value": "Ior"},
+            {"name": "Specular Level", "value": "Specularlevel"},
+            {"name": "Blending Mask", "value": "BlendingMask"},
+            {"name": "Translucency", "value": "Translucency"},
+            {"name": "Scattering", "value": "Scattering"},
+            {"name": "Scatter Color", "value": "ScatterColor"},
+            {"name": "Sheen Opacity", "value": "SheenOpacity"},
+            {"name": "Sheen Color", "value": "SheenColor"},
+            {"name": "Coat Opacity", "value": "CoatOpacity"},
+            {"name": "Coat Color", "value": "CoatColor"},
+            {"name": "Coat Roughness", "value": "CoatRoughness"},
+            {"name": "CoatSpecularLevel",
+             "value": "Coat Specular Level"},
+            {"name": "CoatNormal", "value": "Coat Normal"}
+        ],
+    }
+}

server_addon/substancepainter/server/settings/main.py

@@ -1,5 +1,6 @@
 from ayon_server.settings import BaseSettingsModel, SettingsField
 from .imageio import ImageIOSettings, DEFAULT_IMAGEIO_SETTINGS
+from .creator_plugins import CreatorsModel, DEFAULT_CREATOR_SETTINGS
 from .load_plugins import LoadersModel, DEFAULT_LOADER_SETTINGS
 
 
@@ -18,12 +19,16 @@ class SubstancePainterSettings(BaseSettingsModel):
         default_factory=list,
         title="Shelves"
     )
+    create: CreatorsModel = SettingsField(
+        default_factory=DEFAULT_CREATOR_SETTINGS, title="Creators")
     load: LoadersModel = SettingsField(
         default_factory=DEFAULT_LOADER_SETTINGS, title="Loaders")
 
 
 DEFAULT_SPAINTER_SETTINGS = {
     "imageio": DEFAULT_IMAGEIO_SETTINGS,
     "shelves": [],
+    "create": DEFAULT_CREATOR_SETTINGS,
     "load": DEFAULT_LOADER_SETTINGS,
+
 }