new terrain plugin

2025-08-13 21:08:35 +02:00
parent 43fb8410c3
commit 85d50d3bd4
221 changed files with 11867 additions and 1 deletions
--- a/addons/terrain_3d/src/asset_dock.gd
+++ b/addons/terrain_3d/src/asset_dock.gd
@@ -0,0 +1,883 @@
+# Copyright © 2025 Cory Petkovsek, Roope Palmroos, and Contributors.
+# Asset Dock for Terrain3D
+@tool
+extends PanelContainer
+
+signal confirmation_closed
+signal confirmation_confirmed
+signal confirmation_canceled
+
+const ES_DOCK_SLOT: String = "terrain3d/dock/slot"
+const ES_DOCK_TILE_SIZE: String = "terrain3d/dock/tile_size"
+const ES_DOCK_FLOATING: String = "terrain3d/dock/floating"
+const ES_DOCK_PINNED: String = "terrain3d/dock/always_on_top"
+const ES_DOCK_WINDOW_POSITION: String = "terrain3d/dock/window_position"
+const ES_DOCK_WINDOW_SIZE: String = "terrain3d/dock/window_size"
+const ES_DOCK_TAB: String = "terrain3d/dock/tab"
+
+var texture_list: ListContainer
+var mesh_list: ListContainer
+var _current_list: ListContainer
+var _last_thumb_update_time: int = 0
+const MAX_UPDATE_TIME: int = 1000
+
+var placement_opt: OptionButton
+var floating_btn: Button
+var pinned_btn: Button
+var size_slider: HSlider
+var box: BoxContainer
+var buttons: BoxContainer
+var textures_btn: Button
+var meshes_btn: Button
+var asset_container: ScrollContainer
+var confirm_dialog: ConfirmationDialog
+var _confirmed: bool = false
+
+# Used only for editor, so change to single visible/hiddden
+enum {
+	HIDDEN = -1,
+	SIDEBAR = 0,
+	BOTTOM = 1,
+	WINDOWED = 2,
+}
+var state: int = HIDDEN
+
+enum {
+	POS_LEFT_UL = 0,
+	POS_LEFT_BL = 1,
+	POS_LEFT_UR = 2,
+	POS_LEFT_BR = 3,
+	POS_RIGHT_UL = 4,
+	POS_RIGHT_BL = 5,
+	POS_RIGHT_UR = 6,
+	POS_RIGHT_BR = 7,
+	POS_BOTTOM = 8,
+	POS_MAX = 9,
+}
+var slot: int = POS_RIGHT_BR
+var _initialized: bool = false
+var plugin: EditorPlugin
+var window: Window
+var _godot_last_state: Window.Mode = Window.MODE_FULLSCREEN
+
+
+func initialize(p_plugin: EditorPlugin) -> void:
+	if p_plugin:
+		plugin = p_plugin
+	
+	_godot_last_state = plugin.godot_editor_window.mode
+	placement_opt = $Box/Buttons/PlacementOpt
+	pinned_btn = $Box/Buttons/Pinned
+	floating_btn = $Box/Buttons/Floating
+	floating_btn.owner = null
+	size_slider = $Box/Buttons/SizeSlider
+	size_slider.owner = null
+	box = $Box
+	buttons = $Box/Buttons
+	textures_btn = $Box/Buttons/TexturesBtn
+	meshes_btn = $Box/Buttons/MeshesBtn
+	asset_container = $Box/ScrollContainer
+
+	texture_list = ListContainer.new()
+	texture_list.plugin = plugin
+	texture_list.type = Terrain3DAssets.TYPE_TEXTURE
+	asset_container.add_child(texture_list)
+	mesh_list = ListContainer.new()
+	mesh_list.plugin = plugin
+	mesh_list.type = Terrain3DAssets.TYPE_MESH
+	mesh_list.visible = false
+	asset_container.add_child(mesh_list)
+	_current_list = texture_list
+
+	load_editor_settings()
+
+	# Connect signals
+	resized.connect(update_layout)
+	textures_btn.pressed.connect(_on_textures_pressed)
+	meshes_btn.pressed.connect(_on_meshes_pressed)
+	placement_opt.item_selected.connect(set_slot)
+	floating_btn.pressed.connect(make_dock_float)
+	pinned_btn.toggled.connect(_on_pin_changed)
+	pinned_btn.visible = ( window != null )
+	size_slider.value_changed.connect(_on_slider_changed)
+	plugin.ui.toolbar.tool_changed.connect(_on_tool_changed)
+
+	meshes_btn.add_theme_font_size_override("font_size", 16 * EditorInterface.get_editor_scale())
+	textures_btn.add_theme_font_size_override("font_size", 16 * EditorInterface.get_editor_scale())
+
+	_initialized = true
+	update_dock()
+	update_layout()
+
+
+func _ready() -> void:
+	if not _initialized:
+		return
+		
+	# Setup styles
+	set("theme_override_styles/panel", get_theme_stylebox("panel", "Panel"))
+	# Avoid saving icon resources in tscn when editing w/ a tool script
+	if EditorInterface.get_edited_scene_root() != self:
+		pinned_btn.icon = get_theme_icon("Pin", "EditorIcons")
+		pinned_btn.text = ""
+		floating_btn.icon = get_theme_icon("MakeFloating", "EditorIcons")
+		floating_btn.text = ""
+
+	update_thumbnails()
+	confirm_dialog = ConfirmationDialog.new()
+	add_child(confirm_dialog)
+	confirm_dialog.hide()
+	confirm_dialog.confirmed.connect(func(): _confirmed = true; \
+		emit_signal("confirmation_closed"); \
+		emit_signal("confirmation_confirmed") )
+	confirm_dialog.canceled.connect(func(): _confirmed = false; \
+		emit_signal("confirmation_closed"); \
+		emit_signal("confirmation_canceled") )
+
+
+func get_current_list() -> ListContainer:
+	return _current_list
+
+
+## Dock placement
+
+func set_slot(p_slot: int) -> void:
+	p_slot = clamp(p_slot, 0, POS_MAX-1)
+	
+	if slot != p_slot:
+		slot = p_slot
+		placement_opt.selected = slot
+		save_editor_settings()
+		plugin.select_terrain()
+		update_dock()
+
+
+func remove_dock(p_force: bool = false) -> void:
+	if state == SIDEBAR:
+		plugin.remove_control_from_docks(self)
+		state = HIDDEN
+
+	elif state == BOTTOM:
+		plugin.remove_control_from_bottom_panel(self)
+		state = HIDDEN
+
+	# If windowed and destination is not window or final exit, otherwise leave
+	elif state == WINDOWED and p_force and window:
+		var parent: Node = get_parent()
+		if parent:
+			parent.remove_child(self)
+		plugin.godot_editor_window.mouse_entered.disconnect(_on_godot_window_entered)
+		plugin.godot_editor_window.focus_entered.disconnect(_on_godot_focus_entered)
+		plugin.godot_editor_window.focus_exited.disconnect(_on_godot_focus_exited)
+		window.hide()
+		window.queue_free()
+		window = null
+		floating_btn.button_pressed = false
+		floating_btn.visible = true
+		pinned_btn.visible = false
+		placement_opt.visible = true
+		state = HIDDEN
+		update_dock() # return window to side/bottom
+
+
+func update_dock() -> void:
+	if not _initialized or window:
+		return
+
+	update_assets()
+
+	# Move dock to new destination
+	remove_dock()
+	# Sidebar
+	if slot < POS_BOTTOM:
+		state = SIDEBAR
+		plugin.add_control_to_dock(slot, self)
+	# Bottom
+	elif slot == POS_BOTTOM:
+		state = BOTTOM
+		plugin.add_control_to_bottom_panel(self, "Terrain3D")
+		plugin.make_bottom_panel_item_visible(self)
+
+
+func update_layout() -> void:
+	if not _initialized:
+		return
+
+	# Detect if we have a new window from Make floating, grab it so we can free it properly
+	if not window and get_parent() and get_parent().get_parent() is Window:
+		window = get_parent().get_parent()
+		make_dock_float()
+		return # Will call this function again upon display
+
+	var size_parent: Control = size_slider.get_parent()
+	# Vertical layout in window / sidebar
+	if window or slot < POS_BOTTOM:
+		box.vertical = true
+		buttons.vertical = false
+
+		if size.x >= 500 and size_parent != buttons:
+			size_slider.reparent(buttons)
+			buttons.move_child(size_slider, 3)
+		elif size.x < 500 and size_parent != box:
+			size_slider.reparent(box)
+			box.move_child(size_slider, 1)
+		floating_btn.reparent(buttons)
+		buttons.move_child(floating_btn, 4)
+
+	# Wide layout on bottom bar
+	else:
+		size_slider.reparent(buttons)
+		buttons.move_child(size_slider, 3)
+		floating_btn.reparent(box)
+		box.vertical = false
+		buttons.vertical = true
+
+	save_editor_settings()
+
+
+func update_thumbnails() -> void:
+	if not is_instance_valid(plugin.terrain):
+		return
+	if _current_list.type == Terrain3DAssets.TYPE_MESH and \
+			Time.get_ticks_msec() - _last_thumb_update_time > MAX_UPDATE_TIME:
+		plugin.terrain.assets.create_mesh_thumbnails()
+		_last_thumb_update_time = Time.get_ticks_msec()
+		for mesh_asset in mesh_list.entries:
+			mesh_asset.queue_redraw()
+
+
+## Dock Button handlers
+
+
+func _on_pin_changed(toggled: bool) -> void:
+	if window:
+		window.always_on_top = pinned_btn.button_pressed
+	save_editor_settings()
+
+
+func _on_slider_changed(value: float) -> void:
+	if texture_list:
+		texture_list.set_entry_width(value)
+	if mesh_list:
+		mesh_list.set_entry_width(value)
+	save_editor_settings()
+
+
+func _on_textures_pressed() -> void:
+	_current_list = texture_list
+	texture_list.update_asset_list()
+	texture_list.visible = true
+	mesh_list.visible = false
+	textures_btn.button_pressed = true
+	meshes_btn.button_pressed = false
+	texture_list.set_selected_id(texture_list.selected_id)
+	if plugin.is_terrain_valid():
+		EditorInterface.edit_node(plugin.terrain)
+	save_editor_settings()
+
+
+func _on_meshes_pressed() -> void:
+	_current_list = mesh_list
+	mesh_list.update_asset_list()
+	mesh_list.visible = true
+	texture_list.visible = false
+	meshes_btn.button_pressed = true
+	textures_btn.button_pressed = false
+	mesh_list.set_selected_id(mesh_list.selected_id)
+	if plugin.is_terrain_valid():
+		EditorInterface.edit_node(plugin.terrain)
+	update_thumbnails()
+	save_editor_settings()
+
+
+func _on_tool_changed(p_tool: Terrain3DEditor.Tool, p_operation: Terrain3DEditor.Operation) -> void:
+	if p_tool == Terrain3DEditor.INSTANCER:
+		_on_meshes_pressed()
+	elif p_tool in [ Terrain3DEditor.TEXTURE, Terrain3DEditor.COLOR, Terrain3DEditor.ROUGHNESS ]:
+		_on_textures_pressed()
+
+
+## Update Dock Contents
+
+
+func update_assets() -> void:
+	if not _initialized:
+		return
+	
+	# Verify signals to individual lists
+	if plugin.is_terrain_valid() and plugin.terrain.assets:
+		if not plugin.terrain.assets.textures_changed.is_connected(texture_list.update_asset_list):
+			plugin.terrain.assets.textures_changed.connect(texture_list.update_asset_list)
+		if not plugin.terrain.assets.meshes_changed.is_connected(mesh_list.update_asset_list):
+			plugin.terrain.assets.meshes_changed.connect(mesh_list.update_asset_list)
+
+	_current_list.update_asset_list()
+
+
+## Window Management
+
+
+func make_dock_float() -> void:
+	# If not already created (eg from editor panel 'Make Floating' button)	
+	if not window:
+		remove_dock()
+		create_window()
+
+	state = WINDOWED
+	visible = true # Asset dock contents are hidden when popping out of the bottom!
+	pinned_btn.visible = true
+	floating_btn.visible = false
+	placement_opt.visible = false
+	window.title = "Terrain3D Asset Dock"
+	window.always_on_top = pinned_btn.button_pressed
+	window.close_requested.connect(remove_dock.bind(true))
+	window.window_input.connect(_on_window_input)
+	window.focus_exited.connect(save_editor_settings)
+	window.mouse_exited.connect(save_editor_settings)
+	window.size_changed.connect(save_editor_settings)
+	plugin.godot_editor_window.mouse_entered.connect(_on_godot_window_entered)
+	plugin.godot_editor_window.focus_entered.connect(_on_godot_focus_entered)
+	plugin.godot_editor_window.focus_exited.connect(_on_godot_focus_exited)
+	plugin.godot_editor_window.grab_focus()
+	update_assets()
+	save_editor_settings()
+
+
+func create_window() -> void:
+	window = Window.new()
+	window.wrap_controls = true
+	var mc := MarginContainer.new()
+	mc.set_anchors_preset(PRESET_FULL_RECT, false)
+	mc.add_child(self)
+	window.add_child(mc)
+	window.set_transient(false)
+	window.set_size(plugin.get_setting(ES_DOCK_WINDOW_SIZE, Vector2i(512, 512)))
+	window.set_position(plugin.get_setting(ES_DOCK_WINDOW_POSITION, Vector2i(704, 284)))
+	plugin.add_child(window)
+	window.show()
+
+
+func clamp_window_position() -> void:
+	if window and window.visible:
+		var bounds: Vector2i
+		if EditorInterface.get_editor_settings().get_setting("interface/editor/single_window_mode"):
+			bounds = EditorInterface.get_base_control().size
+		else:
+			bounds = DisplayServer.screen_get_position(window.current_screen)
+			bounds += DisplayServer.screen_get_size(window.current_screen)
+		var margin: int = 40
+		window.position.x = clamp(window.position.x, -window.size.x + 2*margin, bounds.x - margin)
+		window.position.y = clamp(window.position.y, 25, bounds.y - margin)
+
+
+func _on_window_input(event: InputEvent) -> void:
+	# Capture CTRL+S when doc focused to save scene
+	if event is InputEventKey and event.keycode == KEY_S and event.pressed and event.is_command_or_control_pressed():
+		save_editor_settings()
+		EditorInterface.save_scene()
+
+
+func _on_godot_window_entered() -> void:
+	if is_instance_valid(window) and window.has_focus():
+		plugin.godot_editor_window.grab_focus()
+
+
+func _on_godot_focus_entered() -> void:
+	# If asset dock is windowed, and Godot was minimized, and now is not, restore asset dock window
+	if is_instance_valid(window):
+		if _godot_last_state == Window.MODE_MINIMIZED and plugin.godot_editor_window.mode != Window.MODE_MINIMIZED:
+			window.show()
+			_godot_last_state = plugin.godot_editor_window.mode
+			plugin.godot_editor_window.grab_focus()
+
+
+func _on_godot_focus_exited() -> void:
+	if is_instance_valid(window) and plugin.godot_editor_window.mode == Window.MODE_MINIMIZED:
+		window.hide()
+		_godot_last_state = plugin.godot_editor_window.mode
+
+
+## Manage Editor Settings
+
+func load_editor_settings() -> void:
+	floating_btn.button_pressed = plugin.get_setting(ES_DOCK_FLOATING, false)
+	pinned_btn.button_pressed = plugin.get_setting(ES_DOCK_PINNED, true)
+	size_slider.value = plugin.get_setting(ES_DOCK_TILE_SIZE, 83)
+	_on_slider_changed(size_slider.value)
+	set_slot(plugin.get_setting(ES_DOCK_SLOT, POS_BOTTOM))
+	if floating_btn.button_pressed:
+		make_dock_float()
+	# TODO Don't save tab until thumbnail generation more reliable
+	#if plugin.get_setting(ES_DOCK_TAB, 0) == 1:
+	#	_on_meshes_pressed()
+
+
+func save_editor_settings() -> void:
+	if not _initialized:
+		return
+	clamp_window_position()
+	plugin.set_setting(ES_DOCK_SLOT, slot)
+	plugin.set_setting(ES_DOCK_TILE_SIZE, size_slider.value)
+	plugin.set_setting(ES_DOCK_FLOATING, floating_btn.button_pressed)
+	plugin.set_setting(ES_DOCK_PINNED, pinned_btn.button_pressed)
+	# TODO Don't save tab until thumbnail generation more reliable
+	# plugin.set_setting(ES_DOCK_TAB, 0 if _current_list == texture_list else 1)
+	if window:
+		plugin.set_setting(ES_DOCK_WINDOW_SIZE, window.size)
+		plugin.set_setting(ES_DOCK_WINDOW_POSITION, window.position)
+
+
+##############################################################
+## class ListContainer
+##############################################################
+
+	
+class ListContainer extends Container:
+	var plugin: EditorPlugin
+	var type := Terrain3DAssets.TYPE_TEXTURE
+	var entries: Array[ListEntry]
+	var selected_id: int = 0
+	var height: float = 0
+	var width: float = 83
+	var focus_style: StyleBox
+
+	
+	func _ready() -> void:
+		set_v_size_flags(SIZE_EXPAND_FILL)
+		set_h_size_flags(SIZE_EXPAND_FILL)
+
+
+	func clear() -> void:
+		for e in entries:
+			e.get_parent().remove_child(e)
+			e.queue_free()
+		entries.clear()
+
+
+	func update_asset_list() -> void:
+		clear()
+		
+		# Grab terrain
+		var t: Terrain3D
+		if plugin.is_terrain_valid():
+			t = plugin.terrain
+		elif is_instance_valid(plugin._last_terrain) and plugin.is_terrain_valid(plugin._last_terrain):
+			t = plugin._last_terrain
+		else:
+			return
+		
+		if not t.assets:
+			return
+		
+		if type == Terrain3DAssets.TYPE_TEXTURE:
+			var texture_count: int = t.assets.get_texture_count()
+			for i in texture_count:
+				var texture: Terrain3DTextureAsset = t.assets.get_texture(i)
+				add_item(texture)
+			if texture_count < Terrain3DAssets.MAX_TEXTURES:
+				add_item()
+		else:
+			var mesh_count: int = t.assets.get_mesh_count()
+			for i in mesh_count:
+				var mesh: Terrain3DMeshAsset = t.assets.get_mesh_asset(i)
+				add_item(mesh, t.assets)
+			if mesh_count < Terrain3DAssets.MAX_MESHES:
+				add_item()
+			if selected_id >= mesh_count or selected_id < 0:
+				set_selected_id(0)
+
+
+	func add_item(p_resource: Resource = null, p_assets: Terrain3DAssets = null) -> void:
+		var entry: ListEntry = ListEntry.new()
+		entry.focus_style = focus_style
+		var id: int = entries.size()
+		
+		entry.set_edited_resource(p_resource)
+		entry.hovered.connect(_on_resource_hovered.bind(id))
+		entry.selected.connect(set_selected_id.bind(id))
+		entry.inspected.connect(_on_resource_inspected)
+		entry.changed.connect(_on_resource_changed.bind(id))
+		entry.type = type
+		entry.asset_list = p_assets
+		add_child(entry)
+		entries.push_back(entry)
+		
+		if p_resource:
+			entry.set_selected(id == selected_id)
+			if not p_resource.id_changed.is_connected(set_selected_after_swap):
+				p_resource.id_changed.connect(set_selected_after_swap)
+
+
+	func _on_resource_hovered(p_id: int):
+		if type == Terrain3DAssets.TYPE_MESH:
+			if plugin.terrain:
+				plugin.terrain.assets.create_mesh_thumbnails(p_id)
+
+	
+	func set_selected_after_swap(p_type: Terrain3DAssets.AssetType, p_old_id: int, p_new_id: int) -> void:
+		set_selected_id(clamp(p_new_id, 0, entries.size() - 2))
+
+
+	func set_selected_id(p_id: int) -> void:
+		selected_id = p_id
+		
+		for i in entries.size():
+			var entry: ListEntry = entries[i]
+			entry.set_selected(i == selected_id)
+		
+		plugin.select_terrain()
+
+		# Select Paint tool if clicking a texture
+		if type == Terrain3DAssets.TYPE_TEXTURE and \
+				not plugin.editor.get_tool() in [ Terrain3DEditor.TEXTURE, Terrain3DEditor.COLOR, Terrain3DEditor.ROUGHNESS ]:
+			var paint_btn: Button = plugin.ui.toolbar.get_node_or_null("PaintTexture")
+			if paint_btn:
+				paint_btn.set_pressed(true)
+				plugin.ui._on_tool_changed(Terrain3DEditor.TEXTURE, Terrain3DEditor.REPLACE)
+
+		elif type == Terrain3DAssets.TYPE_MESH and plugin.editor.get_tool() != Terrain3DEditor.INSTANCER:
+			var instancer_btn: Button = plugin.ui.toolbar.get_node_or_null("InstanceMeshes")
+			if instancer_btn:
+				instancer_btn.set_pressed(true)
+				plugin.ui._on_tool_changed(Terrain3DEditor.INSTANCER, Terrain3DEditor.ADD)
+		
+		# Update editor with selected brush
+		plugin.ui._on_setting_changed()
+
+
+	func _on_resource_inspected(p_resource: Resource) -> void:
+		await get_tree().create_timer(.01).timeout
+		EditorInterface.edit_resource(p_resource)
+	
+	
+	func _on_resource_changed(p_resource: Resource, p_id: int) -> void:
+		if not p_resource:
+			var asset_dock: Control = get_parent().get_parent().get_parent()
+			if type == Terrain3DAssets.TYPE_TEXTURE:
+				asset_dock.confirm_dialog.dialog_text = "Are you sure you want to clear this texture?"
+			else:
+				asset_dock.confirm_dialog.dialog_text = "Are you sure you want to clear this mesh and delete all instances?"
+			asset_dock.confirm_dialog.popup_centered()
+			await asset_dock.confirmation_closed
+			if not asset_dock._confirmed:
+				update_asset_list()
+				return
+			
+		if not plugin.is_terrain_valid():
+			plugin.select_terrain()
+			await get_tree().create_timer(.01).timeout
+
+		if plugin.is_terrain_valid():
+			if type == Terrain3DAssets.TYPE_TEXTURE:
+				plugin.terrain.get_assets().set_texture(p_id, p_resource)
+			else:
+				plugin.terrain.get_assets().set_mesh_asset(p_id, p_resource)
+				await get_tree().create_timer(.01).timeout
+				plugin.terrain.assets.create_mesh_thumbnails(p_id)
+
+			# If removing an entry, clear inspector
+			if not p_resource:
+				EditorInterface.inspect_object(null)			
+				
+		# If null resource, remove last 
+		if not p_resource:
+			var last_offset: int = 2
+			if p_id == entries.size()-2:
+				last_offset = 3
+			set_selected_id(clamp(selected_id, 0, entries.size() - last_offset))
+
+
+	func get_selected_id() -> int:
+		return selected_id
+
+
+	func set_entry_width(value: float) -> void:
+		width = clamp(value, 66, 230)
+		redraw()
+
+
+	func get_entry_width() -> float:
+		return width
+	
+
+	func redraw() -> void:
+		height = 0
+		var id: int = 0
+		var separation: float = 4
+		var columns: int = 3
+		columns = clamp(size.x / width, 1, 100)
+		
+		for c in get_children():
+			if is_instance_valid(c):
+				c.size = Vector2(width, width) - Vector2(separation, separation)
+				c.position = Vector2(id % columns, id / columns) * width + \
+					Vector2(separation / columns, separation / columns)
+				height = max(height, c.position.y + width)
+				id += 1
+
+
+	# Needed to enable ScrollContainer scroll bar
+	func _get_minimum_size() -> Vector2:
+		return Vector2(0, height)
+
+		
+	func _notification(p_what) -> void:
+		if p_what == NOTIFICATION_SORT_CHILDREN:
+			redraw()
+
+
+##############################################################
+## class ListEntry
+##############################################################
+
+
+class ListEntry extends VBoxContainer:
+	signal hovered()
+	signal selected()
+	signal changed(resource: Resource)
+	signal inspected(resource: Resource)
+	
+	var resource: Resource
+	var type := Terrain3DAssets.TYPE_TEXTURE
+	var _thumbnail: Texture2D
+	var drop_data: bool = false
+	var is_hovered: bool = false
+	var is_selected: bool = false
+	var asset_list: Terrain3DAssets
+	
+	@onready var button_row := HBoxContainer.new()
+	@onready var button_clear := TextureButton.new()
+	@onready var button_edit := TextureButton.new()
+	@onready var spacer := Control.new()
+	@onready var button_enabled := TextureButton.new()
+	@onready var clear_icon: Texture2D = get_theme_icon("Close", "EditorIcons")
+	@onready var edit_icon: Texture2D = get_theme_icon("Edit", "EditorIcons")
+	@onready var enabled_icon: Texture2D = get_theme_icon("GuiVisibilityVisible", "EditorIcons")
+	@onready var disabled_icon: Texture2D = get_theme_icon("GuiVisibilityHidden", "EditorIcons")
+
+	var name_label: Label
+	@onready var add_icon: Texture2D = get_theme_icon("Add", "EditorIcons")
+	@onready var background: StyleBox = get_theme_stylebox("pressed", "Button")
+	@onready var focus_style: StyleBox = get_theme_stylebox("focus", "Button").duplicate()
+
+
+	func _ready() -> void:
+		setup_buttons()
+		setup_label()
+		focus_style.set_border_width_all(2)
+		focus_style.set_border_color(Color(1, 1, 1, .67))
+
+
+	func setup_buttons() -> void:
+		var icon_size: Vector2 = Vector2(12, 12)
+		var margin_container := MarginContainer.new()
+		margin_container.mouse_filter = Control.MOUSE_FILTER_PASS
+		margin_container.add_theme_constant_override("margin_top", 5)
+		margin_container.add_theme_constant_override("margin_left", 5)
+		margin_container.add_theme_constant_override("margin_right", 5)
+		add_child(margin_container)
+		
+		button_row.size_flags_horizontal = Control.SIZE_EXPAND_FILL
+		button_row.alignment = BoxContainer.ALIGNMENT_CENTER
+		button_row.mouse_filter = Control.MOUSE_FILTER_PASS
+		margin_container.add_child(button_row)
+
+		if type == Terrain3DAssets.TYPE_MESH:
+			button_enabled.set_texture_normal(enabled_icon)
+			button_enabled.set_texture_pressed(disabled_icon)
+			button_enabled.set_custom_minimum_size(icon_size)
+			button_enabled.set_h_size_flags(Control.SIZE_SHRINK_END)
+			button_enabled.set_visible(resource != null)
+			button_enabled.toggle_mode = true
+			button_enabled.mouse_filter = Control.MOUSE_FILTER_PASS
+			button_enabled.pressed.connect(enable)
+			button_row.add_child(button_enabled)
+		
+		button_edit.set_texture_normal(edit_icon)
+		button_edit.set_custom_minimum_size(icon_size)
+		button_edit.set_h_size_flags(Control.SIZE_SHRINK_END)
+		button_edit.set_visible(resource != null)
+		button_edit.mouse_filter = Control.MOUSE_FILTER_PASS
+		button_edit.pressed.connect(edit)
+		button_row.add_child(button_edit)
+
+		spacer.size_flags_horizontal = Control.SIZE_EXPAND_FILL
+		spacer.mouse_filter = Control.MOUSE_FILTER_PASS
+		button_row.add_child(spacer)
+		
+		button_clear.set_texture_normal(clear_icon)
+		button_clear.set_custom_minimum_size(icon_size)
+		button_clear.set_h_size_flags(Control.SIZE_SHRINK_END)
+		button_clear.set_visible(resource != null)
+		button_clear.mouse_filter = Control.MOUSE_FILTER_PASS
+		button_clear.pressed.connect(clear)
+		button_row.add_child(button_clear)
+
+
+	func setup_label() -> void:
+		name_label = Label.new()
+		add_child(name_label, true)
+		name_label.visible = false
+		name_label.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
+		name_label.vertical_alignment = VERTICAL_ALIGNMENT_BOTTOM
+		name_label.size_flags_vertical = Control.SIZE_EXPAND_FILL
+		name_label.add_theme_color_override("font_color", Color.WHITE)
+		name_label.add_theme_color_override("font_shadow_color", Color.BLACK)
+		name_label.add_theme_constant_override("shadow_offset_x", 1.)
+		name_label.add_theme_constant_override("shadow_offset_y", 1.)
+		name_label.add_theme_font_size_override("font_size", 15)
+		name_label.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
+		name_label.text_overrun_behavior = TextServer.OVERRUN_TRIM_ELLIPSIS
+		if type == Terrain3DAssets.TYPE_TEXTURE:
+			name_label.text = "Add Texture"
+		else:
+			name_label.text = "Add Mesh"
+
+
+	func _notification(p_what) -> void:
+		match p_what:
+			NOTIFICATION_DRAW:
+				# Hide spacer if icons are crowding small textures
+				spacer.visible = size.x > 70 or type == Terrain3DAssets.TYPE_TEXTURE
+				
+				var rect: Rect2 = Rect2(Vector2.ZERO, get_size())
+				if !resource:
+					draw_style_box(background, rect)
+					draw_texture(add_icon, (get_size() / 2) - (add_icon.get_size() / 2))
+				else:
+					if type == Terrain3DAssets.TYPE_TEXTURE:
+						name_label.text = (resource as Terrain3DTextureAsset).get_name()
+						self_modulate = resource.get_albedo_color()
+						_thumbnail = resource.get_albedo_texture()
+						if _thumbnail:
+							draw_texture_rect(_thumbnail, rect, false)
+							texture_filter = CanvasItem.TEXTURE_FILTER_NEAREST_WITH_MIPMAPS
+					else:
+						name_label.text = (resource as Terrain3DMeshAsset).get_name()
+						var id: int = (resource as Terrain3DMeshAsset).get_id()
+						_thumbnail = resource.get_thumbnail()
+						if _thumbnail:
+							draw_texture_rect(_thumbnail, rect, false)
+							texture_filter = CanvasItem.TEXTURE_FILTER_LINEAR_WITH_MIPMAPS
+						else:
+							draw_rect(rect, Color(.15, .15, .15, 1.))
+						button_enabled.set_pressed_no_signal(!resource.is_enabled())
+				name_label.add_theme_font_size_override("font_size", 4 + rect.size.x/10)
+				if drop_data:
+					draw_style_box(focus_style, rect)
+				if is_hovered:
+					draw_rect(rect, Color(1, 1, 1, 0.2))
+				if is_selected:
+					draw_style_box(focus_style, rect)
+			NOTIFICATION_MOUSE_ENTER:
+				is_hovered = true
+				name_label.visible = true
+				emit_signal("hovered")
+				queue_redraw()
+			NOTIFICATION_MOUSE_EXIT:
+				is_hovered = false
+				name_label.visible = false
+				drop_data = false
+				queue_redraw()
+
+	
+	func _gui_input(p_event: InputEvent) -> void:
+		if p_event is InputEventMouseButton:
+			if p_event.is_pressed():
+				match p_event.get_button_index():
+					MOUSE_BUTTON_LEFT:
+						# If `Add new` is clicked
+						if !resource:
+							if type == Terrain3DAssets.TYPE_TEXTURE:
+								set_edited_resource(Terrain3DTextureAsset.new(), false)
+							else:
+								set_edited_resource(Terrain3DMeshAsset.new(), false)
+							edit()
+						else:
+							emit_signal("selected")
+					MOUSE_BUTTON_RIGHT:
+						if resource:
+							edit()
+					MOUSE_BUTTON_MIDDLE:
+						if resource:
+							clear()
+
+
+	func _can_drop_data(p_at_position: Vector2, p_data: Variant) -> bool:
+		drop_data = false
+		if typeof(p_data) == TYPE_DICTIONARY:
+			if p_data.files.size() == 1:
+				queue_redraw()
+				drop_data = true
+		return drop_data
+
+		
+	func _drop_data(p_at_position: Vector2, p_data: Variant) -> void:
+		if typeof(p_data) == TYPE_DICTIONARY:
+			var res: Resource = load(p_data.files[0])
+			if res is Texture2D and type == Terrain3DAssets.TYPE_TEXTURE:
+				var ta := Terrain3DTextureAsset.new()
+				if resource is Terrain3DTextureAsset:
+					ta.id = resource.id
+				ta.set_albedo_texture(res)
+				set_edited_resource(ta, false)
+				resource = ta
+			elif res is Terrain3DTextureAsset and type == Terrain3DAssets.TYPE_TEXTURE:
+				if resource is Terrain3DTextureAsset:
+					res.id = resource.id
+				set_edited_resource(res, false)
+			elif res is PackedScene and type == Terrain3DAssets.TYPE_MESH:
+				var ma := Terrain3DMeshAsset.new()
+				if resource is Terrain3DMeshAsset:
+					ma.id = resource.id
+				set_edited_resource(ma, false)
+				ma.set_scene_file(res)
+				resource = ma
+			elif res is Terrain3DMeshAsset and type == Terrain3DAssets.TYPE_MESH:
+				if resource is Terrain3DMeshAsset:
+					res.id = resource.id
+				set_edited_resource(res, false)
+			emit_signal("selected")
+			emit_signal("inspected", resource)
+
+
+
+	func set_edited_resource(p_res: Resource, p_no_signal: bool = true) -> void:
+		resource = p_res
+		if resource:
+			resource.setting_changed.connect(_on_resource_changed)
+			resource.file_changed.connect(_on_resource_changed)
+			if resource is Terrain3DMeshAsset:
+				resource.instancer_setting_changed.connect(_on_resource_changed)
+		
+		if button_clear:
+			button_clear.set_visible(resource != null)
+			
+		queue_redraw()
+		if !p_no_signal:
+			emit_signal("changed", resource)
+
+
+	func _on_resource_changed() -> void:
+		queue_redraw()
+		emit_signal("changed", resource)
+
+
+	func set_selected(value: bool) -> void:
+		is_selected = value
+		queue_redraw()
+
+
+	func clear() -> void:
+		if resource:
+			set_edited_resource(null, false)
+
+	
+	func edit() -> void:
+		emit_signal("selected")
+		emit_signal("inspected", resource)
+
+
+	func enable() -> void:
+		if resource is Terrain3DMeshAsset:
+			resource.set_enabled(!resource.is_enabled())
--- a/addons/terrain_3d/src/asset_dock.gd.uid
+++ b/addons/terrain_3d/src/asset_dock.gd.uid
@@ -0,0 +1 @@
+uid://bgoifepft1hjw
--- a/addons/terrain_3d/src/asset_dock.tscn
+++ b/addons/terrain_3d/src/asset_dock.tscn
@@ -0,0 +1,92 @@
+[gd_scene load_steps=2 format=3 uid="uid://dkb6hii5e48m2"]
+
+[ext_resource type="Script" path="res://addons/terrain_3d/src/asset_dock.gd" id="1_e23pg"]
+
+[node name="Terrain3D" type="PanelContainer"]
+custom_minimum_size = Vector2(256, 95)
+offset_right = 766.0
+offset_bottom = 100.0
+script = ExtResource("1_e23pg")
+
+[node name="Box" type="BoxContainer" parent="."]
+layout_mode = 2
+size_flags_vertical = 3
+vertical = true
+
+[node name="Buttons" type="BoxContainer" parent="Box"]
+layout_mode = 2
+
+[node name="TexturesBtn" type="Button" parent="Box/Buttons"]
+custom_minimum_size = Vector2(80, 30)
+layout_mode = 2
+size_flags_horizontal = 3
+size_flags_vertical = 0
+theme_override_font_sizes/font_size = 16
+toggle_mode = true
+button_pressed = true
+text = "Textures"
+
+[node name="MeshesBtn" type="Button" parent="Box/Buttons"]
+custom_minimum_size = Vector2(80, 30)
+layout_mode = 2
+size_flags_horizontal = 3
+size_flags_vertical = 0
+theme_override_font_sizes/font_size = 16
+toggle_mode = true
+text = "Meshes"
+
+[node name="PlacementOpt" type="OptionButton" parent="Box/Buttons"]
+custom_minimum_size = Vector2(80, 30)
+layout_mode = 2
+size_flags_horizontal = 3
+size_flags_vertical = 0
+selected = 7
+item_count = 9
+popup/item_0/text = "Left_UL"
+popup/item_1/text = "Left_BL"
+popup/item_1/id = 1
+popup/item_2/text = "Left_UR"
+popup/item_2/id = 2
+popup/item_3/text = "Left_BR"
+popup/item_3/id = 3
+popup/item_4/text = "Right_UL"
+popup/item_4/id = 4
+popup/item_5/text = "Right_BL "
+popup/item_5/id = 5
+popup/item_6/text = "Right_UR"
+popup/item_6/id = 6
+popup/item_7/text = "Right_BR"
+popup/item_7/id = 7
+popup/item_8/text = "Bottom"
+popup/item_8/id = 8
+
+[node name="SizeSlider" type="HSlider" parent="Box/Buttons"]
+custom_minimum_size = Vector2(80, 10)
+layout_mode = 2
+size_flags_horizontal = 3
+min_value = 66.0
+max_value = 230.0
+value = 83.0
+
+[node name="Floating" type="Button" parent="Box/Buttons"]
+layout_mode = 2
+size_flags_horizontal = 0
+size_flags_vertical = 0
+tooltip_text = "Pop this dock out to a floating window."
+toggle_mode = true
+text = "F"
+flat = true
+
+[node name="Pinned" type="Button" parent="Box/Buttons"]
+layout_mode = 2
+size_flags_horizontal = 0
+size_flags_vertical = 0
+tooltip_text = "Make this window \"Always on top\"."
+toggle_mode = true
+text = "P"
+flat = true
+
+[node name="ScrollContainer" type="ScrollContainer" parent="Box"]
+layout_mode = 2
+size_flags_horizontal = 3
+size_flags_vertical = 3
--- a/addons/terrain_3d/src/double_slider.gd
+++ b/addons/terrain_3d/src/double_slider.gd
@@ -0,0 +1,164 @@
+# Copyright © 2025 Cory Petkovsek, Roope Palmroos, and Contributors.
+# DoubleSlider for Terrain3D
+# Should work for other UIs
+@tool
+class_name DoubleSlider
+extends Control
+
+signal value_changed(Vector2)
+var label: Label
+var suffix: String
+var grabbed_handle: int = 0 # -1 left, 0 none, 1 right
+var min_value: float = 0.0
+var max_value: float = 100.0
+var step: float = 1.0
+var range := Vector2(0, 100) 
+var display_scale: float = 1.
+var position_x: float = 0.
+var minimum_x: float = 60.
+
+
+func _ready() -> void:
+	# Setup Display Scale
+	# 0 auto, 1 75%, 2 100%, 3 125%, 4 150%, 5 175%, 6 200%, 7 custom
+	var es: EditorSettings = EditorInterface.get_editor_settings()
+	var ds: int = es.get_setting("interface/editor/display_scale")
+	if ds == 0:
+		ds = 2
+	elif ds == 7:
+		display_scale = es.get_setting("interface/editor/custom_display_scale")
+	else:
+		display_scale = float(ds + 2) * .25
+
+	update_label()
+
+
+func set_min(p_value: float) -> void:
+	min_value = p_value
+	if range.x <= min_value:
+		range.x = min_value
+		set_value(range)
+	update_label()
+
+
+func get_min() -> float:
+	return min_value
+	
+	
+func set_max(p_value: float) -> void:
+	max_value = p_value
+	if range.y == 0 or range.y >= max_value:
+		range.y = max_value
+		set_value(range)
+	update_label()
+
+
+func get_max() -> float:
+	return max_value
+	
+	
+func set_step(p_step: float) -> void:
+	step = p_step
+	
+
+func get_step() -> float:
+	return step
+	
+
+func set_value(p_range: Vector2) -> void:
+	range.x = clamp(p_range.x, min_value, max_value)
+	range.y = clamp(p_range.y, min_value, max_value)
+	if range.y < range.x:
+		var tmp: float = range.x
+		range.x = range.y
+		range.y = tmp
+
+	update_label()
+	emit_signal("value_changed", Vector2(range.x, range.y))
+	queue_redraw()
+
+
+func get_value() -> Vector2:
+	return range
+
+
+func update_label() -> void:
+	if label:
+		label.set_text(str(range.x) + suffix + "/" + str(range.y) + suffix)
+		if position_x == 0:
+			position_x = label.position.x
+		else:
+			label.position.x = position_x + 5 * display_scale
+		label.custom_minimum_size.x = minimum_x + 5 * display_scale
+
+
+func _get_handle() -> int:
+	return 1
+
+
+func _gui_input(p_event: InputEvent) -> void:
+	if p_event is InputEventMouseButton:
+		var button: int = p_event.get_button_index()
+		if button in [ MOUSE_BUTTON_LEFT, MOUSE_BUTTON_WHEEL_UP, MOUSE_BUTTON_WHEEL_DOWN ]:
+			if p_event.is_pressed():
+				var mid_point = (range.x + range.y) / 2.0
+				var xpos: float = p_event.get_position().x * 2.0
+				if xpos >= mid_point:
+					grabbed_handle = 1
+				else:
+					grabbed_handle = -1
+				match button:
+					MOUSE_BUTTON_LEFT:
+						set_slider(p_event.get_position().x)
+					MOUSE_BUTTON_WHEEL_DOWN:
+						set_slider(-1., true)
+					MOUSE_BUTTON_WHEEL_UP:
+						set_slider(1., true)
+			else:
+				grabbed_handle = 0
+			
+	if p_event is InputEventMouseMotion:
+		if grabbed_handle != 0:
+			set_slider(p_event.get_position().x)
+	
+	
+func set_slider(p_xpos: float, p_relative: bool = false) -> void:
+	if grabbed_handle == 0:
+		return
+	var xpos_step: float = clamp(snappedf((p_xpos / size.x) * max_value, step), min_value, max_value)
+	if(grabbed_handle < 0):
+		if p_relative:
+			range.x += p_xpos
+		else:
+			range.x = xpos_step
+	else:
+		if p_relative:
+			range.y += p_xpos
+		else:
+			range.y = xpos_step	
+	set_value(range)
+
+
+func _notification(p_what: int) -> void:
+	if p_what == NOTIFICATION_DRAW:
+		# Draw background bar
+		var bg: StyleBox = get_theme_stylebox("slider", "HSlider")
+		var bg_height: float = bg.get_minimum_size().y
+		var mid_y: float = (size.y - bg_height) / 2.0
+		draw_style_box(bg, Rect2(Vector2(0, mid_y), Vector2(size.x, bg_height)))
+		
+		# Draw foreground bar
+		var handle: Texture2D = get_theme_icon("grabber", "HSlider")
+		var area: StyleBox = get_theme_stylebox("grabber_area", "HSlider")
+		var startx: float = (range.x / max_value) * size.x
+		var endx: float = (range.y / max_value) * size.x
+		draw_style_box(area, Rect2(Vector2(startx, mid_y), Vector2(endx - startx, bg_height)))
+		
+		# Draw handles, slightly in so they don't get on the outside edges
+		var handle_pos: Vector2
+		handle_pos.x = clamp(startx - handle.get_size().x/2, -10, size.x)
+		handle_pos.y = clamp(endx - handle.get_size().x/2, 0, size.x - 10)
+		draw_texture(handle, Vector2(handle_pos.x, -mid_y - 10 * (display_scale - 1.)))
+		draw_texture(handle, Vector2(handle_pos.y, -mid_y - 10 * (display_scale - 1.)))
+		
+		update_label()
--- a/addons/terrain_3d/src/double_slider.gd.uid
+++ b/addons/terrain_3d/src/double_slider.gd.uid
@@ -0,0 +1 @@
+uid://stro0p1oawfb
--- a/addons/terrain_3d/src/editor_plugin.gd
+++ b/addons/terrain_3d/src/editor_plugin.gd
@@ -0,0 +1,458 @@
+# Copyright © 2025 Cory Petkovsek, Roope Palmroos, and Contributors.
+# Editor Plugin for Terrain3D
+@tool
+extends EditorPlugin
+
+
+# Includes
+const UI: Script = preload("res://addons/terrain_3d/src/ui.gd")
+const RegionGizmo: Script = preload("res://addons/terrain_3d/src/region_gizmo.gd")
+const ASSET_DOCK: String = "res://addons/terrain_3d/src/asset_dock.tscn"
+
+var modifier_ctrl: bool
+var modifier_alt: bool
+var modifier_shift: bool
+var _last_modifiers: int = 0
+var _input_mode: int = 0 # -1: camera move, 0: none, 1: operating
+var rmb_release_time: int = 0
+var _use_meta: bool = false
+
+var terrain: Terrain3D
+var _last_terrain: Terrain3D
+var nav_region: NavigationRegion3D
+
+var editor: Terrain3DEditor
+var editor_settings: EditorSettings
+var ui: Node # Terrain3DUI see Godot #75388
+var asset_dock: PanelContainer
+var region_gizmo: RegionGizmo
+var current_region_position: Vector2
+var mouse_global_position: Vector3 = Vector3.ZERO
+var godot_editor_window: Window # The Godot Editor window
+
+
+func _init() -> void:
+	if OS.get_name() == "macOS":
+		_use_meta = true
+	
+	# Get the Godot Editor window. Structure is root:Window/EditorNode/Base Control
+	godot_editor_window = EditorInterface.get_base_control().get_parent().get_parent()
+	godot_editor_window.focus_entered.connect(_on_godot_focus_entered)
+
+	
+func _enter_tree() -> void:
+	editor = Terrain3DEditor.new()
+	setup_editor_settings()
+	ui = UI.new()
+	ui.plugin = self
+	add_child(ui)
+
+	region_gizmo = RegionGizmo.new()
+
+	scene_changed.connect(_on_scene_changed)
+
+	asset_dock = load(ASSET_DOCK).instantiate()
+	asset_dock.initialize(self)
+
+
+func _exit_tree() -> void:
+	asset_dock.remove_dock(true)
+	asset_dock.queue_free()
+	ui.queue_free()
+	editor.free()
+
+	scene_changed.disconnect(_on_scene_changed)
+	godot_editor_window.focus_entered.disconnect(_on_godot_focus_entered)
+
+
+func _on_godot_focus_entered() -> void:
+	_read_input()
+	ui.update_decal()
+
+
+## EditorPlugin selection function call chain isn't consistent. Here's the map of calls:
+## Assume we handle Terrain3D and NavigationRegion3D  
+# Click Terrain3D: 					_handles(Terrain3D), _make_visible(true), _edit(Terrain3D)
+# Deselect:							_make_visible(false), _edit(null)
+# Click other node:					_handles(OtherNode)
+# Click NavRegion3D:				_handles(NavReg3D), _make_visible(true), _edit(NavReg3D)
+# Click NavRegion3D, Terrain3D:		_handles(Terrain3D), _edit(Terrain3D)
+# Click Terrain3D, NavRegion3D:		_handles(NavReg3D), _edit(NavReg3D)
+func _handles(p_object: Object) -> bool:
+	if p_object is Terrain3D:
+		return true
+	elif p_object is NavigationRegion3D and is_instance_valid(_last_terrain):
+		return true
+	
+	# Terrain3DObjects requires access to EditorUndoRedoManager. The only way to make sure it
+	# always has it, is to pass it in here. _edit is NOT called if the node is cut and pasted.
+	elif p_object is Terrain3DObjects:
+		p_object.editor_setup(self)
+	elif p_object is Node3D and p_object.get_parent() is Terrain3DObjects:
+		p_object.get_parent().editor_setup(self)
+	
+	return false
+
+
+func _make_visible(p_visible: bool, p_redraw: bool = false) -> void:
+	if p_visible and is_selected():
+		ui.set_visible(true)
+		asset_dock.update_dock()
+	else:
+		ui.set_visible(false)
+
+
+func _edit(p_object: Object) -> void:
+	if !p_object:
+		_clear()
+
+	if p_object is Terrain3D:
+		if p_object == terrain:
+			return
+		terrain = p_object
+		_last_terrain = terrain
+		terrain.set_plugin(self)
+		terrain.set_editor(editor)
+		editor.set_terrain(terrain)
+		region_gizmo.set_node_3d(terrain)
+		terrain.add_gizmo(region_gizmo)
+		ui.set_visible(true)
+		terrain.set_meta("_edit_lock_", true)
+
+		# Get alerted when a new asset list is loaded
+		if not terrain.assets_changed.is_connected(asset_dock.update_assets):
+			terrain.assets_changed.connect(asset_dock.update_assets)
+		asset_dock.update_assets()
+		# Get alerted when the region map changes
+		if not terrain.data.region_map_changed.is_connected(update_region_grid):
+			terrain.data.region_map_changed.connect(update_region_grid)
+		update_region_grid()
+	else:
+		_clear()
+
+	if is_terrain_valid(_last_terrain):
+		if p_object is NavigationRegion3D:
+			ui.set_visible(true, true)
+			nav_region = p_object
+		else:
+			nav_region = null
+
+	
+func _clear() -> void:
+	if is_terrain_valid():
+		if terrain.data.region_map_changed.is_connected(update_region_grid):
+			terrain.data.region_map_changed.disconnect(update_region_grid)
+		
+		terrain.clear_gizmos()
+		terrain = null
+		editor.set_terrain(null)
+		
+		ui.clear_picking()
+		
+	region_gizmo.clear()
+
+
+func _forward_3d_gui_input(p_viewport_camera: Camera3D, p_event: InputEvent) -> AfterGUIInput:
+	if not is_terrain_valid():
+		return AFTER_GUI_INPUT_PASS
+
+	var continue_input: AfterGUIInput = _read_input(p_event)
+	if continue_input != AFTER_GUI_INPUT_CUSTOM:
+		return continue_input
+	ui.update_decal()
+	
+	## Setup active camera & viewport
+	# Always update this for all inputs, as the mouse position can move without
+	# necessarily being a InputEventMouseMotion object. get_intersection() also
+	# returns the last frame position, and should be updated more frequently.
+	
+	# Snap terrain to current camera 
+	terrain.set_camera(p_viewport_camera)
+
+	# Detect if viewport is set to half_resolution
+	# Structure is: Node3DEditorViewportContainer/Node3DEditorViewport(4)/SubViewportContainer/SubViewport/Camera3D
+	var editor_vpc: SubViewportContainer = p_viewport_camera.get_parent().get_parent()
+	var full_resolution: bool = false if editor_vpc.stretch_shrink == 2 else true
+
+	## Get mouse location on terrain
+	# Project 2D mouse position to 3D position and direction
+	var vp_mouse_pos: Vector2 = editor_vpc.get_local_mouse_position()
+	var mouse_pos: Vector2 = vp_mouse_pos if full_resolution else vp_mouse_pos / 2
+	var camera_pos: Vector3 = p_viewport_camera.project_ray_origin(mouse_pos)
+	var camera_dir: Vector3 = p_viewport_camera.project_ray_normal(mouse_pos)
+
+	# If region tool, grab mouse position without considering height
+	if editor.get_tool() == Terrain3DEditor.REGION:
+		var t = -Vector3(0, 1, 0).dot(camera_pos) / Vector3(0, 1, 0).dot(camera_dir)
+		mouse_global_position = (camera_pos + t * camera_dir)
+	else:
+	#Else look for intersection with terrain
+		var intersection_point: Vector3 = terrain.get_intersection(camera_pos, camera_dir, true)
+		if intersection_point.z > 3.4e38 or is_nan(intersection_point.y): # max double or nan
+			return AFTER_GUI_INPUT_PASS
+		mouse_global_position = intersection_point
+	
+	## Handle mouse movement
+	if p_event is InputEventMouseMotion:
+
+		if _input_mode != -1: # Not cam rotation
+			## Update region highlight
+			var region_position: Vector2 = ( Vector2(mouse_global_position.x, mouse_global_position.z) \
+				/ (terrain.get_region_size() * terrain.get_vertex_spacing()) ).floor()
+			if current_region_position != region_position:
+				current_region_position = region_position
+				update_region_grid()
+
+			if _input_mode > 0 and editor.is_operating():
+				# Inject pressure - Relies on C++ set_brush_data() using same dictionary instance
+				ui.brush_data["mouse_pressure"] = p_event.pressure
+
+				editor.operate(mouse_global_position, p_viewport_camera.rotation.y)
+				return AFTER_GUI_INPUT_STOP
+			
+		return AFTER_GUI_INPUT_PASS
+
+	if p_event is InputEventMouseButton and _input_mode > 0:
+		if p_event.is_pressed():
+			# If picking
+			if ui.is_picking():
+				ui.pick(mouse_global_position)
+				if not ui.operation_builder or not ui.operation_builder.is_ready():
+					return AFTER_GUI_INPUT_STOP
+			
+			if modifier_ctrl and editor.get_tool() == Terrain3DEditor.HEIGHT:
+				var height: float = terrain.data.get_height(mouse_global_position)
+				ui.brush_data["height"] = height
+				ui.tool_settings.set_setting("height", height)
+				
+			# If adjusting regions
+			if editor.get_tool() == Terrain3DEditor.REGION:
+				# Skip regions that already exist or don't
+				var has_region: bool = terrain.data.has_regionp(mouse_global_position)
+				var op: int = editor.get_operation()
+				if	( has_region and op == Terrain3DEditor.ADD) or \
+					( not has_region and op == Terrain3DEditor.SUBTRACT ):
+					return AFTER_GUI_INPUT_STOP
+			
+			# If an automatic operation is ready to go (e.g. gradient)
+			if ui.operation_builder and ui.operation_builder.is_ready():
+				ui.operation_builder.apply_operation(editor, mouse_global_position, p_viewport_camera.rotation.y)
+				return AFTER_GUI_INPUT_STOP
+			
+			# Mouse clicked, start editing
+			editor.start_operation(mouse_global_position)
+			editor.operate(mouse_global_position, p_viewport_camera.rotation.y)
+			return AFTER_GUI_INPUT_STOP
+		
+		# _input_apply released, save undo data
+		elif editor.is_operating():
+			editor.stop_operation()
+			return AFTER_GUI_INPUT_STOP
+
+	return AFTER_GUI_INPUT_PASS
+
+
+func _read_input(p_event: InputEvent = null) -> AfterGUIInput:
+	## Determine if user is moving camera or applying
+	if Input.is_mouse_button_pressed(MOUSE_BUTTON_LEFT) or \
+		p_event is InputEventMouseButton and p_event.is_released() and \
+		p_event.get_button_index() == MOUSE_BUTTON_LEFT:
+			_input_mode = 1 
+	else:
+			_input_mode = 0
+	
+	match get_setting("editors/3d/navigation/navigation_scheme", 0):
+		2, 1: # Modo, Maya
+			if Input.is_mouse_button_pressed(MOUSE_BUTTON_RIGHT) or \
+	 			( Input.is_key_pressed(KEY_ALT) and Input.is_mouse_button_pressed(MOUSE_BUTTON_LEFT) ):
+					_input_mode = -1 
+			if p_event is InputEventMouseButton and p_event.is_released() and \
+				( p_event.get_button_index() == MOUSE_BUTTON_RIGHT or \
+				( Input.is_key_pressed(KEY_ALT) and p_event.get_button_index() == MOUSE_BUTTON_LEFT )):
+					rmb_release_time = Time.get_ticks_msec()
+		0, _: # Godot
+			if Input.is_mouse_button_pressed(MOUSE_BUTTON_RIGHT) or \
+				Input.is_mouse_button_pressed(MOUSE_BUTTON_MIDDLE):
+					_input_mode = -1 
+			if p_event is InputEventMouseButton and p_event.is_released() and \
+				( p_event.get_button_index() == MOUSE_BUTTON_RIGHT or \
+				p_event.get_button_index() == MOUSE_BUTTON_MIDDLE ):
+					rmb_release_time = Time.get_ticks_msec()
+	if _input_mode < 0:
+		# Camera is moving, skip input
+		return AFTER_GUI_INPUT_PASS
+
+	## Determine modifiers pressed
+	modifier_shift = Input.is_key_pressed(KEY_SHIFT)
+	
+	# Editor responds to modifier_ctrl so we must register touchscreen Invert 
+	if _use_meta:
+		modifier_ctrl = Input.is_key_pressed(KEY_META) || ui.inverted_input
+	else:
+		modifier_ctrl = Input.is_key_pressed(KEY_CTRL) || ui.inverted_input
+	
+	# Keybind enum: Alt,Space,Meta,Capslock
+	var alt_key: int
+	match get_setting("terrain3d/config/alt_key_bind", 0):
+		3: alt_key = KEY_CAPSLOCK
+		2: alt_key = KEY_META
+		1: alt_key = KEY_SPACE
+		0, _: alt_key = KEY_ALT
+	modifier_alt = Input.is_key_pressed(alt_key)
+	var current_mods: int = int(modifier_shift) | int(modifier_ctrl) << 1 | int(modifier_alt) << 2
+
+	## Process Hotkeys
+	if p_event is InputEventKey and \
+			current_mods == 0 and \
+			p_event.is_pressed() and \
+			not p_event.is_echo() and \
+			consume_hotkey(p_event.keycode):
+		# Hotkey found, consume event, and stop input processing
+		EditorInterface.get_editor_viewport_3d().set_input_as_handled()
+		return AFTER_GUI_INPUT_STOP
+
+	# Brush data is cleared on set_tool, or clicking textures in the asset dock
+	# Update modifiers if changed or missing
+	if  _last_modifiers != current_mods or not ui.brush_data.has("modifier_shift"):
+		_last_modifiers = current_mods
+		ui.brush_data["modifier_shift"] = modifier_shift
+		ui.brush_data["modifier_ctrl"] = modifier_ctrl
+		ui.brush_data["modifier_alt"] = modifier_alt
+		ui.set_active_operation()
+
+	## Continue processing input
+	return AFTER_GUI_INPUT_CUSTOM
+
+
+# Returns true if hotkey matches and operation triggered
+func consume_hotkey(keycode: int) -> bool:
+	match keycode:
+		KEY_1:
+			terrain.material.set_show_region_grid(!terrain.material.get_show_region_grid())
+		KEY_2:
+			terrain.material.set_show_instancer_grid(!terrain.material.get_show_instancer_grid())
+		KEY_3:
+			terrain.material.set_show_vertex_grid(!terrain.material.get_show_vertex_grid())
+		KEY_4:
+			terrain.material.set_show_contours(!terrain.material.get_show_contours())
+		KEY_E:
+			ui.toolbar.get_button("AddRegion").set_pressed(true)
+		KEY_R:
+			ui.toolbar.get_button("Raise").set_pressed(true)
+		KEY_H:
+			ui.toolbar.get_button("Height").set_pressed(true)
+		KEY_S:
+			ui.toolbar.get_button("Slope").set_pressed(true)
+		KEY_C:
+			ui.toolbar.get_button("PaintColor").set_pressed(true)
+		KEY_N:
+			ui.toolbar.get_button("PaintNavigableArea").set_pressed(true)
+		KEY_I:
+			ui.toolbar.get_button("InstanceMeshes").set_pressed(true)
+		KEY_X:
+			ui.toolbar.get_button("AddHoles").set_pressed(true)
+		KEY_W:
+			ui.toolbar.get_button("PaintWetness").set_pressed(true)
+		KEY_B:
+			ui.toolbar.get_button("PaintTexture").set_pressed(true)
+		KEY_V:
+			ui.toolbar.get_button("SprayTexture").set_pressed(true)
+		KEY_A:
+			ui.toolbar.get_button("PaintAutoshader").set_pressed(true)
+		_:
+			return false
+	return true
+
+
+func update_region_grid() -> void:
+	if not region_gizmo:
+		return
+	region_gizmo.set_hidden(not ui.visible)
+
+	if is_terrain_valid():
+		region_gizmo.show_rect = editor.get_tool() == Terrain3DEditor.REGION
+		region_gizmo.use_secondary_color = editor.get_operation() == Terrain3DEditor.SUBTRACT
+		region_gizmo.region_position = current_region_position
+		region_gizmo.region_size = terrain.get_region_size() * terrain.get_vertex_spacing()
+		region_gizmo.grid = terrain.get_data().get_region_locations()
+		
+		terrain.update_gizmos()
+		return
+		
+	region_gizmo.show_rect = false
+	region_gizmo.region_size = 1024
+	region_gizmo.grid = [Vector2i.ZERO]
+
+
+func _on_scene_changed(scene_root: Node) -> void:
+	if not scene_root:
+		return
+		
+	for node in scene_root.find_children("", "Terrain3DObjects"):
+		node.editor_setup(self)
+
+	asset_dock.update_assets()
+	await get_tree().create_timer(2).timeout
+	asset_dock.update_thumbnails()
+
+		
+func is_terrain_valid(p_terrain: Terrain3D = null) -> bool:
+	var t: Terrain3D
+	if p_terrain:
+		t = p_terrain
+	else:
+		t = terrain
+	if is_instance_valid(t) and t.is_inside_tree() and t.data:
+		return true
+	return false
+
+
+func is_selected() -> bool:
+	var selected: Array[Node] = EditorInterface.get_selection().get_selected_nodes()
+	for node in selected:
+		if ( is_instance_valid(_last_terrain) and node.get_instance_id() == _last_terrain.get_instance_id() ) or \
+			node is Terrain3D:
+				return true
+	return false	
+
+
+func select_terrain() -> void:
+	if is_instance_valid(_last_terrain) and is_terrain_valid(_last_terrain) and not is_selected():
+		var es: EditorSelection = EditorInterface.get_selection()
+		es.clear()
+		es.add_node(_last_terrain)
+
+
+## Editor Settings
+
+
+func setup_editor_settings() -> void:
+	editor_settings = EditorInterface.get_editor_settings()
+	if not editor_settings.has_setting("terrain3d/config/alt_key_bind"):
+		editor_settings.set("terrain3d/config/alt_key_bind", 0)
+	var property_info = {
+		"name": "terrain3d/config/alt_key_bind",
+		"type": TYPE_INT,
+		"hint": PROPERTY_HINT_ENUM,
+		"hint_string": "Alt,Space,Meta,Capslock"
+	}
+	editor_settings.add_property_info(property_info)
+	
+
+func set_setting(p_str: String, p_value: Variant) -> void:
+	editor_settings.set_setting(p_str, p_value)
+
+
+func get_setting(p_str: String, p_default: Variant) -> Variant:
+	if editor_settings.has_setting(p_str):
+		return editor_settings.get_setting(p_str)
+	else:
+		return p_default
+
+
+func has_setting(p_str: String) -> bool:
+	return editor_settings.has_setting(p_str)
+
+
+func erase_setting(p_str: String) -> void:
+	editor_settings.erase(p_str)
--- a/addons/terrain_3d/src/editor_plugin.gd.uid
+++ b/addons/terrain_3d/src/editor_plugin.gd.uid
@@ -0,0 +1 @@
+uid://bsgxo1qywjdf3
--- a/addons/terrain_3d/src/gradient_operation_builder.gd
+++ b/addons/terrain_3d/src/gradient_operation_builder.gd
@@ -0,0 +1,56 @@
+# Copyright © 2025 Cory Petkovsek, Roope Palmroos, and Contributors.
+# Gradient Operation Builder for Terrain3D
+extends "res://addons/terrain_3d/src/operation_builder.gd"
+
+
+const MultiPicker: Script = preload("res://addons/terrain_3d/src/multi_picker.gd")
+
+
+func _get_point_picker() -> MultiPicker:
+	return tool_settings.settings["gradient_points"]
+
+
+func _get_brush_size() -> float:
+	return tool_settings.get_setting("size")
+
+
+func _is_drawable() -> bool:
+	return tool_settings.get_setting("drawable")
+
+
+func is_picking() -> bool:
+	return not _get_point_picker().all_points_selected()
+
+
+func pick(p_global_position: Vector3, p_terrain: Terrain3D) -> void:
+	if not _get_point_picker().all_points_selected():
+		_get_point_picker().add_point(p_global_position)
+
+
+func is_ready() -> bool:
+	return _get_point_picker().all_points_selected() and not _is_drawable()
+
+
+func apply_operation(p_editor: Terrain3DEditor, p_global_position: Vector3, p_camera_direction: float) -> void:
+	var points: PackedVector3Array = _get_point_picker().get_points()
+	assert(points.size() == 2)
+	assert(not _is_drawable())
+	
+	var brush_size: float = _get_brush_size()
+	assert(brush_size > 0.0)
+	
+	var start: Vector3 = points[0]
+	var end: Vector3 = points[1]
+	
+	p_editor.start_operation(start)
+	
+	var dir: Vector3 = (end - start).normalized()
+	
+	var pos: Vector3 = start
+	while dir.dot(end - pos) > 0.0:
+		p_editor.operate(pos, p_camera_direction)
+		pos += dir * brush_size * 0.2
+	
+	p_editor.stop_operation()
+	
+	_get_point_picker().clear()
--- a/addons/terrain_3d/src/gradient_operation_builder.gd.uid
+++ b/addons/terrain_3d/src/gradient_operation_builder.gd.uid
@@ -0,0 +1 @@
+uid://def7sych6dp8b
--- a/addons/terrain_3d/src/multi_picker.gd
+++ b/addons/terrain_3d/src/multi_picker.gd
@@ -0,0 +1,88 @@
+# Copyright © 2025 Cory Petkovsek, Roope Palmroos, and Contributors.
+# Multipicker for Terrain3D
+extends HBoxContainer
+
+
+signal pressed
+signal value_changed
+
+
+const ICON_PICKER_CHECKED: String = "res://addons/terrain_3d/icons/picker_checked.svg"
+const MAX_POINTS: int = 2
+
+
+var icon_picker: Texture2D
+var icon_picker_checked: Texture2D
+var points: PackedVector3Array
+var picking_index: int = -1
+
+
+func _enter_tree() -> void:
+	icon_picker = get_theme_icon("ColorPick", "EditorIcons")
+	icon_picker_checked = load(ICON_PICKER_CHECKED)
+	
+	points.resize(MAX_POINTS)
+	
+	for i in range(MAX_POINTS):
+		var button := Button.new()
+		button.icon = icon_picker
+		button.tooltip_text = "Pick point on the Terrain"
+		button.set_meta(&"point_index", i)
+		button.pressed.connect(_on_button_pressed.bind(i))
+		add_child(button)
+	
+	_update_buttons()
+
+
+func _on_button_pressed(button_index: int) -> void:
+	points[button_index] = Vector3.ZERO
+	picking_index = button_index
+	_update_buttons()
+	pressed.emit()
+
+
+func _update_buttons() -> void:
+	for child in get_children():
+		if child is Button:
+			_update_button(child)
+
+
+func _update_button(button: Button) -> void:
+	var index: int = button.get_meta(&"point_index")
+	
+	if points[index] != Vector3.ZERO:
+		button.icon = icon_picker_checked
+	else:
+		button.icon = icon_picker
+
+
+func clear() -> void:
+	points.fill(Vector3.ZERO)
+	_update_buttons()
+	value_changed.emit()
+
+
+func all_points_selected() -> bool:
+	return points.count(Vector3.ZERO) == 0
+
+
+func add_point(p_value: Vector3) -> void:
+	if points.has(p_value):
+		return
+	
+	# If manually selecting a point individually
+	if picking_index != -1:
+		points[picking_index] = p_value
+		picking_index = -1
+	else:
+		# Else picking a sequence of points (non-drawable)
+		for i in range(MAX_POINTS):
+			if points[i] == Vector3.ZERO:
+				points[i] = p_value
+				break
+	_update_buttons()
+	value_changed.emit()
+
+
+func get_points() -> PackedVector3Array:
+	return points
--- a/addons/terrain_3d/src/multi_picker.gd.uid
+++ b/addons/terrain_3d/src/multi_picker.gd.uid
@@ -0,0 +1 @@
+uid://dvdtoa32h6xdn
--- a/addons/terrain_3d/src/operation_builder.gd
+++ b/addons/terrain_3d/src/operation_builder.gd
@@ -0,0 +1,25 @@
+# Copyright © 2025 Cory Petkovsek, Roope Palmroos, and Contributors.
+# Operation Builder for Terrain3D
+extends RefCounted
+
+
+const ToolSettings: Script = preload("res://addons/terrain_3d/src/tool_settings.gd")
+
+
+var tool_settings: ToolSettings
+
+
+func is_picking() -> bool:
+	return false
+
+
+func pick(p_global_position: Vector3, p_terrain: Terrain3D) -> void:
+	pass
+
+
+func is_ready() -> bool:
+	return false
+
+
+func apply_operation(editor: Terrain3DEditor, p_global_position: Vector3, p_camera_direction: float) -> void:
+	pass
--- a/addons/terrain_3d/src/operation_builder.gd.uid
+++ b/addons/terrain_3d/src/operation_builder.gd.uid
@@ -0,0 +1 @@
+uid://bu5cm0eh052rm
--- a/addons/terrain_3d/src/region_gizmo.gd
+++ b/addons/terrain_3d/src/region_gizmo.gd
@@ -0,0 +1,68 @@
+# Copyright © 2025 Cory Petkovsek, Roope Palmroos, and Contributors.
+# Editor Region Gizmos for Terrain3D
+extends EditorNode3DGizmo
+	
+var material: StandardMaterial3D
+var selection_material: StandardMaterial3D
+var region_position: Vector2
+var region_size: float
+var grid: Array[Vector2i]
+var use_secondary_color: bool = false
+var show_rect: bool = true
+
+var main_color: Color = Color.GREEN_YELLOW
+var secondary_color: Color = Color.RED
+var grid_color: Color = Color.WHITE
+var border_color: Color = Color.BLUE
+
+
+func _init() -> void:
+	material = StandardMaterial3D.new()
+	material.set_flag(BaseMaterial3D.FLAG_DISABLE_DEPTH_TEST, true)
+	material.set_flag(BaseMaterial3D.FLAG_ALBEDO_FROM_VERTEX_COLOR, true)
+	material.set_shading_mode(BaseMaterial3D.SHADING_MODE_UNSHADED)
+	material.set_albedo(Color.WHITE)
+	
+	selection_material = material.duplicate()
+	selection_material.set_render_priority(0)
+
+
+func _redraw() -> void:
+	clear()
+	
+	var rect_position = region_position * region_size
+
+	if show_rect:
+		var modulate: Color = main_color if !use_secondary_color else secondary_color
+		if abs(region_position.x) > Terrain3DData.REGION_MAP_SIZE*.5 or abs(region_position.y) > Terrain3DData.REGION_MAP_SIZE*.5:
+			modulate = Color.GRAY
+		draw_rect(Vector2(region_size,region_size)*.5 + rect_position, region_size, selection_material, modulate)
+	
+	for pos in grid:
+		var grid_tile_position = Vector2(pos) * region_size
+		if show_rect and grid_tile_position == rect_position:
+			# Skip this one, otherwise focused region borders are not always visible due to draw order
+			continue
+			
+		draw_rect(Vector2(region_size,region_size)*.5 + grid_tile_position, region_size, material, grid_color)
+		
+	draw_rect(Vector2.ZERO, region_size * Terrain3DData.REGION_MAP_SIZE, material, border_color)
+
+
+func draw_rect(p_pos: Vector2, p_size: float, p_material: StandardMaterial3D, p_modulate: Color) -> void:
+	var lines: PackedVector3Array = [
+		Vector3(-1, 0, -1),
+		Vector3(-1, 0, 1),
+		Vector3(1, 0, 1),
+		Vector3(1, 0, -1),
+		Vector3(-1, 0, 1),
+		Vector3(1, 0, 1),
+		Vector3(1, 0, -1),
+		Vector3(-1, 0, -1),
+	]
+	
+	for i in lines.size():
+		lines[i] = ((lines[i] / 2.0) * p_size) + Vector3(p_pos.x, 0, p_pos.y)
+	
+	add_lines(lines, p_material, false, p_modulate)
+		
--- a/addons/terrain_3d/src/region_gizmo.gd.uid
+++ b/addons/terrain_3d/src/region_gizmo.gd.uid
@@ -0,0 +1 @@
+uid://bh6qwe1ok4cx3
--- a/addons/terrain_3d/src/tool_settings.gd
+++ b/addons/terrain_3d/src/tool_settings.gd
@@ -0,0 +1,693 @@
+# Copyright © 2025 Cory Petkovsek, Roope Palmroos, and Contributors.
+# Tool settings bar for Terrain3D
+extends PanelContainer
+
+signal picking(type: Terrain3DEditor.Tool, callback: Callable)
+signal setting_changed(setting: Variant)
+
+enum Layout {
+	HORIZONTAL,
+	VERTICAL,
+	GRID,
+}
+
+enum SettingType {
+	CHECKBOX,
+	COLOR_SELECT,
+	DOUBLE_SLIDER,
+	OPTION,
+	PICKER,
+	MULTI_PICKER,
+	SLIDER,
+	LABEL,
+	TYPE_MAX,
+}
+
+const MultiPicker: Script = preload("res://addons/terrain_3d/src/multi_picker.gd")
+const DEFAULT_BRUSH: String = "circle0.exr"
+const BRUSH_PATH: String = "res://addons/terrain_3d/brushes"
+const ES_TOOL_SETTINGS: String = "terrain3d/tool_settings/"
+
+# Add settings flags
+const NONE: int = 0x0
+const ALLOW_LARGER: int = 0x1
+const ALLOW_SMALLER: int = 0x2
+const ALLOW_OUT_OF_BOUNDS: int = 0x3 # LARGER|SMALLER
+const NO_LABEL: int = 0x4
+const ADD_SEPARATOR: int = 0x8 # Add a vertical line before this entry
+const ADD_SPACER: int = 0x10 # Add a space before this entry
+const NO_SAVE: int = 0x20 # Don't save this in EditorSettings
+
+var plugin: EditorPlugin # Actually Terrain3DEditorPlugin, but Godot still has CRC errors
+var brush_preview_material: ShaderMaterial
+var select_brush_button: Button
+var selected_brush_imgs: Array
+var main_list: HFlowContainer
+var advanced_list: VBoxContainer
+var height_list: VBoxContainer
+var scale_list: VBoxContainer
+var rotation_list: VBoxContainer
+var color_list: VBoxContainer
+var settings: Dictionary = {}
+
+
+func _ready() -> void:
+	# Remove old editor settings
+	for setting in ["lift_floor", "flatten_peaks", "lift_flatten", "automatic_regions"]:
+		plugin.erase_setting(ES_TOOL_SETTINGS + setting)
+
+	# Setup buttons	
+	main_list = HFlowContainer.new()
+	add_child(main_list, true)
+	
+	add_brushes(main_list)
+
+	add_setting({ "name":"instructions", "label":"Click the terrain to add a region. CTRL+Click to remove. Or select another tool on the left.",
+		"type":SettingType.LABEL, "list":main_list, "flags":NO_LABEL|NO_SAVE })
+
+	add_setting({ "name":"size", "type":SettingType.SLIDER, "list":main_list, "default":20, "unit":"m",
+								"range":Vector3(0.1, 200, 1), "flags":ALLOW_LARGER|ADD_SPACER })
+		
+	add_setting({ "name":"strength", "type":SettingType.SLIDER, "list":main_list, "default":33, 
+								"unit":"%", "range":Vector3(1, 100, 1), "flags":ALLOW_LARGER })
+
+	add_setting({ "name":"height", "type":SettingType.SLIDER, "list":main_list, "default":20, 
+								"unit":"m", "range":Vector3(-500, 500, 0.1), "flags":ALLOW_OUT_OF_BOUNDS })
+	add_setting({ "name":"height_picker", "type":SettingType.PICKER, "list":main_list, 
+								"default":Terrain3DEditor.HEIGHT, "flags":NO_LABEL })
+	
+	add_setting({ "name":"color", "type":SettingType.COLOR_SELECT, "list":main_list, 
+								"default":Color.WHITE, "flags":ADD_SEPARATOR })
+	add_setting({ "name":"color_picker", "type":SettingType.PICKER, "list":main_list, 
+								"default":Terrain3DEditor.COLOR, "flags":NO_LABEL })
+
+	add_setting({ "name":"roughness", "type":SettingType.SLIDER, "list":main_list, "default":-65,
+								"unit":"%", "range":Vector3(-100, 100, 1), "flags":ADD_SEPARATOR })
+	add_setting({ "name":"roughness_picker", "type":SettingType.PICKER, "list":main_list, 
+								"default":Terrain3DEditor.ROUGHNESS, "flags":NO_LABEL })
+
+	add_setting({ "name":"enable_texture", "label":"Texture", "type":SettingType.CHECKBOX, 
+								"list":main_list, "default":true, "flags":ADD_SEPARATOR })
+
+	add_setting({ "name":"texture_filter", "label":"Texture Filter", "type":SettingType.CHECKBOX, 
+								"list":main_list, "default":false, "flags":ADD_SEPARATOR })
+
+	add_setting({ "name":"margin", "type":SettingType.SLIDER, "list":main_list, "default":0, 
+								"unit":"", "range":Vector3(-50, 50, 1), "flags":ALLOW_OUT_OF_BOUNDS })
+
+	# Slope painting filter
+	add_setting({ "name":"slope", "type":SettingType.DOUBLE_SLIDER, "list":main_list, "default":Vector2(0, 90), 
+								"unit":"°", "range":Vector3(0, 90, 1), "flags":ADD_SEPARATOR })
+	
+	add_setting({ "name":"enable_angle", "label":"Angle", "type":SettingType.CHECKBOX, 
+								"list":main_list, "default":true, "flags":ADD_SEPARATOR })
+	add_setting({ "name":"angle", "type":SettingType.SLIDER, "list":main_list, "default":0,
+								"unit":"%", "range":Vector3(0, 337.5, 22.5), "flags":NO_LABEL })
+	add_setting({ "name":"angle_picker", "type":SettingType.PICKER, "list":main_list, 
+								"default":Terrain3DEditor.ANGLE, "flags":NO_LABEL })
+	add_setting({ "name":"dynamic_angle", "label":"Dynamic", "type":SettingType.CHECKBOX, 
+								"list":main_list, "default":false, "flags":ADD_SPACER })
+	
+	add_setting({ "name":"enable_scale", "label":"Scale", "type":SettingType.CHECKBOX, 
+								"list":main_list, "default":true, "flags":ADD_SEPARATOR })
+	add_setting({ "name":"scale", "label":"±", "type":SettingType.SLIDER, "list":main_list, "default":0,
+								"unit":"%", "range":Vector3(-60, 80, 20), "flags":NO_LABEL })
+	add_setting({ "name":"scale_picker", "type":SettingType.PICKER, "list":main_list, 
+								"default":Terrain3DEditor.SCALE, "flags":NO_LABEL })
+
+	## Slope sculpting brush
+	add_setting({ "name":"gradient_points", "type":SettingType.MULTI_PICKER, "label":"Points", 
+								"list":main_list, "default":Terrain3DEditor.SCULPT, "flags":ADD_SEPARATOR })
+	add_setting({ "name":"drawable", "type":SettingType.CHECKBOX, "list":main_list, "default":false, 
+								"flags":ADD_SEPARATOR })
+	settings["drawable"].toggled.connect(_on_drawable_toggled)
+	
+	## Instancer
+	height_list = create_submenu(main_list, "Height", Layout.VERTICAL)
+	add_setting({ "name":"height_offset", "type":SettingType.SLIDER, "list":height_list, "default":0, 
+								"unit":"m", "range":Vector3(-10, 10, 0.05), "flags":ALLOW_OUT_OF_BOUNDS })
+	add_setting({ "name":"random_height", "label":"Random Height ±", "type":SettingType.SLIDER, 
+								"list":height_list, "default":0, "unit":"m", "range":Vector3(0, 10, 0.05),
+								"flags":ALLOW_OUT_OF_BOUNDS })
+
+	scale_list = create_submenu(main_list, "Scale", Layout.VERTICAL)
+	add_setting({ "name":"fixed_scale", "type":SettingType.SLIDER, "list":scale_list, "default":100, 
+								"unit":"%", "range":Vector3(1, 1000, 1), "flags":ALLOW_OUT_OF_BOUNDS })
+	add_setting({ "name":"random_scale", "label":"Random Scale ±", "type":SettingType.SLIDER, "list":scale_list, 
+								"default":20, "unit":"%", "range":Vector3(0, 99, 1), "flags":ALLOW_OUT_OF_BOUNDS })
+
+	rotation_list = create_submenu(main_list, "Rotation", Layout.VERTICAL)
+	add_setting({ "name":"fixed_spin", "label":"Fixed Spin (Around Y)", "type":SettingType.SLIDER, "list":rotation_list, 
+								"default":0, "unit":"°", "range":Vector3(0, 360, 1) })
+	add_setting({ "name":"random_spin", "type":SettingType.SLIDER, "list":rotation_list, "default":360, 
+								"unit":"°", "range":Vector3(0, 360, 1) })
+	add_setting({ "name":"fixed_tilt", "label":"Fixed Tilt", "type":SettingType.SLIDER, "list":rotation_list, 
+								"default":0, "unit":"°", "range":Vector3(-85, 85, 1), "flags":ALLOW_OUT_OF_BOUNDS })
+	add_setting({ "name":"random_tilt", "label":"Random Tilt ±", "type":SettingType.SLIDER, "list":rotation_list, 
+								"default":10, "unit":"°", "range":Vector3(0, 85, 1), "flags":ALLOW_OUT_OF_BOUNDS })
+	add_setting({ "name":"align_to_normal", "type":SettingType.CHECKBOX, "list":rotation_list, "default":false })
+	
+	color_list = create_submenu(main_list, "Color", Layout.VERTICAL)
+	add_setting({ "name":"vertex_color", "type":SettingType.COLOR_SELECT, "list":color_list, 
+								"default":Color.WHITE })
+	add_setting({ "name":"random_hue", "label":"Random Hue Shift ±", "type":SettingType.SLIDER, 
+								"list":color_list, "default":0, "unit":"°", "range":Vector3(0, 360, 1) })
+	add_setting({ "name":"random_darken", "type":SettingType.SLIDER, "list":color_list, "default":50, 
+								"unit":"%", "range":Vector3(0, 100, 1) })
+	#add_setting({ "name":"blend_mode", "type":SettingType.OPTION, "list":color_list, "default":0, 
+								#"range":Vector3(0, 3, 1) })
+
+	if DisplayServer.is_touchscreen_available():
+		add_setting({ "name":"invert", "label":"Invert", "type":SettingType.CHECKBOX, "list":main_list, "default":false, "flags":ADD_SEPARATOR })
+
+	var spacer: Control = Control.new()
+	spacer.size_flags_horizontal = Control.SIZE_EXPAND_FILL
+	main_list.add_child(spacer, true)
+
+	## Advanced Settings Menu
+	advanced_list = create_submenu(main_list, "", Layout.VERTICAL, false)
+	add_setting({ "name":"auto_regions", "label":"Add regions while sculpting", "type":SettingType.CHECKBOX, 
+								"list":advanced_list, "default":true })
+	add_setting({ "name":"align_to_view", "type":SettingType.CHECKBOX, "list":advanced_list, 
+								"default":true })
+	add_setting({ "name":"show_cursor_while_painting", "type":SettingType.CHECKBOX, "list":advanced_list, 
+								"default":true })
+	advanced_list.add_child(HSeparator.new(), true)
+	add_setting({ "name":"gamma", "type":SettingType.SLIDER, "list":advanced_list, "default":1.0, 
+								"unit":"γ", "range":Vector3(0.1, 2.0, 0.01) })
+	add_setting({ "name":"jitter", "type":SettingType.SLIDER, "list":advanced_list, "default":50, 
+								"unit":"%", "range":Vector3(0, 100, 1) })
+	add_setting({ "name":"crosshair_threshold", "type":SettingType.SLIDER, "list":advanced_list, "default":16., 
+								"unit":"m", "range":Vector3(0, 200, 1) })
+
+
+func create_submenu(p_parent: Control, p_button_name: String, p_layout: Layout, p_hover_pop: bool = true) -> Container:
+	var menu_button: Button = Button.new()
+	if p_button_name.is_empty():
+		menu_button.icon = get_theme_icon("GuiTabMenuHl", "EditorIcons")
+	else:
+		menu_button.set_text(p_button_name)
+	menu_button.set_toggle_mode(true)
+	menu_button.set_v_size_flags(SIZE_SHRINK_CENTER)
+	menu_button.toggled.connect(_on_show_submenu.bind(menu_button))
+	
+	var submenu: PopupPanel = PopupPanel.new()
+	submenu.popup_hide.connect(menu_button.set_pressed.bind(false))
+	var panel_style: StyleBox = get_theme_stylebox("panel", "PopupMenu").duplicate()
+	panel_style.set_content_margin_all(10)
+	submenu.set("theme_override_styles/panel", panel_style)
+	submenu.add_to_group("terrain3d_submenus")
+
+	# Pop up menu on hover, hide on exit
+	if p_hover_pop:
+		menu_button.mouse_entered.connect(_on_show_submenu.bind(true, menu_button))
+		
+	submenu.mouse_entered.connect(func(): submenu.set_meta("mouse_entered", true))
+	
+	submenu.mouse_exited.connect(func():
+		# On mouse_exit, hide popup unless LineEdit focused
+		var focused_element: Control = submenu.gui_get_focus_owner()
+		if not focused_element is LineEdit:
+			_on_show_submenu(false, menu_button)
+			submenu.set_meta("mouse_entered", false)
+			return
+			
+		focused_element.focus_exited.connect(func():
+			# Close submenu once lineedit loses focus
+			if not submenu.get_meta("mouse_entered"):
+				_on_show_submenu(false, menu_button)
+				submenu.set_meta("mouse_entered", false)
+		)
+	)
+	
+	var sublist: Container
+	match(p_layout):
+		Layout.GRID:
+			sublist = GridContainer.new()
+		Layout.VERTICAL:
+			sublist = VBoxContainer.new()
+		Layout.HORIZONTAL, _:
+			sublist = HBoxContainer.new()
+	
+	p_parent.add_child(menu_button, true)
+	menu_button.add_child(submenu, true)
+	submenu.add_child(sublist, true)
+	
+	return sublist
+
+
+func _on_show_submenu(p_toggled: bool, p_button: Button) -> void:
+	# Don't show if mouse already down (from painting)
+	if p_toggled and Input.is_mouse_button_pressed(MOUSE_BUTTON_LEFT):
+		return
+	
+	# Hide menu if mouse is not in button or panel 
+	var button_rect: Rect2 = Rect2(p_button.get_screen_transform().origin, p_button.get_global_rect().size)
+	var in_button: bool = button_rect.has_point(DisplayServer.mouse_get_position())
+	var popup: PopupPanel = p_button.get_child(0)
+	var popup_rect: Rect2 = Rect2(popup.position, popup.size)
+	var in_popup: bool = popup_rect.has_point(DisplayServer.mouse_get_position())
+	if not p_toggled and ( in_button or in_popup ):
+		return
+	
+	# Hide all submenus before possibly enabling the current one
+	get_tree().call_group("terrain3d_submenus", "set_visible", false)
+	popup.set_visible(p_toggled)
+	var popup_pos: Vector2 = p_button.get_screen_transform().origin
+	popup_pos.y -= popup.size.y
+	if popup.get_child_count()>0 and popup.get_child(0) == advanced_list:
+		popup_pos.x -= popup.size.x - p_button.size.x
+	popup.set_position(popup_pos)
+	
+
+func add_brushes(p_parent: Control) -> void:
+	var brush_list: GridContainer = create_submenu(p_parent, "Brush", Layout.GRID)
+	brush_list.name = "BrushList"
+
+	var brush_button_group: ButtonGroup = ButtonGroup.new()
+	brush_button_group.pressed.connect(_on_setting_changed)
+	var default_brush_btn: Button
+	
+	var dir: DirAccess = DirAccess.open(BRUSH_PATH)
+	if dir:
+		dir.list_dir_begin()
+		var file_name = dir.get_next()
+		while file_name != "":
+			if !dir.current_is_dir() and file_name.ends_with(".exr"):
+				var img: Image = Image.load_from_file(BRUSH_PATH + "/" + file_name)
+				var thumbimg: Image = img.duplicate()
+				img.convert(Image.FORMAT_RF)
+
+				if thumbimg.get_width() != 100 and thumbimg.get_height() != 100:
+					thumbimg.resize(100, 100, Image.INTERPOLATE_CUBIC)
+				thumbimg = Terrain3DUtil.black_to_alpha(thumbimg)
+				thumbimg.convert(Image.FORMAT_LA8)
+				var thumbtex: ImageTexture = ImageTexture.create_from_image(thumbimg)
+				
+				var brush_btn: Button = Button.new()
+				brush_btn.set_custom_minimum_size(Vector2.ONE * 100)
+				brush_btn.set_button_icon(thumbtex)
+				brush_btn.set_meta("image", img)
+				brush_btn.set_expand_icon(true)
+				brush_btn.set_material(_get_brush_preview_material())
+				brush_btn.set_toggle_mode(true)
+				brush_btn.set_button_group(brush_button_group)
+				brush_btn.mouse_entered.connect(_on_brush_hover.bind(true, brush_btn))
+				brush_btn.mouse_exited.connect(_on_brush_hover.bind(false, brush_btn))
+				brush_list.add_child(brush_btn, true)
+				if file_name == DEFAULT_BRUSH:
+					default_brush_btn = brush_btn 
+				
+				var lbl: Label = Label.new()
+				brush_btn.name = file_name.get_basename().to_pascal_case()
+				brush_btn.add_child(lbl, true)
+				lbl.text = brush_btn.name
+				lbl.visible = false
+				lbl.position.y = 70
+				lbl.add_theme_color_override("font_shadow_color", Color.BLACK)
+				lbl.add_theme_constant_override("shadow_offset_x", 1)
+				lbl.add_theme_constant_override("shadow_offset_y", 1)
+				lbl.add_theme_font_size_override("font_size", 16)
+				
+			file_name = dir.get_next()
+	
+	brush_list.columns = sqrt(brush_list.get_child_count()) + 2
+	
+	if not default_brush_btn:
+		default_brush_btn = brush_button_group.get_buttons()[0]
+	default_brush_btn.set_pressed(true)
+	_generate_brush_texture(default_brush_btn)
+	
+	settings["brush"] = brush_button_group
+
+	select_brush_button = brush_list.get_parent().get_parent()
+	# Optionally erase the main brush button text and replace it with the texture
+	select_brush_button.set_text("")
+	select_brush_button.set_button_icon(default_brush_btn.get_button_icon())
+	select_brush_button.set_custom_minimum_size(Vector2.ONE * 36)
+	select_brush_button.set_icon_alignment(HORIZONTAL_ALIGNMENT_CENTER)
+	select_brush_button.set_expand_icon(true)
+
+
+func _on_brush_hover(p_hovering: bool, p_button: Button) -> void:
+	if p_button.get_child_count() > 0:
+		var child = p_button.get_child(0)
+		if child is Label:
+			if p_hovering:
+				child.visible = true
+			else:
+				child.visible = false
+
+
+func _on_pick(p_type: Terrain3DEditor.Tool) -> void:
+	emit_signal("picking", p_type, _on_picked)
+
+
+func _on_picked(p_type: Terrain3DEditor.Tool, p_color: Color, p_global_position: Vector3) -> void:
+	match p_type:
+		Terrain3DEditor.HEIGHT:
+			settings["height"].value = p_color.r if not is_nan(p_color.r) else 0.
+		Terrain3DEditor.COLOR:
+			settings["color"].color = p_color if not is_nan(p_color.r) else Color.WHITE
+		Terrain3DEditor.ROUGHNESS:
+			# This converts 0,1 to -100,100
+			# It also quantizes explicitly so picked values matches painted values
+			settings["roughness"].value = round(200. * float(int(p_color.a * 255.) / 255. - .5)) if not is_nan(p_color.r) else 0.
+		Terrain3DEditor.ANGLE:
+			settings["angle"].value = p_color.r
+		Terrain3DEditor.SCALE:
+			settings["scale"].value = p_color.r
+	_on_setting_changed()
+
+
+func _on_point_pick(p_type: Terrain3DEditor.Tool, p_name: String) -> void:
+	assert(p_type == Terrain3DEditor.SCULPT)
+	emit_signal("picking", p_type, _on_point_picked.bind(p_name))
+
+
+func _on_point_picked(p_type: Terrain3DEditor.Tool, p_color: Color, p_global_position: Vector3, p_name: String) -> void:
+	assert(p_type == Terrain3DEditor.SCULPT)
+	var point: Vector3 = p_global_position
+	point.y = p_color.r
+	settings[p_name].add_point(point)
+	_on_setting_changed()
+
+
+func add_setting(p_args: Dictionary) -> void:
+	var p_name: StringName = p_args.get("name", "")
+	var p_label: String = p_args.get("label", "") # Optional replacement for name
+	var p_type: SettingType = p_args.get("type", SettingType.TYPE_MAX)
+	var p_list: Control = p_args.get("list")
+	var p_default: Variant = p_args.get("default")
+	var p_suffix: String = p_args.get("unit", "")
+	var p_range: Vector3 = p_args.get("range", Vector3(0, 0, 1))
+	var p_minimum: float = p_range.x
+	var p_maximum: float = p_range.y
+	var p_step: float = p_range.z
+	var p_flags: int = p_args.get("flags", NONE)
+	
+	if p_name.is_empty() or p_type == SettingType.TYPE_MAX:
+		return
+
+	var container: HBoxContainer = HBoxContainer.new()
+	container.set_v_size_flags(SIZE_EXPAND_FILL)
+	var control: Control	# Houses the setting to be saved
+	var pending_children: Array[Control]
+
+	match p_type:
+		SettingType.LABEL:
+			var label := Label.new()
+			label.set_text(p_label)
+			pending_children.push_back(label)
+			control = label
+
+		SettingType.CHECKBOX:
+			var checkbox := CheckBox.new()
+			if !(p_flags & NO_SAVE):
+				checkbox.set_pressed_no_signal(plugin.get_setting(ES_TOOL_SETTINGS + p_name, p_default))
+				checkbox.toggled.connect( (
+					func(value, path):
+						plugin.set_setting(path, value)
+				).bind(ES_TOOL_SETTINGS + p_name) )
+			else:
+				checkbox.set_pressed_no_signal(p_default)				
+			checkbox.pressed.connect(_on_setting_changed)
+			pending_children.push_back(checkbox)
+			control = checkbox
+			
+		SettingType.COLOR_SELECT:
+			var picker := ColorPickerButton.new()
+			picker.set_custom_minimum_size(Vector2(100, 25))
+			picker.edit_alpha = false
+			picker.get_picker().set_color_mode(ColorPicker.MODE_HSV)
+			if !(p_flags & NO_SAVE):
+				picker.set_pick_color(plugin.get_setting(ES_TOOL_SETTINGS + p_name, p_default))
+				picker.color_changed.connect( (
+					func(value, path):
+						plugin.set_setting(path, value)
+				).bind(ES_TOOL_SETTINGS + p_name) )
+			else:
+				picker.set_pick_color(p_default)
+			picker.color_changed.connect(_on_setting_changed)
+			pending_children.push_back(picker)
+			control = picker
+
+		SettingType.PICKER:
+			var button := Button.new()
+			button.set_v_size_flags(SIZE_SHRINK_CENTER)
+			button.icon = get_theme_icon("ColorPick", "EditorIcons")
+			button.tooltip_text = "Pick value from the Terrain"
+			button.pressed.connect(_on_pick.bind(p_default))
+			pending_children.push_back(button)
+			control = button
+
+		SettingType.MULTI_PICKER:
+			var multi_picker: HBoxContainer = MultiPicker.new()
+			multi_picker.pressed.connect(_on_point_pick.bind(p_default, p_name))
+			multi_picker.value_changed.connect(_on_setting_changed)
+			pending_children.push_back(multi_picker)
+			control = multi_picker
+
+		SettingType.OPTION:
+			var option := OptionButton.new()
+			for i in int(p_maximum):
+				option.add_item("a", i)
+			option.selected = p_minimum
+			option.item_selected.connect(_on_setting_changed)
+			pending_children.push_back(option)
+			control = option
+
+		SettingType.SLIDER, SettingType.DOUBLE_SLIDER:
+			var slider: Control
+			if p_type == SettingType.SLIDER:
+				# Create an editable value box
+				var spin_slider := EditorSpinSlider.new()
+				spin_slider.set_flat(false)
+				spin_slider.set_hide_slider(true)
+				spin_slider.value_changed.connect(_on_setting_changed)
+				spin_slider.set_max(p_maximum)
+				spin_slider.set_min(p_minimum)
+				spin_slider.set_step(p_step)
+				spin_slider.set_suffix(p_suffix)
+				spin_slider.set_v_size_flags(SIZE_SHRINK_CENTER)
+				spin_slider.set_custom_minimum_size(Vector2(65, 0))
+
+				# Create horizontal slider linked to the above box
+				slider = HSlider.new()
+				slider.share(spin_slider)
+				if p_flags & ALLOW_LARGER:
+					slider.set_allow_greater(true)
+				if p_flags & ALLOW_SMALLER:
+					slider.set_allow_lesser(true)
+				
+				pending_children.push_back(slider)
+				pending_children.push_back(spin_slider)
+				control = spin_slider
+						
+			else: # DOUBLE_SLIDER
+				var label := Label.new()
+				label.set_custom_minimum_size(Vector2(60, 0))
+				label.set_horizontal_alignment(HORIZONTAL_ALIGNMENT_CENTER)
+				slider = DoubleSlider.new()
+				slider.label = label
+				slider.suffix = p_suffix
+				slider.value_changed.connect(_on_setting_changed)
+				pending_children.push_back(slider)
+				pending_children.push_back(label)
+				control = slider
+			
+			slider.set_min(p_minimum)
+			slider.set_max(p_maximum)
+			slider.set_step(p_step)
+			slider.set_value(p_default)
+			slider.set_v_size_flags(SIZE_SHRINK_CENTER)
+			slider.set_custom_minimum_size(Vector2(50, 10))
+
+			if !(p_flags & NO_SAVE):
+				slider.set_value(plugin.get_setting(ES_TOOL_SETTINGS + p_name, p_default))
+				slider.value_changed.connect( (
+					func(value, path):
+						plugin.set_setting(path, value)
+				).bind(ES_TOOL_SETTINGS + p_name) )
+			else:
+				slider.set_value(p_default)
+
+	control.name = p_name.to_pascal_case()
+	settings[p_name] = control
+
+	# Setup button labels
+	if not (p_flags & NO_LABEL):
+		# Labels are actually buttons styled to look like labels
+		var label := Button.new()
+		label.set("theme_override_styles/normal", get_theme_stylebox("normal", "Label"))
+		label.set("theme_override_styles/hover", get_theme_stylebox("normal", "Label"))
+		label.set("theme_override_styles/pressed", get_theme_stylebox("normal", "Label"))
+		label.set("theme_override_styles/focus", get_theme_stylebox("normal", "Label"))
+		label.pressed.connect(_on_label_pressed.bind(p_name, p_default))
+		if p_label.is_empty():
+			label.set_text(p_name.capitalize() + ": ")
+		else:
+			label.set_text(p_label.capitalize() + ": ")
+		pending_children.push_front(label)
+
+	# Add separators to front
+	if p_flags & ADD_SEPARATOR:
+		pending_children.push_front(VSeparator.new())
+	if p_flags & ADD_SPACER:
+		var spacer := Control.new()
+		spacer.set_custom_minimum_size(Vector2(5, 0))
+		pending_children.push_front(spacer)
+
+	# Add all children to container and list
+	for child in pending_children:
+		container.add_child(child, true)
+	p_list.add_child(container, true)
+
+
+# If label button is pressed, reset value to default or toggle checkbox
+func _on_label_pressed(p_name: String, p_default: Variant) -> void:
+	var control: Control = settings.get(p_name)
+	if not control:
+		return
+	if control is CheckBox:
+		set_setting(p_name, !control.button_pressed)
+	elif p_default != null:
+		set_setting(p_name, p_default)
+
+
+func get_settings() -> Dictionary:
+	var dict: Dictionary
+	for key in settings.keys():
+		dict[key] = get_setting(key)
+	return dict
+
+
+func get_setting(p_setting: String) -> Variant:
+	var object: Object = settings.get(p_setting)
+	var value: Variant
+	if object is Range:
+		value = object.get_value()
+		# Adjust widths of all sliders on update of values
+		var digits: float = count_digits(value)
+		var width: float = clamp( (1 + count_digits(value)) * 19., 50, 80) * clamp(EditorInterface.get_editor_scale(), .9, 2)
+		object.set_custom_minimum_size(Vector2(width, 0))
+	elif object is DoubleSlider:
+		value = object.get_value()
+	elif object is ButtonGroup: # "brush"
+		value = selected_brush_imgs
+	elif object is CheckBox:
+		value = object.is_pressed()
+	elif object is ColorPickerButton:
+		value = object.color
+	elif object is MultiPicker:
+		value = object.get_points()
+	if value == null:
+		value = 0
+	return value
+
+
+func set_setting(p_setting: String, p_value: Variant) -> void:
+	var object: Object = settings.get(p_setting)
+	if object is DoubleSlider: # Expects p_value is Vector2
+		object.set_value(p_value)
+	elif object is Range:
+		object.set_value(p_value)
+	elif object is ButtonGroup: # Expects p_value is Array [ "button name", boolean ]
+		if p_value is Array and p_value.size() == 2:
+			for button in object.get_buttons():
+				if button.name == p_value[0]:
+					button.button_pressed = p_value[1]
+	elif object is CheckBox:
+		object.button_pressed = p_value
+	elif object is ColorPickerButton:
+		object.color = p_value
+		plugin.set_setting(ES_TOOL_SETTINGS + p_setting, p_value) # Signal doesn't fire on CPB
+	elif object is MultiPicker: # Expects p_value is PackedVector3Array
+		object.points = p_value
+	_on_setting_changed(object)
+
+
+func show_settings(p_settings: PackedStringArray) -> void:
+	for setting in settings.keys():
+		var object: Object = settings[setting]
+		if object is Control:
+			if setting in p_settings:
+				object.get_parent().show()
+			else:
+				object.get_parent().hide()
+	if select_brush_button:
+		if not "brush" in p_settings:
+			select_brush_button.hide()
+		else:
+			select_brush_button.show()
+
+
+func _on_setting_changed(p_setting: Variant = null) -> void:
+	# If a brush was selected
+	if p_setting is Button and p_setting.get_parent().name == "BrushList":
+		_generate_brush_texture(p_setting)
+		# Optionally Set selected brush texture in main brush button
+		if select_brush_button:
+			select_brush_button.set_button_icon(p_setting.get_button_icon())
+		# Hide popup
+		p_setting.get_parent().get_parent().set_visible(false)
+		# Hide label
+		if p_setting.get_child_count() > 0:
+			p_setting.get_child(0).visible = false
+	emit_signal("setting_changed", p_setting)
+
+
+func _generate_brush_texture(p_btn: Button) -> void:
+	if p_btn is Button:
+		var img: Image = p_btn.get_meta("image")
+		if img.get_width() < 1024 and img.get_height() < 1024:
+			img = img.duplicate()
+			img.resize(1024, 1024, Image.INTERPOLATE_CUBIC)
+		var tex: ImageTexture = ImageTexture.create_from_image(img)
+		selected_brush_imgs = [ img, tex ]
+
+
+func _on_drawable_toggled(p_button_pressed: bool) -> void:
+	if not p_button_pressed:
+		settings["gradient_points"].clear()
+
+
+func _get_brush_preview_material() -> ShaderMaterial:
+	if !brush_preview_material:
+		brush_preview_material = ShaderMaterial.new()
+		var shader: Shader = Shader.new()
+		var code: String = "shader_type canvas_item;\n"
+		code += "varying vec4 v_vertex_color;\n"
+		code += "void vertex() {\n"
+		code += "	v_vertex_color = COLOR;\n"
+		code += "}\n"
+		code += "void fragment(){\n"
+		code += "	vec4 tex = texture(TEXTURE, UV);\n"
+		code += "	COLOR.a *= pow(tex.r, 0.666);\n"
+		code += "	COLOR.rgb = v_vertex_color.rgb;\n"
+		code += "}\n"
+		shader.set_code(code)
+		brush_preview_material.set_shader(shader)
+	return brush_preview_material
+
+
+# Counts digits of a number including negative sign, decimal points, and up to 3 decimals 
+func count_digits(p_value: float) -> int:
+	var count: int = 1
+	for i in range(5, 0, -1):
+		if abs(p_value) >= pow(10, i):
+			count = i+1
+			break
+	if p_value - floor(p_value) >= .1:
+		count += 1 # For the decimal
+		if p_value*10 - floor(p_value*10.) >= .1: 
+			count += 1
+			if p_value*100 - floor(p_value*100.) >= .1: 
+				count += 1
+				if p_value*1000 - floor(p_value*1000.) >= .1: 
+					count += 1
+	# Negative sign
+	if p_value < 0:
+		count += 1
+	return count
+	
--- a/addons/terrain_3d/src/tool_settings.gd.uid
+++ b/addons/terrain_3d/src/tool_settings.gd.uid
@@ -0,0 +1 @@
+uid://ciskaaennrffu
--- a/addons/terrain_3d/src/toolbar.gd
+++ b/addons/terrain_3d/src/toolbar.gd
@@ -0,0 +1,154 @@
+# Copyright © 2025 Cory Petkovsek, Roope Palmroos, and Contributors.
+# Toolbar for Terrain3D
+extends VFlowContainer
+
+signal tool_changed(p_tool: Terrain3DEditor.Tool, p_operation: Terrain3DEditor.Operation)
+
+const ICON_REGION_ADD: String = "res://addons/terrain_3d/icons/region_add.svg"
+const ICON_REGION_REMOVE: String = "res://addons/terrain_3d/icons/region_remove.svg"
+const ICON_HEIGHT_ADD: String = "res://addons/terrain_3d/icons/height_add.svg"
+const ICON_HEIGHT_SUB: String = "res://addons/terrain_3d/icons/height_sub.svg"
+const ICON_HEIGHT_FLAT: String = "res://addons/terrain_3d/icons/height_flat.svg"
+const ICON_HEIGHT_SLOPE: String = "res://addons/terrain_3d/icons/height_slope.svg"
+const ICON_HEIGHT_SMOOTH: String = "res://addons/terrain_3d/icons/height_smooth.svg"
+const ICON_PAINT_TEXTURE: String = "res://addons/terrain_3d/icons/texture_paint.svg"
+const ICON_SPRAY_TEXTURE: String = "res://addons/terrain_3d/icons/texture_spray.svg"
+const ICON_COLOR: String = "res://addons/terrain_3d/icons/color_paint.svg"
+const ICON_WETNESS: String = "res://addons/terrain_3d/icons/wetness.svg"
+const ICON_AUTOSHADER: String = "res://addons/terrain_3d/icons/autoshader.svg"
+const ICON_HOLES: String = "res://addons/terrain_3d/icons/holes.svg"
+const ICON_NAVIGATION: String = "res://addons/terrain_3d/icons/navigation.svg"
+const ICON_INSTANCER: String = "res://addons/terrain_3d/icons/multimesh.svg"
+
+var add_tool_group: ButtonGroup = ButtonGroup.new()
+var sub_tool_group: ButtonGroup = ButtonGroup.new()
+var buttons: Dictionary
+
+
+func _init() -> void:
+	set_custom_minimum_size(Vector2(20, 0))
+
+
+func _ready() -> void:
+	add_tool_group.pressed.connect(_on_tool_selected)
+	sub_tool_group.pressed.connect(_on_tool_selected)
+
+	add_tool_button({ "tool":Terrain3DEditor.REGION, 
+		"add_text":"Add Region (E)", "add_op":Terrain3DEditor.ADD, "add_icon":ICON_REGION_ADD,
+		"sub_text":"Remove Region", "sub_op":Terrain3DEditor.SUBTRACT, "sub_icon":ICON_REGION_REMOVE })
+	
+	add_child(HSeparator.new())
+	
+	add_tool_button({ "tool":Terrain3DEditor.SCULPT, 
+		"add_text":"Raise (R)", "add_op":Terrain3DEditor.ADD, "add_icon":ICON_HEIGHT_ADD,
+		"sub_text":"Lower (R)", "sub_op":Terrain3DEditor.SUBTRACT, "sub_icon":ICON_HEIGHT_SUB })
+
+	add_tool_button({ "tool":Terrain3DEditor.SCULPT, 
+		"add_text":"Smooth (Shift)", "add_op":Terrain3DEditor.AVERAGE, "add_icon":ICON_HEIGHT_SMOOTH })
+
+	add_tool_button({ "tool":Terrain3DEditor.HEIGHT, 
+		"add_text":"Height (H)", "add_op":Terrain3DEditor.ADD, "add_icon":ICON_HEIGHT_FLAT,
+		"sub_text":"Height (H)", "sub_op":Terrain3DEditor.SUBTRACT, "sub_icon":ICON_HEIGHT_FLAT })
+
+	add_tool_button({ "tool":Terrain3DEditor.SCULPT, 
+		"add_text":"Slope (S)", "add_op":Terrain3DEditor.GRADIENT, "add_icon":ICON_HEIGHT_SLOPE })
+
+	add_child(HSeparator.new())
+
+	add_tool_button({ "tool":Terrain3DEditor.TEXTURE, 
+		"add_text":"Paint Texture (B)", "add_op":Terrain3DEditor.REPLACE, "add_icon":ICON_PAINT_TEXTURE })
+
+	add_tool_button({ "tool":Terrain3DEditor.TEXTURE, 
+		"add_text":"Spray Texture (V)", "add_op":Terrain3DEditor.ADD, "add_icon":ICON_SPRAY_TEXTURE })
+
+	add_tool_button({ "tool":Terrain3DEditor.AUTOSHADER,
+		"add_text":"Paint Autoshader (A)", "add_op":Terrain3DEditor.ADD, "add_icon":ICON_AUTOSHADER,
+		"sub_text":"Disable Autoshader (A)", "sub_op":Terrain3DEditor.SUBTRACT })
+
+	add_child(HSeparator.new())
+
+	add_tool_button({ "tool":Terrain3DEditor.COLOR,
+		"add_text":"Paint Color (C)", "add_op":Terrain3DEditor.ADD, "add_icon":ICON_COLOR,
+		"sub_text":"Remove Color (C)", "sub_op":Terrain3DEditor.SUBTRACT })
+	
+	add_tool_button({ "tool":Terrain3DEditor.ROUGHNESS,
+		"add_text":"Paint Wetness (W)", "add_op":Terrain3DEditor.ADD, "add_icon":ICON_WETNESS,
+		"sub_text":"Remove Wetness (W)", "sub_op":Terrain3DEditor.SUBTRACT })
+
+	add_child(HSeparator.new())
+
+	add_tool_button({ "tool":Terrain3DEditor.HOLES,
+		"add_text":"Add Holes (X)", "add_op":Terrain3DEditor.ADD, "add_icon":ICON_HOLES,
+		"sub_text":"Remove Holes (X)", "sub_op":Terrain3DEditor.SUBTRACT })
+
+	add_tool_button({ "tool":Terrain3DEditor.NAVIGATION,
+		"add_text":"Paint Navigable Area (N)", "add_op":Terrain3DEditor.ADD, "add_icon":ICON_NAVIGATION,
+		"sub_text":"Remove Navigable Area (N)", "sub_op":Terrain3DEditor.SUBTRACT })
+
+	add_tool_button({ "tool":Terrain3DEditor.INSTANCER,
+		"add_text":"Instance Meshes (I)", "add_op":Terrain3DEditor.ADD, "add_icon":ICON_INSTANCER,
+		"sub_text":"Remove Meshes (I)", "sub_op":Terrain3DEditor.SUBTRACT })
+
+	# Select first button
+	var buttons: Array[BaseButton] = add_tool_group.get_buttons()
+	buttons[0].set_pressed(true)
+	show_add_buttons(true)
+
+
+func add_tool_button(p_params: Dictionary) -> void:
+	# Additive button
+	var button := Button.new()
+	var name_str: String = p_params.get("add_text", "blank").get_slice('(', 0).to_pascal_case()
+	button.set_name(name_str)
+	button.set_meta("Tool", p_params.get("tool", 0))
+	button.set_meta("Operation", p_params.get("add_op", 0))
+	button.set_meta("ID", add_tool_group.get_buttons().size() + 1)
+	button.set_tooltip_text(p_params.get("add_text", "blank"))
+	button.set_button_icon(load(p_params.get("add_icon")))
+	button.set_flat(true)
+	button.set_toggle_mode(true)
+	button.set_h_size_flags(SIZE_SHRINK_END)
+	button.set_button_group(p_params.get("group", add_tool_group))
+	add_child(button, true)
+	buttons[button.get_name()] = button
+
+	# Subtractive button
+	var button2: Button
+	if p_params.has("sub_text"):
+		button2 = Button.new()
+		name_str = p_params.get("sub_text", "blank").get_slice('(', 0).to_pascal_case()
+		button2.set_name(name_str)
+		button2.set_meta("Tool", p_params.get("tool", 0))
+		button2.set_meta("Operation", p_params.get("sub_op", 0))
+		button2.set_meta("ID", button.get_meta("ID"))
+		button2.set_tooltip_text(p_params.get("sub_text", "blank"))
+		button2.set_button_icon(load(p_params.get("sub_icon", p_params.get("add_icon"))))
+		button2.set_flat(true)
+		button2.set_toggle_mode(true)
+		button2.set_h_size_flags(SIZE_SHRINK_END)
+	else:
+		button2 = button.duplicate()
+	button2.set_button_group(p_params.get("group", sub_tool_group))
+	add_child(button2, true)
+	buttons[button2.get_name()] = button
+
+
+func get_button(p_name: String) -> Button:
+	return buttons.get(p_name, null)
+
+
+func show_add_buttons(p_enable: bool) -> void:
+	for button in add_tool_group.get_buttons():
+		button.visible = p_enable
+	for button in sub_tool_group.get_buttons():
+		button.visible = !p_enable
+
+
+func _on_tool_selected(p_button: BaseButton) -> void:
+	# Select same tool on negative bar
+	var group: ButtonGroup = p_button.get_button_group()
+	var change_group: ButtonGroup = add_tool_group if group == sub_tool_group else sub_tool_group
+	var id: int = p_button.get_meta("ID", -2)
+	for button in change_group.get_buttons():
+		button.set_pressed_no_signal(button.get_meta("ID", -1) == id)
+	emit_signal("tool_changed", p_button.get_meta("Tool", Terrain3DEditor.TOOL_MAX), p_button.get_meta("Operation", Terrain3DEditor.OP_MAX))
--- a/addons/terrain_3d/src/toolbar.gd.uid
+++ b/addons/terrain_3d/src/toolbar.gd.uid
@@ -0,0 +1 @@
+uid://b1j37u6utjbom
--- a/addons/terrain_3d/src/ui.gd
+++ b/addons/terrain_3d/src/ui.gd
@@ -0,0 +1,576 @@
+# Copyright © 2025 Cory Petkovsek, Roope Palmroos, and Contributors.
+# UI for Terrain3D
+extends Node
+
+
+# Includes
+const TerrainMenu: Script = preload("res://addons/terrain_3d/menu/terrain_menu.gd")
+const Toolbar: Script = preload("res://addons/terrain_3d/src/toolbar.gd")
+const ToolSettings: Script = preload("res://addons/terrain_3d/src/tool_settings.gd")
+const OperationBuilder: Script = preload("res://addons/terrain_3d/src/operation_builder.gd")
+const GradientOperationBuilder: Script = preload("res://addons/terrain_3d/src/gradient_operation_builder.gd")
+const COLOR_RAISE := Color.WHITE
+const COLOR_LOWER := Color.BLACK
+const COLOR_SMOOTH := Color(0.5, 0, .2)
+const COLOR_LIFT := Color.ORANGE
+const COLOR_FLATTEN := Color.BLUE_VIOLET
+const COLOR_HEIGHT := Color(0., 0.32, .4)
+const COLOR_SLOPE := Color.YELLOW
+const COLOR_PAINT := Color.DARK_GREEN
+const COLOR_SPRAY := Color.PALE_GREEN
+const COLOR_ROUGHNESS := Color.ROYAL_BLUE
+const COLOR_AUTOSHADER := Color.DODGER_BLUE
+const COLOR_HOLES := Color.BLACK
+const COLOR_NAVIGATION := Color(.28, .0, .25)
+const COLOR_INSTANCER := Color.CRIMSON
+const COLOR_PICK_COLOR := Color.WHITE
+const COLOR_PICK_HEIGHT := Color.DARK_RED
+const COLOR_PICK_ROUGH := Color.ROYAL_BLUE
+
+const OP_NONE: int = 0x0
+const OP_POSITIVE_ONLY: int = 0x01
+const OP_NEGATIVE_ONLY: int = 0x02
+
+const RING1: String = "res://addons/terrain_3d/brushes/ring1.exr"
+var ring_texture : ImageTexture
+@onready var region_texture := ImageTexture.new() :
+	set(value):
+		var image: Image = Image.create_empty(1, 1, false, Image.FORMAT_R8)
+		image.fill(Color.WHITE)
+		value.create_from_image(image)
+		region_texture = value
+var plugin: EditorPlugin # Actually Terrain3DEditorPlugin, but Godot still has CRC errors
+var toolbar: Toolbar
+var tool_settings: ToolSettings
+var terrain_menu: TerrainMenu
+var setting_has_changed: bool = false
+var visible: bool = false
+var picking: int = Terrain3DEditor.TOOL_MAX
+var picking_callback: Callable
+var brush_data: Dictionary
+var operation_builder: OperationBuilder
+var active_tool: Terrain3DEditor.Tool
+var _selected_tool: Terrain3DEditor.Tool
+var active_operation: Terrain3DEditor.Operation
+var _selected_operation: Terrain3DEditor.Operation
+var inverted_input: bool = false
+
+# Editor decals, indices; 0 = main brush, 1 = slope point A, 2 = slope point B
+var mat_rid: RID
+var editor_decal_position: Array[Vector2] = [Vector2(), Vector2(), Vector2()]
+var editor_decal_rotation: Array[float] = [float(), float(), float()]
+var editor_decal_size: Array[float] = [float(), float(), float()]
+var editor_decal_color: Array[Color] = [Color(), Color(), Color()]
+var editor_decal_visible: Array[bool] = [bool(), bool(), bool()]
+var editor_brush_texture_rid: RID = RID()
+var editor_decal_timer: Timer
+var editor_decal_fade: float :
+	set(value):
+		editor_decal_fade = value
+		if editor_decal_color.size() > 0:
+			editor_decal_color[0].a = value
+			if is_shader_valid():
+				RenderingServer.material_set_param(mat_rid, "_editor_decal_color", editor_decal_color)
+				if value < 0.001:
+					var r_map: PackedInt32Array = plugin.terrain.data.get_region_map()
+					RenderingServer.material_set_param(mat_rid, "_region_map", r_map)
+var editor_ring_texture_rid: RID
+
+
+func _enter_tree() -> void:
+	toolbar = Toolbar.new()
+	toolbar.hide()
+	toolbar.tool_changed.connect(_on_tool_changed)
+	
+	tool_settings = ToolSettings.new()
+	tool_settings.setting_changed.connect(_on_setting_changed)
+	tool_settings.picking.connect(_on_picking)
+	tool_settings.plugin = plugin
+	tool_settings.hide()
+
+	terrain_menu = TerrainMenu.new()
+	terrain_menu.plugin = plugin
+	terrain_menu.hide()
+
+	plugin.add_control_to_container(EditorPlugin.CONTAINER_SPATIAL_EDITOR_SIDE_LEFT, toolbar)
+	plugin.add_control_to_container(EditorPlugin.CONTAINER_SPATIAL_EDITOR_BOTTOM, tool_settings)
+	plugin.add_control_to_container(EditorPlugin.CONTAINER_SPATIAL_EDITOR_MENU, terrain_menu)
+
+	_on_tool_changed(Terrain3DEditor.REGION, Terrain3DEditor.ADD)
+	
+	editor_decal_timer = Timer.new()
+	editor_decal_timer.wait_time = .5
+	editor_decal_timer.one_shot = true
+	editor_decal_timer.timeout.connect(func():
+		get_tree().create_tween().tween_property(self, "editor_decal_fade", 0.0, 0.15))
+	add_child(editor_decal_timer)
+
+
+func _ready() -> void:
+	var img: Image = Image.load_from_file(RING1)
+	img.convert(Image.FORMAT_R8)
+	ring_texture = ImageTexture.create_from_image(img)
+	editor_ring_texture_rid = ring_texture.get_rid()
+
+
+func _exit_tree() -> void:
+	plugin.remove_control_from_container(EditorPlugin.CONTAINER_SPATIAL_EDITOR_SIDE_LEFT, toolbar)
+	plugin.remove_control_from_container(EditorPlugin.CONTAINER_SPATIAL_EDITOR_BOTTOM, tool_settings)
+	toolbar.queue_free()
+	tool_settings.queue_free()
+	terrain_menu.queue_free()
+	editor_decal_timer.queue_free()
+
+
+func set_visible(p_visible: bool, p_menu_only: bool = false) -> void:
+	terrain_menu.set_visible(p_visible)
+
+	if p_menu_only:
+		toolbar.set_visible(false)
+		tool_settings.set_visible(false)
+	else:
+		visible = p_visible
+		toolbar.set_visible(p_visible)
+		tool_settings.set_visible(p_visible)
+		update_decal()
+
+	if plugin.editor:
+		if p_visible:
+			await get_tree().create_timer(.01).timeout # Won't work, otherwise
+			_on_tool_changed(_selected_tool, _selected_operation)
+		else:
+			plugin.editor.set_tool(Terrain3DEditor.TOOL_MAX)
+			plugin.editor.set_operation(Terrain3DEditor.OP_MAX)
+
+	
+func set_menu_visibility(p_list: Control, p_visible: bool) -> void:
+	if p_list:
+		p_list.get_parent().get_parent().visible = p_visible
+	
+
+func _on_tool_changed(p_tool: Terrain3DEditor.Tool, p_operation: Terrain3DEditor.Operation) -> void:
+	_selected_tool = p_tool
+	_selected_operation = p_operation
+	clear_picking()
+	set_menu_visibility(tool_settings.advanced_list, true)
+	set_menu_visibility(tool_settings.scale_list, false)
+	set_menu_visibility(tool_settings.rotation_list, false)
+	set_menu_visibility(tool_settings.height_list, false)
+	set_menu_visibility(tool_settings.color_list, false)
+
+	# Select which settings to show. Options in tool_settings.gd:_ready
+	var to_show: PackedStringArray = []
+	
+	match _selected_tool:
+		Terrain3DEditor.REGION:
+			to_show.push_back("instructions")
+			to_show.push_back("invert")
+			set_menu_visibility(tool_settings.advanced_list, false)
+
+		Terrain3DEditor.SCULPT:
+			to_show.push_back("brush")
+			to_show.push_back("size")
+			to_show.push_back("strength")
+			if _selected_operation in [Terrain3DEditor.ADD, Terrain3DEditor.SUBTRACT]:
+					to_show.push_back("invert")
+			elif _selected_operation == Terrain3DEditor.GRADIENT:
+				to_show.push_back("gradient_points")
+				to_show.push_back("drawable")
+
+		Terrain3DEditor.HEIGHT:
+			to_show.push_back("brush")
+			to_show.push_back("size")
+			to_show.push_back("strength")
+			to_show.push_back("height")
+			to_show.push_back("height_picker")
+			to_show.push_back("invert")
+
+		Terrain3DEditor.TEXTURE:
+			to_show.push_back("brush")
+			to_show.push_back("size")
+			to_show.push_back("enable_texture")
+			if _selected_operation == Terrain3DEditor.ADD:
+				to_show.push_back("strength")
+				to_show.push_back("invert")
+			to_show.push_back("slope")
+			to_show.push_back("enable_angle")
+			to_show.push_back("angle")
+			to_show.push_back("angle_picker")
+			to_show.push_back("dynamic_angle")
+			to_show.push_back("enable_scale")
+			to_show.push_back("scale")
+			to_show.push_back("scale_picker")
+
+		Terrain3DEditor.COLOR:
+			to_show.push_back("brush")
+			to_show.push_back("size")
+			to_show.push_back("strength")
+			to_show.push_back("color")
+			to_show.push_back("color_picker")
+			to_show.push_back("slope")
+			to_show.push_back("texture_filter")
+			to_show.push_back("margin")
+			to_show.push_back("invert")
+
+		Terrain3DEditor.ROUGHNESS:
+			to_show.push_back("brush")
+			to_show.push_back("size")
+			to_show.push_back("strength")
+			to_show.push_back("roughness")
+			to_show.push_back("roughness_picker")
+			to_show.push_back("slope")
+			to_show.push_back("texture_filter")
+			to_show.push_back("margin")
+			to_show.push_back("invert")
+
+		Terrain3DEditor.AUTOSHADER, Terrain3DEditor.HOLES, Terrain3DEditor.NAVIGATION:
+			to_show.push_back("brush")
+			to_show.push_back("size")
+			to_show.push_back("invert")
+
+		Terrain3DEditor.INSTANCER:
+			to_show.push_back("size")
+			to_show.push_back("strength")
+			to_show.push_back("slope")
+			set_menu_visibility(tool_settings.height_list, true)
+			to_show.push_back("height_offset")
+			to_show.push_back("random_height")
+			set_menu_visibility(tool_settings.scale_list, true)
+			to_show.push_back("fixed_scale")
+			to_show.push_back("random_scale")
+			set_menu_visibility(tool_settings.rotation_list, true)
+			to_show.push_back("fixed_spin")
+			to_show.push_back("random_spin")
+			to_show.push_back("fixed_tilt")
+			to_show.push_back("random_tilt")
+			to_show.push_back("align_to_normal")
+			set_menu_visibility(tool_settings.color_list, true)
+			to_show.push_back("vertex_color")
+			to_show.push_back("random_darken")
+			to_show.push_back("random_hue")
+			to_show.push_back("invert")
+
+		_:
+			pass
+
+	# Advanced menu settings
+	to_show.push_back("auto_regions")
+	to_show.push_back("align_to_view")
+	to_show.push_back("show_cursor_while_painting")
+	to_show.push_back("gamma")
+	to_show.push_back("jitter")
+	to_show.push_back("crosshair_threshold")
+	tool_settings.show_settings(to_show)
+
+	operation_builder = null
+	if _selected_operation == Terrain3DEditor.GRADIENT:
+		operation_builder = GradientOperationBuilder.new()
+		operation_builder.tool_settings = tool_settings
+
+	_on_setting_changed()
+	plugin.update_region_grid()
+
+
+func _on_setting_changed(p_setting: Variant = null) -> void:
+	if not plugin.asset_dock: # Skip function if not _ready()
+		return
+	brush_data = tool_settings.get_settings()
+	brush_data["asset_id"] = plugin.asset_dock.get_current_list().get_selected_id()
+	if plugin.editor:
+		plugin.editor.set_brush_data(brush_data)
+	inverted_input = brush_data.get("invert", false)
+	if p_setting is CheckBox and p_setting.name == &"Invert":
+		plugin._read_input() # Revalidate keyboard input for modifier_ctrl
+	set_active_operation()
+	update_decal()
+
+
+# Change tool/operation based on modifiers. Called from:
+# * editor_plugin.gd:_read_input() - when a modifier key is pressed
+# * _on_tool_changed() via:
+# * _on_setting_changed() eg. Touchscreen Invert
+func set_active_operation() -> void:
+	var inverted: bool = plugin.modifier_ctrl || inverted_input
+
+	# Toggle toolbar buttons
+	toolbar.show_add_buttons(not inverted)
+	
+	# If Shift, Smoothness 
+	if plugin.modifier_shift and not inverted:
+		active_tool = Terrain3DEditor.SCULPT
+		active_operation = Terrain3DEditor.AVERAGE	
+	
+	# Else if Ctrl/Invert checked, opposite
+	elif _selected_operation == Terrain3DEditor.ADD and inverted:
+		active_tool = _selected_tool
+		active_operation = Terrain3DEditor.SUBTRACT
+	elif _selected_operation == Terrain3DEditor.SUBTRACT and not inverted:
+		active_tool = _selected_tool
+		active_operation = Terrain3DEditor.ADD
+
+	# Else use default and set
+	else:
+		active_tool = _selected_tool
+		active_operation = _selected_operation
+
+	if plugin.editor:
+		plugin.editor.set_tool(active_tool)
+		plugin.editor.set_operation(active_operation)
+
+
+func update_decal() -> void:
+	if not plugin.terrain or brush_data.size() <= 3:
+		return
+	mat_rid = plugin.terrain.material.get_material_rid()
+	editor_decal_timer.start()
+	
+	# If not a state that should show the decal, hide everything and return
+	if not visible or \
+		plugin._input_mode < 0 or \
+		# After moving camera, wait for mouse cursor to update before revealing
+		# See https://github.com/godotengine/godot/issues/70098
+		Time.get_ticks_msec() - plugin.rmb_release_time <= 100 or \
+		(plugin._input_mode > 0 and not brush_data["show_cursor_while_painting"]):
+			hide_decal()
+			return
+	
+	reset_decal_arrays()
+	editor_decal_position[0] = Vector2(plugin.mouse_global_position.x, plugin.mouse_global_position.z)
+	editor_decal_visible[0] = true
+	# Set region size, and modify region map for none background mode.
+	var r_map: PackedInt32Array = plugin.terrain.data.get_region_map()
+	if plugin.editor.get_tool() == Terrain3DEditor.REGION:
+		var r_size: float = float(plugin.terrain.get_region_size()) * plugin.terrain.get_vertex_spacing()
+		var map_size: int = plugin.terrain.data.REGION_MAP_SIZE
+		var half_r_size: float = r_size * 0.5
+		var pos: Vector2 = (Vector2(plugin.mouse_global_position.x, plugin.mouse_global_position.z) +
+			Vector2(half_r_size, half_r_size)).snappedf(r_size) - Vector2(half_r_size, half_r_size)
+		editor_brush_texture_rid = region_texture.get_rid()
+		editor_decal_position[0] = pos
+		editor_decal_size[0] = r_size
+		editor_decal_rotation[0] = 0.0
+		
+		var loc: Vector2i = plugin.terrain.data.get_region_location(plugin.mouse_global_position)
+		loc += Vector2i(map_size / 2, map_size / 2)
+		if !(loc.x < 0 or loc.x > map_size - 1 or loc.y < 0 or loc.y > map_size - 1):
+			var index: int = clampi(loc.y * map_size + loc.x, 0, map_size * map_size - 1)
+			if plugin.terrain.material.get_world_background() == Terrain3DMaterial.WorldBackground.NONE:
+				if r_map[index] == 0 and active_operation == Terrain3DEditor.ADD:
+					r_map[index] = -index - 1
+				else:
+					r_map[index] = r_map[index]
+			
+			match active_operation:
+				Terrain3DEditor.ADD:
+					if r_map[index] <= 0:
+						editor_decal_color[0] = Color.WHITE
+						editor_decal_color[0].a = 0.25
+					else:
+						hide_decal()
+				
+				Terrain3DEditor.SUBTRACT:
+					if r_map[index] > 0:
+						editor_decal_color[0] = Color.WHITE * .15
+						editor_decal_color[0].a = 0.75
+					else:
+						hide_decal()
+		else:
+			hide_decal()
+	# Set texture and color
+	elif picking != Terrain3DEditor.TOOL_MAX:
+		editor_brush_texture_rid = ring_texture.get_rid()
+		editor_decal_size[0] = 10. * plugin.terrain.get_vertex_spacing()
+		match picking:
+			Terrain3DEditor.HEIGHT:
+				editor_decal_color[0] = COLOR_PICK_HEIGHT
+			Terrain3DEditor.COLOR:
+				editor_decal_color[0] = COLOR_PICK_COLOR
+			Terrain3DEditor.ROUGHNESS:
+				editor_decal_color[0] = COLOR_PICK_ROUGH
+		editor_decal_color[0].a = 1.0
+	else:
+		editor_brush_texture_rid = brush_data["brush"][1].get_rid()
+		editor_decal_size[0] = maxf(brush_data["size"], .5)
+		if brush_data["align_to_view"]:
+			var cam: Camera3D = plugin.terrain.get_camera();
+			if (cam):
+				editor_decal_rotation[0] = cam.rotation.y
+			else:
+				editor_decal_rotation[0] = 0.
+		match plugin.editor.get_tool():
+			Terrain3DEditor.SCULPT:
+				match active_operation:
+					Terrain3DEditor.ADD:
+						if plugin.modifier_alt:
+							editor_decal_color[0] = COLOR_LIFT
+							editor_decal_color[0].a = clamp(brush_data["strength"], .2, .5)
+						else:
+							editor_decal_color[0] = COLOR_RAISE
+							editor_decal_color[0].a = clamp(brush_data["strength"], .25, .5)
+					Terrain3DEditor.SUBTRACT:
+						if plugin.modifier_alt:
+							editor_decal_color[0] = COLOR_FLATTEN
+							editor_decal_color[0].a = clamp(brush_data["strength"], .25, .5) + .1
+						else:
+							editor_decal_color[0] = COLOR_LOWER
+							editor_decal_color[0].a = clamp(brush_data["strength"], .2, .5) + .25
+					Terrain3DEditor.AVERAGE:
+						editor_decal_color[0] = COLOR_SMOOTH
+						editor_decal_color[0].a = clamp(brush_data["strength"], .2, .5) + .25
+					Terrain3DEditor.GRADIENT:
+						editor_decal_color[0] = COLOR_SLOPE
+						editor_decal_color[0].a = clamp(brush_data["strength"], .2, .4)
+			Terrain3DEditor.HEIGHT:
+				editor_decal_color[0] = COLOR_HEIGHT
+				editor_decal_color[0].a = clamp(brush_data["strength"], .2, .5) + .25
+			Terrain3DEditor.TEXTURE:
+				match active_operation:
+					Terrain3DEditor.REPLACE:
+						editor_decal_color[0] = COLOR_PAINT
+						editor_decal_color[0].a = .6
+					Terrain3DEditor.SUBTRACT:
+						editor_decal_color[0] = COLOR_PAINT
+						editor_decal_color[0].a = clamp(brush_data["strength"], .2, .5) + .1
+					Terrain3DEditor.ADD:
+						editor_decal_color[0] = COLOR_SPRAY
+						editor_decal_color[0].a = clamp(brush_data["strength"], .15, .4)
+			Terrain3DEditor.COLOR:
+				editor_decal_color[0] = brush_data["color"].srgb_to_linear()
+				editor_decal_color[0].a *= clamp(brush_data["strength"], .2, .5)
+			Terrain3DEditor.ROUGHNESS:
+				editor_decal_color[0] = COLOR_ROUGHNESS
+				editor_decal_color[0].a = clamp(brush_data["strength"], .2, .5) + .1
+			Terrain3DEditor.AUTOSHADER:
+				editor_decal_color[0] = COLOR_AUTOSHADER
+				editor_decal_color[0].a = .6
+			Terrain3DEditor.HOLES:
+				editor_decal_color[0] = COLOR_HOLES
+				editor_decal_color[0].a = .75
+			Terrain3DEditor.NAVIGATION:
+				editor_decal_color[0] = COLOR_NAVIGATION
+				editor_decal_color[0].a = .80
+			Terrain3DEditor.INSTANCER:
+				editor_brush_texture_rid = ring_texture.get_rid()
+				editor_decal_color[0] = COLOR_INSTANCER
+				editor_decal_color[0].a = .75
+	
+	editor_decal_visible[1] = false
+	editor_decal_visible[2] = false
+	
+	if active_operation == Terrain3DEditor.GRADIENT:
+		var point1: Vector3 = brush_data["gradient_points"][0]
+		if point1 != Vector3.ZERO:
+			editor_decal_color[1] = COLOR_SLOPE
+			editor_decal_size[1] = 10. * plugin.terrain.get_vertex_spacing()
+			editor_decal_visible[1] = true
+			editor_decal_position[1] = Vector2(point1.x, point1.z)
+		var point2: Vector3 = brush_data["gradient_points"][1]
+		if point2 != Vector3.ZERO:
+			editor_decal_color[2] = COLOR_SLOPE
+			editor_decal_size[2] = 10. * plugin.terrain.get_vertex_spacing()
+			editor_decal_visible[2] = true
+			editor_decal_position[2] = Vector2(point2.x, point2.z)
+	
+	if RenderingServer.get_current_rendering_method().contains("gl_compatibility"):
+		for i in editor_decal_color.size():
+			editor_decal_color[i].a = maxf(0.1, editor_decal_color[i].a - .25)
+	
+	editor_decal_fade = editor_decal_color[0].a
+	# Update Shader params
+	if is_shader_valid():
+		RenderingServer.material_set_param(mat_rid, "_editor_brush_texture", editor_brush_texture_rid)
+		RenderingServer.material_set_param(mat_rid, "_editor_ring_texture", editor_ring_texture_rid)
+		RenderingServer.material_set_param(mat_rid, "_editor_decal_position", editor_decal_position)
+		RenderingServer.material_set_param(mat_rid, "_editor_decal_rotation", editor_decal_rotation)
+		RenderingServer.material_set_param(mat_rid, "_editor_decal_size", editor_decal_size)
+		RenderingServer.material_set_param(mat_rid, "_editor_decal_color", editor_decal_color)
+		RenderingServer.material_set_param(mat_rid, "_editor_decal_visible", editor_decal_visible)
+		RenderingServer.material_set_param(mat_rid, "_editor_crosshair_threshold", brush_data["crosshair_threshold"] + 0.1)
+		RenderingServer.material_set_param(mat_rid, "_region_map", r_map)
+
+
+func is_shader_valid() -> bool:
+	# As long as the compiled shader contains at least 1 uniform, we can use it to check
+	# if the shader compilation has failed, as this will then return an empty dictionary.
+	if not plugin.terrain:
+		return false
+	var params = RenderingServer.get_shader_parameter_list(plugin.terrain.material.get_shader_rid())
+	if params.is_empty():
+		return false
+	else:
+		return true
+
+
+func hide_decal() -> void:
+	editor_decal_visible = [false, false, false]
+	if is_shader_valid():
+		var r_map: PackedInt32Array = plugin.terrain.data.get_region_map()
+		RenderingServer.material_set_param(mat_rid, "_editor_decal_visible", editor_decal_visible)
+		RenderingServer.material_set_param(mat_rid, "_region_map", r_map)
+
+
+# These array sizes are reset to 0 when closing scenes for some unknown reason, so check and reset
+func reset_decal_arrays() -> void:
+	if editor_decal_color.size() < 3:
+		editor_decal_position = [Vector2(), Vector2(), Vector2()]
+		editor_decal_rotation = [float(), float(), float()]
+		editor_decal_size = [float(), float(), float()]
+		editor_decal_color = [Color(), Color(), Color()]
+		editor_decal_visible = [false, false, false]
+		editor_brush_texture_rid = RID()
+
+
+func set_decal_rotation(p_rot: float) -> void:
+	editor_decal_rotation[0] = p_rot
+	if is_shader_valid():
+		RenderingServer.material_set_param(mat_rid, "_editor_decal_rotation", editor_decal_rotation)
+
+
+func _on_picking(p_type: Terrain3DEditor.Tool, p_callback: Callable) -> void:
+	picking = p_type
+	picking_callback = p_callback
+	update_decal()
+
+
+func clear_picking() -> void:
+	picking = Terrain3DEditor.TOOL_MAX
+
+
+func is_picking() -> bool:
+	if picking != Terrain3DEditor.TOOL_MAX:
+		return true
+	
+	if operation_builder and operation_builder.is_picking():
+		return true
+	
+	return false
+
+
+func pick(p_global_position: Vector3) -> void:
+	if picking != Terrain3DEditor.TOOL_MAX:
+		var color: Color
+		match picking:
+			Terrain3DEditor.HEIGHT, Terrain3DEditor.SCULPT:
+				color = Color(plugin.terrain.data.get_height(p_global_position), 0., 0., 1.)
+			Terrain3DEditor.ROUGHNESS:
+				color = plugin.terrain.data.get_pixel(Terrain3DRegion.TYPE_COLOR, p_global_position)
+			Terrain3DEditor.COLOR:
+				color = plugin.terrain.data.get_color(p_global_position)
+			Terrain3DEditor.ANGLE:
+				color = Color(plugin.terrain.data.get_control_angle(p_global_position), 0., 0., 1.)
+			Terrain3DEditor.SCALE:
+				color = Color(plugin.terrain.data.get_control_scale(p_global_position), 0., 0., 1.)
+			_:
+				push_error("Unsupported picking type: ", picking)
+				return
+		if picking_callback.is_valid():
+			picking_callback.call(picking, color, p_global_position)
+			picking_callback = Callable()
+		picking = Terrain3DEditor.TOOL_MAX
+	
+	elif operation_builder and operation_builder.is_picking():
+		operation_builder.pick(p_global_position, plugin.terrain)
+
+
+func set_button_editor_icon(p_button: Button, p_icon_name: String) -> void:
+	p_button.icon = EditorInterface.get_base_control().get_theme_icon(p_icon_name, "EditorIcons")
--- a/addons/terrain_3d/src/ui.gd.uid
+++ b/addons/terrain_3d/src/ui.gd.uid
@@ -0,0 +1 @@
+uid://bpad72s36mwkx