Simplified alternative to if Engine.is_editor_hint()

[NaleVex]

How it works now

At this time to use utility features for visual debugging of different stuff right in GD editor we may use bundle of @tool annotation with statement Engine.is_editor_hint()

The problem

When we work with script implementing some game mechanics and at some moment find needy to visualize something in editor we need to use @tool annotation in that script. Now we got an issue that whole script starts "working" in editor, while we need to see in action only one or couple of special features. To make our main script not work in editor we need to wrap mostly whole script in if not Engine.is_editor_hint(): function. This is not what we want especially when we already have a lot of code because not only it'll make it cluttered with excessive indents. But we want only to test and debug something fast, not rewrite everything just for that.

Solution

Adding special function like _macro, for example, for code that we want to run in editor.
Something like that:

func _process(delta):
	#this part works only when running the game
        position.x += delta * speed
        
#this part works only in editor

func _macro(delta): 
	rotation.x += delta
#since we cannot get delta from _process, _macro provides it's own in editor delta time

This way we can implement in editor features to work with current node.
I guess this also need to have annotation so editor should understand that there may be _macro functions inside this script, so we simply add @macro at the beginning instead of @tool.
Of course this is just example, but I hope you understand the idea.

[Zireael07]

How is your opaque macro better than is_editor_hint()?

[NaleVex]

The code that should work only when game is running shouldn't be wrapped in if not Engine.is_editor_hint(): meaning that you don't need to do these changes in whole code if want just to add some temporary debugging in editor viewed script.

[Zireael07]

If I want to do some temp debugging I do if Engine.is_editor_hint():
debugging here - it's often two or three lines.

It's not quite "whole code" (and I'm someone who uses tool scripts A LOT)

[theraot]

OK, here is a variation of the idea: We could have _tool_ready() and _tool_process(delta). Then have _ready(), _process() do not run in the editor, but _tool_ready, _tool_process run in the editor instead. And we keep using @tool, no new annotation.

[kubecz3k]

We had a good discussion about this in godotengine/godot#8735 with some really good proposals in there, especially: godotengine/godot#8735 (comment)

[dalexeev]

• See also: Preprocess scripts on export to take constant feature tags into account #4234 (in the comments there are links to old proposals about conditional compilation).

[InkONat]

I personally think that

@macro(process) # could be ready, init, notification, etc
func macro_process_example(delta):
    ...

is a better option, since it allows for any function to be called inside the editor and also whenever you want (process would be in every frame, ready would be when the node is done, etc.)
I don't know what should happen if something like @macro(process) func _process(delta) is ran, though. Maybe it could run like a normal macro process function, "overshadowing" the base _process function