collect_multiverse_look

class CollectMultiverseLookData(plugin.MayaInstancePlugin):
    """Collect Multiverse Look

    Searches through the overrides finding all material overrides. From there
    it extracts the shading group and then finds all texture files in the
    shading group network. It also checks for mipmap versions of texture files
    and adds them to the resources to get published.

    """

    order = pyblish.api.CollectorOrder + 0.2
    label = 'Collect Multiverse Look'
    families = ["mvLook"]

    def process(self, instance):
        # Load plugin first
        cmds.loadPlugin("MultiverseForMaya", quiet=True)
        import multiverse

        self.log.debug("Processing mvLook for '{}'".format(instance))

        nodes = set()
        for node in instance:
            # We want only mvUsdCompoundShape nodes.
            nodes_of_interest = cmds.ls(node,
                                        dag=True,
                                        shapes=False,
                                        type="mvUsdCompoundShape",
                                        noIntermediate=True,
                                        long=True)
            nodes.update(nodes_of_interest)

        sets = {}
        instance.data["resources"] = []
        publishMipMap = instance.data["publishMipMap"]

        for node in nodes:
            self.log.debug("Getting resources for '{}'".format(node))

            # We know what nodes need to be collected, now we need to
            # extract the materials overrides.
            overrides = multiverse.ListMaterialOverridePrims(node)
            for override in overrides:
                matOver = multiverse.GetMaterialOverride(node, override)

                if isinstance(matOver, multiverse.MaterialSourceShadingGroup):
                    # We now need to grab the shadingGroup so add it to the
                    # sets we pass down the pipe.
                    shadingGroup = matOver.shadingGroupName
                    self.log.debug("ShadingGroup = '{}'".format(shadingGroup))
                    sets[shadingGroup] = {"uuid": lib.get_id(
                        shadingGroup), "members": list()}

                    # The SG may reference files, add those too!
                    history = cmds.listHistory(
                        shadingGroup, allConnections=True)

                    # We need to iterate over node_types since `cmds.ls` may
                    # error out if we don't have the appropriate plugin loaded.
                    files = []
                    for node_type in NODETYPES.keys():
                        files += cmds.ls(history,
                                         type=node_type,
                                         long=True)

                    for f in files:
                        resources = self.collect_resource(f, publishMipMap)
                        instance.data["resources"] += resources

                elif isinstance(matOver, multiverse.MaterialSourceUsdPath):
                    # TODO: Handle this later.
                    pass

        # Store data on the instance for validators, extractos, etc.
        instance.data["lookData"] = {
            "attributes": [],
            "relationships": sets
        }

    def collect_resource(self, node, publishMipMap):
        """Collect the link to the file(s) used (resource)
        Args:
            node (str): name of the node

        Returns:
            dict
        """

        node_type = cmds.nodeType(node)
        self.log.debug("processing: {}/{}".format(node, node_type))

        if node_type not in NODETYPES:
            self.log.error("Unsupported file node: {}".format(node_type))
            raise AssertionError("Unsupported file node")

        resources = []
        for node_type_attr in NODETYPES[node_type]:
            fname_attrib = node_type_attr.get_fname(node)
            computed_fname_attrib = node_type_attr.get_computed_fname(node)
            colour_space_attrib = node_type_attr.get_colour_space(node)

            source = cmds.getAttr(fname_attrib)
            color_space = "Raw"
            try:
                color_space = cmds.getAttr(colour_space_attrib)
            except ValueError:
                # node doesn't have colorspace attribute, use "Raw" from before
                pass
            # Compare with the computed file path, e.g. the one with the <UDIM>
            # pattern in it, to generate some logging information about this
            # difference
            # computed_attribute = "{}.computedFileTextureNamePattern".format(node)  # noqa
            computed_source = cmds.getAttr(computed_fname_attrib)
            if source != computed_source:
                self.log.debug("Detected computed file pattern difference "
                               "from original pattern: {0} "
                               "({1} -> {2})".format(node,
                                                     source,
                                                     computed_source))

            # We replace backslashes with forward slashes because V-Ray
            # can't handle the UDIM files with the backslashes in the
            # paths as the computed patterns
            source = source.replace("\\", "/")

            files = get_file_node_files(node)
            files = self.handle_files(files, publishMipMap)
            if len(files) == 0:
                self.log.error("No valid files found from node `%s`" % node)

            self.log.debug("collection of resource done:")
            self.log.debug("  - node: {}".format(node))
            self.log.debug("  - attribute: {}".format(fname_attrib))
            self.log.debug("  - source: {}".format(source))
            self.log.debug("  - file: {}".format(files))
            self.log.debug("  - color space: {}".format(color_space))

            # Define the resource
            resource = {"node": node,
                        "attribute": fname_attrib,
                        "source": source,  # required for resources
                        "files": files,
                        "color_space": color_space}  # required for resources
            resources.append(resource)
        return resources

    def handle_files(self, files, publishMipMap):
        """This will go through all the files and make sure that they are
        either already mipmapped or have a corresponding mipmap sidecar and
        add that to the list."""
        if not publishMipMap:
            return files

        extra_files = []
        self.log.debug("Expecting MipMaps, going to look for them.")
        for fname in files:
            self.log.debug("Checking '{}' for mipmaps".format(fname))
            if is_mipmap(fname):
                self.log.debug(" - file is already MipMap, skipping.")
                continue

            mipmap = get_mipmap(fname)
            if mipmap:
                self.log.debug(" mipmap found for '{}'".format(fname))
                extra_files.append(mipmap)
            else:
                self.log.warning(" no mipmap found for '{}'".format(fname))
        return files + extra_files