Documentation
¶
Overview ¶
Godot loads resources in the editor or in exported games using ResourceFormatLoaders. They are queried automatically via the ResourceLoader singleton, or when a resource with internal dependencies is loaded. Each file type may load as a different resource type, so multiple ResourceFormatLoaders are registered in the engine.
Extending this class allows you to define your own loader. Be sure to respect the documented return types and values. You should give it a global class name with class_name for it to be registered. Like built-in ResourceFormatLoaders, it will be called automatically when loading resources of its handled type(s). You may also implement a ResourceFormatSaver.
Note: You can also extend EditorImportPlugin if the resource type you need exists but Godot is unable to load its format. Choosing one way over another depends on if the format is suitable or not for the final exported game. For example, it's better to import .png textures as .ctex (CompressedTexture2D) first, so they can be loaded with better efficiency on the graphics card.
Index ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type Advanced ¶
type Advanced = class
Advanced exposes a 1:1 low-level instance of the class, undocumented, for those who know what they are doing.
type CacheMode ¶
type CacheMode int //gd:ResourceFormatLoader.CacheMode
const ( // Neither the main resource (the one requested to be loaded) nor any of its subresources are retrieved from cache nor stored into it. Dependencies (external resources) are loaded with [CacheModeReuse]. CacheModeIgnore CacheMode = 0 // The main resource (the one requested to be loaded), its subresources, and its dependencies (external resources) are retrieved from cache if present, instead of loaded. Those not cached are loaded and then stored into the cache. The same rules are propagated recursively down the tree of dependencies (external resources). CacheModeReuse CacheMode = 1 // Like [CacheModeReuse], but the cache is checked for the main resource (the one requested to be loaded) as well as for each of its subresources. Those already in the cache, as long as the loaded and cached types match, have their data refreshed from storage into the already existing instances. Otherwise, they are recreated as completely new objects. CacheModeReplace CacheMode = 2 // Like [CacheModeIgnore], but propagated recursively down the tree of dependencies (external resources). CacheModeIgnoreDeep CacheMode = 3 // Like [CacheModeReplace], but propagated recursively down the tree of dependencies (external resources). CacheModeReplaceDeep CacheMode = 4 )
type Extension ¶
Extension can be embedded in a new struct to create an extension of this class. T should be the type that is embedding this [Extension]See Interface for methods that can be overridden by T.
func (*Extension[T]) AsRefCounted ¶
func (self *Extension[T]) AsRefCounted() [1]gd.RefCounted
func (*Extension[T]) AsResourceFormatLoader ¶
type ID ¶
ID is a typed object ID (reference) to an instance of this class, use it to store references to objects with unknown lifetimes, as an ID will not panic on use if the underlying object has been destroyed.
type Implementation ¶
type Implementation = implementation
Implementation implements Interface with empty methods.
type Instance ¶
type Instance [1]gdclass.ResourceFormatLoader
Instance of the class with convieniently typed arguments and results.
var Nil Instance
Nil is a nil/null instance of the class. Equivalent to the zero value.
func (Instance) AsRefCounted ¶
func (self Instance) AsRefCounted() [1]gd.RefCounted
func (Instance) AsResourceFormatLoader ¶
type Interface ¶
type Interface interface {
// Gets the list of extensions for files this loader is able to read.
GetRecognizedExtensions() []string
// Tells whether or not this loader should load a resource from its resource path for a given type.
//
// If it is not implemented, the default behavior returns whether the path's extension is within the ones provided by [GetRecognizedExtensions], and if the type is within the ones provided by [GetResourceType].
//
// [GetRecognizedExtensions]: https://pkg.go.dev/graphics.gd/classdb/ResourceFormatLoader#Interface
// [GetResourceType]: https://pkg.go.dev/graphics.gd/classdb/ResourceFormatLoader#Interface
RecognizePath(path string, atype string) bool
// Tells which resource class this loader can load.
//
// Note: Custom resource types defined by scripts aren't known by the [ClassDB], so you might just handle "Resource" for them.
//
// [ClassDB]: https://pkg.go.dev/graphics.gd/classdb/ClassDB
HandlesType(atype string) bool
// Gets the class name of the resource associated with the given path. If the loader cannot handle it, it should return "".
//
// Note: Custom resource types defined by scripts aren't known by the [ClassDB], so you might just return "Resource" for them.
//
// [ClassDB]: https://pkg.go.dev/graphics.gd/classdb/ClassDB
GetResourceType(path string) string
// Returns the script class name associated with the [Resource] under the given 'path'. If the resource has no script or the script isn't a named class, it should return "".
//
// [Resource]: https://pkg.go.dev/graphics.gd/classdb/Resource
GetResourceScriptClass(path string) string
// Should return the unique ID for the resource associated with the given path. If this method is not overridden, a .uid file is generated along with the resource file, containing the unique ID.
GetResourceUid(path string) int
// Should return the dependencies for the resource at the given 'path'. Each dependency is a string composed of one to three sections separated by ::, with trailing empty sections omitted:
//
// - The first section should contain the UID if the resource has one. Otherwise, it should contain the file path.
//
// - The second section should contain the class name of the dependency if 'add_types' is true. Otherwise, it should be empty.
//
// - The third section should contain the fallback path if the resource has a UID. Otherwise, it should be empty.
//
//
//
// func _get_dependencies(path, add_types):
//
// return [
//
// "uid://fqgvuwrkuixh::Script::res://script.gd",
//
// "uid://fqgvuwrkuixh::::res://script.gd",
//
// "res://script.gd::Script",
//
// "res://script.gd",
//
// ]
//
//
//
// Note: Custom resource types defined by scripts aren't known by the [ClassDB], so "Resource" can be used for the class name.
//
// [ClassDB]: https://pkg.go.dev/graphics.gd/classdb/ClassDB
GetDependencies(path string, add_types bool) []string
// If implemented, renames dependencies within the given resource and saves it. 'renames' is a dictionary { String => String } mapping old dependency paths to new paths.
//
// Returns [Ok] on success, or an [Error] constant in case of failure.
RenameDependencies(path string, renames map[string]string) error
Exists(path string) bool
GetClassesUsed(path string) []string
// Loads a resource when the engine finds this loader to be compatible. If the loaded resource is the result of an import, 'original_path' will target the source file. Returns a [Resource] object on success, or an [Error] constant in case of failure.
//
// The 'cache_mode' property defines whether and how the cache should be used or updated when loading the resource. See [CacheMode] for details.
//
// [Resource]: https://pkg.go.dev/graphics.gd/classdb/Resource
Load(path string, original_path string, use_sub_threads bool, cache_mode int) any
}
Source Files