Allow writing resource.ext instead of preload("res://path/to/resource.ext")

[mieldepoche]

PROBLEM:
Strinlgy referencing (such as in preloading) resources in scripts has a big drawback: moving the file, renaming it or renaming any of its parent folders breaks the link and it has to be updated sometimes in several scripts.

SOLUTION:
But we know that at project export, res:// is set and will remain unchanged.
That means that file paths can at least be resolved at export time!

So consider the following code:

$Heart.texture = preload("res://player/gfx/heart_full.png")
var bullet := preload("res://weapons/Bullet.tscn").instantiate()
const MyScript := preload("res://MyScript.gd")
var object: MyScript

I'm proposing that instead we're allowed to write:

$Heart.texture = heart_full.png
var bullet := Bullet.tscn.instantiate() # ugly?
var object: MyScript.gd # why do we need named classes again?

And it will be turned into the first example at export time.

• Solves the moving the files part, but not the renaming one (unless of course scripts are automagically updated on resource rename)
• control-clicking opens the scene, script or selects the resource in the inspector
• cool too if you could benefit from autocompletion
• if there's a space in filename: could use a fake function (replaced by result at compile time): preload(res("filename.ext")) -> preload("res://path/filename.ext"). I like the idea of such a function with a short name (like tr) but it could also be respath.
• if there's several resources with the same name, you could use parent folder: player/Head.gd, preload(res("Enemy B/eye.png"))

This is actually two ideas in one:

1. The automatic resource path resolution,
2. and the automatic preloading.
3. the bonus idea: it requires a GDScript preprocessor?

Also/Alternatively automatic resource path resolution could be provided in the form of a specific notation much like $ can precede an unquoted node path, we could have a character or special quote too like res:"resource.ext" or res/resource.ext or something.

[xix-xeaon]

This would just be messy. You can use relative paths like preload("resource.ext") to load a resource from the same folder, including folder traversal like preload("../assets/resource.ext") to go up one folder and then down into the assets-folder to get your resource.

I do however think that preload-statements could be updated automatically when moving things, just like it works when moving resources referenced in scenes.

[mieldepoche]

In fact, I think you're right.
My proposal is just a complex solution (+ unnecessary bits) to this problem of automatic path update which already has a proposal: #531.

[Calinou]

PROBLEM:
Strinlgy referencing (such as in preloading) resources in scripts has a big drawback: moving the file, renaming it or renaming any of its parent folders breaks the link and it has to be updated sometimes in several scripts.

Consider using the ResourcePreloader node (added in Godot 3.1) and moving files using the FileSystem dock. It was designed specifically to address this problem 🙂

[Zireael07]

This needs more docs/visibility - I literally didn't know it existed even though I've been using Godot nearly every day for like 1,5 year or so...

[mieldepoche]

I had forgotten about that node, It may fit my needs partially.
However it has drawbacks too:

1. it adds a layer of code complexity (need to get the node) whereas preload can't get more simple
2. you don't get warnings in the editor when referencing non-existing resources in code with ResourcePreloader.get_resource("invalid name")
3. you need a Node parent, so can't use it directly in Object or RefCounted scripts.
4. No get_resource param autocompletion like in AnimationPlayer.play
5. unusable if I need to preload things into constants, for cases where the constant was used as a static class member
6. you lose the static-typing preload provided (can't var xx := my_preloader.get_resource("..."))
7. also, changing the name of the resource in the preloader will break the reference in scripts getting this resource

So rename safety basically comes at the cost of... usability.
I feel this node's actual main benefit is being able to use a variable path in a preload: my_preloader.get_resource("map_%d_%d" % [...])

[azur-wolve]

What about have an in-editor table of "aliases", similar to an autoload/singleton, but built-in in the editor.
You would update paths there, and aliases get updated. (more accessible that do it yourself by using string collections stored somewhere).

Then if it needs to be used at run-time either on debug mode or for exported projects, the compiler replaces the aliases with the actual paths.
Or even better, give the option the keep the aliases to modify paths at run-time or whatever application it could have.

If in-editor you only would be able to select a certain file, and let the path get updated automatically on re-ubication, would be great.