EditorSpinSlider in Godot – Complete Guide

Navigating the world of game development can often be as thrilling as playing the games themselves, particularly when you have the right tools at your disposal. Today, we’re delving into the Godot Engine, a powerful open source tool for game developers. Specifically, we’re focusing on the EditorSpinSlider class in Godot 4, a component that every Godot developer should master for editing numeric values in the editor’s Inspector dock. Whether you are a beginner just starting out, or an experienced developer looking to polish your skills, understanding EditorSpinSlider will enhance the way you work with numerical input in the Godot editor.

What is EditorSpinSlider?

In Godot Engine, the EditorSpinSlider class is a specialized Control node that facilitates the editing of numeric values within the editor’s interface. It is tailored for use in the Inspector dock, a panel where developers can tweak the properties of various game elements and configurations. The EditorSpinSlider offers a streamlined and interactive way to input and adjust these values, enhancing the user experience and development efficiency.

What is it for?

The primary purpose of the EditorSpinSlider is to offer a convenient GUI component for editing numerical data. Game development often involves tweaking numbers for positions, sizes, physics properties, and more. The EditorSpinSlider gives developers the ability to do this through both a text input and a sliding mechanism, which can be a huge time-saver.

Why Should I Learn It?

Understanding the EditorSpinSlider is crucial for any Godot developer because:

– It enables rapid adjustments to properties, helping streamline the development process.
– It is a frequent element in custom Godot tools and plugins, so mastery of this class is very beneficial.
– It showcases the power of Godot’s extendable editor, as you can use EditorSpinSlider to enhance the editor for your own needs or plugins.

Learning how EditorSpinSlider works and how to implement it effectively in your projects can save you time and effort. It’s a small yet important part of the Godot Editor that can make a big difference in your development workflow.

CTA Small Image

Creating an EditorSpinSlider in Godot 4

To begin using an EditorSpinSlider, you need to create one within the Godot Editor. Here’s a simple example of how to add an EditorSpinSlider to your editor plugin or custom tool script:

extends EditorPlugin

func _enter_tree():
    var spin_slider = EditorSpinSlider.new()
    add_control_to_container(EditorInterface.CONTAINER_PROPERTY_EDITOR_BOTTOM, spin_slider)
    spin_slider.connect("value_changed", self, "_on_spin_slider_value_changed")

func _on_spin_slider_value_changed(value):
    print("The new value is: ", value)

In this snippet, we’re creating a new instance of EditorSpinSlider and adding it to the bottom of the property editor. We also connect the `value_changed` signal to a callback function that will print out the new value whenever it’s changed.

Configuring the EditorSpinSlider Range and Step

Once you have an EditorSpinSlider, you’ll likely want to configure its range – the minimum and maximum values – as well as the step, which defines the granularity of changes to the value. Here’s how you can set these parameters:

func _enter_tree():
    var spin_slider = EditorSpinSlider.new()
    add_control_to_container(EditorInterface.CONTAINER_PROPERTY_EDITOR_BOTTOM, spin_slider)
    spin_slider.connect("value_changed", self, "_on_spin_slider_value_changed")

    # Set the range of the spin slider

In the above code, we set the minimum value of the EditorSpinSlider to 0, the maximum to 100, and the step to 0.1. This means the slider can handle values between 0 and 100, changing in increments of 0.1.

Customizing the EditorSpinSlider Appearance

Customization can make your EditorSpinSlider fit better within your editor interface. Here’s an example of how you can change the appearance of your spin slider:

func _enter_tree():
    var spin_slider = EditorSpinSlider.new()
    add_control_to_container(EditorInterface.CONTAINER_PROPERTY_EDITOR_BOTTOM, spin_slider)

    # Customizing the appearance
    spin_slider.set_flat(false)  # Gives the 3D bezel effect if true
    spin_slider.set_hide_slider(false)  # Hides the slider thumbs if true

The `set_flat()` method can be used to give your EditorSpinSlider a 3D bezel effect, whereas the `set_hide_slider()` method can be utilised to hide the slider thumb, only showing the numerical input if desired.

Using EditorSpinSlider to Control Node Properties

The real power of EditorSpinSlider comes to light when you use it to control properties of nodes in your scene. Here’s how you can tie the value of an EditorSpinSlider to, for example, the scale of a Sprite node:

func _enter_tree():
    var spin_slider = EditorSpinSlider.new()
    add_control_to_container(EditorInterface.CONTAINER_PROPERTY_EDITOR_BOTTOM, spin_slider)
    spin_slider.connect("value_changed", self, "_on_spin_slider_value_changed")

    # Assume you have a Sprite node in the scene
    var sprite = get_node("Sprite")

    # Connect the spin slider value to the sprite scale
    spin_slider.connect("value_changed", sprite, "set_scale")

Now, whenever you change the value on the spin slider, the sprite’s scale will change accordingly in the editor, providing immediate visual feedback for your adjustments.

Remember, as you explore the potential of EditorSpinSlider within your Godot projects, you may encounter various other features and methods specific to your individual needs. The key is to experiment and find the most efficient and intuitive ways to integrate this tool into your workflow.Utilizing EditorSpinSlider is not just about changing properties on the fly; it’s also about getting precise and convenient controls for your custom editor tools. This next section will guide you through additional code examples to give you a comprehensive insight into leveraging EditorSpinSlider within your own Godot 4 projects.

Defining Custom Step Values

Sometimes, you need more nuanced control over the step values. EditorSpinSlider allows you to set custom step increments which can be very helpful for various design needs.

spin_slider.set_step(5) # Changes in increments of 5
spin_slider.set_page(10) # Changes in larger jumps of 10 when page up or page down are used

This makes the slider more versatile, allowing for rapid changes with page up/page down keys, alongside finer adjustments with the default slider movement or arrow keys.

Linking EditorSpinSlider to a Custom Inspector

When building editor plugins, you may want to have the EditorSpinSlider interact with a custom inspector. The following example outlines how to update a property in a custom inspector and ensure the spin slider reflects the current state of that property.

var my_custom_inspector : CustomInspector
var my_spin_slider : EditorSpinSlider = EditorSpinSlider.new()

func _ready():
    my_custom_inspector = get_node("CustomInspector")
    add_control_to_container(EditorInterface.CONTAINER_PROPERTY_EDITOR_BOTTOM, my_spin_slider)
    my_spin_slider.connect("value_changed", this, "_on_spin_slider_value_changed")

func _on_spin_slider_value_changed(value):
    my_custom_inspector.update_property("my_property", value)

In this code, anytime the value of the spin slider is changed, the `update_property` function of your custom inspector is called, and the view is refreshed to reflect this change.

Responding to User Input

The user’s experience can be enhanced by providing immediate feedback as they adjust values with the EditorSpinSlider. For example, you could update text or other scene elements in real-time in response to changes.

func _enter_tree():
    var text_label = get_node("Label")
    func _on_spin_slider_value_changed(value):
        text_label.text = "Value: %s" % value

This snippet updates a label in the editor with the current value of the EditorSpinSlider whenever it changes, giving immediate feedback to the user.

Clamping Values

You may also want to clamp the values within a certain range beyond the built-in min and max. Although EditorSpinSlider has its own range, sometimes programmatic constraints are needed.

func _on_spin_slider_value_changed(value):
    value = clamp(value, 20, 80) # Ensure value remains between 20 and 80
    enacting_node.set_property("some_property", value)

With this code, even if the spin slider’s range exceeds 20 to 80, the value set on the target property will be clamped within this range.

Integrating Undo/Redo

Integrating with the editor’s undo and redo functionality can greatly improve the user experience, making it easy to reverse changes or restore them. Godot’s editor has built-in support for undo/redo which can work in tandem with EditorSpinSlider.

func _on_spin_slider_value_changed(value):
    var action = UndoRedo.Action.new()
    action.set_do_method(self, "set_some_property", value)
    action.set_undo_method(self, "set_some_property", previous_value)
    get_undo_redo().add_action("Change Some Property", action)
    previous_value = value

Here, each change to the slider’s value is encapsulated in an undo/redo action, allowing developers to track changes and revert them if necessary.

Remember that these are just a few ways to utilize EditorSpinSlider in Godot 4. Godot’s flexibility and the power of GDScript mean that there are near endless possibilities for customizing and controlling your development environment with tools like EditorSpinSlider. As you grow more familiar with its functionality and integrate it into more complex tools, you’ll unlock an ever-increasing potential for rapid and intuitive game development, enhancing your workflow and productivity.Building on our discussion of the EditorSpinSlider in Godot 4, it’s time to delve into even more code examples. Showing its versatility, we’ll look at how to use this Control node in different scenarios that might come up in your game development journey.

**Example 1: Synchronizing EditorSpinSlider With Scene Updates**

You may want to ensure that the EditorSpinSlider not only changes properties but also triggers updates in your game scenes whenever adjustments are made. Here’s how to link slider value changes to a function that refreshes the scene.

func _enter_tree():
    var spin_slider = EditorSpinSlider.new()
    add_control_to_container(EditorInterface.CONTAINER_PROPERTY_EDITOR_BOTTOM, spin_slider)
    spin_slider.connect("value_changed", self, "_on_spin_slider_value_changed")

func _on_spin_slider_value_changed(value):

When the EditorSpinSlider value changes, the `update_scene_properties` method of the current scene is called, passing the new value as a parameter for scene updates.

**Example 2: Adding Undo/Redo With More Context**

Providing more context to your undo/redo actions often makes the process more user-friendly. This example demonstrates how to include a meaningful description for each undo operation.

func _on_spin_slider_value_changed(value):
    var previous_value = editor.get_property('my_property')
    editor.set_property('my_property', value)
    var action_name = "Set 'My Property' to %s" % [value]
    undo_redo.add_do_property(editor, 'my_property', value)
    undo_redo.add_undo_property(editor, 'my_property', previous_value)

Every time the EditorSpinSlider changes the value, an undo/redo action is recorded with a descriptive name that indicates the property and the new value.

**Example 3: Implementing Snap Values**

Sometimes, you want the EditorSpinSlider to adjust in fixed increments or snaps. The following code ensures that the value is always a multiple of the set snap value.

func _enter_tree():
    spin_slider.snap = true

func _on_spin_slider_value_changed(value):
    print("Snapped value is: ", value)

With `snap` set to true and a step of 10, the EditorSpinSlider value will always be a multiple of 10.

**Example 4: Creating a Custom EditorSpinSlider for Vector Properties**

Suppose you require a spinner slider that deals with vector properties, like adjusting the x and y values of a position. This example sets up such a customized EditorSpinSlider.

var spin_slider_x = EditorSpinSlider.new()
var spin_slider_y = EditorSpinSlider.new()

func _enter_tree():
    add_control_to_container(EditorInterface.CONTAINER_PROPERTY_EDITOR_BOTTOM, spin_slider_x)
    add_control_to_container(EditorInterface.CONTAINER_PROPERTY_EDITOR_BOTTOM, spin_slider_y)
    spin_slider_x.connect("value_changed", self, "_on_spin_slider_value_x_changed")
    spin_slider_y.connect("value_changed", self, "_on_spin_slider_value_y_changed")

func _on_spin_slider_value_x_changed(value):
    var position = get_tree().current_scene.get_node("MyNode2D").position
    position.x = value
    # Apply the new position x value

func _on_spin_slider_value_y_changed(value):
    var position = get_tree().current_scene.get_node("MyNode2D").position
    position.y = value
    # Apply the new position y value

By creating two EditorSpinSliders, you can separately adjust the x and y components of a node’s position vector within the Godot editor.

**Example 5: Reflecting Real-Time Property Changes**

A feedback loop where real-time changes are displayed can greatly enhance user interaction. This snippet updates the EditorSpinSlider to reflect real-time changes in a property even if the change didn’t originate from the slider itself.

func _on_some_property_changed(new_value):
    spin_slider.value = new_value

Here, `_on_some_property_changed` is a function that gets called whenever ‘some_property’ changes. The EditorSpinSlider’s value is updated accordingly to ensure that the displayed value is always current.

**Example 6: Disabling and Enabling EditorSpinSlider Dynamically**

There might be situations where you want to enable or disable the EditorSpinSlider based on certain conditions. The following example demonstrates how to disable the EditorSpinSlider if a checkbox is unchecked in the editor.

var checkbox = CheckBox.new()
var spin_slider = EditorSpinSlider.new()

func _enter_tree():
    checkbox.connect("toggled", self, "_on_checkbox_toggled")

func _on_checkbox_toggled(button_pressed):
    spin_slider.disabled = !button_pressed

When the checkbox is toggled, the EditorSpinSlider is enabled or disabled depending on the state of the checkbox.

By integrating these examples into your workflow, you can craft a development environment that is efficient, user-friendly, and customized to your unique project’s needs. These tailored tools not only speed up development but also make the process more enjoyable, reflecting the creative spirit inherent in game development. With EditorSpinSlider’s flexible capabilities, the only limit is your imagination.

Continuing Your Game Development Journey

Mastering the EditorSpinSlider in Godot 4 is just the beginning of your game development adventure. If you’re eager to take your skills to the next level and create diverse and engaging games, we invite you to explore our Godot Game Development Mini-Degree. This comprehensive collection of courses will guide you from the fundamentals of Godot 4 to crafting your own fully-fledged projects. And remember, learning with us fits into your schedule, allowing you to grow at your own pace.

Want to dive deeper into the vast world of Godot? Check out our broad range of Godot courses. Each one is designed to equip you with the knowledge and practical skills needed to bring your game ideas to life. From 2D sidescrollers to 3D adventures, the only limit is your imagination. Don’t just dream about making games – with Zenva, turn those dreams into reality, and join the ranks of aspiring developers on the journey from beginner to professional.

Whether you’re just starting out or looking to polish your existing skills, our courses have something for everyone. As always, happy learning and happy developing – we can’t wait to see what you create!


As you’ve ventured through the intricacies of the EditorSpinSlider in Godot 4, you’ve armed yourself with a valuable tool that can transform your game development workflow. Emboldened by this knowledge, you now stand at the threshold of a myriad of possibilities, ready to craft interactive and dynamic game experiences with finesse. We encourage you to keep this momentum going by exploring our Godot Game Development Mini-Degree, where you can continue to harness the power of Godot and hone your creative prowess.

Let this be just the starting point of a fruitful journey where you breathe life into your game concepts and shape them into reality. With every tutorial, course, and line of code, you’re not just developing games—you’re also developing your future. We at Zenva are excited to accompany you on this path and cannot wait to see the remarkable worlds you’ll construct. Happy coding!

Python Blog Image

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