965 lines
43 KiB
GDScript
Executable File
965 lines
43 KiB
GDScript
Executable File
@tool
|
|
class_name PdMain
|
|
extends VBoxContainer
|
|
## Polydoodle main screen: toolbar | quad views (Top/Persp/Side/Front) | panel.
|
|
|
|
const VIEW2D := preload("res://addons/polydoodle/editor/pd_view2d.gd")
|
|
const VIEW3D := preload("res://addons/polydoodle/editor/pd_view3d.gd")
|
|
const TOOLBAR := preload("res://addons/polydoodle/editor/pd_toolbar.gd")
|
|
const PANEL := preload("res://addons/polydoodle/editor/pd_panel.gd")
|
|
const UVCANVAS := preload("res://addons/polydoodle/editor/pd_uvcanvas.gd")
|
|
|
|
var doc: PdDocument
|
|
var toolbar: PdToolbar
|
|
var panel: PdPanel
|
|
var view3d: PdView3D
|
|
var views2d: Array = [] # [top, side, front]
|
|
var status_label: Label
|
|
var hint_label: Label
|
|
|
|
var view_holder: Control
|
|
var _split: HSplitContainer # views | panel - width-clamped drags
|
|
var _fullscreen_view: Control = null
|
|
var _focused_view: Control = null
|
|
var _dlg: EditorFileDialog
|
|
var _file_dlg: EditorFileDialog # image import dialog
|
|
var _expand_syncing := false # guard while pushing pressed states out
|
|
|
|
# Texture Paint mode: 3D viewport on top, UV canvas below. The tool
|
|
# buttons live IN THE TOP TOOLBAR (the texture group replaces the
|
|
# modeling buttons); sliders and deeper options live in the right panel.
|
|
var uv_canvas: PdUVCanvas
|
|
var _last_canvas_size := Vector2.ZERO
|
|
var last_3d_mode: int = PdDocument.Mode.OBJECT # workspace memory
|
|
|
|
const PANEL_MIN_W := 240.0 # panel floor (also on the panel itself):
|
|
# SplitContainer refuses to shrink it below
|
|
const VIEW_MIN_W := 410.0 # hard floor for the quad views: must fit
|
|
# TWO columns of view3d's own 200px minimum
|
|
# width (+ gap) or view3d gets clamped wider
|
|
# than its allotted half and visually spills
|
|
# out of view_holder into the panel next to
|
|
# it. Was 300 (only 150/column) - too small
|
|
# for view3d's 200 floor, which is exactly
|
|
# what caused the 3D viewport / panel
|
|
# overlap when the panel was dragged wide.
|
|
|
|
|
|
func _init() -> void:
|
|
doc = PdDocument.new()
|
|
set_anchors_and_offsets_preset(Control.PRESET_FULL_RECT)
|
|
size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
|
size_flags_vertical = Control.SIZE_EXPAND_FILL
|
|
add_theme_constant_override("separation", 4)
|
|
_build_ui()
|
|
doc.doc_changed.connect(_on_doc_changed)
|
|
doc.sel_changed.connect(_on_doc_changed)
|
|
doc.settings_changed.connect(_on_doc_changed)
|
|
doc.undo.version_changed.connect(_on_doc_changed)
|
|
doc.status_msg.connect(func(t: String): set_status(t))
|
|
doc.warning_msg.connect(show_toast)
|
|
_setup_autosave()
|
|
set_status("Welcome to Polydoodle - add a shape or switch to Draw mode and doodle one!")
|
|
hint_label.text = _hint_text()
|
|
|
|
|
|
func _build_ui() -> void:
|
|
toolbar = TOOLBAR.new()
|
|
toolbar.setup(doc)
|
|
toolbar.mode_requested.connect(_set_mode)
|
|
# the two-half workspace switch: left = 3D editor (restore the last
|
|
# 3D mode), right = texture editor
|
|
toolbar.workspace_requested.connect(func(tex: bool):
|
|
_set_mode(PdDocument.Mode.TEXTURE if tex else last_3d_mode))
|
|
toolbar.toggle_gizmo.connect(func(v: bool):
|
|
doc.set_gizmo(v)
|
|
_sync()
|
|
if v:
|
|
_warn_gizmo_target())
|
|
toolbar.toggle_snap.connect(func(v: bool): doc.set_snap(v))
|
|
toolbar.toggle_grid.connect(func(v: bool): doc.set_grid_visible(v))
|
|
toolbar.toggle_both_sides.connect(func(v: bool): doc.set_both_sides(v))
|
|
toolbar.draw_kind.connect(func(k: String): doc.set_draw_kind(k))
|
|
toolbar.add_shape.connect(func(kind: String):
|
|
doc.add_primitive(kind)
|
|
frame_selection())
|
|
toolbar.duplicate_requested.connect(func(): doc.duplicate_selected())
|
|
toolbar.delete_requested.connect(func(): doc.delete_selection())
|
|
toolbar.undo_requested.connect(doc.do_undo)
|
|
toolbar.redo_requested.connect(doc.do_redo)
|
|
toolbar.save_requested.connect(_save_project)
|
|
toolbar.load_requested.connect(_open_project)
|
|
toolbar.import_model_requested.connect(_import_model)
|
|
toolbar.export_requested.connect(_export)
|
|
toolbar.bg_changed.connect(func(c: Color): doc.set_bg(c))
|
|
# texture-editor toolbar group: submode + contextual tools
|
|
toolbar.tex_submode.connect(func(edit: bool): doc.set_tex_edit(edit))
|
|
toolbar.paint_tool_requested.connect(func(t: String): doc.set_paint_tool(t))
|
|
toolbar.uv_snap_requested.connect(func(v: bool): doc.set_uv_snap(v))
|
|
toolbar.rotate_uv_requested.connect(func(dir: int):
|
|
doc.rotate_uv_selected(doc.active_obj, dir))
|
|
toolbar.uv_tool_requested.connect(func(t: String):
|
|
doc.set_uv_tool(t))
|
|
toolbar.import_requested.connect(_import_image)
|
|
toolbar.detach_requested.connect(func():
|
|
doc.uv_detach_selected(doc.active_obj))
|
|
toolbar.reset_uvs_requested.connect(func():
|
|
doc.uv_reset_object(doc.active_obj))
|
|
# Scroll wrap: the toolbar's own minimum width must never push
|
|
# the layout wider than the main screen (that shoved the panel
|
|
# off-screen and stretched the viewports on smaller windows).
|
|
var tb_scroll := ScrollContainer.new()
|
|
tb_scroll.horizontal_scroll_mode = ScrollContainer.SCROLL_MODE_AUTO
|
|
tb_scroll.vertical_scroll_mode = ScrollContainer.SCROLL_MODE_DISABLED
|
|
tb_scroll.size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
|
toolbar.size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
|
tb_scroll.add_child(toolbar)
|
|
add_child(tb_scroll)
|
|
|
|
var split := HSplitContainer.new()
|
|
split.size_flags_vertical = Control.SIZE_EXPAND_FILL
|
|
split.size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
|
split.add_theme_constant_override("separation", 8)
|
|
_split = split
|
|
add_child(split)
|
|
|
|
# Classic quad view, same format as the earlier version:
|
|
# TOP (top-left) | PERSPECTIVE (top-right)
|
|
# SIDE (bottom-left) | FRONT (bottom-right)
|
|
view_holder = Control.new()
|
|
# engine-level floor: the splitter itself refuses to shrink the
|
|
# views below this, so the panel can never be dragged over them
|
|
view_holder.custom_minimum_size = Vector2(VIEW_MIN_W, 0)
|
|
view_holder.size_flags_vertical = Control.SIZE_EXPAND_FILL
|
|
view_holder.size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
|
# belt-and-braces: even if some child ever reports a minimum size
|
|
# wider than its allotted quadrant, clip it here instead of letting
|
|
# it bleed into the panel next door.
|
|
view_holder.clip_contents = true
|
|
split.add_child(view_holder)
|
|
|
|
var v_top: PdView2D = VIEW2D.new()
|
|
v_top.setup(doc, self, 0)
|
|
view_holder.add_child(v_top)
|
|
views2d.append(v_top)
|
|
|
|
view3d = VIEW3D.new()
|
|
view3d.setup(doc, self)
|
|
view3d.custom_minimum_size = Vector2(200, 150)
|
|
view_holder.add_child(view3d)
|
|
|
|
var v_side: PdView2D = VIEW2D.new()
|
|
v_side.setup(doc, self, 2)
|
|
view_holder.add_child(v_side)
|
|
views2d.append(v_side)
|
|
|
|
var v_front: PdView2D = VIEW2D.new()
|
|
v_front.setup(doc, self, 1)
|
|
view_holder.add_child(v_front)
|
|
views2d.append(v_front)
|
|
|
|
for v in all_views():
|
|
v.focus_entered.connect(func(): _focused_view = v)
|
|
view_holder.resized.connect(_relayout_views)
|
|
|
|
# Texture-mode canvas (hidden until Texture mode). Its tools live
|
|
# in the toolbar; its settings live in the right panel.
|
|
uv_canvas = UVCANVAS.new()
|
|
uv_canvas.setup(doc, self)
|
|
view_holder.add_child(uv_canvas)
|
|
uv_canvas.visible = false
|
|
uv_canvas.focus_entered.connect(func(): _focused_view = uv_canvas)
|
|
|
|
panel = PANEL.new()
|
|
panel.setup(doc, self)
|
|
panel.custom_minimum_size = Vector2(240, 0)
|
|
split.add_child(panel)
|
|
|
|
var status := HBoxContainer.new()
|
|
status.add_theme_constant_override("separation", 10)
|
|
add_child(status)
|
|
hint_label = Label.new()
|
|
hint_label.text = ""
|
|
hint_label.add_theme_font_size_override("font_size", 11)
|
|
hint_label.add_theme_color_override("font_color", Color(1, 1, 1, 0.4))
|
|
hint_label.size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
|
hint_label.clip_text = true
|
|
status.add_child(hint_label)
|
|
status_label = Label.new()
|
|
status_label.text = ""
|
|
status_label.add_theme_font_size_override("font_size", 11)
|
|
status_label.add_theme_color_override("font_color", Color(1, 1, 1, 0.55))
|
|
status_label.clip_text = true # long status text must not force width
|
|
status.add_child(status_label)
|
|
|
|
split.split_offset = -250
|
|
split.collapsed = false
|
|
_relayout_views.call_deferred()
|
|
_build_toast()
|
|
|
|
|
|
# -------------------------------------------------------------- toast ---
|
|
## A short notice that floats over the top of the main screen. It is a raised
|
|
## card in the plugin's own style (flat dark fill, darker bottom edge) and is
|
|
## sized from the real text metrics - no auto-wrapping label - so its height
|
|
## can never drift away from its content.
|
|
var _toast: PanelContainer
|
|
var _toast_label: Label
|
|
var _toast_tween: Tween
|
|
const TOAST_SECONDS := 3.8
|
|
const TOAST_FONT := 12
|
|
const TOAST_MAX_WIDTH := 560.0
|
|
const TOAST_MAX_LINES := 4
|
|
const TOAST_PAD_X := 14.0
|
|
|
|
|
|
func _build_toast() -> void:
|
|
_toast = PanelContainer.new()
|
|
_toast.top_level = true # floats over the layout
|
|
_toast.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
_toast.clip_contents = true
|
|
_toast.z_index = 100
|
|
_toast.visible = false
|
|
var sb := StyleBoxFlat.new()
|
|
sb.bg_color = Color(0.215, 0.235, 0.285)
|
|
sb.set_corner_radius_all(5)
|
|
sb.border_width_bottom = 3 # darker lower edge: raised look
|
|
sb.border_color = Color(0.105, 0.115, 0.145)
|
|
sb.content_margin_left = TOAST_PAD_X
|
|
sb.content_margin_right = TOAST_PAD_X
|
|
sb.content_margin_top = 7
|
|
sb.content_margin_bottom = 10 # 7 of padding + the 3 px lower edge
|
|
_toast.add_theme_stylebox_override("panel", sb)
|
|
_toast_label = Label.new()
|
|
_toast_label.add_theme_font_size_override("font_size", TOAST_FONT)
|
|
_toast_label.add_theme_color_override("font_color", Color(1, 1, 1, 0.92))
|
|
_toast_label.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
# the editor theme pads labels; the card does its own padding
|
|
_toast_label.add_theme_stylebox_override("normal", StyleBoxEmpty.new())
|
|
_toast.add_child(_toast_label)
|
|
add_child(_toast)
|
|
resized.connect(_place_toast)
|
|
visibility_changed.connect(func():
|
|
if not is_visible_in_tree() and _toast != null:
|
|
_toast.visible = false)
|
|
|
|
|
|
## Greedy word wrap using the font's real metrics. A word that cannot fit on
|
|
## a line by itself (a long file path, say) is broken across lines. At most
|
|
## `max_lines` lines are returned; the last one ends in "..." when cut.
|
|
func _wrap_text(text: String, font: Font, font_size: int, max_w: float,
|
|
max_lines := 1000) -> PackedStringArray:
|
|
var lines := PackedStringArray()
|
|
var cur := ""
|
|
for token in text.split(" ", false):
|
|
var word: String = token
|
|
while word.length() > 1 and font.get_string_size(word,
|
|
HORIZONTAL_ALIGNMENT_LEFT, -1, font_size).x > max_w:
|
|
var n := word.length()
|
|
while n > 1 and font.get_string_size(word.substr(0, n),
|
|
HORIZONTAL_ALIGNMENT_LEFT, -1, font_size).x > max_w:
|
|
n -= 1
|
|
if not cur.is_empty():
|
|
lines.append(cur)
|
|
cur = ""
|
|
lines.append(word.substr(0, n))
|
|
word = word.substr(n)
|
|
var cand: String = word if cur.is_empty() else cur + " " + word
|
|
if cur.is_empty() or font.get_string_size(cand,
|
|
HORIZONTAL_ALIGNMENT_LEFT, -1, font_size).x <= max_w:
|
|
cur = cand
|
|
else:
|
|
lines.append(cur)
|
|
cur = word
|
|
if not cur.is_empty():
|
|
lines.append(cur)
|
|
if lines.size() > max_lines:
|
|
lines.resize(max_lines)
|
|
var last := lines[max_lines - 1]
|
|
while last.length() > 1 and font.get_string_size(last + "...",
|
|
HORIZONTAL_ALIGNMENT_LEFT, -1, font_size).x > max_w:
|
|
last = last.substr(0, last.length() - 1)
|
|
lines[max_lines - 1] = last + "..."
|
|
return lines
|
|
|
|
|
|
func _place_toast() -> void:
|
|
if _toast == null or not _toast.visible:
|
|
return
|
|
var top := (toolbar.size.y if toolbar != null else 40.0) + 10.0
|
|
var x := clampf((size.x - _toast.size.x) * 0.5, 8.0,
|
|
maxf(8.0, size.x - _toast.size.x - 8.0))
|
|
_toast.global_position = global_position + Vector2(x, top)
|
|
|
|
|
|
## Show a notice. Replaces the previous one; fades out by itself.
|
|
func show_toast(text: String) -> void:
|
|
if _toast == null or text.is_empty() or not is_visible_in_tree():
|
|
return
|
|
var font := _toast_label.get_theme_font("font")
|
|
var card_w := clampf(size.x - 48.0, 200.0, TOAST_MAX_WIDTH)
|
|
var lines := _wrap_text(text, font, TOAST_FONT,
|
|
card_w - TOAST_PAD_X * 2.0, TOAST_MAX_LINES)
|
|
_toast_label.text = "\n".join(lines)
|
|
# explicit size from the text metrics: widest line + padding, one text
|
|
# row per line - the label never wraps by itself
|
|
var widest := 0.0
|
|
for l in lines:
|
|
widest = maxf(widest, font.get_string_size(l,
|
|
HORIZONTAL_ALIGNMENT_LEFT, -1, TOAST_FONT).x)
|
|
var sb := _toast.get_theme_stylebox("panel") as StyleBoxFlat
|
|
var gap := float(_toast_label.get_theme_constant("line_spacing"))
|
|
var card := Vector2(
|
|
minf(widest + TOAST_PAD_X * 2.0 + 2.0, card_w),
|
|
lines.size() * font.get_height(TOAST_FONT) + (lines.size() - 1) * gap
|
|
+ sb.content_margin_top + sb.content_margin_bottom)
|
|
_toast.custom_minimum_size = card
|
|
_toast.size = card
|
|
_toast.visible = true
|
|
_place_toast()
|
|
_toast.modulate.a = 1.0
|
|
if _toast_tween != null and _toast_tween.is_valid():
|
|
_toast_tween.kill()
|
|
_toast_tween = create_tween()
|
|
_toast_tween.tween_interval(TOAST_SECONDS)
|
|
_toast_tween.tween_property(_toast, "modulate:a", 0.0, 0.45)
|
|
_toast_tween.tween_callback(func(): _toast.visible = false)
|
|
|
|
|
|
# ------------------------------------------------------------- status ---
|
|
func set_status(text: String) -> void:
|
|
if status_label:
|
|
status_label.text = text
|
|
|
|
|
|
func _on_doc_changed() -> void:
|
|
_sync()
|
|
|
|
|
|
func _sync() -> void:
|
|
toolbar.sync_from_doc()
|
|
hint_label.text = _hint_text()
|
|
|
|
|
|
func _hint_text() -> String:
|
|
if not doc.hints_enabled:
|
|
return ""
|
|
return MODE_HINTS.get(doc.mode, "") + HINT_TAIL
|
|
|
|
|
|
func all_views() -> Array:
|
|
return [views2d[0], view3d, views2d[1], views2d[2]]
|
|
|
|
|
|
# ------------------------------------------------------ session ---
|
|
## SAVE SYSTEM: the document autosaves to user:// (debounced) and is
|
|
## restored when the editor reopens, so closing Godot and coming back
|
|
## brings the models back exactly as they were left.
|
|
var _autosave: Timer
|
|
|
|
|
|
func _setup_autosave() -> void:
|
|
_autosave = Timer.new()
|
|
_autosave.one_shot = true
|
|
_autosave.wait_time = 2.0
|
|
_autosave.timeout.connect(_autosave_now)
|
|
add_child(_autosave)
|
|
doc.doc_changed.connect(_kick_autosave)
|
|
doc.settings_changed.connect(_kick_autosave)
|
|
|
|
|
|
func _kick_autosave() -> void:
|
|
if _autosave != null:
|
|
_autosave.start()
|
|
|
|
|
|
func _autosave_now() -> void:
|
|
# never serialize from inside a live gesture: the pause that lets
|
|
# the timer fire would stall the drag mid-stroke. Retry when the
|
|
# gesture ends; skip entirely when nothing changed since last time.
|
|
if doc.gesture_depth > 0:
|
|
_autosave.start()
|
|
return
|
|
if not doc.session_dirty:
|
|
return
|
|
var err := PdIo.save_session(doc)
|
|
if err == OK:
|
|
doc.session_dirty = false
|
|
|
|
|
|
## Immediate flush (editor quit / plugin disable). Called by the plugin
|
|
## BEFORE the screen is freed.
|
|
func persist_session() -> void:
|
|
if _autosave != null and not _autosave.is_stopped():
|
|
_autosave.stop()
|
|
if not doc.session_dirty:
|
|
return
|
|
var err := PdIo.save_session(doc)
|
|
if err != OK:
|
|
push_warning("Polydoodle: session save failed: %s"
|
|
% error_string(err))
|
|
else:
|
|
doc.session_dirty = false
|
|
|
|
|
|
## Load the saved session (if any) into the fresh document at startup.
|
|
## Missing / corrupt file = silently start empty.
|
|
func restore_session() -> void:
|
|
var d := PdIo.load_session()
|
|
if d.is_empty():
|
|
return
|
|
var n := PdIo.apply_session(doc, d)
|
|
if n < 0:
|
|
return
|
|
var m := int(d.get("mode", PdDocument.Mode.OBJECT))
|
|
if m < 0 or m > PdDocument.Mode.TEXTURE:
|
|
m = PdDocument.Mode.OBJECT
|
|
if m == PdDocument.Mode.TEXTURE:
|
|
doc.set_tex_edit(bool(d.get("tex_edit", false)))
|
|
_set_mode(m)
|
|
doc.notify_doc()
|
|
doc.settings_changed.emit()
|
|
set_status("Session restored - %d object(s), right where you left them" % n)
|
|
frame_selection()
|
|
|
|
|
|
func _notification(what: int) -> void:
|
|
if what == NOTIFICATION_EXIT_TREE:
|
|
persist_session()
|
|
elif what == NOTIFICATION_PREDELETE:
|
|
if doc != null:
|
|
doc.release()
|
|
|
|
|
|
# ------------------------------------------------- in-viewport hints ---
|
|
## One-line contextual hints drawn INSIDE each viewport (small muted text
|
|
## at the bottom), so the editor teaches itself without reading the docs:
|
|
## with a face or vertex selected the viewport says "Right-click: options
|
|
## (extrude, delete...)", the texture canvas announces "wheel: scale ·
|
|
## right-click: rotate" while an image is being placed, and so on.
|
|
## kind: "3d" (perspective view), "2d" (orthographic views), "canvas"
|
|
## (texture canvas). The sticker hint itself is drawn by PdUVCanvas.
|
|
static func context_hint(doc: PdDocument, kind: String) -> String:
|
|
if doc == null or not doc.hints_enabled:
|
|
return ""
|
|
var empty_3d := "Ctrl+drag: rectangle select" if kind == "3d" \
|
|
else "drag empty space: box-select"
|
|
match doc.mode:
|
|
PdDocument.Mode.OBJECT:
|
|
if doc.sel_objs.is_empty():
|
|
return "Click a shape to select it · Shift+click: add · %s" % empty_3d
|
|
return "Drag: move · Right-click: options (duplicate, delete and more) · Ctrl+drag: rectangle select · Del: delete"
|
|
PdDocument.Mode.VERTEX:
|
|
if doc.sel_verts.is_empty():
|
|
return "Click a vertex to select it (Shift adds) · %s" % empty_3d
|
|
return "Drag: move · Right-click: options (merge, delete and more) · Del: delete"
|
|
PdDocument.Mode.EDGE:
|
|
if doc.sel_edges.is_empty():
|
|
return "Click an edge to select it (Shift adds) · %s" % empty_3d
|
|
return "Drag: move · Right-click: options (EXTRUDE edges, delete and more) · Del: delete"
|
|
PdDocument.Mode.FACE:
|
|
if doc.sel_faces.is_empty():
|
|
return "Click inside a face to select it (Shift adds) · %s" % empty_3d
|
|
return "Drag: move · Right-click: options (EXTRUDE faces, fill, delete and more) · Del: delete"
|
|
PdDocument.Mode.DRAW:
|
|
return "Drag to sketch a shape · Shift: square/circle · Right-click: cancel · pick the shape on the Draw button"
|
|
PdDocument.Mode.TEXTURE:
|
|
if kind == "canvas":
|
|
if doc.tex_edit:
|
|
return "Drag islands/edges/corners to move · Right-click: options (extrude, merge, delete and more) · Wheel: zoom · MMB: pan"
|
|
return "Drag: paint · Click an island to select it · Wheel: zoom · MMB: pan"
|
|
if doc.tex_edit:
|
|
return "Click a face to select it · Drag empty space: orbit"
|
|
return "Drag on the model: paint · the Eraser tool removes paint · Wheel: zoom"
|
|
return ""
|
|
|
|
|
|
# ------------------------------------------------------ texture strip ---
|
|
## Layout note: the texture tools live IN THE TOP TOOLBAR - the texture
|
|
## group replaces the modeling buttons when the texture editor is active,
|
|
## and the sliders/settings live in the right panel, so the canvas gets
|
|
## the full lower area.
|
|
|
|
|
|
func _relayout_views() -> void:
|
|
if view_holder == null:
|
|
return
|
|
var r := Rect2(Vector2.ZERO, view_holder.size)
|
|
var gap := 2.0
|
|
# ---- Texture Paint layout: 3D on top, texture canvas below (the
|
|
# canvas owns the full lower area - the tools live in the
|
|
# top toolbar)
|
|
if doc != null and doc.mode == PdDocument.Mode.TEXTURE \
|
|
and _fullscreen_view == null:
|
|
var gap2 := gap * 2.0
|
|
var avail := maxf(160.0, r.size.y - gap2)
|
|
var top_h := avail * 0.52
|
|
top_h = clampf(top_h, 90.0, avail - 90.0)
|
|
for v in views2d:
|
|
v.visible = false
|
|
view3d.visible = true
|
|
view3d.position = r.position
|
|
view3d.size = Vector2(r.size.x, top_h)
|
|
uv_canvas.visible = true
|
|
uv_canvas.position = Vector2(0, top_h + gap)
|
|
uv_canvas.size = Vector2(r.size.x, avail - top_h)
|
|
# refit the canvas when the layout resized it (a stale zoom
|
|
# made the atlas appear cut off after workspace switches)
|
|
_refit_canvas_if_resized()
|
|
return
|
|
if uv_canvas != null:
|
|
uv_canvas.visible = false
|
|
var half := (r.size - Vector2.ONE * gap) * 0.5
|
|
var vs := all_views()
|
|
if _fullscreen_view != null:
|
|
# one view alone fills the area. In the texture editor the
|
|
# expanded view can be the canvas itself.
|
|
var fsvs := vs.duplicate()
|
|
if doc != null and doc.mode == PdDocument.Mode.TEXTURE:
|
|
fsvs.append(uv_canvas)
|
|
for v in fsvs:
|
|
v.visible = v == _fullscreen_view
|
|
v.position = r.position
|
|
v.size = r.size
|
|
if _fullscreen_view == uv_canvas:
|
|
_refit_canvas_if_resized()
|
|
return
|
|
var pos := [Vector2.ZERO,
|
|
Vector2(r.size.x * 0.5 + gap * 0.5, 0.0),
|
|
Vector2(0.0, r.size.y * 0.5 + gap * 0.5),
|
|
Vector2(r.size.x * 0.5 + gap * 0.5, r.size.y * 0.5 + gap * 0.5)]
|
|
for i in vs.size():
|
|
vs[i].visible = true
|
|
vs[i].position = pos[i]
|
|
vs[i].size = half
|
|
|
|
|
|
## Re-fit the canvas zoom when the layout changed its size (shared by the
|
|
## normal texture layout and the expanded-canvas layout).
|
|
func _refit_canvas_if_resized() -> void:
|
|
if uv_canvas == null or not uv_canvas.visible:
|
|
return
|
|
if uv_canvas.size.distance_squared_to(_last_canvas_size) > 1.0:
|
|
_last_canvas_size = uv_canvas.size
|
|
uv_canvas.fit_view.call_deferred()
|
|
|
|
|
|
func _toggle_view_fullscreen() -> void:
|
|
if view_holder == null or views2d.size() < 3:
|
|
return
|
|
_toggle_expand(_focused_view if _focused_view != null else view3d)
|
|
|
|
|
|
## Expand/retract ONE viewport (corner button or Space): the
|
|
## expanded view alone fills the whole view area, pressing again retracts
|
|
## to the previous layout. Works for all six views: Top/Side/Front, the
|
|
## perspective 3D view and the texture canvas.
|
|
func _toggle_expand(v: Control) -> void:
|
|
if view_holder == null or v == null:
|
|
return
|
|
_fullscreen_view = null if _fullscreen_view == v else v
|
|
if _fullscreen_view == null:
|
|
set_status("View restored")
|
|
else:
|
|
set_status("View expanded - press the button again (or Space) to show all views")
|
|
_relayout_views()
|
|
_sync_expand_btns()
|
|
|
|
|
|
## Mirror the expanded state on every view's corner toggle button.
|
|
func _sync_expand_btns() -> void:
|
|
if _expand_syncing:
|
|
return
|
|
_expand_syncing = true
|
|
var all: Array = all_views()
|
|
if uv_canvas != null:
|
|
all.append(uv_canvas)
|
|
for v in all:
|
|
if v != null and "expand_btn" in v \
|
|
and v.expand_btn != null \
|
|
and is_instance_valid(v.expand_btn):
|
|
v.expand_btn.set_pressed_no_signal(
|
|
_fullscreen_view == v)
|
|
_expand_syncing = false
|
|
|
|
|
|
const HINT_TAIL := " · Space: expand focused view"
|
|
|
|
const MODE_HINTS := {
|
|
PdDocument.Mode.OBJECT: "Click: select · Drag: move · Shift+Click: multi-select · 2D: drag empty = box-select · 3D: drag empty = orbit · Ctrl+drag: rectangle multi-select · right-click: object menu · Ctrl+D: duplicate",
|
|
PdDocument.Mode.VERTEX: "Drag a vertex to move it · Shift+Click: add · 2D: drag empty = box-select · 3D: Ctrl+drag: rectangle select · right-click: merge / delete menu · Del: delete",
|
|
PdDocument.Mode.EDGE: "Click an edge, drag to move · Shift+Click: add · 3D: right-click: EXTRUDE edges / delete · Del: delete",
|
|
PdDocument.Mode.FACE: "Click inside a face, drag to move · Shift+Click: add · 3D: right-click: EXTRUDE face(s) / fill / delete · Del: delete",
|
|
PdDocument.Mode.DRAW: "Drag in ANY viewport to sketch - pick the shape from the dropdown on the Draw button · Shift: square/circle · Right-drag: pan · MMB or Alt+drag: orbit · Right-click: cancel",
|
|
PdDocument.Mode.TEXTURE: "Texture editor · tools: TOP TOOLBAR · sizes, color, resolution: RIGHT PANEL · full guide: the book button",
|
|
}
|
|
|
|
|
|
func _set_mode(m: int) -> void:
|
|
# workspace memory: remember the last 3D mode so the Texture
|
|
# Editor button and KEY_6 can toggle back to where the user was
|
|
if m != PdDocument.Mode.TEXTURE:
|
|
last_3d_mode = m
|
|
else:
|
|
_fullscreen_view = null
|
|
_sync_expand_btns()
|
|
doc.set_mode(m)
|
|
hint_label.text = _hint_text()
|
|
_relayout_views()
|
|
_sync()
|
|
|
|
|
|
## Toggle between the two workspaces (the toolbar split button, KEY_6).
|
|
func toggle_workspace() -> void:
|
|
if doc.mode == PdDocument.Mode.TEXTURE:
|
|
_set_mode(last_3d_mode)
|
|
else:
|
|
_set_mode(PdDocument.Mode.TEXTURE)
|
|
|
|
|
|
func frame_selection() -> void:
|
|
if doc.objects.is_empty():
|
|
doc.warn("Nothing to frame. The scene is empty - add a shape first.")
|
|
return
|
|
view3d.frame_selection()
|
|
|
|
|
|
# ---------------------------------------------------------- shortcuts ---
|
|
## G / S / R pick the Move / Scale / Rotate gizmo, Blender-style. The key
|
|
## for the kind that is ALREADY active hides the gizmo again - the exact
|
|
## semantics of the toolbar's [Move] [Scale] [Rotate] toggles.
|
|
func _gizmo_shortcut(kind: int) -> void:
|
|
if doc.gizmo_on and doc.gizmo_kind == kind:
|
|
doc.set_gizmo(false)
|
|
else:
|
|
doc.set_gizmo_kind(kind)
|
|
doc.set_gizmo(true)
|
|
_warn_gizmo_target()
|
|
|
|
|
|
func _warn_gizmo_target() -> void:
|
|
var hint := doc.gizmo_hint()
|
|
if hint != "":
|
|
doc.warn(hint)
|
|
|
|
|
|
func _shortcut_input(event: InputEvent) -> void:
|
|
if not visible:
|
|
return
|
|
var k := event as InputEventKey
|
|
if k == null or not k.pressed or k.echo:
|
|
return
|
|
var fo := get_viewport().gui_get_focus_owner()
|
|
if fo is LineEdit or fo is TextEdit or fo is SpinBox:
|
|
return
|
|
var ctrl := k.ctrl_pressed or k.meta_pressed
|
|
match k.keycode:
|
|
KEY_1: _set_mode(PdDocument.Mode.OBJECT); get_viewport().set_input_as_handled()
|
|
KEY_2: _set_mode(PdDocument.Mode.VERTEX); get_viewport().set_input_as_handled()
|
|
KEY_3: _set_mode(PdDocument.Mode.EDGE); get_viewport().set_input_as_handled()
|
|
KEY_4: _set_mode(PdDocument.Mode.FACE); get_viewport().set_input_as_handled()
|
|
KEY_5: _set_mode(PdDocument.Mode.DRAW); get_viewport().set_input_as_handled()
|
|
KEY_6: toggle_workspace(); get_viewport().set_input_as_handled()
|
|
KEY_G:
|
|
# 3D workspace: G/S/R pick the Move/Scale/Rotate
|
|
# gizmo (pressing the active kind's key hides the
|
|
# gizmo, same as the toolbar toggles). Texture
|
|
# workspace keeps G = gizmo visibility toggle.
|
|
if doc.mode == PdDocument.Mode.TEXTURE:
|
|
doc.set_gizmo(not doc.gizmo_on)
|
|
else:
|
|
_gizmo_shortcut(0)
|
|
get_viewport().set_input_as_handled()
|
|
KEY_S:
|
|
# 3D workspace: S = Scale gizmo; texture workspace
|
|
# keeps the snap toggle (T toggles snap everywhere).
|
|
if doc.mode == PdDocument.Mode.TEXTURE:
|
|
doc.set_snap(not doc.snap_enabled)
|
|
else:
|
|
_gizmo_shortcut(1)
|
|
get_viewport().set_input_as_handled()
|
|
KEY_T:
|
|
doc.set_snap(not doc.snap_enabled)
|
|
get_viewport().set_input_as_handled()
|
|
KEY_V:
|
|
doc.set_grid_visible(not doc.grid_visible)
|
|
get_viewport().set_input_as_handled()
|
|
KEY_B:
|
|
doc.set_both_sides(not doc.both_sides)
|
|
get_viewport().set_input_as_handled()
|
|
KEY_Z:
|
|
if ctrl:
|
|
if event.shift_pressed:
|
|
doc.do_redo()
|
|
else:
|
|
doc.do_undo()
|
|
get_viewport().set_input_as_handled()
|
|
KEY_Y:
|
|
if ctrl:
|
|
doc.do_redo()
|
|
get_viewport().set_input_as_handled()
|
|
KEY_D:
|
|
if ctrl:
|
|
doc.duplicate_selected()
|
|
get_viewport().set_input_as_handled()
|
|
KEY_A:
|
|
if ctrl:
|
|
doc.select_all()
|
|
get_viewport().set_input_as_handled()
|
|
KEY_DELETE, KEY_BACKSPACE:
|
|
doc.delete_selection()
|
|
get_viewport().set_input_as_handled()
|
|
KEY_F:
|
|
frame_selection()
|
|
get_viewport().set_input_as_handled()
|
|
KEY_R:
|
|
if doc.mode == PdDocument.Mode.TEXTURE and doc.tex_edit:
|
|
# UV editor: rotate the selected faces' UVs 90
|
|
# degrees (Shift = counter-clockwise)
|
|
doc.rotate_uv_selected(doc.active_obj,
|
|
-1 if k.shift_pressed else 1)
|
|
else:
|
|
# 3D workspace: R = Rotate gizmo
|
|
_gizmo_shortcut(2)
|
|
get_viewport().set_input_as_handled()
|
|
KEY_SPACE:
|
|
_toggle_view_fullscreen()
|
|
get_viewport().set_input_as_handled()
|
|
KEY_ESCAPE:
|
|
doc.clear_all_sel()
|
|
get_viewport().set_input_as_handled()
|
|
|
|
|
|
func _make_input_handled() -> void:
|
|
get_viewport().set_input_as_handled()
|
|
|
|
|
|
# ------------------------------------------------------------- export ---
|
|
func _file_dialog(save: bool, filters: PackedStringArray, cb: Callable, title: String,
|
|
access := EditorFileDialog.ACCESS_RESOURCES, start_dir := "res://") -> void:
|
|
if _dlg and is_instance_valid(_dlg):
|
|
_dlg.queue_free()
|
|
_dlg = EditorFileDialog.new()
|
|
_dlg.access = access
|
|
_dlg.file_mode = EditorFileDialog.FILE_MODE_SAVE_FILE if save \
|
|
else EditorFileDialog.FILE_MODE_OPEN_FILE
|
|
_dlg.filters = filters
|
|
_dlg.current_dir = start_dir
|
|
_dlg.title = title
|
|
_dlg.ok_button_text = "Save" if save else "Open"
|
|
EditorInterface.get_base_control().add_child(_dlg)
|
|
_dlg.file_selected.connect(cb)
|
|
_dlg.canceled.connect(func():
|
|
_dlg.queue_free()
|
|
_dlg = null)
|
|
_dlg.popup_centered(Vector2i(760, 460))
|
|
|
|
|
|
func _refresh_filesystem() -> void:
|
|
EditorInterface.get_resource_filesystem().scan()
|
|
|
|
|
|
func _save_project() -> void:
|
|
_file_dialog(true,
|
|
PackedStringArray(["*.pdoodle ; Polydoodle Project"]),
|
|
func(path: String):
|
|
var err := PdIo.save_project(doc, path)
|
|
if err == OK:
|
|
_refresh_filesystem()
|
|
set_status("Saved project to %s" % path if err == OK
|
|
else "Save failed: %s" % error_string(err)),
|
|
"Save Polydoodle Project")
|
|
|
|
|
|
var _importing := false
|
|
var _last_import_dir := ""
|
|
var _import_dlg: AcceptDialog = null
|
|
|
|
|
|
func _import_model() -> void:
|
|
if _importing:
|
|
set_status("A model import is already running")
|
|
return
|
|
var start := _last_import_dir
|
|
if start.is_empty() or not DirAccess.dir_exists_absolute(start):
|
|
start = ProjectSettings.globalize_path("res://")
|
|
_file_dialog(false, PdImport.dialog_filters(),
|
|
func(path: String):
|
|
_last_import_dir = path.get_base_dir()
|
|
_run_import(path),
|
|
"Import 3D Model", EditorFileDialog.ACCESS_FILESYSTEM, start)
|
|
|
|
|
|
func _run_import(path: String) -> void:
|
|
if _importing:
|
|
set_status("A model import is already running")
|
|
return
|
|
_importing = true
|
|
path = ProjectSettings.localize_path(path)
|
|
var opts := {"textures": true, "merge": true, "fit": true}
|
|
var progress := func(f: float, text: String):
|
|
set_status("%s... %d%%" % [text, int(f * 100.0)])
|
|
var model: Dictionary = await PdImport.load_model(path, opts, self,
|
|
progress)
|
|
if not is_instance_valid(self) or not is_inside_tree():
|
|
return
|
|
if not model["ok"]:
|
|
_importing = false
|
|
_import_report("Import failed", String(model["error"]), [])
|
|
return
|
|
var res: Dictionary = await PdImport.build(model, opts, self, progress)
|
|
if not is_instance_valid(self) or not is_inside_tree():
|
|
return
|
|
_importing = false
|
|
if not res["ok"]:
|
|
_import_report("Import failed", String(res["error"]), [])
|
|
return
|
|
var objs: Array = res["objects"]
|
|
doc.add_imported_objects(objs, path.get_file().get_basename())
|
|
frame_selection()
|
|
set_status("Imported %s: %d objects, %d faces" % [
|
|
path.get_file(), objs.size(), int(res["faces"])])
|
|
var notes: Array = res["warnings"]
|
|
if not notes.is_empty():
|
|
_import_report("Import notes",
|
|
"%s was imported with notes:" % path.get_file(), notes)
|
|
|
|
|
|
func _import_report(title: String, text: String, notes: Array) -> void:
|
|
set_status(text)
|
|
var font := get_theme_font("font", "Label")
|
|
var fsize := get_theme_font_size("font_size", "Label")
|
|
var win := get_window().size
|
|
# the dialog never takes more than ~70% of the editor window; the text
|
|
# is trimmed to the lines that fit so nothing is ever clipped
|
|
var max_w := clampf(win.x * 0.6, 300.0, 520.0)
|
|
var max_h := int(win.y * 0.7)
|
|
var line_h := font.get_height(fsize) + 3.0
|
|
var capacity := maxi(4, int((max_h - 110.0) / line_h))
|
|
var out := PackedStringArray()
|
|
out.append_array(_wrap_text(text, font, fsize, max_w, mini(4, capacity)))
|
|
var shown := 0
|
|
for n in notes:
|
|
var item := _wrap_text(String(n), font, fsize, max_w - 14.0, 2)
|
|
if out.size() + item.size() >= capacity:
|
|
out.append("- ... and %d more" % (notes.size() - shown))
|
|
break
|
|
for k in item.size():
|
|
out.append(("- " if k == 0 else " ") + item[k])
|
|
shown += 1
|
|
if is_instance_valid(_import_dlg):
|
|
_import_dlg.queue_free()
|
|
var dlg := AcceptDialog.new()
|
|
dlg.title = title
|
|
dlg.dialog_text = "\n".join(out)
|
|
dlg.dialog_autowrap = false # wrapped above, so the size is exact
|
|
dlg.exclusive = false
|
|
dlg.min_size = Vector2i(320, 0)
|
|
dlg.max_size = Vector2i(int(max_w) + 90, max_h)
|
|
dlg.confirmed.connect(dlg.queue_free)
|
|
dlg.canceled.connect(dlg.queue_free)
|
|
_import_dlg = dlg
|
|
add_child(dlg)
|
|
dlg.popup_centered()
|
|
|
|
|
|
## Image import for the texture editor: the picked image floats on the
|
|
## canvas as a sticker (move / wheel-scale / click places). Placement is
|
|
## alpha-blended into the atlas and undoable; afterwards the texels can
|
|
## be painted over or erased like any other paint.
|
|
func _import_image() -> void:
|
|
if doc.active() == null:
|
|
doc.warn("Select a shape first, then import an image onto its texture.")
|
|
return
|
|
_file_dialog(false,
|
|
PackedStringArray(["*.png,*.jpg,*.jpeg,*.webp,*.bmp,*.tga ; Images"]),
|
|
func(path: String):
|
|
var img := Image.load_from_file(path)
|
|
if img == null or img.is_empty():
|
|
doc.warn("Could not load image: %s" % path)
|
|
return
|
|
uv_canvas.begin_sticker(img),
|
|
"Import Image to Texture")
|
|
|
|
|
|
func _open_project() -> void:
|
|
_file_dialog(false,
|
|
PackedStringArray(["*.pdoodle ; Polydoodle Project"]),
|
|
func(path: String):
|
|
var d := PdIo.load_project(path)
|
|
if d == null:
|
|
set_status("Could not open %s" % path)
|
|
return
|
|
# copy loaded doc contents into our live doc
|
|
doc.restore_snapshot(d.snapshot())
|
|
doc.bg_color = d.bg_color
|
|
doc.grid_size = d.grid_size
|
|
doc.grid_visible = d.grid_visible
|
|
doc.snap_enabled = d.snap_enabled
|
|
doc.gizmo_on = d.gizmo_on
|
|
doc.draw_free = d.draw_free
|
|
doc.draw_kind = d.draw_kind
|
|
doc.paint_color = d.paint_color
|
|
doc.paint_tool = d.paint_tool
|
|
doc.brush_size = d.brush_size
|
|
doc.pixel_size = d.pixel_size
|
|
doc.recent_colors = d.recent_colors
|
|
doc.both_sides = d.both_sides
|
|
doc.view_shading = d.view_shading
|
|
doc.uv_snap = d.uv_snap
|
|
doc.tex_filter = d.tex_filter
|
|
doc.pixel_px = d.pixel_px
|
|
doc.gizmo_kind = d.gizmo_kind
|
|
doc.brush_opacity = d.brush_opacity
|
|
doc.brush_smooth = d.brush_smooth
|
|
doc.face_lock = d.face_lock
|
|
doc.inset_dist = d.inset_dist
|
|
doc.hints_enabled = d.hints_enabled
|
|
doc.show_checker = d.show_checker
|
|
doc.export_checker = d.export_checker
|
|
d.release()
|
|
doc.notify_doc()
|
|
doc.settings_changed.emit()
|
|
set_status("Opened %s" % path)
|
|
frame_selection(),
|
|
"Open Polydoodle Project")
|
|
|
|
|
|
func _export_result(err: Error, ok_text: String) -> void:
|
|
if err == OK:
|
|
_refresh_filesystem()
|
|
set_status(ok_text)
|
|
else:
|
|
doc.warn("Export failed: %s. Check that the folder is writable." % error_string(err))
|
|
|
|
|
|
func _export(kind: String) -> void:
|
|
if doc.exportable_count() == 0:
|
|
if doc.objects.is_empty():
|
|
doc.warn("Nothing to export. The scene is empty - add a shape first.")
|
|
else:
|
|
doc.warn("Nothing to export. Every shape is hidden - show one (eye icon in the hierarchy).")
|
|
return
|
|
match kind:
|
|
"tres":
|
|
_file_dialog(true, PackedStringArray(["*.tres ; Godot Mesh"]),
|
|
func(path: String):
|
|
_export_result(PdIo.save_mesh_tres(doc, path), "Exported mesh to %s" % path),
|
|
"Export Mesh (.tres)")
|
|
"tscn":
|
|
_file_dialog(true, PackedStringArray(["*.tscn ; Godot Scene"]),
|
|
func(path: String):
|
|
_export_result(PdIo.save_scene_tscn(doc, path), "Exported scene to %s" % path),
|
|
"Export Scene (.tscn)")
|
|
"obj":
|
|
_file_dialog(true, PackedStringArray(["*.obj ; Wavefront OBJ"]),
|
|
func(path: String):
|
|
_export_result(PdIo.write_obj(doc, path), "Exported OBJ to %s" % path),
|
|
"Export OBJ")
|
|
"scene":
|
|
var msg := PdIo.add_to_scene(doc)
|
|
if msg.begins_with("Open or") or msg.begins_with("Nothing"):
|
|
doc.warn(msg)
|
|
else:
|
|
set_status(msg)
|