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

Eredita: ResourceImporter < RefCounted < Object

Registra un importatore di risorse personalizzato nell'editor. Utilizza la classe per analizzare qualsiasi file e importarlo come un nuovo tipo di risorsa.

Descrizione

Gli EditorImportPlugin forniscono un modo per estendere la funzionalità di importazione delle risorse dell'editor. Utilizzali per importare risorse da file personalizzati o per fornire alternative agli importatori esistenti dell'editor.

Gli EditorImportPlugin funzionano associandosi a specifiche estensioni di file e a un tipo di risorsa. Vedi _get_recognized_extensions() e _get_resource_type(). Possono facoltativamente specificare alcune preimpostazioni di importazione che influenzano il processo di importazione. Gli EditorImportPlugin sono responsabili della creazione delle risorse e del loro salvataggio nella cartella .godot/imported (vedi ProjectSettings.application/config/use_hidden_project_data_directory).

Di seguito è riportato un esempio di EditorImportPlugin che importa una Mesh da un file con l'estensione ".special" o ".spec":

@tool
extends EditorImportPlugin

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

func _get_visible_name():
    return "Special Mesh"

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(preset_index):
    return "Default"

func _get_import_options(path, preset_index):
    return [{"name": "my_option", "default_value": false}]

func _import(source_file, save_path, options, platform_variants, gen_files):
    var file = FileAccess.open(source_file, FileAccess.READ)
    if file == null:
        return FAILED
    var mesh = ArrayMesh.new()
    # Riempi la Mesh con i dati letti in "file", lasciati come esercizio al lettore.

    var filename = save_path + "." + _get_save_extension()
    return ResourceSaver.save(mesh, filename)

using Godot;

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

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

    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", "myOption" },
                { "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 file = FileAccess.Open(sourceFile, FileAccess.ModeFlags.Read);
        if (file.GetError() != Error.Ok)
        {
            return Error.Failed;
        }

        var mesh = new ArrayMesh();
        // Riempi la Mesh con i dati letti in "file", lasciati come esercizio al lettore.
        string filename = $"{savePath}.{_GetSaveExtension()}";
        return ResourceSaver.Save(mesh, filename);
    }
}

Per utilizzare EditorImportPlugin, registrarlo prima attraverso il metodo EditorPlugin.add_import_plugin().

Tutorial

Estensioni di esportazione

Metodi

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)

Descrizioni dei metodi

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 🔗

Ottiene la versione del formato di questo importatore. Incrementa questa versione quando si apportano modifiche incompatibili al formato delle risorse importate.

Se non sovrascritto, la versione del formato è 0.

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

Ottiene le opzioni e i valori predefiniti per la preimpostazione a questo indice. Restituisce un array di dizionari con le seguenti chiavi: name, default_value, property_hint (facoltativo), hint_string (facoltativo), usage (facoltativo).

int _get_import_order() virtual const 🔗

Ottiene l'ordine di questo importatore da eseguire durante l'importazione di risorse. Gli importatori con ordini di importazione più bassi saranno chiamati per primi, mentre quelli con valori più alti saranno chiamati in seguito. Utilizza questo per assicurarti che l'importatore sia eseguito dopo che le dipendenze sono già state importate. L'ordine di importazione predefinito è 0 a meno che non sia sovrascritto da un importatore specifico. Consulta ImportOrder per alcuni valori predefiniti.

String _get_importer_name() virtual required const 🔗

Ottiene il nome univoco dell'importatore.

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

Determina se bisogna mostrare l'opzione di importazione specificata da option_name nel pannello Importazione. L'implementazione predefinita restituisce sempre true, rendendo visibili tutte le opzioni. È utile principalmente per nascondere le opzioni che dipendono da altre se una di esse è disabilitata.

func _get_option_visibility(path, option_name, options):
    # Mostra solo l'impostazione della qualità lossy se la modalità di compressione è impostata su "Lossy".
    if option_name == "compress/lossy_quality" and options.has("compress/mode"):
        return int(options["compress/mode"]) == COMPRESS_LOSSY # Questa è una costante che imposti

    return true

public override bool _GetOptionVisibility(string path, StringName optionName, Godot.Collections.Dictionary options)
{
    // Mostra solo l'impostazione della qualità lossy se la modalità di compressione è impostata su "Lossy".
    if (optionName == "compress/lossy_quality" && options.ContainsKey("compress/mode"))
    {
        return (int)options["compress/mode"] == CompressLossy; // Questa è una costante che imposti
    }

    return true;
}

int _get_preset_count() virtual const 🔗

Ottiene il numero di preimpostazioni iniziali definite dalle estensioni. Usa _get_import_options() per ottenere le opzioni predefinite per la preimpostazione e _get_preset_name() per ottenere il nome della preimpostazione.

Normalmente, non ci sono preimpostazioni.

String _get_preset_name(preset_index: int) virtual required const 🔗

Ottiene il nome del preset delle opzioni a questo indice.

float _get_priority() virtual const 🔗

Ottiene la priorità di questa estensione per l'estensione riconosciuta. Le estensioni con priorità più alta saranno preferiti. La priorità predefinita è 1.0.

PackedStringArray _get_recognized_extensions() virtual required const 🔗

Ottiene la lista delle estensioni di file da associare a questo caricatore (senza distinzione tra maiuscole e minuscole). Ad esempio ["obj"].

String _get_resource_type() virtual required const 🔗

Ottiene il tipo di risorsa di Godot associato a questo caricatore, ad esempio "Mesh" o "Animation".

String _get_save_extension() virtual required const 🔗

Ottiene l'estensione utilizzata per salvare questa risorsa nella cartella .godot/imported (vedi ProjectSettings.application/config/use_hidden_project_data_directory).

String _get_visible_name() virtual required const 🔗

Ottiene il nome da visualizzare nella finestra di importazione. Dovresti scegliere questo nome come continuazione di "Importa come", ad esempio "Importa come Mesh speciale".

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

Importa source_file con le opzioni di importazione options. Dovrebbe restituire @GlobalScope.OK se l'importazione ha avuto successo, altri valori indicano un errore.

La risorsa importata si dovrebbe salvare in save_path + "." + _get_save_extension(). Se si preferisce una variante diversa per un tag di funzionalità, salvare la variante in save_path + "." + tag + "." + _get_save_extension() e aggiungere il tag di funzionalità a platform_variants.

Se vengono generati file di risorse aggiuntivi nel file system delle risorse (res://), aggiungere il loro percorso completo a gen_files in modo che l'editor sappia che dipendono da source_file.

Questo metodo si deve sovrascrivere per eseguire l'importazione effettiva. Per un esempio di come sovrascrivere questo metodo, vedere la descrizione di questa classe.

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

Questa funzione può essere chiamata solo durante il callback _import() e consente di importare manualmente risorse da essa. Ciò è utile quando il file importato genera risorse esterne che richiedono un'importazione (ad esempio, immagini). È possibile passare parametri personalizzati per il file ".import" tramite custom_options. Inoltre, nei casi in cui più importatori possono gestire un file, è possibile specificare custom_importer per forzarne uno specifico. Questa funzione effettua un'importazione di risorse e restituisce immediatamente un codice di successo o di errore. generator_parameters definisce ulteriori metadati facoltativi che verranno memorizzati come generator_parameters nella sezione remap del file .import, ad esempio per archiviare un hash md5 dei dati di origine.