Support to export texture sets as single output per texture map

client/ayon_substancepainter/plugins/create/create_textures.py

@@ -53,7 +53,9 @@ def create(self, product_name, instance_data, pre_create_data):
             "exportPadding",
             "exportDilationDistance",
             "useCustomExportPreset",
-            "exportChannel"
+            "exportChannel",
+            "exportTextureSets",
+            "exportTextureSetsAsOneOutput"
         ]:
             if key in pre_create_data:
                 creator_attributes[key] = pre_create_data[key]
@@ -152,6 +154,11 @@ def get_instance_attr_defs(self):
                     label="Review",
                     tooltip="Mark as reviewable",
                     default=True),
+            BoolDef("exportTextureSetsAsOneOutput",
+                    label="Export Texture Sets As One Texture Output",
+                    tooltip="Export multiple texture set(s) "
+                            "as one Texture Output",
+                    default=False),
             EnumDef("exportTextureSets",
                     items=export_texture_set_enum,
                     multiselection=True,

client/ayon_substancepainter/plugins/publish/collect_textureset_images.py

@@ -4,6 +4,7 @@
 import pyblish.api
 import ayon_api
 
+from collections import defaultdict
 import substance_painter.textureset
 from ayon_core.pipeline import publish
 from ayon_substancepainter.api.lib import (
@@ -44,14 +45,31 @@ def process(self, instance):
 
         # Let's break the instance into multiple instances to integrate
         # a product per generated texture or texture UDIM sequence
-        for (texture_set_name, stack_name), template_maps in maps.items():
-            self.log.info(f"Processing {texture_set_name}/{stack_name}")
-            for template, outputs in template_maps.items():
-                self.log.info(f"Processing {template}")
+        creator_attr = instance.data["creator_attributes"]
+        if creator_attr.get("exportTextureSetsAsOneOutput", False):
+            texture_sets_by_map_identifier = defaultdict(list)
+            for (texture_set_name, stack_name), template_maps in maps.items():
+                for template, outputs in template_maps.items():
+                    self.log.info(f"Processing {template}")
+                    map_identifier = strip_template(template)
+                    map_identifier = f"{map_identifier}"
+                    texture_sets_by_map_identifier[map_identifier].extend(outputs)
+            for map_identifier, outputs in texture_sets_by_map_identifier.items():
+                self.log.info(f"Processing {map_identifier}")
                 self.create_image_instance(instance, template, outputs,
-                                           task_entity=task_entity,
-                                           texture_set_name=texture_set_name,
-                                           stack_name=stack_name)
+                                            task_entity=task_entity,
+                                            texture_set_name=texture_set_name,
+                                            stack_name=stack_name)
+
+        else:
+            for (texture_set_name, stack_name), template_maps in maps.items():
+                self.log.info(f"Processing {texture_set_name}/{stack_name}")
+                for template, outputs in template_maps.items():
+                    self.log.info(f"Processing {template}")
+                    self.create_image_instance(instance, template, outputs,
+                                                task_entity=task_entity,
+                                                texture_set_name=texture_set_name,
+                                                stack_name=stack_name)
 
     def create_image_instance(self, instance, template, outputs,
                               task_entity, texture_set_name, stack_name):
@@ -63,9 +81,22 @@ def create_image_instance(self, instance, template, outputs,
 
         context = instance.context
         first_filepath = outputs[0]["filepath"]
+        is_single_output = instance.data["creator_attributes"].get(
+            "exportTextureSetsAsOneOutput", False)
         fnames = [os.path.basename(output["filepath"]) for output in outputs]
         ext = os.path.splitext(first_filepath)[1]
         assert ext.lstrip("."), f"No extension: {ext}"
+        if is_single_output:
+            # Function to remove textureSet from filepath
+            def remove_texture_set_token(filepath, texture_set):
+                return filepath.replace(texture_set, "")
+
+            fnames = [
+                remove_texture_set_token(
+                    output["output"], output["textureSet"]
+                )
+                for output in outputs
+            ]
 
         always_include_texture_set_name = False  # todo: make this configurable
         all_texture_sets = substance_painter.textureset.all_texture_sets()
@@ -76,12 +107,13 @@ def create_image_instance(self, instance, template, outputs,
         # Define the suffix we want to give this particular texture
         # set and set up a remapped product naming for it.
         suffix = ""
-        if always_include_texture_set_name or len(all_texture_sets) > 1:
-            # More than one texture set, include texture set name
-            suffix += f".{texture_set_name}"
-        if texture_set.is_layered_material() and stack_name:
-            # More than one stack, include stack name
-            suffix += f".{stack_name}"
+        if not is_single_output:
+            if always_include_texture_set_name or len(all_texture_sets) > 1:
+                # More than one texture set, include texture set name
+                suffix += f".{texture_set_name}"
+            if texture_set.is_layered_material() and stack_name:
+                # More than one stack, include stack name
+                suffix += f".{stack_name}"
 
         # Always include the map identifier
         map_identifier = strip_template(template)
@@ -146,6 +178,10 @@ def create_image_instance(self, instance, template, outputs,
         image_instance.data["families"] = [product_type, "textures"]
         if instance.data["creator_attributes"].get("review"):
             image_instance.data["families"].append("review")
+        if is_single_output:
+            image_instance.data["image_outputs"] = [
+                os.path.basename(output["filepath"]) for output in outputs
+            ]
 
         image_instance.data["representations"] = [representation]
 

client/ayon_substancepainter/plugins/publish/extract_map_as_single_output.py

@@ -0,0 +1,110 @@
+import clique
+import os
+
+from ayon_core.pipeline import publish
+from ayon_core.lib import (
+    get_oiio_tool_args,
+    run_subprocess,
+)
+
+
+def get_texture_outputs(staging_dir, image_outputs, has_udim=False):
+    """Getting the expected texture output(s) with/without udim sequence
+    before merging them with oiio tools.
+
+    Args:
+        staging_dir (str): staging dir
+        image_outputs (list): source image outputs
+        has_udim (bool, optional): Is with UDIM. Defaults to False.
+
+    Returns:
+        list: Texture outputs which are used for merging.
+    """
+    if has_udim:
+        collections, remainder = clique.assemble(image_outputs, minimum_items=1)
+        return [
+            os.path.join(
+                staging_dir,
+                collection.format(pattern="{head}{padding}{tail}")
+            )
+            for collection in collections
+        ]
+    else:
+        return [
+            os.path.join(staging_dir, output) for output in image_outputs
+        ]
+
+
+def convert_texture_maps_as_single_output(staging_dir, source_image_outputs,
+                                          dest_image_outputs, has_udim=False,
+                                          log=None):
+    oiio_tool_args = get_oiio_tool_args("oiiotool")
+
+    source_maps = get_texture_outputs(
+        staging_dir, source_image_outputs, has_udim=has_udim)
+    dest_map = next(get_texture_outputs(
+        staging_dir, dest_image_outputs, has_udim=has_udim
+        ), None)
+
+    log.info(f"{source_maps} composited as {dest_map}")
+    oiio_cmd = oiio_tool_args + source_maps + [
+        "--paste:mergeroi=1",
+        "+0+0",
+        "-o",
+       dest_map
+    ]
+
+    subprocess_args = " ".join(oiio_cmd)
+
+    env = os.environ.copy()
+
+    try:
+        run_subprocess(subprocess_args, env=env)
+    except Exception as exc:
+        raise RuntimeError("Flattening texture stack to single output image failed") from exc
+
+
+class ExtractTexturesAsSingleOutput(publish.Extractor):
+    """Extract Texture As Single Output
+
+    Combine the multliple texture sets into one single texture output.
+
+    """
+
+    label = "Extract Texture Sets as Single Texture Output"
+    hosts = ["substancepainter"]
+    families = ["image"]
+    settings_category = "substancepainter"
+
+    # Run directly after textures export
+    order = publish.Extractor.order - 0.099
+
+    def process(self, instance):
+        if not instance.data.get("creator_attributes", {}).get(
+            "exportTextureSetsAsOneOutput", False):
+            self.log.debug(
+                "Skipping to export texture sets as single texture output.."
+            )
+            return
+
+        representations: "list[dict]" = instance.data["representations"]
+        repre = representations[0]
+
+        staging_dir = instance.data["stagingDir"]
+        source_image_outputs = instance.data["image_outputs"]
+        has_udim = False
+        dest_image_outputs = []
+        dest_files = repre["files"]
+        is_sequence = isinstance(dest_files, (list, tuple))
+        if not is_sequence:
+            dest_image_outputs = [dest_image_outputs]
+        else:
+            dest_image_outputs = dest_files
+        if "udim" in repre:
+            has_udim = True
+
+        convert_texture_maps_as_single_output(
+            staging_dir, source_image_outputs,
+            dest_image_outputs, has_udim=has_udim,
+            log=self.log
+        )