admin
4463e524aa
Auto-format all GDScript files using gdformat from gdtoolkit. This is a baseline formatting pass to ensure consistent style: - Normalizes indentation and spacing - Wraps long lines to 100 characters - Removes trailing whitespace - Standardizes blank lines between functions 68 files reformatted, 8 files left unchanged (3rd-party addon files with parse errors excluded).
905 lines
28 KiB
GDScript
905 lines
28 KiB
GDScript
# Copyright © 2023-2026 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_TILE_SIZE: String = "terrain3d/dock/tile_size"
|
|
const ES_DOCK_PINNED: String = "terrain3d/dock/always_on_top"
|
|
const ES_DOCK_TAB: String = "terrain3d/dock/tab"
|
|
|
|
var texture_list: ListContainer
|
|
var mesh_list: ListContainer
|
|
var current_list: ListContainer
|
|
var _updating_list: bool
|
|
|
|
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
|
|
var search_box: TextEdit
|
|
var search_button: Button
|
|
|
|
#DEPRECATED 4.5
|
|
#class EdDock extends EditorDock:
|
|
#func _update_layout(layout: int) -> void:
|
|
#layout 1 vertical, 2 horizontal, 4 window
|
|
#print("Terrain3DAssetDock: _update_layout called with: ", layout)
|
|
|
|
var _dock: MarginContainer #DEPRECATED 4.5 - Use EdDock
|
|
var _initialized: bool = false
|
|
var plugin: EditorPlugin
|
|
var window: Window
|
|
|
|
|
|
func _notification(what: int) -> void:
|
|
if what == NOTIFICATION_ENTER_TREE:
|
|
await get_tree().process_frame
|
|
update_layout()
|
|
|
|
|
|
func initialize(p_plugin: EditorPlugin) -> void:
|
|
if p_plugin:
|
|
plugin = p_plugin
|
|
|
|
_dock = ClassDB.instantiate("EditorDock") #DEPRECATED 4.5 - EdDock.new()
|
|
_dock.title = "Terrain3D"
|
|
_dock.dock_icon = preload("../icons/terrain3d.svg")
|
|
_dock.default_slot = 8 #DEPRECATED 4.5 - EditorDock.DockSlot.DOCK_SLOT_BOTTOM
|
|
_dock.closable = false
|
|
_dock.available_layouts = 0x7 #DEPRECATED 4.5 - EditorDock.DOCK_LAYOUT_ALL
|
|
_dock.add_child(self)
|
|
plugin.add_dock(_dock)
|
|
_dock.open()
|
|
_dock.make_visible()
|
|
|
|
pinned_btn = $Box/Buttons/Pinned
|
|
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
|
|
search_box = $Box/Buttons/SearchBox
|
|
search_box.owner = null
|
|
# Scale left column width to editor scale
|
|
var editor_scale: float = EditorInterface.get_editor_scale()
|
|
search_box.custom_minimum_size = Vector2(100. * editor_scale, 30. * editor_scale)
|
|
search_button = $Box/Buttons/SearchBox/SearchButton
|
|
|
|
texture_list = ListContainer.new()
|
|
texture_list.name = "TextureList"
|
|
texture_list.plugin = plugin
|
|
texture_list.type = Terrain3DAssets.TYPE_TEXTURE
|
|
asset_container.add_child(texture_list, true)
|
|
mesh_list = ListContainer.new()
|
|
mesh_list.name = "MeshList"
|
|
mesh_list.plugin = plugin
|
|
mesh_list.type = Terrain3DAssets.TYPE_MESH
|
|
mesh_list.visible = false
|
|
asset_container.add_child(mesh_list, true)
|
|
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)
|
|
pinned_btn.toggled.connect(_on_pin_changed)
|
|
pinned_btn.owner = 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", int(16. * EditorInterface.get_editor_scale())
|
|
)
|
|
textures_btn.add_theme_font_size_override(
|
|
"font_size", int(16. * EditorInterface.get_editor_scale())
|
|
)
|
|
|
|
search_box.text_changed.connect(_on_search_text_changed)
|
|
search_button.pressed.connect(_on_search_button_pressed)
|
|
|
|
confirm_dialog = ConfirmationDialog.new()
|
|
add_child(confirm_dialog, true)
|
|
confirm_dialog.hide()
|
|
confirm_dialog.confirmed.connect(
|
|
func():
|
|
_confirmed = true
|
|
confirmation_closed.emit()
|
|
confirmation_confirmed.emit()
|
|
)
|
|
confirm_dialog.canceled.connect(
|
|
func():
|
|
_confirmed = false
|
|
confirmation_closed.emit()
|
|
confirmation_canceled.emit()
|
|
)
|
|
|
|
# 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 = ""
|
|
search_button.icon = get_theme_icon("Search", "EditorIcons")
|
|
|
|
_initialized = true
|
|
update_dock()
|
|
update_layout()
|
|
|
|
|
|
func _gui_input(p_event: InputEvent) -> void:
|
|
if p_event is InputEventMouseButton:
|
|
if search_box.has_focus():
|
|
if plugin.debug:
|
|
print("Terrain3DAssetDock: _on_box_gui_input: search_box releasing focus")
|
|
search_box.release_focus()
|
|
|
|
|
|
## Dock placement
|
|
|
|
|
|
func remove_dock(p_force: bool = false) -> void:
|
|
plugin.remove_dock(_dock)
|
|
|
|
|
|
func update_dock() -> void:
|
|
if not _initialized:
|
|
return
|
|
update_assets()
|
|
_dock.make_visible()
|
|
|
|
|
|
func update_layout() -> void:
|
|
if not _initialized:
|
|
return
|
|
if plugin.debug > 1:
|
|
print("Terrain3DAssetDock: update_layout")
|
|
|
|
## Detect if we have a new window from `Make floating` and grab it
|
|
if not window:
|
|
if get_parent().get_parent().get_parent() is Window:
|
|
window = get_parent().get_parent().get_parent()
|
|
_on_pin_changed(pinned_btn.button_pressed)
|
|
plugin.godot_editor_window.mouse_entered.connect(_on_godot_window_entered)
|
|
return # Displaying will call this function again
|
|
# Check if window was just freed. Freed objects have a different hash than null
|
|
elif hash(window) != hash(null):
|
|
window = null
|
|
plugin.godot_editor_window.mouse_entered.disconnect(_on_godot_window_entered)
|
|
return # Will call this function again upon display
|
|
|
|
## Vertical layout: buttons on top
|
|
if size.x < 700:
|
|
box.vertical = true
|
|
buttons.vertical = false
|
|
search_box.reparent(box)
|
|
box.move_child(search_box, 1)
|
|
size_slider.reparent(box)
|
|
box.move_child(size_slider, 2)
|
|
pinned_btn.reparent(buttons)
|
|
else:
|
|
# Wide layout: buttons on left
|
|
box.vertical = false
|
|
buttons.vertical = true
|
|
search_box.reparent(buttons)
|
|
buttons.move_child(search_box, 0)
|
|
size_slider.reparent(buttons)
|
|
buttons.move_child(size_slider, 3)
|
|
pinned_btn.reparent(box)
|
|
|
|
pinned_btn.visible = is_instance_valid(window)
|
|
save_editor_settings()
|
|
|
|
|
|
# When a floating asset dock has focus and the mouse returns, grab focus so cursor decal works
|
|
func _on_godot_window_entered() -> void:
|
|
if plugin.debug > 1:
|
|
print("Terrain3DAssetDock: _on_godot_window_entered")
|
|
if is_instance_valid(window) and window.has_focus():
|
|
plugin.godot_editor_window.grab_focus()
|
|
|
|
|
|
func set_selected_by_asset_id(p_id: int) -> void:
|
|
search_box.text = ""
|
|
_on_search_text_changed()
|
|
current_list.set_selected_id(p_id)
|
|
|
|
|
|
func _on_search_text_changed() -> void:
|
|
if plugin.debug:
|
|
print("Terrain3DAssetDock: _on_search_text_changed: ", search_box.text)
|
|
search_box.text = search_box.text.strip_escapes()
|
|
var len: int = search_box.text.length()
|
|
if len > 0:
|
|
search_box.set_caret_column(len)
|
|
search_button.icon = get_theme_icon("Close", "EditorIcons")
|
|
else:
|
|
search_button.icon = get_theme_icon("Search", "EditorIcons")
|
|
|
|
mesh_list.search_text = search_box.text
|
|
texture_list.search_text = search_box.text
|
|
current_list.update_asset_list()
|
|
current_list.set_selected_id(0)
|
|
|
|
|
|
func _on_search_button_pressed() -> void:
|
|
if plugin.debug:
|
|
print("Terrain3DAssetDock: _on_search_button_pressed")
|
|
if search_box.text.length() > 0:
|
|
search_box.text = ""
|
|
_on_search_text_changed()
|
|
else:
|
|
if plugin.debug:
|
|
print("Terrain3DAssetDock: _on_search_button_pressed: Search box grabbing focus")
|
|
search_box.grab_focus()
|
|
|
|
|
|
## 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:
|
|
# Set both lists so they match
|
|
if texture_list:
|
|
texture_list.set_entry_width(value)
|
|
if mesh_list:
|
|
mesh_list.set_entry_width(value)
|
|
save_editor_settings()
|
|
# Hack to trigger ScrollContainer::_reposition_children() to update size of scroll bar handle
|
|
asset_container.layout_direction = Control.LAYOUT_DIRECTION_LTR
|
|
asset_container.layout_direction = Control.LAYOUT_DIRECTION_INHERITED
|
|
|
|
|
|
func _on_textures_pressed() -> void:
|
|
if plugin.debug:
|
|
print("Terrain3DAssetDock: _on_textures_pressed")
|
|
if _updating_list or current_list == texture_list:
|
|
return
|
|
_updating_list = true
|
|
current_list = texture_list
|
|
texture_list.visible = true
|
|
mesh_list.visible = false
|
|
textures_btn.set_pressed_no_signal(true)
|
|
meshes_btn.set_pressed_no_signal(false)
|
|
texture_list.update_asset_list()
|
|
if plugin.is_terrain_valid():
|
|
EditorInterface.edit_node(plugin.terrain)
|
|
save_editor_settings()
|
|
_updating_list = false
|
|
|
|
|
|
func _on_meshes_pressed() -> void:
|
|
if plugin.debug:
|
|
print("Terrain3DAssetDock: _on_meshes_pressed")
|
|
if _updating_list or current_list == mesh_list:
|
|
return
|
|
_updating_list = true
|
|
current_list = mesh_list
|
|
mesh_list.visible = true
|
|
texture_list.visible = false
|
|
meshes_btn.set_pressed_no_signal(true)
|
|
textures_btn.set_pressed_no_signal(false)
|
|
mesh_list.update_asset_list()
|
|
if plugin.is_terrain_valid():
|
|
EditorInterface.edit_node(plugin.terrain)
|
|
save_editor_settings()
|
|
_updating_list = false
|
|
|
|
|
|
func _on_tool_changed(p_tool: Terrain3DEditor.Tool, p_operation: Terrain3DEditor.Operation) -> void:
|
|
if plugin.debug:
|
|
print("Terrain3DAssetDock: _on_tool_changed: ", p_tool, ", ", p_operation)
|
|
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 plugin.debug:
|
|
print(
|
|
"Terrain3DAssetDock: update_assets: ", plugin.terrain.assets if plugin.terrain else ""
|
|
)
|
|
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()
|
|
|
|
|
|
## Manage Editor Settings
|
|
|
|
|
|
func load_editor_settings() -> void:
|
|
# Remove old editor settings
|
|
const ES_DOCK: String = "terrain3d/dock/"
|
|
for setting in ["slot", "floating", "window_position", "window_size"]:
|
|
plugin.erase_setting(ES_DOCK + setting)
|
|
pinned_btn.button_pressed = plugin.get_setting(ES_DOCK_PINNED, true)
|
|
size_slider.value = plugin.get_setting(ES_DOCK_TILE_SIZE, 90)
|
|
_on_slider_changed(size_slider.value)
|
|
# 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
|
|
plugin.set_setting(ES_DOCK_TILE_SIZE, size_slider.value)
|
|
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)
|
|
|
|
|
|
##############################################################
|
|
## 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 = 90.
|
|
var focus_style: StyleBox
|
|
var _clearing_resource: bool = false
|
|
var search_text: String = ""
|
|
|
|
func _ready() -> void:
|
|
set_v_size_flags(SIZE_EXPAND_FILL)
|
|
set_h_size_flags(SIZE_EXPAND_FILL)
|
|
add_theme_color_override("font_color", Color.WHITE)
|
|
add_theme_color_override("font_shadow_color", Color.BLACK)
|
|
add_theme_constant_override("shadow_offset_x", 1)
|
|
add_theme_constant_override("shadow_offset_y", 1)
|
|
|
|
func clear() -> void:
|
|
for e in entries:
|
|
e.get_parent().remove_child(e)
|
|
e.queue_free()
|
|
entries.clear()
|
|
|
|
func update_asset_list() -> void:
|
|
if plugin.debug:
|
|
print("Terrain3DListContainer ", name, ": update_asset_list")
|
|
clear()
|
|
|
|
# Grab terrain
|
|
var t: Terrain3D = plugin.get_terrain()
|
|
if not (t and 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:
|
|
if plugin.terrain:
|
|
plugin.terrain.assets.create_mesh_thumbnails()
|
|
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)
|
|
if mesh_count < Terrain3DAssets.MAX_MESHES:
|
|
add_item()
|
|
set_selected_id(selected_id)
|
|
|
|
func add_item(p_resource: Resource = null) -> void:
|
|
var entry: ListEntry = ListEntry.new()
|
|
entry.focus_style = focus_style
|
|
entry.set_edited_resource(p_resource)
|
|
if not entry.get_resource_name().containsn(search_text) and not search_text == "":
|
|
return
|
|
|
|
var res_id: int = p_resource.id if p_resource else entries.size()
|
|
entry.hovered.connect(_on_resource_hovered.bind(res_id))
|
|
entry.clicked.connect(clicked_id.bind(entries.size()))
|
|
entry.inspected.connect(_on_resource_inspected)
|
|
entry.changed.connect(_on_resource_changed.bind(res_id))
|
|
entry.type = type
|
|
add_child(entry, true)
|
|
entries.push_back(entry)
|
|
|
|
if p_resource:
|
|
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:
|
|
EditorInterface.mark_scene_as_unsaved()
|
|
set_selected_id(clamp(p_new_id, 0, entries.size() - 2))
|
|
|
|
func clicked_id(p_id: int) -> void:
|
|
# Select Tool if clicking an asset
|
|
plugin.select_terrain()
|
|
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)
|
|
set_selected_id(p_id)
|
|
|
|
func set_selected_id(p_id: int) -> void:
|
|
# "Add new" is the final entry only when search box is blank
|
|
var max_id: int = max(0, entries.size() - (1 if search_text else 2))
|
|
if plugin.debug:
|
|
print(
|
|
"Terrain3DListContainer ",
|
|
name,
|
|
": set_selected_id: ",
|
|
selected_id,
|
|
" to ",
|
|
clamp(p_id, 0, max_id)
|
|
)
|
|
selected_id = clamp(p_id, 0, max_id)
|
|
for i in entries.size():
|
|
var entry: ListEntry = entries[i]
|
|
entry.set_selected(i == selected_id)
|
|
plugin.ui._on_setting_changed()
|
|
|
|
func get_selected_asset_id() -> int:
|
|
# "Add new" is the final entry only when search box is blank
|
|
var max_id: int = max(0, entries.size() - (1 if search_text else 2))
|
|
var id: int = clamp(selected_id, 0, max_id)
|
|
if plugin.debug:
|
|
print(
|
|
"Terrain3DListContainer ",
|
|
name,
|
|
": get_selected_asset_id: selected_id: ",
|
|
selected_id,
|
|
", clamped: ",
|
|
id,
|
|
", entries: ",
|
|
entries.size()
|
|
)
|
|
if id >= entries.size():
|
|
return 0
|
|
var res: Resource = entries[id].resource
|
|
if not res:
|
|
return 0
|
|
if type == Terrain3DAssets.AssetType.TYPE_MESH:
|
|
return (res as Terrain3DMeshAsset).id
|
|
else:
|
|
return (res as Terrain3DTextureAsset).id
|
|
|
|
func _on_resource_inspected(p_resource: Resource) -> void:
|
|
await get_tree().process_frame
|
|
EditorInterface.edit_resource(p_resource)
|
|
|
|
func _on_resource_changed(p_resource: Resource, p_id: int) -> void:
|
|
if not p_resource and _clearing_resource:
|
|
return
|
|
if not p_resource:
|
|
if plugin.debug:
|
|
print(
|
|
"Terrain3DListContainer ",
|
|
name,
|
|
": _on_resource_changed: removing asset ID: ",
|
|
p_id
|
|
)
|
|
_clearing_resource = true
|
|
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()
|
|
_clearing_resource = false
|
|
return
|
|
|
|
if not plugin.is_terrain_valid():
|
|
plugin.select_terrain()
|
|
await get_tree().process_frame
|
|
|
|
if plugin.is_terrain_valid():
|
|
if type == Terrain3DAssets.TYPE_TEXTURE:
|
|
plugin.terrain.assets.set_texture(p_id, p_resource)
|
|
else:
|
|
plugin.terrain.assets.set_mesh_asset(p_id, p_resource)
|
|
|
|
# If removing an entry, clear inspector
|
|
if not p_resource:
|
|
EditorInterface.inspect_object(null)
|
|
_clearing_resource = false
|
|
|
|
func set_entry_width(value: float) -> void:
|
|
var min_width: float = 90.0 * max(1.0, EditorInterface.get_editor_scale())
|
|
width = clamp(value, min_width, 512.0)
|
|
redraw()
|
|
|
|
func get_entry_width() -> float:
|
|
return width
|
|
|
|
func redraw() -> void:
|
|
height = 0
|
|
var id: int = 0
|
|
var separation: float = 2.
|
|
var columns: int = 3
|
|
columns = clamp(size.x / width, 1, 100)
|
|
var tile_size: Vector2 = Vector2(width, width) - Vector2(separation, separation)
|
|
var name_font_size := int(
|
|
clamp(tile_size.x / 12., 12., 16.) * EditorInterface.get_editor_scale()
|
|
)
|
|
for c in get_children():
|
|
if is_instance_valid(c):
|
|
c.size = tile_size
|
|
c.position = (
|
|
Vector2(id % columns, id / columns) * width
|
|
+ Vector2(separation / columns, separation / columns)
|
|
)
|
|
height = max(height, c.position.y + width)
|
|
id += 1
|
|
c.name_label.add_theme_font_size_override("font_size", name_font_size)
|
|
|
|
# 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 MarginContainer
|
|
signal hovered
|
|
signal clicked
|
|
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 name_label: Label
|
|
var button_row: FlowContainer
|
|
var button_enabled: TextureButton
|
|
var button_edit: TextureButton
|
|
var spacer: Control
|
|
var button_clear: TextureButton
|
|
|
|
@onready var focus_style: StyleBox = get_theme_stylebox("focus", "Button").duplicate()
|
|
@onready var background: StyleBox = get_theme_stylebox("pressed", "Button")
|
|
@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")
|
|
@onready var add_icon: Texture2D = get_theme_icon("Add", "EditorIcons")
|
|
|
|
func _ready() -> void:
|
|
name = "ListEntry"
|
|
custom_minimum_size = Vector2i(86., 86.)
|
|
mouse_filter = Control.MOUSE_FILTER_PASS
|
|
add_theme_constant_override("margin_top", 5)
|
|
add_theme_constant_override("margin_left", 5)
|
|
add_theme_constant_override("margin_right", 5)
|
|
|
|
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:
|
|
destroy_buttons()
|
|
|
|
button_row = FlowContainer.new()
|
|
button_enabled = TextureButton.new()
|
|
button_edit = TextureButton.new()
|
|
spacer = Control.new()
|
|
button_clear = TextureButton.new()
|
|
|
|
var icon_size: Vector2 = Vector2(12, 12)
|
|
|
|
button_row.size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
|
button_row.alignment = FlowContainer.ALIGNMENT_CENTER
|
|
button_row.mouse_filter = Control.MOUSE_FILTER_PASS
|
|
add_child(button_row, true)
|
|
|
|
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.tooltip_text = "Enable Instances"
|
|
button_enabled.toggle_mode = true
|
|
button_enabled.mouse_filter = Control.MOUSE_FILTER_PASS
|
|
button_enabled.mouse_default_cursor_shape = Control.CURSOR_POINTING_HAND
|
|
button_enabled.pressed.connect(_on_enable)
|
|
button_row.add_child(button_enabled, true)
|
|
|
|
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.tooltip_text = "Edit Asset"
|
|
button_edit.mouse_filter = Control.MOUSE_FILTER_PASS
|
|
button_edit.mouse_default_cursor_shape = Control.CURSOR_POINTING_HAND
|
|
button_edit.pressed.connect(_on_edit)
|
|
button_row.add_child(button_edit, true)
|
|
|
|
spacer.size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
|
spacer.mouse_filter = Control.MOUSE_FILTER_PASS
|
|
button_row.add_child(spacer, true)
|
|
|
|
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.tooltip_text = "Clear Asset"
|
|
button_clear.mouse_filter = Control.MOUSE_FILTER_PASS
|
|
button_clear.mouse_default_cursor_shape = Control.CURSOR_POINTING_HAND
|
|
button_clear.pressed.connect(_on_clear)
|
|
button_row.add_child(button_clear, true)
|
|
|
|
func destroy_buttons() -> void:
|
|
if button_row:
|
|
button_row.free()
|
|
button_row = null
|
|
if button_enabled:
|
|
button_enabled.free()
|
|
button_enabled = null
|
|
if button_edit:
|
|
button_edit.free()
|
|
button_edit = null
|
|
if spacer:
|
|
spacer.free()
|
|
spacer = null
|
|
if button_clear:
|
|
button_clear.free()
|
|
button_clear = null
|
|
|
|
func get_resource_name() -> StringName:
|
|
if resource:
|
|
if resource is Terrain3DMeshAsset:
|
|
return (resource as Terrain3DMeshAsset).get_name()
|
|
elif resource is Terrain3DTextureAsset:
|
|
return (resource as Terrain3DTextureAsset).get_name()
|
|
return ""
|
|
|
|
func setup_label() -> void:
|
|
name_label = Label.new()
|
|
name_label.name = "MeshLabel"
|
|
name_label.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
name_label.vertical_alignment = VERTICAL_ALIGNMENT_CENTER
|
|
name_label.size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
|
name_label.size_flags_vertical = Control.SIZE_EXPAND_FILL
|
|
name_label.add_theme_font_size_override(
|
|
"font_size", int(14. * EditorInterface.get_editor_scale())
|
|
)
|
|
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.visible = false
|
|
name_label.autowrap_mode = TextServer.AUTOWRAP_OFF
|
|
name_label.text_overrun_behavior = TextServer.OVERRUN_TRIM_ELLIPSIS
|
|
add_child(name_label, true)
|
|
|
|
func _notification(p_what) -> void:
|
|
match p_what:
|
|
NOTIFICATION_PREDELETE:
|
|
destroy_buttons()
|
|
NOTIFICATION_DRAW:
|
|
# Hide spacer if icons are crowding small textures
|
|
spacer.visible = size.x > 94. 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:
|
|
_thumbnail = resource.get_albedo_texture()
|
|
else:
|
|
_thumbnail = resource.get_thumbnail()
|
|
if _thumbnail:
|
|
draw_texture_rect(_thumbnail, rect, false)
|
|
texture_filter = CanvasItem.TEXTURE_FILTER_NEAREST_WITH_MIPMAPS
|
|
else:
|
|
draw_rect(rect, Color(.15, .15, .15, 1.))
|
|
if type == Terrain3DAssets.TYPE_TEXTURE:
|
|
self_modulate = resource.get_albedo_color()
|
|
else:
|
|
button_enabled.set_pressed_no_signal(!resource.is_enabled())
|
|
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:
|
|
if not resource:
|
|
name_label.visible = false
|
|
else:
|
|
name_label.visible = true
|
|
is_hovered = true
|
|
name_label.text = get_resource_name()
|
|
tooltip_text = get_resource_name()
|
|
emit_signal("hovered")
|
|
queue_redraw()
|
|
NOTIFICATION_MOUSE_EXIT:
|
|
name_label.visible = false
|
|
is_hovered = 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)
|
|
_on_edit()
|
|
else:
|
|
emit_signal("clicked")
|
|
MOUSE_BUTTON_RIGHT:
|
|
if resource:
|
|
_on_edit()
|
|
MOUSE_BUTTON_MIDDLE:
|
|
if resource:
|
|
_on_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:
|
|
if not resource:
|
|
resource = Terrain3DMeshAsset.new()
|
|
set_edited_resource(resource, false)
|
|
resource.set_scene_file(res)
|
|
elif res is Terrain3DMeshAsset and type == Terrain3DAssets.TYPE_MESH:
|
|
if resource is Terrain3DMeshAsset:
|
|
res.id = resource.id
|
|
set_edited_resource(res, false)
|
|
emit_signal("clicked")
|
|
emit_signal("inspected", resource)
|
|
|
|
func set_edited_resource(p_res: Resource, p_no_signal: bool = true) -> void:
|
|
resource = p_res
|
|
if resource:
|
|
if not resource.setting_changed.is_connected(_on_resource_changed):
|
|
resource.setting_changed.connect(_on_resource_changed)
|
|
if resource is Terrain3DTextureAsset:
|
|
if not resource.file_changed.is_connected(_on_resource_changed):
|
|
resource.file_changed.connect(_on_resource_changed)
|
|
elif resource is Terrain3DMeshAsset:
|
|
if not resource.instancer_setting_changed.is_connected(_on_resource_changed):
|
|
resource.instancer_setting_changed.connect(_on_resource_changed)
|
|
|
|
if button_clear:
|
|
button_clear.set_visible(resource != null)
|
|
|
|
queue_redraw()
|
|
if not p_no_signal:
|
|
emit_signal("changed", resource)
|
|
|
|
func _on_resource_changed(_value: int = 0) -> void:
|
|
queue_redraw()
|
|
emit_signal("changed", resource)
|
|
|
|
func set_selected(value: bool) -> void:
|
|
if not is_inside_tree():
|
|
#push_error("not in tree")
|
|
return
|
|
is_selected = value
|
|
if is_selected:
|
|
# Handle scrolling to show the selected item
|
|
await get_tree().process_frame
|
|
if is_inside_tree():
|
|
get_parent().get_parent().get_v_scroll_bar().ratio = (
|
|
position.y / get_parent().size.y
|
|
)
|
|
queue_redraw()
|
|
|
|
func _on_clear() -> void:
|
|
if resource:
|
|
name_label.hide()
|
|
set_edited_resource(null, false)
|
|
|
|
func _on_edit() -> void:
|
|
emit_signal("clicked")
|
|
emit_signal("inspected", resource)
|
|
|
|
func _on_enable() -> void:
|
|
if resource is Terrain3DMeshAsset:
|
|
resource.set_enabled(!resource.is_enabled())
|
|
|
|
func _format_number(num: int) -> String:
|
|
var is_negative: bool = num < 0
|
|
var str_num: String = str(abs(num))
|
|
var result: String = ""
|
|
var length: int = str_num.length()
|
|
for i in length:
|
|
result = str_num[length - 1 - i] + result
|
|
if i < length - 1 and (i + 1) % 3 == 0:
|
|
result = "," + result
|
|
return "-" + result if is_negative else result
|