EditorFileSystemImportFormatSupportQuery in Godot – Complete Guide

Welcome to our detailed exploration of the EditorFileSystemImportFormatSupportQuery class in Godot 4, the latest iteration of the beloved open-source game engine. Diving into this niche yet crucial aspect of Godot gives us an understanding of how the engine handles asset importing—a foundational aspect of game development. By conquering this topic, you’ll equip yourself with the knowledge to wield Godot’s importing functionality like a pro, opening new avenues for creativity and efficiency in your game development journey.

What is EditorFileSystemImportFormatSupportQuery?

The EditorFileSystemImportFormatSupportQuery class provides a streamlined way for Godot users to interact with the import system of the engine. It serves as a bridge between the developers and the underlying import mechanisms, allowing for a more intuitive and controlled asset importing process.

What is it for?

This class comes into play when using custom or plugin-based asset importers. It’s particularly useful for querying which file extensions are supported by a given importer and whether said importer is actively available for use within Godot. This becomes essential when dealing with a wide array of asset types and sources.

Why Should I Learn It?

Having a firm grasp of the EditorFileSystemImportFormatSupportQuery class is critical for anyone looking to enhance their Godot experience, specifically when creating custom import plugins or utilizing third-party ones. It’s a key component of asset management and can make the difference between a smooth development ride and a bumpy one fraught with import issues. Plus, learning such advanced tools can significantly bolster your problem-solving skills and make you a more versatile game developer.

CTA Small Image

Getting Started with EditorFileSystemImportFormatSupportQuery

In this section, we’ll start exploring practical applications of the EditorFileSystemImportFormatSupportQuery class. Before proceeding, ensure you have a Godot 4 project setup and are ready to handle custom import functionality.

First things first, let’s see how we can instantiate an object of the EditorFileSystemImportFormatSupportQuery class. This would typically be done within an editor plugin script or a custom import script.

var import_query = EditorFileSystemImportFormatSupportQuery.new()

With our query object ready, we can begin querying the support status of different file formats. This can be used to check if a certain file extension is supported by any importer before attempting to import a file.

var is_extension_supported = import_query.is_extension_supported("png")
print("Is PNG supported: " + str(is_extension_supported))

Checking Importer Availability

Once you’ve identified the file extensions, you may also want to know if a specific importer is available to handle an extension. This can be particularly crucial when working with various import plugins.

In this example, we will check if the importer identified by the unique importer name is available.

var importer_name = "my_custom_importer"
var is_importer_available = import_query.is_importer_available(importer_name)
print("Is my custom importer available: " + str(is_importer_available))

Querying Details of a Specific Importer

Suppose you want to gather more information about what an importer can handle. The query class allows you to retrieve the list of extensions supported by a particular importer:

var supported_extensions = import_query.get_importer_supported_extensions(importer_name)
for extension in supported_extensions:
    print("Supported extension: " + extension)

Checking Importer Support Level

In certain scenarios, importers may offer different levels of support for a file extension. You can precisely identify the level of support an importer has for a certain extension using the EditorFileSystemImportFormatSupportQuery class:

var support_level = import_query.get_importer_support_level_for_extension(importer_name, "ogg")
print("Support level for OGG: " + str(support_level))

This method returns an enum representing the level of support which could be one of the following: `SUPPORT_ACTIVE`, `SUPPORT_DISABLED` or `SUPPORT_HIDDEN`. Understanding this feedback from the method can help you manage your importers effectively, especially when handling assets that could be interpreted by multiple plugins.Managing assets and understanding the intricacies of file importation is a pillar of efficient game development. We’ll now delve deeper into several code examples illustrating the usage of the EditorFileSystemImportFormatSupportQuery class, where you’ll learn to tailor the import process to your needs, ensuring assets are imported accurately and effectively within Godot 4.

Let’s discuss how you can use the functionality to list all available importers for a file extension. By doing this, you can adapt to situations where multiple importers might handle the same file type, allowing you to select the most appropriate one for your asset.

var extension = "obj"
var importers_for_extension = import_query.get_importers_for_extension(extension)
print("Importers for ." + extension + ": " + str(importers_for_extension))

Additionally, you might want to determine the best importer for a given task. By evaluating the support level, you can automate the selection process for importing various assets. Let’s implement a method to find the best available importer for an extension:

func get_best_importer_for_extension(extension):
    var best_importer_name = ""
    var highest_support_level = EditorFileSystemImportFormatSupportQuery.SUPPORT_NONE
    var available_importers = import_query.get_importers_for_extension(extension)
    for importer_name in available_importers:
        var support_level = import_query.get_importer_support_level_for_extension(importer_name, extension)
        if support_level > highest_support_level:
            highest_support_level = support_level
            best_importer_name = importer_name
    return best_importer_name

var best_importer = get_best_importer_for_extension("fbx")
print("Best importer for FBX: " + best_importer)

In certain cases, you might find yourself creating or modifying importers within Godot. Using our query class, you can verify that your custom importer has been successfully registered and is ready to handle specific file types as intended.

var custom_importer_registered = import_query.is_importer_registered("my_custom_importer")
print("Is my custom importer registered: " + str(custom_importer_registered))

Sometimes, working with importers involves more than just checking support levels; you may need to actually invoke the import process. While the EditorFileSystemImportFormatSupportQuery does not directly import assets, it can be used in tandem with other classes to achieve this.

For instance, you can combine it with EditorPlugin to invoke the import of an asset like so:

# Assuming 'best_importer' is the importer we've determined as best suited for the task
var plugin = EditorPlugin.new()
var import_path = "res://assets/models/my_model.fbx"
plugin.import_resource(import_path, best_importer)

Remember, while these examples illustrate the capabilities of the EditorFileSystemImportFormatSupportQuery, Godot’s import system is quite elaborate. You’ll often need to interact with multiple classes and mechanisms to fully manage the importation process in practice.

By getting comfortable with these advanced tools, you are refining your skill set and ensuring that when it comes to handling assets, nothing will slow you down in the fast-paced world of game development. Whether it’s writing custom importers or leveraging existing ones, this knowledge is invaluable in shaping a seamless and powerful Godot 4 experience.Nurturing your understanding of the EditorFileSystemImportFormatSupportQuery class, let’s extend our grasp further with practical code examples that build upon the strong foundation we’ve set.

Imagine a scenario where you have different variations of importers for textures. You want to enable or disable certain importers based on a condition. For example, perhaps when working in a debug mode, you want to use a different importer that provides verbose logging. Here’s how you might toggle the active state of an importer:

var debug_mode = true
var debug_importer_name = "my_debug_texture_importer"
var normal_importer_name = "my_normal_texture_importer"
var supported_extensions = ["png", "jpg", "bmp"]

# Enable the debug importer and disable the normal one in debug mode
for extension in supported_extensions:
    if debug_mode:
        if import_query.is_importer_registered(debug_importer_name):
            import_query.set_importer_active_for_extension(debug_importer_name, extension, true)
        if import_query.is_importer_registered(normal_importer_name):
            import_query.set_importer_active_for_extension(normal_importer_name, extension, false)
    # And vice versa for normal mode
        if import_query.is_importer_registered(debug_importer_name):
            import_query.set_importer_active_for_extension(debug_importer_name, extension, false)
        if import_query.is_importer_registered(normal_importer_name):
            import_query.set_importer_active_for_extension(normal_importer_name, extension, true)

When addressed methodically, the process of identifying the correct file format for an asset is simplified. Godot’s robust import system allows you to examine the format of a file before deciding on the appropriate action. Here’s an example of how to check a file’s type then print out relevant importers for its format:

var file_path = "res://assets/textures/terrain.png"
var file_extension = file_path.get_extension()

var relevant_importers = import_query.get_importers_for_extension(file_extension)
print("Relevant importers for ." + file_extension + ": " + str(relevant_importers))

Often, asset management necessitates not just identifying but also remembering the best import settings for different types of assets. This is particularly useful for teams that need to maintain consistency across their projects. Below is an example of how this might be coded:

var asset_type_settings = {
    "png": "my_png_importer",
    "wav": "my_wav_importer",
    "ttf": "my_font_importer"

# Later on in your code when you’re about to import assets:
for asset in asset_to_import_list:
    var ext = asset.get_extension()
    var importer_name = asset_type_settings.get(ext, "")
    if importer_name != "" and import_query.is_importer_available(importer_name):
        # Proceed with importing using the specified importer
        # ...

In an advanced scenario, you might need to initiate a re-import of assets after adjusting importer settings or after adding new importers to your project. To trigger a re-import for a specific file, Godot provides functionality through the EditorFileSystem class. Here’s a snippet that initiates a re-import:

var file_to_reimport = "res://assets/models/updated_model.fbx"

More often than not, you’ll be collaborating with other developers, and it’s vital to have a way to convey the support status of different importers. Here, we create a simple function that lists all registered importers along with their support status:

func print_all_importers_status():
    var all_importers = import_query.get_recognized_importers()
    for importer in all_importers:
        var status = "Unknown"
        if import_query.is_importer_active(importer):
            status = "Active"
        elif import_query.is_importer_disabled(importer):
            status = "Disabled"
            status = "Not Registered"
        print("Importer: %s, Status: %s" % [importer, status])


Leveraging the above examples, you can see how the EditorFileSystemImportFormatSupportQuery bridges the gap between your creative ambitions and Godot’s technical capabilities. By mastering these strategies, you arm yourself with the agility to navigate and optimize your projects’ import workflows, ensuring that assets are not only imported correctly but with finesse and precision befitting a professional game development environment.

Furthering Your Godot Mastery

As we wrap up this tutorial on the EditorFileSystemImportFormatSupportQuery class in Godot 4, remember that this is just a stepping stone in your larger journey as a game developer. To continue strengthening your skills and expanding your knowledge, consider exploring our Godot Game Development Mini-Degree, a comprehensive program tailored to guide you through building cross-platform games using the powerful Godot 4 engine. Whether you’re just starting out or looking to deepen your expertise, this Mini-Degree has something for you.

Our curriculum is designed to cover the essentials of game development, from 2D and 3D assets to GDScript, UI systems, and creating engaging game mechanics. Through hands-on projects, you can graduate from basic interactive projects to advanced games in genres including RPGs, RTS games, and platformers. With 24/7 access and self-paced learning, you have the flexibility to learn at your convenience, all while building a portfolio of real Godot projects. And when you’ve mastered the content of the Mini-Degree, don’t forget to check out our broad collection of Godot courses to continue your learning journey.

In both our Godot Game Development Mini-Degree and individual courses, our mission at Zenva is to equip you with the tools and knowledge to take your game development career to the next level. So take the next step, embrace the learning curve, and start creating the games you’ve always dreamed of with the skills that will set you apart in the game development industry.


In your journey through the intricacies of Godot 4’s EditorFileSystemImportFormatSupportQuery class, you’ve gained insights that are crucial for managing assets effectively—an essential skill for any serious game developer. With this knowledge, you’re better equipped to harness the full potential of this powerful game engine. By taking the complexities of asset importing in stride, you set the stage for a more streamlined, creative, and enjoyable game development process.

Your passion and determination to excel in game development are what drive us at Zenva to create the learning experiences that will propel you forward. The road to mastery is an ongoing adventure, and we’re here to support you every step of the way. Come and join us through our Godot Game Development Mini-Degree, and continue to translate your visions into immersive virtual experiences. Together, let’s redefine the landscape of indie game development and bring your unique stories to life.

Python Blog Image

FINAL DAYS: Unlock coding courses in Unity, Godot, Unreal, Python and more.