create_render_layers

class AutoDetectRendeLayersPasses(HarmonyCreator):
    """Create Render Layer and Render Pass instances based on scene data.

    This is auto-detection creator which can be triggered by user to create
    instances based on information in scene. Each used color group in scene
    will be created as Render Layer where group name is used as variant and
    each Harmony layer as Render Pass where layer name is used as variant.

    Never will have any instances, all instances belong to different creators.
    """

    product_type = "render"
    product_base_type = "render"
    label = "Render Layer/Passes"
    identifier = "render.auto.detect.creator"
    # order = CreateRenderPass.order + 10
    description = "Create Render Layers and Render Passes based on scene setup"
    detailed_description = AUTODETECT_RENDER_DETAILED_DESCRIPTION

    # Settings
    default_variants = ["Main"]
    active_on_create = True

    enabled = True

    layer_name_template = {
        "enabled": False,
        "template": "G{group_index}_L{layer_index}_{variant}"
    }
    render_layer_variant_template = "G{group_index}"
    group_idx_offset = 10
    group_idx_padding = 3

    def create(self, product_name, instance_data, pre_create_data):

        project_entity = self.create_context.get_current_project_entity()
        folder_path: str = self.create_context.get_current_folder_path()
        task_name: str = self.create_context.get_current_task_name()
        folder_entity: dict[str, Any] = self.create_context.get_folder_entity(
            folder_path
        )
        task_entity: dict[str, Any] = self.create_context.get_task_entity(
            folder_path, task_name
        )

        render_layers_by_group_id: dict[int, CreatedInstance] = {}
        render_passes_by_render_layer_id: dict[int, list[CreatedInstance]] = (
            collections.defaultdict(list)
        )
        for instance in self.create_context.instances:
            if instance.creator_identifier == CreateRenderLayer.identifier:
                group_id = instance["creator_attributes"]["group_id"]
                render_layers_by_group_id[group_id] = instance
            elif instance.creator_identifier == CreateRenderPass.identifier:
                render_layer_id = (
                    instance
                    ["creator_attributes"]
                    ["render_layer_instance_id"]
                )
                render_passes_by_render_layer_id[render_layer_id].append(
                    instance
                )

        layers_by_group_id: dict[int, list[dict[str, Any]]] = (
            collections.defaultdict(list)
        )
        scene_layers: list[dict[str, Any]] = get_layers_info()
        scene_groups: list[dict[str, Any]] = get_group_infos()
        for layer in scene_layers:
            group_id = layer["color"]
            layers_by_group_id[group_id].append(layer)

        mark_layers_for_review = pre_create_data.get(
            "mark_layers_for_review", False
        )
        mark_passes_for_review = pre_create_data.get(
            "mark_passes_for_review", False
        )
        render_target = pre_create_data.get(
            "render_target", False
        )

        only_visible_groups = pre_create_data.get(
            "only_visible_groups", False
        )
        filtered_groups = self._filter_groups(
            layers_by_group_id,
            scene_groups,
            only_visible_groups
        )
        # Make sure  all render layers are created
        for group in filtered_groups:
            instance: Union[CreatedInstance, None] = (
                self._prepare_render_layer(
                    project_entity,
                    folder_entity,
                    task_entity,
                    group.color,
                    filtered_groups,
                    mark_layers_for_review,
                    render_target,
                    render_layers_by_group_id.get(group.color),
                )
            )
            if instance is not None:
                render_layers_by_group_id[group.color] = instance

        for group in filtered_groups:
            layers: list[dict[str, Any]] = layers_by_group_id[group.color]
            render_layer_instance: Union[CreatedInstance, None] = (
                render_layers_by_group_id.get(group.color)
            )
            if not layers or render_layer_instance is None:
                continue

            self._prepare_render_passes(
                project_entity,
                folder_entity,
                task_entity,
                render_layer_instance,
                layers,
                mark_passes_for_review,
                render_target,
                render_passes_by_render_layer_id[render_layer_instance.id]
            )

        self._wrap_nodes_in_backdrop()

    def _filter_groups(
        self,
        layers_by_group_id,
        scene_groups,
        only_visible_groups
    ):
        filtered_groups = []
        for group in scene_groups:
            layers: list[dict[str, Any]] = layers_by_group_id[group.color]
            if not layers:
                continue

            if only_visible_groups and not any(
                layer for layer in layers if layer["enabled"]
            ):
                continue
            filtered_groups.append(group)
        return filtered_groups

    @staticmethod
    def _get_render_layer_variant(
        template: str,
        group_position: int,
        group_idx_padding: int,
        group_idx_offset: int,
        log
    ) -> str:
        """Calculates render layer portion (G010)"""
        variant = None
        index_template = f"{{:0>{group_idx_padding}}}"
        group_pos = group_position * group_idx_offset
        try:
            group_index = index_template.format(group_pos)
            variant = template.format(
                group_index=group_index,
            )
        except Exception:
            log.warning(
                "Failed to create render layer variant",
                exc_info=True,
            )

        return variant

    def _prepare_render_layer(
        self,
        project_entity: dict[str, Any],
        folder_entity: dict[str, Any],
        task_entity: dict[str, Any],
        group_id: str,
        groups: list[GroupInfo],
        mark_for_review: bool,
        render_target: str,
        existing_instance: Optional[CreatedInstance] = None,
    ) -> Union[CreatedInstance, None]:
        match_group: Optional[dict[str, Any]] = next(
            (group for group in groups if group.color == group_id), None
        )
        if not match_group:
            return None

        task_name = task_entity["name"]
        group_idx = match_group.position
        variant: str = self._get_render_layer_variant(
            self.render_layer_variant_template,
            group_idx,
            self.group_idx_padding,
            self.group_idx_offset,
            self.log,
        )
        creator: CreateRenderLayer = self.create_context.creators[
            CreateRenderLayer.identifier
        ]
        product_name: str = creator.get_product_name(
            project_entity["name"],
            folder_entity,
            task_entity,
            variant,
            host_name=self.create_context.host_name,
            project_entity=project_entity,
        )
        if existing_instance is not None:
            existing_instance["folderPath"] = folder_entity["path"]
            existing_instance["task"] = task_name
            existing_instance["productName"] = product_name
            return existing_instance

        instance_data: dict[str, str] = {
            "folderPath": folder_entity["path"],
            "task": task_name,
            "productType": creator.product_type,
            "variant": variant,
            "group_label": variant
        }
        pre_create_data: dict[str, Any] = {
            "group_id": group_id,
            "mark_for_review": mark_for_review,
            "render_target": render_target,
        }
        return creator.create(product_name, instance_data, pre_create_data)

    def _prepare_render_passes(
        self,
        project_entity: dict[str, Any],
        folder_entity: dict[str, Any],
        task_entity: dict[str, Any],
        render_layer_instance: CreatedInstance,
        layers: list[dict[str, Any]],
        mark_for_review: bool,
        render_target: str,
        existing_render_passes: list[CreatedInstance],
    ):
        task_name = task_entity["name"]
        creator: CreateRenderPass = self.create_context.creators[
            CreateRenderPass.identifier
        ]
        render_pass_by_layer_name = {}
        for render_pass in existing_render_passes:
            render_pass_by_layer_name[render_pass["layer_name"]] = render_pass

        # Use renaming template to parse correct variant from existing layer
        #   names.
        name_regex = None
        if self.layer_name_template["enabled"]:
            template = self.layer_name_template["template"]
            fake_group = "___group___"
            fake_layer = "___layer___"
            fake_variant = "___variant___"
            try:
                name_regex = template.format(
                    layer_index=fake_layer,
                    group_index=fake_group,
                    variant=fake_variant,
                )
            except Exception:
                self.log.error(
                    "Failed to fill name regex template.",
                    exc_info=True
                )
                name_regex = ""

            for src, regex in (
                (fake_group, r"(?P<group>\d+)"),
                (fake_layer, r"(?P<layer>\d+)"),
                (fake_variant, r"(?P<variant>.*)"),
            ):
                name_regex = name_regex.replace(src, regex)
            name_regex = re.compile(name_regex)

        layer_positions_in_groups = get_layer_positions_in_groups(layers)

        for layer in layers:
            if layer.get("isGrouped"):
                continue

            layer_name = layer["name"]
            variant = None
            render_pass = render_pass_by_layer_name.get(layer_name)
            if render_pass is not None and len(render_pass["layer_names"]) > 0:
                variant = render_pass["variant"]
            elif name_regex is not None:
                result = name_regex.match(layer_name)
                if result is not None:
                    variant = result.groupdict().get("variant")

            if not variant:
                variant = layer["name"]

            renderlayer = render_layer_instance["variant"]

            renderpass = get_render_pass_name(
                creator.render_pass_template,
                layer_positions_in_groups[layer["name"]],
                creator.layer_idx_padding,
                creator.layer_idx_offset,
                variant,
                self.log
            )
            if not render_pass:
                render_pass = {}

            render_pass["renderPass"] = renderpass
            render_pass["renderLayer"] = renderlayer

            product_name = creator.get_product_name(
                project_entity["name"],
                folder_entity,
                task_entity,
                variant,
                host_name=self.create_context.host_name,
                instance=render_pass,
                project_entity=project_entity,
            )

            instance_data: dict[str, str] = {
                "folderPath": folder_entity["path"],
                "task": task_name,
                "productType": creator.product_type,
                "variant": variant,
            }

            pre_create_data: dict[str, Any] = {
                "render_layer_instance_id": render_layer_instance.id,
                "layer_name": layer_name,
                "mark_for_review": mark_for_review,
                "render_target": render_target,
            }
            creator.create(product_name, instance_data, pre_create_data)

    def get_pre_create_attr_defs(self) -> list[AbstractAttrDef]:
        get_layers_info.cache_clear()
        get_group_infos.cache_clear()

        render_layer_creator: CreateRenderLayer = self.create_context.creators[
            CreateRenderLayer.identifier
        ]
        render_pass_creator: CreateRenderPass = self.create_context.creators[
            CreateRenderPass.identifier
        ]
        rendering_targets = {
            "local": "Local machine rendering",
            "farm": "Farm rendering",
        }
        return [
            BoolDef(
                "only_visible_groups",
                label="Only visible color groups",
                tooltip=(
                    "Render Layers will happen only on color"
                    " groups with visible layers."
                ),
                default=True
            ),
            BoolDef(
                "mark_layers_for_review",
                label="Mark RenderLayers for review",
                default=render_layer_creator.mark_for_review,
            ),
            BoolDef(
                "mark_passes_for_review",
                label="Mark RenderPasses for review",
                default=render_pass_creator.mark_for_review,
            ),
            EnumDef(
                "render_target",
                items=rendering_targets,
                label="Render target"
            )
        ]

    def product_impl(self, name, instance_data: dict, pre_create_data: dict):
        pass

    def _wrap_nodes_in_backdrop(self):
        """Tries to wrap all nodes of a layer group into Backdrop"""
        scene_containers = harmony.get_scene_data()
        for node_name, container in scene_containers.items():
            identifier = container.get("creator_identifier")
            if identifier != CreateRenderLayer.identifier:
                continue
            group_label = container["variant"]
            group_id = container["creator_attributes"]["group_id"]
            group_color = group_id
            harmony.send(
                {
                    "function": (
                        "AyonHarmony.Creators.CreateRenderLayer.formatNodes"
                    ),
                    "args": [node_name, group_label, group_color]
                }
            )

class CreateRenderLayer(HarmonyRenderCreator):
    """Mark layer group as Render layer instance.

    All Harmony layers in the scene with the color group id are rendered in the
    beauty pass. To create sub passes use Render Layer creator which is
    dependent on existence of render layer instance.
    """

    label = "Render Layer"
    product_type = "render"
    product_base_type = "render"
    product_base_type_filter = "renderLayer"
    identifier = "render.layer"
    icon = "fa5.images"

    # Order to be executed before Render Pass creator
    order = 90
    description = "Mark Harmony color group as one Render Layer."
    detailed_description = RENDER_LAYER_DETAILED_DESCRIPTIONS

    # Settings
    default_variants = ["Main"]
    active_on_create = True

    # - Default render pass name for beauty
    default_pass_name = "beauty"
    # - Mark by default instance for review
    mark_for_review = True

    def get_dynamic_data(
        self,
        project_name,
        folder_entity,
        task_entity,
        variant,
        host_name=None,
        instance=None,
        project_entity=None,
        product_type=None,
    ):
        return {
            "renderpass": self.default_pass_name,
            "renderlayer": variant,
        }

    def product_impl(self, product_name, instance_data, pre_create_data):
        group_id = pre_create_data.get("group_id")
        # This creator should run only on one group
        if group_id is None or group_id == "-1":
            selected_groups = self._get_selected_group_colors()
            if len(selected_groups) > 1:
                raise CreatorError("You have selected more than one group")

            if len(selected_groups) == 0:
                raise CreatorError("You don't have selected any group")
            group_id = tuple(selected_groups)[0]

        for instance in self.create_context.instances:
            if instance.creator_identifier != self.identifier:
                continue
            if instance["creator_attributes"]["group_id"] == group_id:
                raise CreatorError(
                    (
                        f'Group "{group_id}" is already used'
                        f' by another render layer "{instance["productName"]}"'
                    )
                )
            if instance["productName"] == product_name:
                raise CreatorError(
                    f"Product '{product_name}' already exists.")

        creator_attributes = instance_data.setdefault("creator_attributes", {})
        mark_for_review = pre_create_data.get("mark_for_review")
        if mark_for_review is None:
            mark_for_review = self.mark_for_review

        creator_attributes["group_id"] = group_id
        creator_attributes["mark_for_review"] = mark_for_review
        creator_attributes["render_target"] = pre_create_data["render_target"]

        node = self._create_nodes_for_group(group_id, product_name)
        self.log.debug(f"Created node:: {node}")
        return node

    def get_pre_create_attr_defs(self):
        enum_defs = super().get_pre_create_attr_defs()
        group_infos = get_group_infos()
        group_enum_values = [
            {"value": group.color, "label": str(group.position)}
            for group in group_infos
        ]
        group_enum_values.insert(
            0,
            {"label": "<Use selection>", "value": "-1"}
        )

        enum_defs.append(
            EnumDef("group_id", label="Group", items=group_enum_values))
        return enum_defs

    def get_instance_attr_defs(self):
        groups = get_group_infos()

        groups_enum = [
            {"value": group.color, "label": str(group.position)}
            for group in groups
        ]
        return [
            EnumDef(
                "group_id",
                label="Group",
                items=groups_enum,
                enabled=False
            ),
            BoolDef(
                "mark_for_review",
                label="Review",
                default=self.mark_for_review
            ),
            EnumDef(
                "render_target",
                items=self.rendering_targets,
                label="Render target"
            ),
        ]

    def get_product_name(
        self,
        project_name,
        folder_entity,
        task_entity,
        variant,
        host_name=None,
        instance=None,
        project_entity=None,
        product_type=None,
    ):
        if host_name is None:
            host_name = self.create_context.host_name
        if project_entity is None:
            project_entity = self.create_context.get_current_project_entity()
        dynamic_data = self.get_dynamic_data(
            project_name,
            folder_entity,
            task_entity,
            variant,
            host_name,
            instance,
            project_entity,
            product_type,
        )
        task_name = task_type = None
        if task_entity:
            task_name = task_entity["name"]
            task_type = task_entity["taskType"]

        get_product_name_kwargs = {}
        if getattr(get_product_name, "use_entities", False):
            if not product_type:
                product_type = self.product_base_type
            get_product_name_kwargs.update({
                "product_type": product_type,
                "folder_entity": folder_entity,
                "task_entity": task_entity,
                "product_base_type": self.product_base_type,
                "product_base_type_filter": self.product_base_type_filter,
            })
        else:
            get_product_name_kwargs.update({
                "product_type": self.product_base_type,
                "task_name": task_name,
                "task_type": task_type,
                "product_type_filter": self.product_base_type_filter,
            })

        return get_product_name(
            project_name=project_name,
            host_name=host_name,
            variant=variant,
            dynamic_data=dynamic_data,
            project_settings=self.project_settings,
            project_entity=project_entity,
            **get_product_name_kwargs
        )

    def _create_nodes_for_group(self, group_id, product_name):
        layers_data = get_layers_info()
        layers_full_names = []
        for layer in layers_data:
            if layer["color"] != group_id:
                continue
            if layer["isGrouped"]:
                layers_full_names = [layer["parentPath"]]
                break
            layers_full_names.append(layer["fullName"])

        self_name = self.__class__.__name__
        created_node = harmony.send(
            {
                "function": (
                    f"AyonHarmony.Creators.{self_name}.createLayerNodes"
                ),
                "args": [layers_full_names, product_name]
            }
        )["result"]

        return created_node

    def _get_selected_group_colors(self):
        return {
            layer["color"]
            for layer in get_layers_info()
            if layer["selected"]
        }

    def remove_instances(self, instances):
        for instance in instances:
            # There is only ever one workfile instance
            node_name = instance.transient_data["node"]
            container_data = harmony.read(node_name)
            harmony.delete_node(node_name)
            harmony.delete_node(f"{node_name}_comp")
            group_label = container_data.get("group_label")
            container_backdrop = None
            if group_label:
                container_backdrop = harmony.find_backdrop_by_name(
                    group_label
                )
            if container_backdrop:
                harmony.send(
                    {
                        "function": "AyonHarmony.removeBackdrop",
                        "args": [container_backdrop, False]
                    }
                )
            self._remove_instance_from_context(instance)