Spatial gizmo plugins

Introduction

Spatial gizmo plugins are used by the editor and custom plugins to define the gizmos attached to any kind of Spatial node.

This tutorial will show you the two main approaches to defining your own custom gizmos. The first option works well for simple gizmos and creates less clutter in your plugin structure, while the second one will let you store some per-gizmo data.

Note

This tutorial assumes you already know how to make generic plugins. If in doubt, refer to the Making plugins page.

The EditorSpatialGizmoPlugin

Regardless of the approach we choose, we will need to create a new EditorSpatialGizmoPlugin. This will allow us to set a name for the new gizmo type and define other behaviors such as whether the gizmo can be hidden or not.

This would be a basic setup:

  1. # MyCustomGizmoPlugin.gd
  3. extends EditorSpatialGizmoPlugin
  5. func get_name():
  6.     return "CustomNode"
  1. # MyCustomEditorPlugin.gd
  3. tool
  4. extends EditorPlugin
  6. const MyCustomGizmoPlugin = preload("res://addons/my-addon/MyCustomGizmoPlugin.gd")
  8. var gizmo_plugin = MyCustomGizmoPlugin.new()
  10. func _enter_tree():
  11.     add_spatial_gizmo_plugin(gizmo_plugin)
  13. func _exit_tree():
  14.     remove_spatial_gizmo_plugin(gizmo_plugin)

For simple gizmos, just inheriting EditorSpatialGizmoPlugin is enough. If you want to store some per-gizmo data or you are porting a Godot 3.0 gizmo to 3.1+, you should go with the second approach.

Simple approach

The first step is to, in our custom gizmo plugin, override the has_gizmo() method so that it returns true when the spatial parameter is of our target type.

  1. # ...
  3. func has_gizmo(spatial):
  4.     return spatial is MyCustomSpatial
  5. # ...

Then we can override methods like redraw() or all the handle related ones.

  1. # ...
  3. func _init():
  4.     create_material("main", Color(1, 0, 0))
  5.     create_handles_material("handles")
  7. func redraw(gizmo):
  8.     gizmo.clear()
  10.     var spatial = gizmo.get_spatial_node()
  12.     var lines = PoolVector3Array()
  14.     lines.push_back(Vector3(0, 1, 0))
  15.     lines.push_back(Vector3(0, spatial.my_custom_value, 0))
  17.     var handles = PoolVector3Array()
  19.     handles.push_back(Vector3(0, 1, 0))
  20.     handles.push_back(Vector3(0, spatial.my_custom_value, 0))
  22.     gizmo.add_lines(lines, get_material("main", gizmo), false)
  23.     gizmo.add_handles(handles, get_material("handles", gizmo))
  25. # ...

Note that we created a material in the _init method, and retrieved it in the redraw method using get_material(). This method retrieves one of the material’s variants depending on the state of the gizmo (selected and/or editable).

So the final plugin would look somewhat like this:

  1. extends EditorSpatialGizmoPlugin
  3. const MyCustomSpatial = preload("res://addons/my-addon/MyCustomSpatial.gd")
  5. func _init():
  6.     create_material("main", Color(1,0,0))
  7.     create_handles_material("handles")
  9. func has_gizmo(spatial):
  10.     return spatial is MyCustomSpatial
  12. func redraw(gizmo):
  13.     gizmo.clear()
  15.     var spatial = gizmo.get_spatial_node()
  17.     var lines = PoolVector3Array()
  19.     lines.push_back(Vector3(0, 1, 0))
  20.     lines.push_back(Vector3(0, spatial.my_custom_value, 0))
  22.     var handles = PoolVector3Array()
  24.     handles.push_back(Vector3(0, 1, 0))
  25.     handles.push_back(Vector3(0, spatial.my_custom_value, 0))
  27.     gizmo.add_lines(lines, get_material("main", gizmo), false)
  28.     gizmo.add_handles(handles, get_material("handles", gizmo))
  30. # you should implement the rest of handle-related callbacks
  31. # (get_handle_name(), get_handle_value(), commit_handle()...)

Note that we just added some handles in the redraw method, but we still need to implement the rest of handle-related callbacks in EditorSpatialGizmoPlugin to get properly working handles.

Alternative approach

In some cases we want to provide our own implementation of EditorSpatialGizmo, maybe because we want to have some state stored in each gizmo or because we are porting an old gizmo plugin and we don’t want to go through the rewriting process.

In these cases all we need to do is, in our new gizmo plugin, override create_gizmo(), so it returns our custom gizmo implementation for the Spatial nodes we want to target.

  1. # MyCustomGizmoPlugin.gd
  2. extends EditorSpatialGizmoPlugin
  4. const MyCustomSpatial = preload("res://addons/my-addon/MyCustomSpatial.gd")
  5. const MyCustomGizmo = preload("res://addons/my-addon/MyCustomGizmo.gd")
  7. func _init():
  8.     create_material("main", Color(1, 0, 0))
  9.     create_handles_material("handles")
  11. func create_gizmo(spatial):
  12.     if spatial is MyCustomSpatial:
  13.         return MyCustomGizmo.new()
  14.     else:
  15.         return null

This way all the gizmo logic and drawing methods can be implemented in a new clas extending EditorSpatialGizmo, like so:

  1. # MyCustomGizmo.gd
  3. extends EditorSpatialGizmo
  5. # You can store data in the gizmo itself (more useful when working with handles)
  6. var gizmo_size = 3.0
  8. func redraw():
  9.     clear()
  11.     var spatial = get_spatial_node()
  13.     var lines = PoolVector3Array()
  15.     lines.push_back(Vector3(0, 1, 0))
  16.     lines.push_back(Vector3(gizmo_size, spatial.my_custom_value, 0))
  18.     var handles = PoolVector3Array()
  20.     handles.push_back(Vector3(0, 1, 0))
  21.     handles.push_back(Vector3(gizmo_size, spatial.my_custom_value, 0))
  23.     var material = get_plugin().get_material("main", self)
  24.     add_lines(lines, material, false)
  26.     var handles_material = get_plugin().get_material("handles", self)
  27.     add_handles(handles, handles_material)
  29. # you should implement the rest of handle-related callbacks
  30. # (get_handle_name(), get_handle_value(), commit_handle()...)

Note that we just added some handles in the redraw method, but we still need to implement the rest of handle-related callbacks in EditorSpatialGizmo to get properly working handles.