load_pointcache

class LoadPointCache(load.LoaderPlugin):
    """Load Pointcache for project."""
    product_base_types: ClassVar[set[str]] = {"*"}
    product_types: ClassVar[set[str]] = product_base_types
    representations: ClassVar[set[str]] = {"abc", "fbx", "obj"}

    label = "Load Pointcache"
    order = -10
    icon = "code-fork"
    color = "orange"
    # Settings
    scale = 1.0

    @classmethod
    def apply_settings(cls, project_settings: dict) -> None:
        """Apply settings from project settings."""
        md_load_setting = (
            project_settings["marvelous_designer"]
                            ["load"]
                            ["LoadPointCache"]
        )
        cls.scale = md_load_setting.get("scale", cls.scale)

    def load(self,
             context: dict,
             name: Optional[str] = None,
             namespace: Optional[str] = None,
             options: Optional[dict] = None) -> None:
        """Load pointcache into the scene."""
        file_path = self._get_filepath(context)
        extension = os.path.splitext(file_path)[-1].lower()
        loaded_options = self.load_options(extension)
        self.load_pointcache(file_path, extension, loaded_options)
        containerise(
            name=name,
            namespace=namespace,
            context=context,
            loader=self
        )

    @staticmethod
    def load_pointcache(
        file_path: Path,
        extension: str,
        options: Union[ApiTypes.ImportAlembicOption,
                       ApiTypes.ImportExportOption]) -> None:
        """Actual loading logic for pointcache.

        Args:
            file_path (Path): Path to pointcache file.
            extension (str): Extension of pointcache file.
            options (ApiTypes.ImportExportOption): Options for loading.

        Raises:
            LoadError: If the pointcache format is unsupported.

        """
        if extension == ".abc":
            import_api.ImportAlembic(file_path, options)
        elif extension == ".fbx":
            import_api.ImportFBX(file_path, options)
        elif extension == ".obj":
            import_api.ImportOBJ(file_path, options)
        else:
            msg = f"Unsupported pointcache format: {extension}"
            raise LoadError(msg)

    def load_options(self, extension: str) -> Union[
            ApiTypes.ImportAlembicOption, ApiTypes.ImportExportOption]:
        """Return options for loading pointcache.

        Args:
            extension (str): Extension of pointcache file.

        Returns:
            Union[
                ApiTypes.ImportAlembicOption,
                ApiTypes.ImportExportOption]: Options for loading.

        Raises:
            LoadError: If the pointcache format is unsupported.

        """
        if extension == ".abc":
            alembic_options = ApiTypes.ImportAlembicOption()
            alembic_options.aScale = self.scale
            return alembic_options

        if extension in {".fbx", ".obj"}:
            import_options = ApiTypes.ImportExportOption()
            import_options.scale = self.scale
            return import_options

        msg = f"Unsupported pointcache format: {extension}"
        raise LoadError(msg)

    def _get_filepath(self, context: dict) -> str:
        """Gets filepath with either representation trait or context data.

        For backward compatibility only.

        Args:
            context (dict): Context dictionary.

        Returns:
            str: File path to load.

        """
        traits_raw = context["representation"].get("traits")
        if traits_raw is not None:
            # construct Representation object from the context
            representation = Representation.from_dict(
                name=context["representation"]["name"],
                representation_id=context["representation"]["id"],
                trait_data=json.loads(traits_raw),
            )

            file_path: Path = representation.get_trait(FileLocation).file_path
        else:
            filepath = self.filepath_from_context(context)
            file_path = Path(filepath)

        return file_path.as_posix()