Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Checking the stable version of the documentation...

EditorImportPlugin

Hérite de : ResourceImporter < RefCounted < Object

Enregistre un importateur de ressources personnalisée dans l'éditeur. Utilisez cette classe pour interpréter n'importe quel fichier pour l'importer comme nouveau type de ressource.

Description

Les EditorImportPlugin fournissent un moyen d'étendre la fonctionnalité d'importation des ressources de l'éditeur. Utilisez-les pour importer des ressources depuis des fichiers personnalisés ou pour proposer une alternative aux importateurs existants de l'éditeur.

Les EditorImportPlugins fonctionnent en associant certaines extensions de fichiers avec un type de ressource. Voir _get_recognized_extensions() et _get_resource_type(). Ils peuvent aussi spécifier des préréglages d'importation qui changeront le processus d'importation. Les EditorImportPlugins sont responsables pour créer les ressources et les enregistrer dans le dossier .godot/imported (voir ProjectSettings.application/config/use_hidden_project_data_directory).

L'exemple ci-dessous définit un EditorImportPlugin qui importe un Mesh depuis un fichier avec l'extension ".special" ou ".spec" :

@tool
extends EditorImportPlugin

func _get_importer_name():
    return "mon.plugin.special"

func _get_visible_name():
    return "Maillage Special"

func _get_recognized_extensions():
    return ["special", "spec"]

func _get_save_extension():
    return "mesh"

func _get_resource_type():
    return "Mesh"

func _get_preset_count():
    return 1

func _get_preset_name(i):
    return "Default"

func _get_import_options(i):
    return [{"name": "mon_option", "default_value": false}]

func _import(source_file, save_path, options, platform_variants, gen_files):
    var fichier = File.new()
    if file == null:
        return FAILED
    var maillage = Mesh.new()
    # Remplir le maillage avec des données lues depuis "fichier" (exercice laissé au lecteur)

    var nom_de_fichier = save_path + "." + get_save_extension()
    return ResourceSaver.save(maillage, nom_de_fichier)

using Godot;

public partial class MySpecialPlugin : EditorImportPlugin
{
    public override string _GetImporterName()
    {
        return "mon.plugin.special";
    }

    public override string _GetVisibleName()
    {
        return "Maillage Special";
    }

    public override string[] _GetRecognizedExtensions()
    {
        return ["special", "spec"];
    }

    public override string _GetSaveExtension()
    {
        return "mesh";
    }

    public override string _GetResourceType()
    {
        return "Mesh";
    }

    public override int _GetPresetCount()
    {
        return 1;
    }

    public override string _GetPresetName(int presetIndex)
    {
        return "Default";
    }

    public override Godot.Collections.Array<Godot.Collections.Dictionary> _GetImportOptions(string path, int presetIndex)
    {
        return
        [
            new Godot.Collections.Dictionary
            {
                { "name", "mon_option" },
                { "default_value", false },
            },
        ];
    }

    public override Error _Import(string sourceFile, string savePath, Godot.Collections.Dictionary options, Godot.Collections.Array<string> platformVariants, Godot.Collections.Array<string> genFiles)
    {
        using var fichier = FileAccess.Open(sourceFile, FileAccess.ModeFlags.Read);
        if (fichier.GetError() != Error.Ok)
        {
            return Error.Failed;
        }

        var mesh = new ArrayMesh();
        // Remplir le maillage avec des données lues depuis "fichier" (exercice laissé au lecteur)
        string filename = $"{savePath}.{_GetSaveExtension()}";
        return ResourceSaver.Save(maillage, nom_de_fichier);
    }
}

Pour utiliser un EditorImportPlugin, enregistrez-le d'abord avec la méthode EditorPlugin.add_import_plugin().

Tutoriels

Importer des plugins

Méthodes

bool	_can_import_threaded() virtual const
int	_get_format_version() virtual const
Array[Dictionary]	_get_import_options(path: String, preset_index: int) virtual required const
int	_get_import_order() virtual const
String	_get_importer_name() virtual required const
bool	_get_option_visibility(path: String, option_name: StringName, options: Dictionary) virtual const
int	_get_preset_count() virtual const
String	_get_preset_name(preset_index: int) virtual required const
float	_get_priority() virtual const
PackedStringArray	_get_recognized_extensions() virtual required const
String	_get_resource_type() virtual required const
String	_get_save_extension() virtual required const
String	_get_visible_name() virtual required const
Error	_import(source_file: String, save_path: String, options: Dictionary, platform_variants: Array[String], gen_files: Array[String]) virtual required const
Error	append_import_external_resource(path: String, custom_options: Dictionary = {}, custom_importer: String = "", generator_parameters: Variant = null)

Descriptions des méthodes

bool _can_import_threaded() virtual const 🔗

Tells whether this importer can be run in parallel on threads, or, on the contrary, it's only safe for the editor to call it from the main thread, for one file at a time.

If this importer's implementation is thread-safe and can be run in parallel, override this with true to optimize for concurrency.

If not overridden, returns false.

int _get_format_version() virtual const 🔗

Gets the format version of this importer. Increment this version when making incompatible changes to the format of the imported resources.

If not overridden, the format version is 0.

Array[Dictionary] _get_import_options(path: String, preset_index: int) virtual required const 🔗

Obtient les options et les valeurs par défaut pour le préréglage à cet index. Renvoie un Array de Dictionary avec les clés suivantes : name, default_value, property_hint (optionnel), hint_string (optionnel) et usage (optionnel).

int _get_import_order() virtual const 🔗

Obtient l'ordre de lancement de cet importateur lors de l'importation de ressources. Les importateurs avec un ordre d'importation plus bas seront appelés en premier, et des valeurs supérieures seront appelées après. Utilisez-le pour s'assurer que l'importateur fonctionne après l'importation des dépendances. L'ordre d'importation par défaut est 0 à moins d'être remplacé par un importateur spécifique. Voir ImportOrder pour certaines valeurs prédéfinies.

String _get_importer_name() virtual required const 🔗

Obtient le nom unique de l'importateur.

bool _get_option_visibility(path: String, option_name: StringName, options: Dictionary) virtual const 🔗

Obtient si l'option d'importation spécifiée par option_name devrait être visible dans le dock Import. L'implémentation par défaut renvoie toujours true, rendant toutes les options visibles. Ceci est principalement utile pour cacher des options qui dépendent des autres si l'une d'entre elle est désactivée.

func _get_option_visibility(path, option_name, options):
    # Affiche seulement le réglage de la qualité avec perte si le mode de compression est défini à "Lossy".
    if option_name == "compress/lossy_quality" and options.has("compress/mode"):
        return int(options["compress/mode"]) == COMPRESS_LOSSY # Il s'agit d'une constante que vous définissez

    return true

public override bool _GetOptionVisibility(string path, StringName optionName, Godot.Collections.Dictionary options)
{
    // Affiche seulement le réglage de la qualité avec perte si le mode de compression est défini à "Lossy".
    if (optionName == "compress/lossy_quality" && options.ContainsKey("compress/mode"))
    {
        return (int)options["compress/mode"] == CompressLossy; // Il s'agit d'une constante que vous définissez
    }

    return true;
}

int _get_preset_count() virtual const 🔗

Gets the number of initial presets defined by the plugin. Use _get_import_options() to get the default options for the preset and _get_preset_name() to get the name of the preset.

By default, there are no presets.

String _get_preset_name(preset_index: int) virtual required const 🔗

Obtient le nom des préréglages de l'option à cette position.

float _get_priority() virtual const 🔗

Obtient la priorité de ce greffon pour l'extension reconnue. Des greffons le plus prioritaires seront préférés. La priorité par défaut est 1.0.

PackedStringArray _get_recognized_extensions() virtual required const 🔗

Obtient la liste des extensions de fichier à associer à ce chargeur (insensible à la casse). Par exemple ["obj"].

String _get_resource_type() virtual required const 🔗

Obtient le type de ressource de Godot associé avec ce chargeur, par ex. : "Mesh" ou "Animation".

String _get_save_extension() virtual required const 🔗

Gets the extension used to save this resource in the .godot/imported directory (see ProjectSettings.application/config/use_hidden_project_data_directory).

String _get_visible_name() virtual required const 🔗

Obtient le nom à afficher dans la fenêtre d'importation. Vous devriez choisir ce nom comme une suite à "Importer comme", par exemple "Importer comme Maillage Spécial".

Error _import(source_file: String, save_path: String, options: Dictionary, platform_variants: Array[String], gen_files: Array[String]) virtual required const 🔗

Imports source_file with the import options specified. Should return @GlobalScope.OK if the import is successful, other values indicate failure.

The imported resource is expected to be saved to save_path + "." + _get_save_extension(). If a different variant is preferred for a feature tag, save the variant to save_path + "." + tag + "." + _get_save_extension() and add the feature tag to platform_variants.

If additional resource files are generated in the resource filesystem (res://), add their full path to gen_files so that the editor knows they depend on source_file.

This method must be overridden to do the actual importing work. See this class' description for an example of overriding this method.

Error append_import_external_resource(path: String, custom_options: Dictionary = {}, custom_importer: String = "", generator_parameters: Variant = null) 🔗

This function can only be called during the _import() callback and it allows manually importing resources from it. This is useful when the imported file generates external resources that require importing (as example, images). Custom parameters for the ".import" file can be passed via the custom_options. Additionally, in cases where multiple importers can handle a file, the custom_importer can be specified to force a specific one. This function performs a resource import and returns immediately with a success or error code. generator_parameters defines optional extra metadata which will be stored as generator_parameters in the remap section of the .import file, for example to store a md5 hash of the source data.