Interchange Framework est le framework d'importation et d'exportation d'Unreal Engine. Il prend en charge tous les formats de fichiers, fonctionne de manière asynchrone, se personnalise selon vos besoins et peut être déployé en temps réel.
Interface d'importation d'Interchange
Interchange utilise une base de code extensible et fournit une pile de pipelines personnalisables. Vous avez ainsi la liberté de modifier le pipeline d'importation à l'aide d'un script C++ ou Python, ou à l'aide d'un blueprint pour l'adapter aux besoins de votre projet.
Concepts et termes importants
Les concepts et termes suivants relatifs à l'utilisation d'Interchange revêtent une importance particulière :
- Pipeline : Il s'agit d'un ensemble d'opérations qui traitent les données importées. Un pipeline expose les options utilisées pour personnaliser le processus d'importation.
- Pile de pipelines : Il s'agit d'une liste ordonnée de pipelines qui traitent un fichier importé. Les pipelines sont combinés dans la pile et assignés à des formats de fichiers spécifiques. Les piles de pipelines sont dans le répertoire Paramètres du projet > Interchange.
- Fabrique : Il s'agit d'une opération qui génère la ressource à partir des données importées.
Activer les plug-ins Interchange
Interchange Framework a besoin des plug-ins Interchange Editor et Interchange Framework, qui sont activés par défaut. Si ces plug-ins ne sont pas activés dans votre projet, vous pouvez les activer dans les paramètres du projet.
Pour plus d'informations sur l'activation des plug-ins, consultez Travaillez avec des plug-ins.
Importer une ressource
Il existe plusieurs méthodes d'importation de ressources dans Unreal Engine.
Vous pouvez importer des ressources dans le tiroir à contenu ou le navigateur de contenu. Vous pouvez également importer des ressources en sélectionnant File > Import Into Level (Fichier > Importer dans le niveau).
Pour plus d'informations sur l'importation de fichiers, consultez Importation directe de ressources.
La fonction Importer dans le niveau ne fonctionne actuellement qu'avec les formats de fichiers glTF et MaterialX.
Processus d'importation
Commencez votre processus d'importation en utilisant d'abord l'une des méthodes décrites ci-dessus. Cela entraînera l'ouverture de la fenêtre Interchange Pipeline Configuration (Configuration du pipeline d'Interchange) :
- Ouvrez le menu déroulant Choose Pipeline Stack (Choisir la pile de pipelines) et sélectionnez la pile de pipelines à utiliser dans la liste.
- Configurez vos paramètres.
- Appuyez sur Import (Importer) pour terminer le processus.
Sélectionnez vos paramètres d'importation sur cette interface et cliquez sur Import pour continuer.
À chaque importation, le moteur vérifie si le format de fichier est pris en charge par Interchange Framework. Si le fichier est pris en charge, Interchange utilise la pile de pipelines d'importation appropriée pour votre format.
Interchange procède ensuite comme suit :
- Interchange convertit les données importées en une structure de nœud intermédiaire dans Unreal Engine.
- Interchange traite les données via la pile de pipelines et applique les instructions d'importation.
- Il utilise des fabriques pour générer la ressource à partir du résultat.
Si le format de fichier n'est pas pris en charge par Interchange, Unreal Engine utilise l'ancien framework pour importer le fichier.
La fenêtre Interchange Pipeline Configuration (Configuration du pipeline Interchange) offre les options suivantes :
| Option | Description |
|---|---|
| Basic Layout (Disposition de base) | Filtrer les options du pipeline d'importation jusqu'aux propriétés de base du pipeline. |
| Filter on Contents (Filtrer selon le contenu) | Filtrer les options du pipeline d'importation en fonction des données présentes dans le fichier source. |
| Choose Pipeline Stack (Choisir la pile de pipelines) | Sélectionner la pile de pipelines utilisée pour cette importation. |
La prise en charge du format de fichier FBX est actuellement expérimentale. Pour activer l'importation de fichiers FBX à l'aide d'Interchange, utilisez les commandes de console suivantes :
| Commande de console | Description |
|---|---|
| Interchange.FeatureFlags.Import.FBX | Activer/désactiver la prise en charge expérimentale de l'importation de fichiers FBX à l'aide d'Interchange. |
| Interchange.FeatureFlags.Import.FBX.ToLevel | Activer/désactiver la prise en charge expérimentale de l'importation de fichiers FBX dans le niveau. |
Interchange Preview (Aperçu d'Interchange)
La fenêtre d’édition Interchange Preview (Aperçu Interchange) s'ouvre lorsque vous cliquez sur le bouton Preview (Aperçu) dans la fenêtre Interchange Pipeline Configuration :
La fenêtre Interchange Preview affiche une liste des ressources qui seront créées.
Cette fenêtre présente :
- Une liste des ressources qui seront créés.
- Leurs types sous forme d'icônes ou dans le texte de l'infobulle (matériaux, maillage statique, texture2D).
- Leurs propriétés sont définies par l'étape de pré-importation du pipeline.
Conflicts Preview (Aperçu des conflits)
Si le processus d'importation détecte des modifications dans la structure du matériau ou du squelette d'une ressource réimporté, il met en évidence le pipeline concerné. La fenêtre Conflicts Preview (Aperçu des conflits) s'ouvre lorsque vous cliquez sur Show Conflict (Afficher le conflit) :
La fenêtre Interchange Conflicts Preview affiche les modifications apportées à la structure du matériau ou du squelette lors de la réimportation.
Cette fenêtre met en évidence chaque conflit pour vous informer des modifications apportées lors de la réimportation de la ressource.
Dans les versions précédentes, vous pouviez choisir de conserver l'assignation de matériau d'origine ou de la remplacer à partir de la fenêtre de gestion des conflits. Cela n'est plus possible via Interchange. Pour modifier le matériau assigné à une ressource, vous devez effectuer la correction dans le fichier source ou utiliser l'Éditeur de maillage statique. Pour plus d'informations sur l'utilisation de l'Éditeur de maillage statique, voir Appliquer un matériau via l'Éditeur de maillage statique.
Réimporter des ressources à l'aide d'Interchange
Lorsque vous réimportez une ressource précédemment importée à l'aide d'Interchange, Unreal Engine mémorise la pile de pipelines et les options utilisées et affiche ces options.
Importer une ressource à l'aide d'un blueprint
Vous pouvez utiliser le blueprint pour importer des ressources dans Unreal Engine via Interchange Framework.
L'exemple de blueprint crée un objet qui importe des fichiers lors de l'exécution à l'aide d'Interchange.
Vous pouvez, par exemple, utiliser le blueprint pour importer des fichiers à l'aide d'Interchange lors de l'exécution dans une application basée sur Unreal Engine. L'exemple ci-dessus crée une fonction qui importe un fichier de texture dans un emplacement de fichier spécifié à l'aide de la pile de pipelines de texture par défaut. Cette méthode d'importation ne prend actuellement pas en charge les données de maillage squelettique ou d'animation.
Créer une nouvelle classe de blueprint
Procédez comme suit pour recréer l'exemple :
- Dans votre projet, créez une nouvelle classe de blueprint d'acteur pour contenir la fonction. Pour créer le blueprint d'acteur, faites un clic droit dans le Navigateur de contenu, atteignez le menu contextuel et sélectionnez Classe de blueprint.
-
Dans la fenêtre Pick Parent Class (Choisir la classe parent), sélectionnez Actor (Acteur) et nommez la nouvelle classe de blueprint InterchangeActor.
Choisissez la classe parent de votre nouveau blueprint.
Ajouter une fonction
Pour ajouter une fonction :
- Double-cliquez sur le nouveau blueprint pour ouvrir l'éditeur.
-
Dans le panneau My Blueprint, accédez au paramètre Functions, cliquez sur le bouton + et nommez la nouvelle fonction InterchangeImport.
Créer une nouvelle fonction
Ajouter et connecter les nœuds
Pour ajouter et connecter les nœuds :
- Ajoutez un nœud Sequence et connectez-le à la sortie de la fonction.
- Connectez la sortie Then 0 et créez un nœud Create Source Data pour référencer le fichier existant qui sera importé.
- Connectez l'entrée In File Name sur Create Source Data et sélectionnez Promote to Variable dans le menu contextuel.
- Nommez la nouvelle variable de chaîne FilePath. Elle contient l'emplacement du fichier qui sera importé.
- Dans le blueprint, sélectionnez la nouvelle variable et cochez la case Instance Editable (Instance modifiable).
- Promouvez la sortie du nœud Create Source Data en une nouvelle variable nommée SourceData.
- Faites glisser la sortie Then 1 sur la séquence et créez un nœud Get Interchange Manager Scripted. Cette opération crée un pointeur vers le gestionnaire Interchange qui est utilisé à l'étape suivante.
- Faites glisser la sortie Get Interchange Manager Scripted et créez un nœud Import Asset. Connectez la valeur de retour du nœud Get Interchange Manager Scripted à l'entrée cible du nœud Import Asset.
- Faites glisser l'entrée Content Path et promouvez-la en une nouvelle variable nommée SavePath. Elle contient l'emplacement du fichier nouvellement importé.
- Dans le blueprint, sélectionnez la nouvelle variable et cochez la case Instance Editable (Instance modifiable).
- Obtenez une référence à la variable Source Data (Données source) et connectez-la à l'entrée Source Data du nœud Import Asset.
-
Faites glisser l'entrée Import Asset Parameters et créez un nœud Make Input Asset Parameters.
Cliquez sur l'image pour l'afficher à taille réelle.
Rendre la fonction disponible au moment de l'exécution
Pour rendre la fonction disponible au moment de l'exécution :
- Dans My Blueprint, cliquez sur la fonction InterchangeImport, puis cochez la case en regard de Call In Editor dans le panneau Détails. Cette option rend la fonction disponible au moment de l'exécution dans le panneau Détails de l'objet InterchangeActor.
- Enregistrez et compilez votre blueprint.
Utilisez votre nouveau blueprint
- Faites glisser une copie du blueprint InterchangeActor dans le niveau.
- Cliquez sur Play (jouer).
- Sélectionnez InterchangeActor dans l'organiseur.
- Dans le panneau Détails, renseignez le FilePath et le SavePath.
- Cliquez sur le bouton Interchange Import pour importer votre fichier.
La ressource est directement générée dans la scène si vous utilisez un nœud Import Scene avec l'exemple de blueprint ci-dessus.
Utiliser Interchange dans une application préparée
Si vous prévoyez d'utiliser Interchange Framework au moment de l'exécution dans une application préparée, accédez à Project Settings > Project - Packating > Additional Asset Directories to Cook et ajoutez le dossier Interchange.
Cliquez sur l'image pour l'afficher à taille réelle.
Importer une ressource avec Python
Vous pouvez utiliser un script Python pour importer des ressources dans Unreal Engine via Interchange Framework.
import unreal
import_path = "C:/Users/foo/Downloads/Fbx/SkeletalMesh/Animations/Equilibre.fbx"
import_extension = unreal.Paths.get_extension(import_path, False)
is_gltf = import_extension == 'glb' or import_extension == 'gltf'
is_fbx = import_extension == 'fbx'
#si vous souhaitez importer un fichier fbx, assurez-vous que l'importation Interchange de fichiers fbx est activée
if is_fbx:
level_editor_subsystem = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
unreal.SystemLibrary.execute_console_command(level_editor_subsystem.get_world(), 'Interchange.FeatureFlags.Import.FBX true')
editor_asset_subsystem = unreal.get_editor_subsystem(unreal.EditorAssetSubsystem)
transient_path = "/Interchange/Pipelines/Transient/"
transient_pipeline_path = transient_path + "MyAutomationPipeline"
editor_asset_subsystem.delete_directory(transient_path)
#Dupliquez le pipeline de contenu de ressources Interchange par défaut ; gltf comporte des ressources spéciales
if is_gltf:
pipeline = editor_asset_subsystem.duplicate_asset("/Interchange/Pipelines/DefaultGLTFAssetsPipeline", transient_pipeline_path)
else:
pipeline = editor_asset_subsystem.duplicate_asset("/Interchange/Pipelines/DefaultAssetsPipeline", transient_pipeline_path)
#Définissez ici toutes les propriétés de pipeline dont vous avez besoin pour l'importation de vos ressources
#forcer l'importation du maillage statique
pipeline.common_meshes_properties.force_all_mesh_as_type = unreal.InterchangeForceMeshType.IFMT_STATIC_MESH
#combiner un maillage statique
pipeline.mesh_pipeline.combine_static_meshes = True
#Empêcher l'importation des matériaux
pipeline.material_pipeline.import_materials = False
#Empêcher l'importation des textures
pipeline.material_pipeline.texture_pipeline.import_textures = False
#Créer des données sources à partir du nom de fichier
source_data = unreal.InterchangeManager.create_source_data(import_path)
#créer les paramètres pour l'importation Interchange
import_asset_parameters = unreal.ImportAssetParameters()
#Le script est normalement celui d'une importation automatisée
import_asset_parameters.is_automated = True
#Ajouter le pipeline configuré aux arguments d'importation
import_asset_parameters.override_pipelines.append(unreal.SoftObjectPath(transient_pipeline_path + ".MyAutomationPipeline"))
#L'importateur gltf utilise 2 pipelines ; ajoutez donc le second
if is_gltf:
import_asset_parameters.override_pipelines.append(unreal.SoftObjectPath("/Interchange/Pipelines/DefaultGLTFPipeline"))
interchange_manager = unreal.InterchangeManager.get_interchange_manager_scripted()
#importer la ressource
interchange_manager.import_asset("/game/AA0A/testpython/",source_data,import_asset_parameters)
editor_asset_subsystem.delete_directory(transient_path)
Dans l'exemple ci-dessus, un script Python est utilisé pour importer le fichier Equilibre.fbx. Le script vérifie si le format de fichier est ".gltf" ou ".fbx" et assigne ensuite le pipeline correct.
Modifier la pile de pipelines
L'un des avantages d'Interchange Framework est la possibilité de sélectionner et de personnaliser la pile de pipelines, une pile personnalisable de processus qui traitent les données de ressources. Vous pouvez ajouter des pipelines à la pile de pipelines par défaut pour ajouter des comportements pendant le processus d'importation.
Unreal Engine est configuré par défaut avec les pipelines par défaut suivants :
- Pipeline de ressources par défaut
- Pipeline de matériaux par défaut
- Pipeline de textures par défaut
- Pipeline de ressources de scène par défaut
- Pipeline de niveau de scène par défaut
- Pipeline d'inspecteur de graphiques par défaut
Chaque pipeline par défaut contient les options les plus fréquemment utilisées pour ce type d'importation. Vous pouvez adapter ces pipelines aux besoins spécifiques de votre projet.
Modifier un pipeline existant
Chacun des pipelines par défaut peut être adapté aux besoins de votre projet et de votre équipe.
Les méthodes suivantes vous permettent de personnaliser les options d'importation de votre projet :
- Ajouter, supprimer ou réorganiser la pile de pipelines existante dans les paramètres du projet.
- Modifier les pipelines utilisés par défaut.
- Modifier les pipelines par défaut existants.
- Créer un pipeline personnalisé.
Modifier les paramètres du projet
La pile de pipelines se trouve à l'emplacement suivant : Paramètres du projet > Engine > Interchange :
La pile de pipelines dans les paramètres du projet.
La pile de pipelines contient les paramètres par défaut des opérations ou éléments suivants :
- Importer du contenu
- Importer dans le niveau
- Interface de l'éditeur
- Générique
- Classe du pipeline générique de l'éditeur
Importer du contenu
Unreal Engine utilise ces paramètres pour importer du contenu dans le tiroir à contenu ou le navigateur de contenu.
Cliquez sur l'image pour l'afficher à taille réelle.
Vous pouvez modifier les paramètres de chaque type de contenu répertorié. Vous pouvez également ajouter des titres supplémentaires si nécessaire. Par exemple, la configuration par défaut contient Assets, Materials et Textures. Vous pouvez ajouter une section supplémentaire à la pile de pipelines pour les animations, puis un ou plusieurs pipelines personnalisés pour gérer les fichiers d'animation entrants.
Importer dans le niveau
Dans la fenêtre Editor (Éditeur), atteignez File > Import Into Level (Fichier > Importer dans le niveau). Par défaut, cette fonction utilise deux pipelines qui fonctionnent ensemble. Ces pipelines importent les données de l'acteur à partir d'un fichier, puis génèrent un acteur dans le niveau. La fonction d'importation utilise les paramètres suivants :
Cliquez sur l'image pour l'afficher à taille réelle.
- DefaultSceneAssetPipeline est basé sur la même classe que DefaultAssetPipeline et est conçu pour l'importation de scènes.
- DefaultSceneLevelPipeline génère l'acteur dans le monde après la transmission des données par DefaultSceneAssetPipeline.
Modifier les pipelines par défaut existants
Vous pouvez modifier les propriétés des pipelines Interchange par défaut pour modifier les éléments suivants :
- Les valeurs par défaut
- La visibilité
- L'état en lecture seule
Le panneau Détails du pipeline Interchange.
Procédez comme suit pour modifier les paramètres des pipelines Interchange par défaut :
- Localisez les pipelines par défaut dans le tiroir à contenu ou le navigateur de contenu et double-cliquez sur l'un d'eux pour l'ouvrir. Les pipelines se trouvent dans le dossier suivant : Engine > Plugins > Interchange Framework Content > Pipelines. Si vous ne retrouvez pas le dossier Engine, cliquez sur Settings dans le coin supérieur droit du tiroir à contenu ou du navigateur de contenu et cochez la case Show Engine Content.
- Modifiez les éléments suivants selon vos besoins :
- Visibilité pendant le processus d'importation et de réimportation.
- Paramètre par défaut.
- Si la propriété est en lecture seule pendant le processus d'importation.
- Enregistrez les modifications et fermez la fenêtre.
Créer un pipeline personnalisé
Vous pouvez créer de nouveaux pipelines Interchange pour personnaliser davantage le processus d'importation à l'aide de blueprints ou de scripts C++ ou Python.
Créer un pipeline personnalisé à l'aide de blueprints
Pour créer un nouveau pipeline Interchange à l'aide de blueprints, procédez comme suit :
- Dans le tiroir à contenu ou le navigateur de contenu, faites un clic droit et sélectionnez Create Blueprint Class.
- Dans la fenêtre Pick Parent Class (Sélectionner la classe parent), développez la catégorie All Classes (Toutes les classes) et sélectionnez InterchangePipelineBase comme classe parent.
- Double-cliquez sur le nouveau blueprint pour ouvrir le Blueprint Editor (éditeur de blueprint).
Sélectionnez InterchangePipelineBase comme classe parent.
Un pipeline personnalisé créé à l'aide de blueprints possède les fonctions suivantes qui peuvent être remplacées pour ajouter un comportement personnalisé.
Fonctions de remplacement du blueprint Interchange.
| Fonction de remplacement | Description |
|---|---|
| Le script peut s'exécuter sur n'importe quel thread | Il indique au gestionnaire Interchanges que ce pipeline peut être exécuté en mode asynchrone. |
| Le script exécute le pipeline d'exportation | Il s'exécute pendant le processus d'exportation (la fonctionnalité n'est actuellement pas fonctionnelle). |
| Le script exécute le pipeline | Il s'exécute après la conversion du fichier. Il crée la fabrique nécessaire pour générer des ressources. |
| Le script exécute le pipeline post-fabrique | Il s'exécute après que la fabrique a créé une ressource, mais avant que la fonction PostEditChange ne soit appelée. |
| Le script exécute le pipeline post-importation | Il s'exécute une fois la ressource entièrement importée et la fonction PostEditChange appelée. |
| Le script définit l'index source de réimportation | Il s'exécute et indique au pipeline l'index source à réimporter. Utilisez cette fonction lors de la réimportation d'une ressource qui peut avoir plusieurs sources. Par exemple, un maillage squelettique qui possède un fichier source pour la géométrie et un autre pour les informations de surfaçage. |
Créer un pipeline personnalisé à l'aide de scripts C++
Pour créer un nouveau pipeline Interchange à l'aide de C++, créez un fichier d'en-tête contenant les éléments suivants :
#pragma once
#include "CoreMinimal.h"
#include "InterchangePipelineBase.h"
#include "InterchangeSourceData.h"
#include "Nodes/InterchangeBaseNodeContainer.h"
#include "InterchangeMyPipeline.generated.h"
UCLASS(BlueprintType)
class INTERCHANGEPIPELINES_API UInterchangeMyPipeline : public UInterchangePipelineBase
{
GENERATED_BODY()
protected:
virtual void ExecutePipeline(UInterchangeBaseNodeContainer* BaseNodeContainer, const TArray<UInterchangeSourceData*>& SourceDatas) override;
virtual bool CanExecuteOnAnyThread(EInterchangePipelineTask PipelineTask) override
{
return true;
}
};
Ensuite, créez un fichier source contenant les éléments suivants :
#include "InterchangeMyPipeline.h"
void UInterchangeMyPipeline::ExecutePipeline(UInterchangeBaseNodeContainer* NodeContainer, const TArray<UInterchangeSourceData*>& InSourceDatas)
{
Super::ExecutePipeline(NodeContainer, InSourceDatas);
// Placez la logique dont vous avez besoin sur des nœuds convertis ou des nœuds de fabrique.
}
Pour plus d'informations sur l'utilisation de C++ dans Unreal Engine, voir Programmer avec C++.
Créer un pipeline personnalisé à l'aide de scripts Python
Pour créer un nouveau pipeline Interchange à l'aide d'un script Python, créez un nouveau script Python et utilisez les paramètres du projet pour l'ajouter aux Scripts de démarrage. Pour plus d'informations sur l'utilisation de scripts Python dans Unreal Engine, voir Création de scripts pour Unreal Editor à l'aide de Python.
Dans l'exemple de script ci-dessous, le script Python est utilisé pour créer un pipeline d'importation de ressources de base.
import unreal
@unreal.uclass()
class PythonPipelineTest(unreal.InterchangePythonPipelineBase):
import_static_meshes = unreal.uproperty(bool,meta=dict(Category="StaticMesh"))
import_skeletal_meshes = unreal.uproperty(bool,meta=dict(Category="SkeletalMesh"))
def cast(self, object_to_cast, object_class):
try:
return object_class.cast(object_to_cast)
except:
return None
def recursive_set_node_properties(self, base_node_container, node_unique_id):
node = base_node_container.get_node(node_unique_id)
# Définir l'état d'activation du nœud de fabrique du maillage statique
static_mesh_node = self.cast(node, unreal.InterchangeStaticMeshFactoryNode)
if static_mesh_node:
static_mesh_node.set_enabled(self.import_static_meshes)
# Définir l'état d'activation du nœud de fabrique du maillage squelettique
skeletal_mesh_node = self.cast(node, unreal.InterchangeSkeletalMeshFactoryNode)
if skeletal_mesh_node:
skeletal_mesh_node.set_enabled(self.import_static_meshes)
# Itérer les enfants
childrens = base_node_container.get_node_children_uids(node.get_unique_id())
for child_uid in childrens:
self.recursive_set_node_properties(base_node_container, child_uid)
@unreal.ufunction(override=True)
def scripted_execute_pipeline(self, base_node_container, SourceDatas):
root_nodes = base_node_container.get_roots()
for node_unique_id in root_nodes:
self.recursive_set_node_properties(base_node_container, node_unique_id)
return True