First commit
This commit is contained in:
Executable
+849
@@ -0,0 +1,849 @@
|
||||
@tool
|
||||
class_name PdToolbar
|
||||
extends HBoxContainer
|
||||
## Top toolbar: icon-only buttons grouped by category, with tooltips.
|
||||
## The FIRST button is the two-half WORKSPACE switch
|
||||
## [ 3D Editor | Texture Editor ] - exactly one half is always active.
|
||||
## The toolbar then shows the CONTEXTUAL group of the active workspace:
|
||||
## - MODEL group: selection modes, Draw split, view toggles, mesh edits
|
||||
## - TEXTURE group: [Paint | Edit UV] submode + that submode's tools
|
||||
## Exactly one group is visible - texture tools REPLACE the modeling
|
||||
## buttons when the texture editor is active. Sliders and deeper settings
|
||||
## live in the right panel.
|
||||
## Draw stays a SPLIT BUTTON: the main half shows the current shape icon
|
||||
## and activates that mode, the attached arrow half opens the shape menu.
|
||||
## The gizmo button is a split too: main toggles the gizmo, the arrow menu
|
||||
## picks Move or Scale.
|
||||
|
||||
signal mode_requested(m: int)
|
||||
signal workspace_requested(tex: bool)
|
||||
signal toggle_gizmo(v: bool)
|
||||
signal gizmo_kind_requested(k: int)
|
||||
signal toggle_snap(v: bool)
|
||||
signal toggle_grid(v: bool)
|
||||
signal toggle_both_sides(v: bool)
|
||||
signal draw_kind(k: String)
|
||||
signal add_shape(kind: String)
|
||||
signal duplicate_requested
|
||||
signal delete_requested
|
||||
signal undo_requested
|
||||
signal redo_requested
|
||||
signal save_requested
|
||||
signal load_requested
|
||||
signal import_model_requested
|
||||
signal export_requested(kind: String)
|
||||
signal bg_changed(c: Color)
|
||||
signal tex_submode(edit: bool)
|
||||
signal paint_tool_requested(t: String)
|
||||
signal uv_snap_requested(v: bool)
|
||||
signal rotate_uv_requested(dir: int)
|
||||
signal uv_tool_requested(t: String)
|
||||
signal import_requested
|
||||
signal detach_requested
|
||||
signal reset_uvs_requested
|
||||
|
||||
var doc: PdDocument
|
||||
|
||||
var _ws_3d: Button
|
||||
var _ws_tex: Button
|
||||
var _mode_buttons := {}
|
||||
var _mode_group := ButtonGroup.new()
|
||||
# Side-by-side gizmo pair: [Move] [Scale] - the active kind is pressed
|
||||
# while the gizmo is ON; clicking the pressed one again turns it off.
|
||||
var _btn_gizmo_move: Button
|
||||
var _btn_gizmo_scale: Button
|
||||
var _btn_gizmo_rotate: Button
|
||||
var _btn_snap: Button
|
||||
var _btn_grid: Button
|
||||
var _btn_sides: Button
|
||||
var _draw_main: Button
|
||||
var _draw_arrow: Button
|
||||
var _draw_popup: PopupMenu
|
||||
var _btn_undo: Button
|
||||
var _btn_redo: Button
|
||||
var _bg_pick: ColorPickerButton
|
||||
var _btn_settings: Button
|
||||
var _btn_docs: Button
|
||||
var _settings_popup: PopupPanel
|
||||
var _shade_btns: Array = []
|
||||
var _grid_btn: Button
|
||||
var _hints_btn: Button
|
||||
var _checker_btn: Button
|
||||
var _bake_btn: Button
|
||||
var _docs_win: Window
|
||||
|
||||
# contextual groups: exactly one is visible at a time
|
||||
var _model_box: HBoxContainer
|
||||
var _tex_box: HBoxContainer
|
||||
var _tex_paint_box: HBoxContainer
|
||||
var _tex_uv_box: HBoxContainer
|
||||
var _tex_paint: Button
|
||||
var _tex_edituv: Button
|
||||
var _tex_tool_btns := {}
|
||||
var _tex_uv_snap: Button
|
||||
var _tex_uv_rotate: Button
|
||||
var _tex_uv_scale: Button
|
||||
var _uv_tool_group: ButtonGroup
|
||||
|
||||
const ICONS := preload("res://addons/polydoodle/core/pd_icons.gd")
|
||||
const ACCENT := PdDocument.ACCENT
|
||||
const ACCENT_DARK := PdDocument.ACCENT_DARK # bottom bevel of active buttons
|
||||
|
||||
const DRAW_ICONS := {
|
||||
"Freehand": "tool_freehand",
|
||||
"Rectangle": "tool_rect",
|
||||
"Circle": "tool_circle",
|
||||
"Triangle": "tool_triangle",
|
||||
"Pentagon": "tool_pentagon",
|
||||
"Hexagon": "tool_hexagon",
|
||||
"Star": "tool_star",
|
||||
"Torus": "tool_torus",
|
||||
}
|
||||
|
||||
|
||||
func _icon(n: String) -> Texture2D:
|
||||
return ICONS.get_icon(n.trim_suffix(".svg"))
|
||||
|
||||
|
||||
# ------------------------------------------------------------ styling ---
|
||||
## TACTILE button states - reserved for the workspace split button, the
|
||||
## right panel and the settings popup. Idle is flat dark, hover lifts
|
||||
## slightly, and the ACTIVE (pressed) state is a SOLID accent fill - no
|
||||
## transparency - with a darker bottom edge (2px bevel) that gives the
|
||||
## button a physical 3D look, like a key sitting lower on its base. A
|
||||
## lighter top border adds a subtle rim light from above.
|
||||
func _box(corners := Vector4(4, 4, 4, 4)) -> StyleBoxFlat:
|
||||
var sb := StyleBoxFlat.new()
|
||||
sb.bg_color = Color(1, 1, 1, 0.04)
|
||||
sb.set_corner_radius_all(0)
|
||||
sb.corner_radius_top_left = int(corners.x)
|
||||
sb.corner_radius_bottom_left = int(corners.y)
|
||||
sb.corner_radius_top_right = int(corners.z)
|
||||
sb.corner_radius_bottom_right = int(corners.w)
|
||||
sb.content_margin_left = 5
|
||||
sb.content_margin_right = 5
|
||||
sb.content_margin_top = 3
|
||||
sb.content_margin_bottom = 3
|
||||
return sb
|
||||
|
||||
|
||||
func _bevel(sb: StyleBoxFlat, bottom_px: int) -> StyleBoxFlat:
|
||||
sb.border_width_bottom = bottom_px
|
||||
sb.border_color = ACCENT_DARK
|
||||
return sb
|
||||
|
||||
|
||||
func _paint_states(b: Button, base: StyleBoxFlat) -> void:
|
||||
var hover := base.duplicate()
|
||||
hover.bg_color = Color(1, 1, 1, 0.10)
|
||||
# ACTIVE: solid accent (opaque), darker bottom bevel = 3D look
|
||||
var pressed := base.duplicate()
|
||||
pressed.bg_color = ACCENT
|
||||
_bevel(pressed, 3)
|
||||
pressed.content_margin_top = 4
|
||||
pressed.content_margin_bottom = 2
|
||||
# active + hovered: same solid fill, slightly lifted top rim
|
||||
var hover_pressed := base.duplicate()
|
||||
hover_pressed.bg_color = ACCENT.lightened(0.08)
|
||||
_bevel(hover_pressed, 3)
|
||||
hover_pressed.content_margin_top = 4
|
||||
hover_pressed.content_margin_bottom = 2
|
||||
var disabled := base.duplicate()
|
||||
disabled.bg_color = Color(1, 1, 1, 0.015)
|
||||
b.add_theme_stylebox_override("normal", base)
|
||||
b.add_theme_stylebox_override("hover", hover)
|
||||
b.add_theme_stylebox_override("pressed", pressed)
|
||||
b.add_theme_stylebox_override("hover_pressed", hover_pressed)
|
||||
b.add_theme_stylebox_override("disabled", disabled)
|
||||
b.add_theme_stylebox_override("focus", StyleBoxEmpty.new())
|
||||
# Pin EVERY icon state to white. Without icon_hover_pressed_color the
|
||||
# editor theme's fallback tints the icon blue while the active half of
|
||||
# the workspace split is hovered - blue on blue.
|
||||
b.add_theme_color_override("icon_pressed_color", Color(1, 1, 1, 1))
|
||||
b.add_theme_color_override("icon_normal_color", Color(1, 1, 1, 0.82))
|
||||
b.add_theme_color_override("icon_hover_color", Color(1, 1, 1, 1))
|
||||
b.add_theme_color_override("icon_hover_pressed_color", Color(1, 1, 1, 1))
|
||||
b.add_theme_color_override("icon_focus_color", Color(1, 1, 1, 1))
|
||||
b.add_theme_color_override("icon_disabled_color", Color(1, 1, 1, 0.3))
|
||||
|
||||
|
||||
func _style_tactile(b: Button) -> void:
|
||||
_paint_states(b, _box())
|
||||
|
||||
|
||||
## FLAT toolbar states - the Godot-default look for every top-toolbar
|
||||
## button EXCEPT the workspace split. At rest the button is invisible:
|
||||
## only the icon shows. Hovering washes the background slightly lighter.
|
||||
## The ACTIVE (toggled) state colors the ICON with the theme accent - no
|
||||
## solid fill, no bevel.
|
||||
## Geometry: every button is a SQUARE chip with rounded
|
||||
## corners like Godot's own toolbar - symmetric margins, a fixed 28x28
|
||||
## minimum size and shrink-center so the highlight can never stretch
|
||||
## into a portrait rectangle.
|
||||
const TB_CHIP := 28.0 # square side of a toolbar button
|
||||
const TB_RADIUS := 5 # corner radius of the highlight
|
||||
|
||||
func _style_flat(b: Button) -> void:
|
||||
var normal := StyleBoxFlat.new()
|
||||
normal.bg_color = Color(1, 1, 1, 0)
|
||||
normal.set_corner_radius_all(TB_RADIUS)
|
||||
normal.content_margin_left = 6
|
||||
normal.content_margin_right = 6
|
||||
normal.content_margin_top = 6
|
||||
normal.content_margin_bottom = 6
|
||||
var hover := normal.duplicate()
|
||||
hover.bg_color = Color(1, 1, 1, 0.07)
|
||||
var pressed := normal.duplicate()
|
||||
pressed.bg_color = Color(1, 1, 1, 0.045)
|
||||
var hover_pressed := normal.duplicate()
|
||||
hover_pressed.bg_color = Color(1, 1, 1, 0.09)
|
||||
var disabled := normal.duplicate()
|
||||
b.add_theme_stylebox_override("normal", normal)
|
||||
b.add_theme_stylebox_override("hover", hover)
|
||||
b.add_theme_stylebox_override("pressed", pressed)
|
||||
b.add_theme_stylebox_override("hover_pressed", hover_pressed)
|
||||
b.add_theme_stylebox_override("disabled", disabled)
|
||||
b.add_theme_stylebox_override("focus", StyleBoxEmpty.new())
|
||||
b.add_theme_color_override("icon_normal_color", Color(1, 1, 1, 0.78))
|
||||
b.add_theme_color_override("icon_hover_color", Color(1, 1, 1, 1))
|
||||
b.add_theme_color_override("icon_pressed_color", ACCENT)
|
||||
b.add_theme_color_override("icon_disabled_color", Color(1, 1, 1, 0.28))
|
||||
b.custom_minimum_size = Vector2(TB_CHIP, TB_CHIP)
|
||||
b.size_flags_vertical = Control.SIZE_SHRINK_CENTER
|
||||
|
||||
|
||||
func _style(b: Button) -> void:
|
||||
# default for toolbar buttons: flat Godot-like states. The workspace
|
||||
# split and the settings popup explicitly ask for _style_tactile.
|
||||
_style_flat(b)
|
||||
|
||||
|
||||
func _button(icon: String, tip: String) -> Button:
|
||||
var b := Button.new()
|
||||
b.icon = _icon(icon)
|
||||
b.text = ""
|
||||
b.focus_mode = Control.FOCUS_NONE
|
||||
b.tooltip_text = tip
|
||||
b.add_theme_constant_override("icon_max_width", 16)
|
||||
_style(b)
|
||||
return b
|
||||
|
||||
|
||||
func _toggle(icon: String, tip: String, group: ButtonGroup = null) -> Button:
|
||||
var b := _button(icon, tip)
|
||||
b.toggle_mode = true
|
||||
b.button_group = group
|
||||
return b
|
||||
|
||||
|
||||
func _sep() -> VSeparator:
|
||||
return VSeparator.new()
|
||||
|
||||
|
||||
func _gap(px: float) -> Control:
|
||||
var c := Control.new()
|
||||
c.custom_minimum_size = Vector2(px, 0)
|
||||
return c
|
||||
|
||||
|
||||
## A joined pair [main | arrow]: the main half activates the mode and
|
||||
## shows the current tool icon; the arrow half opens the tool menu. The
|
||||
## arrow carries a visible chevron icon so the dropdown affordance reads
|
||||
## at a glance. `tactile` keeps the 3D key look - used by the workspace
|
||||
## switch only; every other split is flat.
|
||||
func _split(main_tip: String, arrow_tip: String, tactile := false) -> Array:
|
||||
var box := HBoxContainer.new()
|
||||
box.add_theme_constant_override("separation", 0)
|
||||
var main := Button.new()
|
||||
main.toggle_mode = true
|
||||
main.focus_mode = Control.FOCUS_NONE
|
||||
main.tooltip_text = main_tip
|
||||
main.add_theme_constant_override("icon_max_width", 16)
|
||||
if tactile:
|
||||
_paint_states(main, _box(Vector4(4, 4, 0, 0)))
|
||||
else:
|
||||
_style_flat(main)
|
||||
# joined pill: outer corners rounded, inner corners square so the
|
||||
# two square chips read as one control
|
||||
_join_split_corners(main, true)
|
||||
var arrow := Button.new()
|
||||
arrow.focus_mode = Control.FOCUS_NONE
|
||||
arrow.tooltip_text = arrow_tip
|
||||
arrow.icon = _icon("arrow_down") # the dropdown indicator
|
||||
arrow.custom_minimum_size = Vector2(20, TB_CHIP)
|
||||
arrow.add_theme_constant_override("icon_max_width", 12)
|
||||
if tactile:
|
||||
_paint_states(arrow, _box(Vector4(0, 0, 4, 4)))
|
||||
else:
|
||||
_style_flat(arrow)
|
||||
_join_split_corners(arrow, false)
|
||||
if not tactile:
|
||||
arrow.add_theme_color_override("icon_normal_color", Color(1, 1, 1, 0.5))
|
||||
arrow.add_theme_color_override("icon_hover_color", Color(1, 1, 1, 0.95))
|
||||
arrow.add_theme_color_override("icon_pressed_color", ACCENT)
|
||||
else:
|
||||
arrow.add_theme_color_override("icon_normal_color", Color(1, 1, 1, 0.55))
|
||||
arrow.add_theme_color_override("icon_hover_color", Color(1, 1, 1, 0.95))
|
||||
box.add_child(main)
|
||||
box.add_child(arrow)
|
||||
return [box, main, arrow]
|
||||
|
||||
|
||||
## Reroute the corner radii of a flat split half: the OUTER corners stay
|
||||
## rounded (the chip look), the INNER corners (where the two halves meet)
|
||||
## square. `is_main` picks which side is outer.
|
||||
func _join_split_corners(b: Button, is_main: bool) -> void:
|
||||
for state in ["normal", "hover", "pressed", "hover_pressed", "disabled"]:
|
||||
var sb := b.get_theme_stylebox(state) as StyleBoxFlat
|
||||
if sb == null:
|
||||
continue
|
||||
var s := sb.duplicate()
|
||||
s.corner_radius_top_left = TB_RADIUS if is_main else 0
|
||||
s.corner_radius_bottom_left = TB_RADIUS if is_main else 0
|
||||
s.corner_radius_top_right = 0 if is_main else TB_RADIUS
|
||||
s.corner_radius_bottom_right = 0 if is_main else TB_RADIUS
|
||||
b.add_theme_stylebox_override(state, s)
|
||||
|
||||
|
||||
func _open_popup(pm: PopupMenu, at: Control) -> void:
|
||||
var gp := at.get_global_rect()
|
||||
pm.position = Vector2i(int(gp.position.x), int(gp.end.y) + 2)
|
||||
pm.popup()
|
||||
|
||||
|
||||
func setup(d: PdDocument) -> void:
|
||||
doc = d
|
||||
add_theme_constant_override("separation", 3)
|
||||
|
||||
# --- WORKSPACE switch (first buttons): 3D Editor | Texture Editor
|
||||
# A joined pair where EXACTLY ONE half is always pressed: the left
|
||||
# half is the 3D modeler (quad view + mesh tools), the right half
|
||||
# the texture editor (3D viewport + texture canvas + tool strip).
|
||||
# The ONLY tactile control on the toolbar: the 3D key look marks
|
||||
# it as the master switch of the whole editor.
|
||||
var wsp := _split("3D Editor\nQuad view: Top / Perspective / Side / Front with all modeling tools (1-5)",
|
||||
"Texture Editor\n3D viewport over the texture canvas: paint and edit UVs (6)", true)
|
||||
_ws_3d = wsp[1]
|
||||
_ws_tex = wsp[2]
|
||||
# the right half is a mode, not a dropdown arrow: a dedicated
|
||||
# checkered-cube icon (distinct from the Edit-UV submode button's)
|
||||
# inside a shared button group, so exactly one half reads as
|
||||
# active at a time.
|
||||
_ws_3d.icon = _icon("ws_3d")
|
||||
_ws_tex.icon = _icon("ws_uv")
|
||||
_ws_tex.toggle_mode = true # the arrow half is not a toggle by default
|
||||
_ws_tex.add_theme_constant_override("icon_max_width", 16)
|
||||
var wsgrp := ButtonGroup.new()
|
||||
_ws_3d.button_group = wsgrp
|
||||
_ws_tex.button_group = wsgrp
|
||||
_ws_3d.pressed.connect(func(): workspace_requested.emit(false))
|
||||
_ws_tex.pressed.connect(func(): workspace_requested.emit(true))
|
||||
add_child(wsp[0])
|
||||
|
||||
add_child(_gap(8))
|
||||
|
||||
# ================================================== MODEL group ==
|
||||
# All 3D-modeling buttons. Hidden while the texture editor is
|
||||
# active - the TEXTURE group replaces it in place.
|
||||
_model_box = HBoxContainer.new()
|
||||
_model_box.add_theme_constant_override("separation", 3)
|
||||
add_child(_model_box)
|
||||
|
||||
# --- ADD MODELS: front of the toolbar group, directly after the
|
||||
# workspace switch - the quickest way to start a scene
|
||||
var add := _menu("add", "Add a primitive shape")
|
||||
var am := add.get_popup()
|
||||
am.add_theme_font_size_override("font_size", 12)
|
||||
am.add_item("Cube", 0)
|
||||
am.add_item("Plane", 1)
|
||||
am.add_item("Cylinder", 2)
|
||||
am.add_item("Sphere", 3)
|
||||
am.add_item("Prism", 4)
|
||||
am.add_item("Torus", 5)
|
||||
am.id_pressed.connect(func(id: int):
|
||||
add_shape.emit(["Cube", "Plane", "Cylinder", "Sphere", "Prism", "Torus"][id]))
|
||||
_model_box.add_child(add)
|
||||
_model_box.add_child(_gap(6))
|
||||
|
||||
# --- selection modes (category 1) ---
|
||||
var modes := [
|
||||
[PdDocument.Mode.OBJECT, "mode_object", "Object mode (1)\nSelect and move whole shapes"],
|
||||
[PdDocument.Mode.VERTEX, "mode_vertex", "Vertex mode (2)\nSelect and drag vertices"],
|
||||
[PdDocument.Mode.EDGE, "mode_edge", "Edge mode (3)\nSelect and drag edges"],
|
||||
[PdDocument.Mode.FACE, "mode_face", "Face mode (4)\nSelect and move faces"],
|
||||
]
|
||||
for m in modes:
|
||||
var b := _toggle(m[1], m[2], _mode_group)
|
||||
b.pressed.connect(func(): mode_requested.emit(m[0]))
|
||||
_mode_buttons[m[0]] = b
|
||||
_model_box.add_child(b)
|
||||
|
||||
# --- draw (category 2, set slightly apart) ---
|
||||
_model_box.add_child(_gap(10))
|
||||
|
||||
# Draw: split button - main shows the current shape, arrow opens
|
||||
# the shapes menu; picking a shape enters Draw mode with it.
|
||||
var dsp := _split("Draw mode (5)\nSketch shapes in any viewport - current shape: Rectangle",
|
||||
"Choose a shape to draw")
|
||||
_draw_main = dsp[1]
|
||||
_draw_arrow = dsp[2]
|
||||
_draw_main.pressed.connect(func(): mode_requested.emit(PdDocument.Mode.DRAW))
|
||||
_mode_buttons[PdDocument.Mode.DRAW] = _draw_main
|
||||
_draw_popup = PopupMenu.new()
|
||||
_draw_popup.add_theme_font_size_override("font_size", 12)
|
||||
# match every other icon in the UI (16px) - PopupMenu draws item
|
||||
# icons at native texture size unless capped, and our source PNGs
|
||||
# are 32px, so without this the shape list looked twice as big as
|
||||
# the toolbar buttons that open it.
|
||||
_draw_popup.add_theme_constant_override("icon_max_width", 16)
|
||||
for i in PdDocument.DRAW_KINDS.size():
|
||||
_draw_popup.add_radio_check_item(PdDocument.DRAW_KINDS[i], i)
|
||||
_draw_popup.set_item_icon(i, _icon(DRAW_ICONS.get(
|
||||
PdDocument.DRAW_KINDS[i], "tool_rect")))
|
||||
_draw_popup.id_pressed.connect(func(id: int):
|
||||
draw_kind.emit(PdDocument.DRAW_KINDS[id])
|
||||
mode_requested.emit(PdDocument.Mode.DRAW))
|
||||
_draw_arrow.pressed.connect(func(): _open_popup(_draw_popup, _draw_arrow))
|
||||
_model_box.add_child(dsp[0])
|
||||
_model_box.add_child(_draw_popup)
|
||||
|
||||
_model_box.add_child(_gap(4))
|
||||
_model_box.add_child(_sep())
|
||||
|
||||
# --- view toggles. The gizmo controls are a SIDE-BY-SIDE pair:
|
||||
# [Move] [Scale]. The active kind is pressed while the gizmo is
|
||||
# on; clicking the pressed half again hides the gizmo.
|
||||
_btn_gizmo_move = _toggle("gizmo_move", "Move Gizmo (G)\nShow the 3-axis move arrows on the selection.\nClick again to hide the gizmo. G/S/R pick Move/Scale/Rotate.\nDirect dragging always works too.")
|
||||
_btn_gizmo_move.pressed.connect(func(): _gizmo_pair(0))
|
||||
_model_box.add_child(_btn_gizmo_move)
|
||||
_btn_gizmo_scale = _toggle("gizmo_scale", "Scale Gizmo (S)\nShow the scale handles on the selection: axis cubes scale one axis,\nthe center cube scales uniformly.\nClick again to hide the gizmo.")
|
||||
_btn_gizmo_scale.pressed.connect(func(): _gizmo_pair(1))
|
||||
_model_box.add_child(_btn_gizmo_scale)
|
||||
_btn_gizmo_rotate = _toggle("gizmo_rotate", "Rotate Gizmo (R)\nShow the rotation rings on the selection: drag a ring to rotate\naround that axis. In the 2D views this is a single ring around the\nview's own axis.\nClick again to hide the gizmo.")
|
||||
_btn_gizmo_rotate.pressed.connect(func(): _gizmo_pair(2))
|
||||
_model_box.add_child(_btn_gizmo_rotate)
|
||||
_btn_snap = _toggle("snap", "Grid snapping (T)\nMoves and shapes land on the grid.\nWorks even when the grid is hidden.")
|
||||
_btn_snap.pressed.connect(func(): toggle_snap.emit(_btn_snap.button_pressed))
|
||||
_model_box.add_child(_btn_snap)
|
||||
_btn_grid = _toggle("grid", "Grid visibility (V)\nHide the grid but keep snapping.")
|
||||
_btn_grid.pressed.connect(func(): toggle_grid.emit(_btn_grid.button_pressed))
|
||||
_model_box.add_child(_btn_grid)
|
||||
_btn_sides = _toggle("doubleside", "Render both sides (B)\nShow backfaces - no culling. On by default.")
|
||||
_btn_sides.pressed.connect(func(): toggle_both_sides.emit(_btn_sides.button_pressed))
|
||||
_model_box.add_child(_btn_sides)
|
||||
_model_box.add_child(_sep())
|
||||
|
||||
# --- edit ---
|
||||
var dup := _button("duplicate", "Duplicate selected object (Ctrl+D)")
|
||||
dup.pressed.connect(func(): duplicate_requested.emit())
|
||||
_model_box.add_child(dup)
|
||||
var del := _button("delete", "Delete selection (Del)")
|
||||
# destructive action = red icon
|
||||
del.add_theme_color_override("icon_normal_color",
|
||||
Color(0.94, 0.44, 0.44, 0.9))
|
||||
del.add_theme_color_override("icon_hover_color", Color(1, 0.52, 0.52))
|
||||
del.pressed.connect(func(): delete_requested.emit())
|
||||
_model_box.add_child(del)
|
||||
|
||||
# ================================================ TEXTURE group ==
|
||||
# Replaces the modeling buttons while the texture editor is
|
||||
# active: the [Paint | Edit UV] submode buttons followed by the
|
||||
# contextual toolset of the active submode. Sizes and colors live
|
||||
# in the right panel.
|
||||
_tex_box = HBoxContainer.new()
|
||||
_tex_box.add_theme_constant_override("separation", 3)
|
||||
_tex_box.visible = false
|
||||
add_child(_tex_box)
|
||||
|
||||
var tgrp := ButtonGroup.new()
|
||||
# own icon (mode_paint), distinct from tool_brush - the submode
|
||||
# button and the individual Brush TOOL button below must not read
|
||||
# as the same control
|
||||
_tex_paint = _toggle("mode_paint",
|
||||
"Paint\nBrush, fill and pixel tools paint the texture directly", tgrp)
|
||||
_tex_paint.pressed.connect(func(): tex_submode.emit(false))
|
||||
_tex_edituv = _toggle("tool_uv",
|
||||
"Edit UV\nDrag island corners, edges or whole islands to re-map UVs.\nClick a face in the 3D view to select it - its island highlights here.\nRight-click: detach / merge / extrude / fill / delete menu", tgrp)
|
||||
_tex_edituv.pressed.connect(func(): tex_submode.emit(true))
|
||||
_tex_box.add_child(_tex_paint)
|
||||
_tex_box.add_child(_tex_edituv)
|
||||
_tex_box.add_child(_sep())
|
||||
|
||||
# ---- PAINT submode tools (visible only in Paint submode)
|
||||
var pgrp := ButtonGroup.new()
|
||||
var tools := [["Brush", "tool_brush", "Brush - paint smooth round strokes"],
|
||||
["Fill", "tool_fill", "Fill - repaint exactly one face's texture island"],
|
||||
["Fill Object", "tool_fillobject", "Fill Object - repaint the whole object's texture"],
|
||||
["Pixel", "tool_pixel", "Pixel - texel-perfect pixel-art brush"],
|
||||
["Eraser", "tool_eraser", "Eraser - restore blank with brush strokes (works on the model and the canvas)"],
|
||||
["Picker", "tool_picker", "Color Picker - click the model or the canvas to make that texel's color the paint color"],
|
||||
["Replace", "tool_replace", "Replace Color - click a texel: its color is swapped for the paint color across the WHOLE canvas (all faces); the Tolerance slider in the right panel widens the color match"]]
|
||||
_tex_paint_box = HBoxContainer.new()
|
||||
_tex_paint_box.add_theme_constant_override("separation", 3)
|
||||
_tex_box.add_child(_tex_paint_box)
|
||||
for t in tools:
|
||||
var b := _toggle(t[1], t[2], pgrp)
|
||||
b.pressed.connect(func(): paint_tool_requested.emit(t[0]))
|
||||
_tex_tool_btns[t[0]] = b
|
||||
_tex_paint_box.add_child(b)
|
||||
var imp := _button("image",
|
||||
"Import Image\nPlace a picture onto the texture: move it, wheel-scales,\nclick places it - then paint over it or erase it")
|
||||
imp.pressed.connect(func(): import_requested.emit())
|
||||
_tex_paint_box.add_child(imp)
|
||||
|
||||
# ---- EDIT UV submode tools (visible only in Edit UV submode)
|
||||
_tex_uv_box = HBoxContainer.new()
|
||||
_tex_uv_box.add_theme_constant_override("separation", 3)
|
||||
_tex_uv_box.visible = false
|
||||
_tex_box.add_child(_tex_uv_box)
|
||||
_tex_uv_snap = _toggle("snap", "UV snapping (texel grid)\nUV drags land on whole texels. Hold Ctrl to drag freely.")
|
||||
_tex_uv_snap.pressed.connect(func(): uv_snap_requested.emit(_tex_uv_snap.button_pressed))
|
||||
var det := _button("detach",
|
||||
"Detach selected face(s)\nMove the selected islands to free texture space so they can\nbe moved individually. Select faces, then press.")
|
||||
det.pressed.connect(func(): detach_requested.emit())
|
||||
var ruv := _button("uv_reset", "Reset UVs\nRe-unwrap every face of the object to its planar projection")
|
||||
ruv.pressed.connect(func(): reset_uvs_requested.emit())
|
||||
# Rotate / Scale: a mutually exclusive toggle pair (the active one
|
||||
# can be clicked again to switch off). The rotate tool shows the
|
||||
# 0..360 angle slider in the right panel; the scale tool turns
|
||||
# every corner drag of the selection into a uniform scale and shows
|
||||
# the percent slider. Quick 90-degree actions stay available via
|
||||
# R / Shift+R and the canvas right-click menu.
|
||||
_uv_tool_group = ButtonGroup.new()
|
||||
_uv_tool_group.allow_unpress = true
|
||||
_tex_uv_rotate = _toggle("rotate",
|
||||
"Rotate UVs\nToggle the rotate tool: an Angle slider (0-360\ndegrees, or type a number) appears in the right panel and\nrotates the selected faces' texture islands around their center.\nR / Shift+R rotate 90 degrees quickly.",
|
||||
_uv_tool_group)
|
||||
_tex_uv_rotate.pressed.connect(func():
|
||||
uv_tool_requested.emit(
|
||||
"rotate" if _tex_uv_rotate.button_pressed else "none"))
|
||||
_tex_uv_scale = _toggle("gizmo_scale",
|
||||
"Scale UVs\nToggle the scale tool: drag any corner of the selected\nisland(s) to scale them uniformly (aspect ratio preserved).\nA Scale slider (10-400%) also appears in the right panel.",
|
||||
_uv_tool_group)
|
||||
_tex_uv_scale.pressed.connect(func():
|
||||
uv_tool_requested.emit(
|
||||
"scale" if _tex_uv_scale.button_pressed else "none"))
|
||||
_tex_uv_box.add_child(_tex_uv_snap)
|
||||
_tex_uv_box.add_child(_tex_uv_rotate)
|
||||
_tex_uv_box.add_child(_tex_uv_scale)
|
||||
_tex_uv_box.add_child(det)
|
||||
_tex_uv_box.add_child(ruv)
|
||||
|
||||
add_child(_sep())
|
||||
|
||||
# --- history ---
|
||||
_btn_undo = _button("undo", "Undo (Ctrl+Z)")
|
||||
_btn_undo.pressed.connect(func(): undo_requested.emit())
|
||||
add_child(_btn_undo)
|
||||
_btn_redo = _button("redo", "Redo (Ctrl+Shift+Z)")
|
||||
_btn_redo.pressed.connect(func(): redo_requested.emit())
|
||||
add_child(_btn_redo)
|
||||
add_child(_sep())
|
||||
|
||||
# --- file ---
|
||||
var save := _button("save", "Save project as .pdoodle")
|
||||
save.pressed.connect(func(): save_requested.emit())
|
||||
add_child(save)
|
||||
var open := _button("open", "Open a .pdoodle project")
|
||||
open.pressed.connect(func(): load_requested.emit())
|
||||
add_child(open)
|
||||
var import_model := _button("import_model",
|
||||
"Import a 3D model (OBJ, glTF, FBX) with its textures")
|
||||
import_model.pressed.connect(func(): import_model_requested.emit())
|
||||
add_child(import_model)
|
||||
|
||||
var export := _menu("export", "Export for use directly in Godot")
|
||||
var em := export.get_popup()
|
||||
em.add_theme_font_size_override("font_size", 12)
|
||||
em.add_item("Mesh (.tres)", 0)
|
||||
em.add_item("Scene (.tscn)", 1)
|
||||
em.add_item("OBJ (.obj + texture)", 2)
|
||||
em.add_item("Add to current scene", 3)
|
||||
em.id_pressed.connect(func(id: int):
|
||||
export_requested.emit(["tres", "tscn", "obj", "scene"][id]))
|
||||
add_child(export)
|
||||
|
||||
var spacer := Control.new()
|
||||
spacer.size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
||||
add_child(spacer)
|
||||
|
||||
_bg_pick = ColorPickerButton.new()
|
||||
_bg_pick.custom_minimum_size = Vector2(34, 24)
|
||||
_bg_pick.focus_mode = Control.FOCUS_NONE
|
||||
_bg_pick.color = doc.bg_color
|
||||
_bg_pick.tooltip_text = "Background color"
|
||||
_bg_pick.color_changed.connect(func(c: Color): bg_changed.emit(c))
|
||||
add_child(_bg_pick)
|
||||
|
||||
# --- editor settings (gear): shading mode buttons, grid toggle ---
|
||||
_btn_settings = _button("gear", "Editor settings\n3D shading mode, grid and contextual hints")
|
||||
_btn_settings.pressed.connect(_open_settings)
|
||||
add_child(_btn_settings)
|
||||
_build_settings_popup()
|
||||
|
||||
# --- documentation (book): every button, tool and feature explained
|
||||
_btn_docs = _button("docs", "Documentation\nEvery button, tool and feature of the plugin, with how-tos\nand use cases")
|
||||
_btn_docs.pressed.connect(_open_docs)
|
||||
add_child(_btn_docs)
|
||||
|
||||
sync_from_doc()
|
||||
|
||||
|
||||
func _menu(icon: String, tip: String) -> MenuButton:
|
||||
var m := MenuButton.new()
|
||||
m.icon = _icon(icon)
|
||||
m.text = ""
|
||||
m.focus_mode = Control.FOCUS_NONE
|
||||
m.tooltip_text = tip
|
||||
m.add_theme_constant_override("icon_max_width", 16)
|
||||
m.flat = false
|
||||
_style(m)
|
||||
return m
|
||||
|
||||
|
||||
# -------------------------------------------------------- settings UI ---
|
||||
## Editor settings: tactile BUTTONS (pressed = active, one button in a
|
||||
## group is always pressed) instead of on/off switches - a shading mode
|
||||
## is a choice, not a switch, and a pressed button clearly shows state.
|
||||
func _build_settings_popup() -> void:
|
||||
_settings_popup = PopupPanel.new()
|
||||
var v := VBoxContainer.new()
|
||||
v.add_theme_constant_override("separation", 8)
|
||||
v.custom_minimum_size = Vector2(252, 0)
|
||||
_settings_popup.add_child(v)
|
||||
|
||||
var head := Label.new()
|
||||
head.text = "Editor Settings"
|
||||
head.add_theme_font_size_override("font_size", 14)
|
||||
v.add_child(head)
|
||||
|
||||
var sh := Label.new()
|
||||
sh.text = "3D shading"
|
||||
sh.add_theme_font_size_override("font_size", 11)
|
||||
sh.modulate = Color(1, 1, 1, 0.6)
|
||||
v.add_child(sh)
|
||||
var row := HBoxContainer.new()
|
||||
row.add_theme_constant_override("separation", 4)
|
||||
v.add_child(row)
|
||||
var grp := ButtonGroup.new()
|
||||
var modes := [[0, "Shaded + Wire", "Solid model with an x-ray wireframe overlay"],
|
||||
[1, "Shaded", "Solid model only - no wireframe"],
|
||||
[2, "Wireframe", "Wireframe only - no solid surfaces"]]
|
||||
for md in modes:
|
||||
var b := Button.new()
|
||||
b.text = md[1]
|
||||
b.toggle_mode = true
|
||||
b.button_group = grp
|
||||
b.focus_mode = Control.FOCUS_NONE
|
||||
b.tooltip_text = md[2]
|
||||
b.add_theme_font_size_override("font_size", 12)
|
||||
b.custom_minimum_size = Vector2(0, 26)
|
||||
_style_tactile(b)
|
||||
var want: int = md[0]
|
||||
b.pressed.connect(func():
|
||||
doc.set_view_shading(want)
|
||||
_sync_settings())
|
||||
_shade_btns.append([b, want])
|
||||
row.add_child(b)
|
||||
|
||||
var gh := Label.new()
|
||||
gh.text = "Viewport"
|
||||
gh.add_theme_font_size_override("font_size", 11)
|
||||
gh.modulate = Color(1, 1, 1, 0.6)
|
||||
v.add_child(gh)
|
||||
_grid_btn = Button.new()
|
||||
_grid_btn.text = "Show Grid"
|
||||
_grid_btn.toggle_mode = true
|
||||
_grid_btn.focus_mode = Control.FOCUS_NONE
|
||||
_grid_btn.tooltip_text = "Show or hide the grid (V)\nSnapping keeps working while the grid is hidden"
|
||||
_grid_btn.add_theme_font_size_override("font_size", 12)
|
||||
_grid_btn.custom_minimum_size = Vector2(0, 26)
|
||||
_style_tactile(_grid_btn)
|
||||
_grid_btn.pressed.connect(func():
|
||||
doc.set_grid_visible(_grid_btn.button_pressed)
|
||||
_sync_settings())
|
||||
v.add_child(_grid_btn)
|
||||
_hints_btn = Button.new()
|
||||
_hints_btn.text = "Contextual Hints"
|
||||
_hints_btn.toggle_mode = true
|
||||
_hints_btn.focus_mode = Control.FOCUS_NONE
|
||||
_hints_btn.tooltip_text = "Show or hide the in-viewport tip lines\n(the small help text at the bottom of each view)"
|
||||
_hints_btn.add_theme_font_size_override("font_size", 12)
|
||||
_hints_btn.custom_minimum_size = Vector2(0, 26)
|
||||
_style_tactile(_hints_btn)
|
||||
_hints_btn.pressed.connect(func():
|
||||
doc.set_hints(_hints_btn.button_pressed)
|
||||
_sync_settings())
|
||||
v.add_child(_hints_btn)
|
||||
|
||||
var ch := Label.new()
|
||||
ch.text = "Checkerboard"
|
||||
ch.add_theme_font_size_override("font_size", 11)
|
||||
ch.modulate = Color(1, 1, 1, 0.6)
|
||||
v.add_child(ch)
|
||||
_checker_btn = Button.new()
|
||||
_checker_btn.text = "Show Checkerboard"
|
||||
_checker_btn.toggle_mode = true
|
||||
_checker_btn.focus_mode = Control.FOCUS_NONE
|
||||
_checker_btn.tooltip_text = "Show or hide the checkerboard under unpainted texels\n\nON: unpainted areas show the checker placeholder (the classic look).\nOFF: unpainted areas are FULLY TRANSPARENT in every view - and they\nexport transparent (alpha 0), so the model gets real holes there."
|
||||
_checker_btn.add_theme_font_size_override("font_size", 12)
|
||||
_checker_btn.custom_minimum_size = Vector2(0, 26)
|
||||
_style_tactile(_checker_btn)
|
||||
_checker_btn.pressed.connect(func():
|
||||
doc.set_show_checker(_checker_btn.button_pressed)
|
||||
_sync_settings())
|
||||
v.add_child(_checker_btn)
|
||||
_bake_btn = Button.new()
|
||||
_bake_btn.text = "Bake Into Export"
|
||||
_bake_btn.toggle_mode = true
|
||||
_bake_btn.focus_mode = Control.FOCUS_NONE
|
||||
_bake_btn.tooltip_text = "Bake the checkerboard into every exported texture\n\nON: exported textures (mesh, scene, OBJ PNGs) carry the checker -\nnothing is transparent where nothing was painted.\nOFF: the export follows the Show Checkerboard switch - hidden checker\nexports transparent, visible checker exports baked.\nRender Both Sides always applies to the exported material."
|
||||
_bake_btn.add_theme_font_size_override("font_size", 12)
|
||||
_bake_btn.custom_minimum_size = Vector2(0, 26)
|
||||
_style_tactile(_bake_btn)
|
||||
_bake_btn.pressed.connect(func():
|
||||
doc.set_export_checker(_bake_btn.button_pressed)
|
||||
_sync_settings())
|
||||
v.add_child(_bake_btn)
|
||||
|
||||
add_child(_settings_popup)
|
||||
|
||||
|
||||
func _open_settings() -> void:
|
||||
_sync_settings()
|
||||
_settings_popup.reset_size()
|
||||
_place_settings_popup()
|
||||
_settings_popup.popup()
|
||||
# embedded popups can be re-fitted by the windowing system on
|
||||
# show: re-place once the REAL size is known
|
||||
_place_settings_popup.call_deferred()
|
||||
|
||||
|
||||
## Position the settings popup on the RIGHT side, right-aligned under the
|
||||
## gear, clamped INSIDE the plugin tab area so it can never spill over
|
||||
## the editor docks. Falls back to the editor base-control rect when the
|
||||
## main screen reports a degenerate (headless / not-yet-laid-out) rect.
|
||||
func _place_settings_popup() -> void:
|
||||
if _settings_popup == null or not is_instance_valid(_settings_popup):
|
||||
return
|
||||
var gear := _btn_settings.get_global_rect()
|
||||
var ps := Vector2(_settings_popup.size)
|
||||
if ps.x <= 1.0 or ps.y <= 1.0:
|
||||
ps = _settings_popup.get_contents_minimum_size() \
|
||||
+ Vector2(8, 8)
|
||||
var main := EditorInterface.get_editor_main_screen().get_global_rect()
|
||||
if main.size.x < 50.0 or main.size.y < 50.0:
|
||||
main = EditorInterface.get_base_control().get_global_rect()
|
||||
var margin := 4.0
|
||||
var pos := Vector2(gear.end.x - ps.x, gear.end.y + 2.0)
|
||||
pos.x = clampf(pos.x, main.position.x + margin,
|
||||
maxf(main.position.x + margin, main.end.x - ps.x - margin))
|
||||
pos.y = clampf(pos.y, main.position.y + margin,
|
||||
maxf(main.position.y + margin, main.end.y - ps.y - margin))
|
||||
_settings_popup.position = Vector2i(int(pos.x), int(pos.y))
|
||||
|
||||
|
||||
func _sync_settings() -> void:
|
||||
if _settings_popup == null:
|
||||
return
|
||||
for pair in _shade_btns:
|
||||
var b: Button = pair[0]
|
||||
b.set_pressed_no_signal(doc.view_shading == int(pair[1]))
|
||||
_grid_btn.set_pressed_no_signal(doc.grid_visible)
|
||||
if _hints_btn != null:
|
||||
_hints_btn.set_pressed_no_signal(doc.hints_enabled)
|
||||
if _checker_btn != null:
|
||||
_checker_btn.set_pressed_no_signal(doc.show_checker)
|
||||
if _bake_btn != null:
|
||||
_bake_btn.set_pressed_no_signal(doc.export_checker)
|
||||
|
||||
|
||||
# --------------------------------------------------------- gizmo pair ---
|
||||
## One of the three gizmo buttons was pressed: select that kind and show
|
||||
## the gizmo, or hide the gizmo when the active kind is clicked again.
|
||||
func _gizmo_pair(kind: int) -> void:
|
||||
if doc.gizmo_on and doc.gizmo_kind == kind:
|
||||
doc.set_gizmo(false)
|
||||
toggle_gizmo.emit(false)
|
||||
else:
|
||||
doc.set_gizmo(true)
|
||||
toggle_gizmo.emit(true)
|
||||
if doc.gizmo_kind != kind:
|
||||
gizmo_kind_requested.emit(kind)
|
||||
doc.set_gizmo_kind(kind)
|
||||
sync_from_doc()
|
||||
|
||||
|
||||
# -------------------------------------------------------------- docs ---
|
||||
## Open (or raise) the documentation window next to the settings gear.
|
||||
## The Window must be parented into the editor's base control or it will
|
||||
## never be shown.
|
||||
func _open_docs() -> void:
|
||||
if _docs_win != null and is_instance_valid(_docs_win):
|
||||
_docs_win.show()
|
||||
_docs_win.move_to_foreground()
|
||||
else:
|
||||
_docs_win = PdDocs.open(null)
|
||||
EditorInterface.get_base_control().add_child(_docs_win)
|
||||
# CENTER the window on the editor: an unpositioned editor
|
||||
# Window opens in the top-left corner. Computed from the
|
||||
# base control's rect (popup_centered mis-centers when the
|
||||
# host screen reports a degenerate size) and clamped so a
|
||||
# degenerate rect can never push it off-screen.
|
||||
var bc := EditorInterface.get_base_control()
|
||||
var br := bc.get_global_rect()
|
||||
var cp := br.position + ((br.size - Vector2(_docs_win.size))
|
||||
* 0.5).floor()
|
||||
_docs_win.position = Vector2i(
|
||||
maxi(0, int(cp.x)), maxi(0, int(cp.y)))
|
||||
|
||||
|
||||
func sync_from_doc() -> void:
|
||||
if doc == null:
|
||||
return
|
||||
# workspace switch: exactly one half active, and the contextual
|
||||
# group swaps in place - texture tools REPLACE the modeling tools
|
||||
var tex := doc.mode == PdDocument.Mode.TEXTURE
|
||||
_ws_3d.button_pressed = not tex
|
||||
_ws_tex.button_pressed = tex
|
||||
if _model_box != null:
|
||||
_model_box.visible = not tex
|
||||
if _tex_box != null:
|
||||
_tex_box.visible = tex
|
||||
for m in _mode_buttons:
|
||||
_mode_buttons[m].button_pressed = m == doc.mode
|
||||
# side-by-side gizmo pair mirrors on/off AND the active kind
|
||||
_btn_gizmo_move.set_pressed_no_signal(doc.gizmo_on and doc.gizmo_kind == 0)
|
||||
_btn_gizmo_scale.set_pressed_no_signal(doc.gizmo_on and doc.gizmo_kind == 1)
|
||||
_btn_gizmo_rotate.set_pressed_no_signal(doc.gizmo_on and doc.gizmo_kind == 2)
|
||||
_btn_snap.button_pressed = doc.snap_enabled
|
||||
_btn_grid.button_pressed = doc.grid_visible
|
||||
_btn_sides.button_pressed = doc.both_sides
|
||||
# draw split button: main icon always mirrors the active shape
|
||||
_draw_main.icon = _icon(DRAW_ICONS.get(doc.draw_kind, "tool_rect"))
|
||||
_draw_main.tooltip_text = "Draw mode (5)\nSketch shapes in any viewport - current shape: %s" % doc.draw_kind
|
||||
for i in PdDocument.DRAW_KINDS.size():
|
||||
_draw_popup.set_item_checked(i, PdDocument.DRAW_KINDS[i] == doc.draw_kind)
|
||||
# texture group state (contextual: paint tools OR uv tools)
|
||||
_tex_paint.set_pressed_no_signal(not doc.tex_edit)
|
||||
_tex_edituv.set_pressed_no_signal(doc.tex_edit)
|
||||
if _tex_paint_box != null:
|
||||
_tex_paint_box.visible = not doc.tex_edit
|
||||
if _tex_uv_box != null:
|
||||
_tex_uv_box.visible = doc.tex_edit
|
||||
for t in _tex_tool_btns:
|
||||
_tex_tool_btns[t].set_pressed_no_signal(t == doc.paint_tool)
|
||||
_tex_uv_snap.set_pressed_no_signal(doc.uv_snap)
|
||||
if _tex_uv_rotate != null:
|
||||
_tex_uv_rotate.set_pressed_no_signal(doc.uv_tool == "rotate")
|
||||
if _tex_uv_scale != null:
|
||||
_tex_uv_scale.set_pressed_no_signal(doc.uv_tool == "scale")
|
||||
_btn_undo.disabled = not doc.undo.has_undo()
|
||||
_btn_redo.disabled = not doc.undo.has_redo()
|
||||
if _bg_pick:
|
||||
_bg_pick.set_deferred("color", doc.bg_color)
|
||||
|
||||
|
||||
func set_bg_silent(c: Color) -> void:
|
||||
if _bg_pick:
|
||||
_bg_pick.set_deferred("color", c)
|
||||
Reference in New Issue
Block a user