Files
2026-11-02 19:38:04 +01:00

1667 lines
76 KiB
GDScript
Executable File

@tool
class_name PdView2D
extends Control
## One 2D working view (Top / Front / Side).
## RMB-drag pans, wheel zooms, LMB selects / drags / doodles per mode.
## Every view can be FLIPPED to its opposite (Top-Bottom, Front-Back,
## Side-Left) with the corner toggle button.
## All three views share this class, so selected vertices are drawn
## consistently in every view.
const HANDLE_IDLE := 2.0
const HANDLE_HOVER := 4.0
const HANDLE_SEL := 3.2 # half-size of the selected square
const PICK_PX := 9.0
const EDGE_PICK_PX := 7.0
const GIZMO_LEN := 46.0
const ICONS := preload("res://addons/polydoodle/core/pd_icons.gd")
enum Op { NONE, PAN, MOVE, BOX, SHAPE, GIZMO, PAINT }
var doc: PdDocument
var main: Control
var axis := 0 # 0 = Top, 1 = Front, 2 = Side
var view_label := "Top"
var flipped := false # opposite view (Bottom / Back / Left)
var center := Vector2.ZERO # planar coords at view center
var zoom := 90.0 # px per world unit
var op := Op.NONE
var pan_last := Vector2.ZERO
var press_px := Vector2.ZERO
var shift_square := false
var _last_paint_key := "" # dedupes paint sweeps (face id or pixel cell)
var box_now := Vector2.ZERO
var shape_pts := PackedVector2Array()
var move_before := [] # document snapshot before the gesture
var move_orig := {} # oi -> {"verts", "pos"} for element modes
var move_orig_pos := {} # oi -> Vector3 (object positions)
var gizmo_axis := -1
var gizmo_dir0 := Vector2.RIGHT
var gizmo_len0 := 1.0
var gizmo_scalar := 0.0
var gizmo_c0 := Vector3.ZERO # selection center FROZEN at gizmo press
var gizmo_ref_len := 1.0 # arm length (screen px) frozen at press (scale)
var gizmo_d0 := 1.0 # cursor distance from center at press (uniform scale)
var move_orig_scale := {} # object scale3 frozen at gizmo press
# rotate gizmo: a 2D view only ever rotates around its own
# view-normal axis, so there is just one ring, not three - see n_axis().
var gizmo_rot_axis := Vector3.UP
var gizmo_rot_u := Vector3.RIGHT
var gizmo_rot_v := Vector3.FORWARD
var gizmo_angle0 := 0.0
var gizmo_angle := 0.0
var gizmo_rot_origs := {} # {oi -> {"verts","pos"}} frozen at press
var hover := {}
var paint_hover := {} # last mesh hit under the cursor (Paint mode)
var _ctx_menu: PopupMenu # right-click mesh-ops menu (edit modes)
var rmb_press_px := Vector2.ZERO # bare right-click (no pan drag) opens the menu
var mouse_in := false
var mouse_px := Vector2(-1, -1)
var expand_btn: Button # fullscreen toggle for this view
static var _font: Font
func _init() -> void:
custom_minimum_size = Vector2(80, 80)
size_flags_horizontal = Control.SIZE_EXPAND_FILL
size_flags_vertical = Control.SIZE_EXPAND_FILL
mouse_filter = Control.MOUSE_FILTER_STOP
mouse_default_cursor_shape = Control.CURSOR_CROSS
focus_mode = Control.FOCUS_ALL
clip_contents = true
## Flat, transparent-at-rest styling for the small corner buttons (expand/
## flip) - matches the main toolbar's own button look instead of the
## default editor Button box, which is what made the expand+flip pair
## read as one overlapping joined pill.
func _style_corner_btn(b: Button) -> void:
var normal := StyleBoxFlat.new()
normal.bg_color = Color(1, 1, 1, 0)
normal.set_corner_radius_all(4)
var hover := normal.duplicate()
hover.bg_color = Color(1, 1, 1, 0.12)
var pressed := normal.duplicate()
pressed.bg_color = Color(1, 1, 1, 0.2)
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("focus", normal)
func setup(d: PdDocument, m: Control, a: int) -> void:
doc = d
main = m
axis = a
match axis:
0: view_label = "Top"
1: view_label = "Front"
_: view_label = "Side"
doc.doc_changed.connect(func(): queue_redraw())
doc.sel_changed.connect(func(): queue_redraw())
doc.settings_changed.connect(func():
# Pixel mode samples textures NEAREST in the ortho views too
texture_filter = CanvasItem.TEXTURE_FILTER_NEAREST \
if doc.tex_filter == 1 else CanvasItem.TEXTURE_FILTER_LINEAR
queue_redraw())
mouse_entered.connect(func():
mouse_in = true
# clear a stale global drag/split cursor left behind by the
# panel splitter: this view restores its own cross shape
Input.set_default_cursor_shape(Input.CURSOR_ARROW))
mouse_exited.connect(func():
mouse_in = false
_set_hover({})
paint_hover = {}
queue_redraw())
# expand/retract toggle LEFT of the opposite-view button: pressed
# = this view alone fills the whole view area
expand_btn = Button.new()
expand_btn.icon = ICONS.get_icon("expand")
expand_btn.toggle_mode = true
expand_btn.focus_mode = Control.FOCUS_NONE
expand_btn.tooltip_text = "Expand view\nShow only this viewport at full size - press again to retract"
expand_btn.custom_minimum_size = Vector2(22, 22)
expand_btn.add_theme_constant_override("icon_max_width", 16)
expand_btn.modulate = Color(1, 1, 1, 0.75)
_style_corner_btn(expand_btn)
add_child(expand_btn)
expand_btn.set_anchors_and_offsets_preset(Control.PRESET_TOP_RIGHT)
expand_btn.offset_left = -58.0
expand_btn.offset_top = 5.0
expand_btn.offset_right = -36.0
expand_btn.offset_bottom = 27.0
expand_btn.pressed.connect(func(): main._toggle_expand(self))
# opposite-view toggle in the top-right corner: Top-Bottom,
# Front-Back, Side-Left. Rotates the view frame 180 degrees so
# grid, axes, picking and painting all follow automatically.
# A real gap (8px) plus a transparent-at-rest
# style (matching the main toolbar's own buttons) keeps this pair
# from reading as one overlapping joined pill.
var flip_btn := Button.new()
flip_btn.icon = ICONS.get_icon("flip")
flip_btn.focus_mode = Control.FOCUS_NONE
flip_btn.tooltip_text = "Show the opposite view\nTop-Bottom / Front-Back / Side-Left"
flip_btn.custom_minimum_size = Vector2(22, 22)
flip_btn.add_theme_constant_override("icon_max_width", 16)
flip_btn.modulate = Color(1, 1, 1, 0.75)
_style_corner_btn(flip_btn)
add_child(flip_btn)
flip_btn.set_anchors_and_offsets_preset(Control.PRESET_TOP_RIGHT)
flip_btn.offset_left = -28.0
flip_btn.offset_top = 5.0
flip_btn.offset_right = -6.0
flip_btn.offset_bottom = 27.0
flip_btn.pressed.connect(_toggle_flip)
if main != null and main.has_method("_sync_expand_btns"):
main._sync_expand_btns.call_deferred()
func _toggle_flip() -> void:
flipped = not flipped
queue_redraw()
# ------------------------------------------------------------- frames ---
## Returns [u_axis, v_axis(up), n_axis(toward viewer)] for this view.
func frame() -> Array:
var f: Array
match axis:
0: f = [Vector3.RIGHT, Vector3(-0, 0, -1), Vector3.UP] # X, -Z, +Y
1: f = [Vector3.RIGHT, Vector3.UP, Vector3(0, 0, -1)] # X, +Y, -Z
_: f = [Vector3(0, 0, 1), Vector3.UP, Vector3.RIGHT] # Z, +Y, +X
if flipped:
# opposite view = rotate the frame 180 degrees about the
# world axis that stays horizontal/vertical on screen:
# vertical (Y) when the view has an up direction, else the
# screen-horizontal axis (Top view).
var ax := Vector3.UP if absf(f[1].y) > 0.5 else (f[0] as Vector3)
var rot := Basis(ax, PI)
f = [rot * (f[0] as Vector3), rot * (f[1] as Vector3), rot * (f[2] as Vector3)]
return f
func view_title() -> String:
var pair: String = ["X-Z", "X-Y", "Z-Y"][axis]
match axis:
0: return ("Bottom (%s)" % pair) if flipped else ("Top (%s)" % pair)
1: return ("Back (%s)" % pair) if flipped else ("Front (%s)" % pair)
_: return ("Left (%s)" % pair) if flipped else ("Side (%s)" % pair)
return view_label
func u_axis() -> Vector3: return frame()[0]
func v_axis() -> Vector3: return frame()[1]
func n_axis() -> Vector3: return frame()[2]
func to_screen(w: Vector3) -> Vector2:
var f := frame()
return size * 0.5 + (Vector2(w.dot(f[0]), -w.dot(f[1])) - center) * zoom
## Planar coords (a, b) -> world point at normal-depth d.
func plane_world(a: float, b: float, d: float) -> Vector3:
var f := frame()
return f[0] * a + f[1] * b + f[2] * d
func to_planar(w: Vector3) -> Vector2:
var f := frame()
return Vector2(w.dot(f[0]), w.dot(f[1]))
func depth_of(w: Vector3) -> float:
return w.dot(n_axis())
## Screen px -> world planar delta.
func basis_delta(dpx: Vector2) -> Vector3:
var f := frame()
return f[0] * (dpx.x / zoom) - f[1] * (dpx.y / zoom)
func mouse_world(mp: Vector2, d: float) -> Vector3:
var pl := center + (mp - size * 0.5) / zoom
return plane_world(pl.x, -pl.y, d)
func work_depth() -> float:
var c := doc.sel_center_w()
return 0.0 if c == Vector3.INF else depth_of(c)
func _snap_planar(w: Vector3) -> Vector3:
if not doc.snap_enabled:
return w
var f := frame()
var out := w
out += f[0] * (snappedf(w.dot(f[0]), doc.grid_size) - w.dot(f[0]))
out += f[1] * (snappedf(w.dot(f[1]), doc.grid_size) - w.dot(f[1]))
return out
static func axis_name(i: int) -> String:
return ["X", "Y", "Z"][i]
# --------------------------------------------------------------- draw ---
func _draw() -> void:
if _font == null:
_font = get_theme_default_font()
draw_rect(Rect2(Vector2.ZERO, size), doc.bg_color)
var f := frame()
var half := size * 0.5 / zoom
var a0 := center.x - half.x
var a1 := center.x + half.x
var b0 := center.y - half.y
var b1 := center.y + half.y
if doc.grid_visible:
_draw_grid(f, a0, a1, b0, b1)
# ALL visible faces of ALL objects render in ONE far -> near
# painter's pass ordered by PHYSICAL depth (world position along
# the view axis), never by hierarchy or creation order - an object
# added last must not paint over everything it physically sits
# behind, and two interpenetrating objects interleave per FACE (the
# actually-in-front surface wins everywhere).
var shaded_ink := doc.view_shading == 1
if _face_fills_visible():
var face_list := face_pass_order()
# each object's LAST face in the pass: its wire/ink edge
# pass runs right after, so nearer objects still paint
# over its edges (x-ray wires never cover a nearer surface)
var last_of := {}
for i in range(face_list.size() - 1, -1, -1):
var oi3: int = face_list[i][1]
if not last_of.has(oi3):
last_of[oi3] = i
var white := Color(1, 1, 1, 1)
for i in face_list.size():
var e: Array = face_list[i]
var ob := doc.obj(e[1])
var rtex := ob.get_texture(doc.show_checker)
if rtex != null:
_draw_face_tris(ob, e[2], rtex, white)
else:
# ultra-defensive: no texture at all - flat
# per-face metadata fills
var c := ob.face_color(e[2])
if c.a > 0.01:
_draw_face_tris(ob, e[2], null, Color(
c.r, c.g, c.b,
minf(0.85, c.a + 0.25)))
if shaded_ink:
_draw_face_ink(ob, e[2])
if last_of.get(e[1], -1) == i:
_draw_object_edges(e[1])
if op == Op.SHAPE:
_draw_shape_preview()
if op == Op.BOX:
var r := Rect2(press_px, box_now - press_px).abs()
draw_rect(r, Color(PdDocument.ACCENT.r, PdDocument.ACCENT.g, PdDocument.ACCENT.b, 0.10))
draw_rect(r, PdDocument.ACCENT, false, 1.2)
# selection overlays and vertex handles draw ABOVE the depth pass -
# they mark what is being edited (the 3D view's overlay behaves the
# same way)
for oi in draw_order():
_draw_object_overlays(oi)
if doc.gizmo_on and op != Op.SHAPE and _gizmo_valid_mode() \
and doc.gizmo_anchor_w() != Vector3.INF:
_draw_gizmo()
# brush ring cursor: same footprint feedback as the 3D view
if doc.mode == PdDocument.Mode.TEXTURE and doc.paint_tool == "Brush" \
and mouse_in and mouse_px.x >= 0:
var bcol := Color(doc.paint_color.lightened(0.25), 0.9)
draw_arc(mouse_px, maxf(4.0, doc.brush_size * zoom), 0, TAU, 48, bcol, 1.6)
draw_circle(mouse_px, 2.0, Color(1, 1, 1, 0.8))
_draw_hud()
func _draw_grid(f: Array, a0: float, a1: float, b0: float, b1: float) -> void:
var step := doc.grid_size
while step * zoom < 6.0:
step *= 2.0
# DARK grid ink - matches the 3D viewport's grid; the
# colored axis lines below are untouched.
var gminor := Color(0, 0, 0, 0.16)
var gmajor := Color(0, 0, 0, 0.32)
var a := floorf(a0 / step) * step
while a <= a1 + 1e-6:
var major := fmod(absf(a) + 1e-9, step * 4.0) < step * 0.5 and absf(a) > 1e-6
var px := to_screen(plane_world(a, 0.0, 0.0))
draw_line(Vector2(px.x, 0), Vector2(px.x, size.y),
gmajor if major else gminor, 1.0)
a += step
var b := floorf(b0 / step) * step
while b <= b1 + 1e-6:
var major := fmod(absf(b) + 1e-9, step * 4.0) < step * 0.5 and absf(b) > 1e-6
var py := to_screen(plane_world(0.0, b, 0.0))
draw_line(Vector2(0, py.y), Vector2(size.x, py.y),
gmajor if major else gminor, 1.0)
b += step
var axis_lines := [
[_axis_idx(f[0]), to_screen(plane_world(a0, 0, 0)), to_screen(plane_world(a1, 0, 0))],
[_axis_idx(f[1]), to_screen(plane_world(0, b0, 0)), to_screen(plane_world(0, b1, 0))],
]
for al in axis_lines:
var c: Color = PdDocument.AXIS_COLORS[al[0]]
draw_line(al[1], al[2], Color(c.r, c.g, c.b, 0.45), 1.5)
func _axis_idx(v: Vector3) -> int:
if absf(v.x) > 0.5: return 0
if absf(v.y) > 0.5: return 1
return 2
func _draw_hud() -> void:
var f := _font
if f == null:
return
var lab := "%s %d px/unit" % [view_title(), int(zoom)]
var ts := f.get_string_size(lab, HORIZONTAL_ALIGNMENT_LEFT, -1, 11)
var pad := Vector2(6, 4)
draw_rect(Rect2(Vector2(4, 4), ts + pad * 2), Color(0, 0, 0, 0.35))
draw_string(f, Vector2(4, 4) + pad + Vector2(0, ts.y - 3), lab,
HORIZONTAL_ALIGNMENT_LEFT, -1, 11, Color(1, 1, 1, 0.75))
if mouse_in and mouse_px.x >= 0:
var w := mouse_world(mouse_px, work_depth())
var pl := to_planar(w)
var txt := "%.2f, %.2f" % [pl.x, pl.y]
var ts2 := f.get_string_size(txt, HORIZONTAL_ALIGNMENT_LEFT, -1, 11)
var anchor := Vector2(size.x - ts2.x - 14, size.y - 12)
draw_rect(Rect2(anchor - Vector2(6, ts2.y), ts2 + Vector2(12, 8)), Color(0, 0, 0, 0.35))
draw_string(f, anchor, txt, HORIZONTAL_ALIGNMENT_LEFT, -1, 11, Color(1, 1, 1, 0.65))
# in-viewport contextual hint, bottom-left: e.g.
# "Right-click: options (EXTRUDE faces, fill, delete and more)"
var hint := PdMain.context_hint(doc, "2d")
if hint != "":
var ts3 := f.get_string_size(hint, HORIZONTAL_ALIGNMENT_LEFT, -1, 11)
var hp := Vector2(4, size.y - ts3.y - 12)
draw_rect(Rect2(hp, ts3 + Vector2(12, 8)), Color(0, 0, 0, 0.4))
draw_string(f, hp + Vector2(6, ts3.y - 3), hint,
HORIZONTAL_ALIGNMENT_LEFT, -1, 11, Color(1, 1, 1, 0.72))
## Wireframe shading (2) hides every face fill in the 2D views too -
## edges and vertices stay, matching the 3D viewport.
func _face_fills_visible() -> bool:
return doc.view_shading != 2
## The faint x-ray wire edges are hidden in SHADED mode (1), exactly like
## the 3D viewport's overlay rules - far-side edges must not bleed through
## the face fills. Exposed so tests can assert the shading matrix.
func wire_edges_visible() -> bool:
return doc.view_shading != 1
## Far -> near object draw order for this view: sorted by PHYSICAL depth
## (world AABB center along the view axis), tie-broken by object index so
## equal-depth objects never flicker between frames. Exposed for tests.
func draw_order() -> Array:
var zorder := []
for oi in doc.objects.size():
zorder.append(oi)
zorder.sort_custom(func(a: int, b: int) -> bool:
var oa := doc.obj(a)
var ob := doc.obj(b)
if oa == null or ob == null:
return false
var da := depth_of(oa.aabb_w().get_center())
var db := depth_of(ob.aabb_w().get_center())
return da < db if not is_equal_approx(da, db) else a < b)
return zorder
## The GLOBAL far -> near face pass of the current view: one entry
## [depth, object_index, face_index] for every visible face of every
## object, sorted by PHYSICAL depth (ties: object, then face index - no
## hierarchy order anywhere). Objects that interpenetrate interleave per
## face, so the surface that is actually in front always paints last.
## Exposed for tests and reused by _draw().
func face_pass_order() -> Array:
var face_list := []
for oi in doc.objects.size():
var o := doc.obj(oi)
if o == null or not o.is_visible:
continue
o.ensure_uv()
for fi in o.nfaces():
face_list.append([depth_of(PdGeo.face_center(
o.face_pts_w(fi))), oi, fi])
face_list.sort_custom(func(a, b):
if not is_equal_approx(a[0], b[0]):
return a[0] < b[0]
if a[1] != b[1]:
return a[1] < b[1]
return a[2] < b[2])
return face_list
## SHADED mode: a face's ink edges draw right after its own fill inside
## the far -> near face loop, so a nearer face paints OVER a farther
## edge - the painter's-algorithm equivalent of the 3D view's
## depth-tested ink surface. Exposed ink keys stay in the global pass.
func _draw_face_ink(o: PdPolyObj, fi: int) -> void:
var loop := o.face_loop(fi)
for i in loop.size():
var a: int = loop[i]
var b: int = loop[(i + 1) % loop.size()]
var ec := o.edge_color(Vector2i(mini(a, b), maxi(a, b)))
if ec.a <= 0.01:
continue
draw_line(to_screen(o.wvert(a)), to_screen(o.wvert(b)),
Color(ec.r, ec.g, ec.b, 0.95), 2.0)
func _draw_object_edges(oi: int) -> void:
var o := doc.obj(oi)
if o == null or not o.is_visible:
return
var is_active := oi == doc.active_obj
var wire := Color(1, 1, 1, 0.30 if is_active else 0.16)
# Edge overlay, matching the 3D viewport's per-shading rules
# (pd_view3d._rebuild_overlay): the faint x-ray wire lines are
# hidden in SHADED mode - without this, far-side edges bleed
# through the depth-sorted face fills. Ink-colored edges
# (edge_color alpha) are model art and stay in every shading.
var shaded_ink := doc.view_shading == 1
var show_wire := wire_edges_visible()
for e in o.edges():
var p1 := to_screen(o.wvert(e.x))
var p2 := to_screen(o.wvert(e.y))
var ec := o.edge_color(e)
if ec.a > 0.01:
if not shaded_ink:
draw_line(p1, p2, Color(ec.r, ec.g, ec.b, 0.95), 2.0)
elif show_wire:
draw_line(p1, p2, wire, 1.0)
func _draw_object_overlays(oi: int) -> void:
var o := doc.obj(oi)
if o == null or not o.is_visible:
return
var is_active := oi == doc.active_obj
var wire := Color(1, 1, 1, 0.30 if is_active else 0.16)
# face-mode accent fill + outline for the active object
if is_active and doc.mode == PdDocument.Mode.FACE \
and _face_fills_visible():
for fi in doc.sel_faces:
_draw_face_tris(o, fi, null, Color(
PdDocument.ACCENT.r, PdDocument.ACCENT.g,
PdDocument.ACCENT.b, 0.30))
if is_active and doc.mode == PdDocument.Mode.FACE:
for fi in doc.sel_faces:
var sp := PackedVector2Array()
for p in o.face_pts_w(fi):
sp.append(to_screen(p))
if sp.size() >= 3:
sp.append(sp[0])
draw_polyline(sp, PdDocument.ACCENT, 2.0)
# EDGE-mode selection / hover accents stay in every shading so
# element editing keeps its affordances
if is_active and doc.mode == PdDocument.Mode.EDGE:
for e in o.edges():
if doc.sel_edges.has(e):
draw_line(to_screen(o.wvert(e.x)),
to_screen(o.wvert(e.y)),
PdDocument.ACCENT, 3.0)
elif op == Op.NONE and hover.get("kind") == "edge" \
and hover.get("obj") == oi and hover.get("idx") == e:
draw_line(to_screen(o.wvert(e.x)),
to_screen(o.wvert(e.y)),
Color(1, 1, 1, 0.6), 3.0)
var show_verts := is_active and doc.mode != PdDocument.Mode.OBJECT \
and doc.mode != PdDocument.Mode.TEXTURE and doc.mode != PdDocument.Mode.DRAW
if show_verts:
for vi in o.nverts():
var sp := to_screen(o.wvert(vi))
if sp.x < -8 or sp.y < -8 or sp.x > size.x + 8 or sp.y > size.y + 8:
continue
var sel := doc.sel_verts.has(vi)
if sel:
var r := Rect2(sp - Vector2.ONE * HANDLE_SEL, Vector2.ONE * HANDLE_SEL * 2)
draw_rect(r, Color(0, 0, 0, 0.85))
draw_rect(r.grow(-1.2), PdDocument.SEL_VERT)
elif doc.mode == PdDocument.Mode.VERTEX:
draw_circle(sp, 2.4, Color(1, 1, 1, 0.62))
if op == Op.NONE and hover.get("kind") == "vert" \
and hover.get("obj") == oi and hover.get("idx") == vi:
draw_circle(sp, HANDLE_HOVER, Color(1, 1, 1, 0.9))
elif _is_sel_face_vert(vi):
draw_circle(sp, HANDLE_IDLE, Color(
PdDocument.SEL_VERT.r, PdDocument.SEL_VERT.g, PdDocument.SEL_VERT.b, 0.8))
elif _is_sel_edge_vert(vi):
draw_circle(sp, HANDLE_IDLE, Color(
PdDocument.ACCENT.r, PdDocument.ACCENT.g, PdDocument.ACCENT.b, 0.85))
if doc.mode == PdDocument.Mode.OBJECT and doc.sel_objs.has(oi):
var ab := o.aabb_w()
var p1 := to_screen(ab.position)
var p2 := to_screen(ab.end)
draw_rect(Rect2(p1, p2 - p1).abs(), Color(
PdDocument.ACCENT.r, PdDocument.ACCENT.g, PdDocument.ACCENT.b, 0.06))
draw_rect(Rect2(p1, p2 - p1).abs(), PdDocument.ACCENT, false, 1.4)
## Draw one face as triangles (textured when `tex` is set, flat color
## otherwise). Each triangle is submitted as a primitive, so nothing goes
## through the engine's polygon triangulator.
func _draw_face_tris(o: PdPolyObj, fi: int, tex: Texture2D, col: Color) -> void:
var tr := o.face_triangulation(fi)
var pts: PackedVector3Array = tr["verts"]
var tris: PackedInt32Array = tr["tris"]
if pts.size() < 3 or tris.size() < 3:
return
var sp := PackedVector2Array()
sp.resize(pts.size())
var uv := PackedVector2Array()
if tex != null:
uv.resize(pts.size())
for k in pts.size():
sp[k] = to_screen(pts[k])
if tex != null:
uv[k] = o.uv_of_world(fi, pts[k])
for t in range(0, tris.size() - 2, 3):
var tri := PackedVector2Array([sp[tris[t]], sp[tris[t + 1]], sp[tris[t + 2]]])
# skip degenerate triangles - Godot's internal polygon
# triangulation errors out on zero-area input
if not PdGeo.tri_drawable(tri[0], tri[1], tri[2]):
continue
var tri_cols := PackedColorArray([col, col, col])
if tex != null:
draw_primitive(tri, tri_cols,
PackedVector2Array([uv[tris[t]], uv[tris[t + 1]], uv[tris[t + 2]]]), tex)
else:
draw_primitive(tri, tri_cols, PackedVector2Array())
func _is_sel_face_vert(vi: int) -> bool:
if doc.mode != PdDocument.Mode.FACE:
return false
var o := doc.active()
if o == null:
return false
for fi in doc.sel_faces:
if o.face_loop(fi).has(vi):
return true
return false
func _is_sel_edge_vert(vi: int) -> bool:
if doc.mode != PdDocument.Mode.EDGE:
return false
for e in doc.sel_edges:
if e.x == vi or e.y == vi:
return true
return false
# -------------------------------------------------------------- gizmo ---
func _gizmo_valid_mode() -> bool:
return doc.mode != PdDocument.Mode.DRAW and doc.mode != PdDocument.Mode.TEXTURE
func gizmo_center_px() -> Vector2:
return to_screen(doc.gizmo_anchor_w())
func gizmo_arrows() -> Array:
var c := doc.gizmo_anchor_w()
var out := []
for i in 3:
var ax := Vector3.RIGHT
match i:
1: ax = Vector3.UP
2: ax = Vector3(0, 0, 1)
var p1 := to_screen(c)
var p2 := to_screen(c + ax)
var d := p2 - p1
var l := d.length()
if l < 6.0:
continue
var dn := d / l
out.append({
"axis": i, "from": p1, "to": p1 + dn * GIZMO_LEN,
"dir": dn, "len_px": l, "col": PdDocument.AXIS_COLORS[i],
})
return out
func _draw_gizmo() -> void:
var c := gizmo_center_px()
if doc.gizmo_kind == 2:
# ROTATE: a single ring - a 2D view only ever rotates around
# its own view-normal axis, so there is no axis to choose,
# just one ring to grab.
var hov: bool = (op == Op.GIZMO) or (op == Op.NONE and _gizmo_hit(mouse_px) == -3)
var col := Color(1, 1, 1, 0.9)
draw_arc(c, GIZMO_LEN, 0, TAU, 48, col, 3.0 if hov else 2.0, true)
draw_circle(c, 3.0, Color(1, 1, 1, 0.9))
if op == Op.GIZMO and _font:
var deg := roundi(rad_to_deg(gizmo_angle))
draw_string(_font, c + Vector2(GIZMO_LEN * 0.7, -GIZMO_LEN * 0.7),
"%d°" % deg, HORIZONTAL_ALIGNMENT_LEFT, -1, 12, Color(1, 1, 1, 0.95))
return
# hollow chip (MOVE) vs filled square (SCALE) so the selected
# element stays visible underneath either way
if doc.gizmo_kind == 1:
draw_rect(Rect2(c - Vector2(5, 5), Vector2(10, 10)), Color(0, 0, 0, 0.55))
draw_rect(Rect2(c - Vector2(3.5, 3.5), Vector2(7, 7)), Color(1, 1, 1, 0.9))
else:
draw_rect(Rect2(c - Vector2(4.5, 4.5), Vector2(9, 9)), Color(0, 0, 0, 0.55))
draw_rect(Rect2(c - Vector2(3, 3), Vector2(6, 6)), Color(1, 1, 1, 0.9), false, 1.4)
for a in gizmo_arrows():
var hov: bool = op == Op.GIZMO and gizmo_axis == a["axis"]
var col: Color = a["col"]
draw_line(a["from"], a["to"], col, 3.0 if hov else 2.0)
var tip: Vector2 = a["to"]
var dn: Vector2 = a["dir"]
var perp := Vector2(-dn.y, dn.x)
if doc.gizmo_kind == 1:
# SCALE: a small filled square tip (matches the 3D
# view's cube handles) instead of an arrowhead
var hs: float = 5.0 if hov else 4.0
var sq := PackedVector2Array([
tip - perp * hs - dn * hs, tip + perp * hs - dn * hs,
tip + perp * hs + dn * hs, tip - perp * hs + dn * hs])
draw_colored_polygon(sq, col)
else:
var head := PackedVector2Array([
tip, tip - dn * 9 + perp * 4.5, tip - dn * 9 - perp * 4.5])
if PdGeo.tri_drawable(head[0], head[1], head[2]):
draw_colored_polygon(head, col)
if _font:
draw_string(_font, tip + dn * 12 + Vector2(-4, 4), axis_name(a["axis"]),
HORIZONTAL_ALIGNMENT_LEFT, -1, 10, col)
# ------------------------------------------------------------ picking ---
## Among candidates within a small radius of the best screen distance, the
## one nearest to the viewer (largest depth along the view normal) wins.
## Extra keys of the winning candidate ("point", "normal", ...) are carried
## through: the brush/pixel tools need the exact hit point under the cursor,
## NOT the face center, or 2D painting would land in the middle of faces.
func _frontmost(cands: Array) -> Dictionary:
if cands.is_empty():
return {}
var best_d := INF
for c in cands:
best_d = minf(best_d, c["d"])
var out := {}
var front_depth := -INF
for c in cands:
if c["d"] <= best_d + 2.0 and c["depth"] > front_depth:
front_depth = c["depth"]
out = {"obj": c["obj"], "idx": c["idx"], "kind": c["kind"]}
for k in ["point", "normal"]:
if c.has(k):
out[k] = c[k]
return out
func _pick_vert(mp: Vector2) -> Dictionary:
var cands := []
for oi in doc.objects.size():
var o := doc.obj(oi)
if o == null or not o.is_visible or o.is_locked:
continue
for vi in o.nverts():
var w := o.wvert(vi)
var d := mp.distance_to(to_screen(w))
if d <= PICK_PX:
cands.append({"obj": oi, "idx": vi, "kind": "vert",
"d": d, "depth": depth_of(w)})
return _frontmost(cands)
func _pick_edge(mp: Vector2) -> Dictionary:
var cands := []
for oi in doc.objects.size():
var o := doc.obj(oi)
if o == null or not o.is_visible or o.is_locked:
continue
for e in o.edges():
var a := o.wvert(e.x)
var b := o.wvert(e.y)
var d := PdGeo.dist_to_seg(mp, to_screen(a), to_screen(b))
if d <= EDGE_PICK_PX:
cands.append({"obj": oi, "idx": e, "kind": "edge",
"d": d, "depth": (depth_of(a) + depth_of(b)) * 0.5})
return _frontmost(cands)
func _pick_face(mp: Vector2) -> Dictionary:
var cands := []
for oi in doc.objects.size():
var o := doc.obj(oi)
if o == null or not o.is_visible or o.is_locked:
continue
for fi in o.nfaces():
var pts := o.face_pts_w(fi)
if pts.size() < 3:
continue
var sp := PackedVector2Array()
for p in pts:
sp.append(to_screen(p))
if PdGeo.point_in_poly2(sp, mp):
var fc := PdGeo.face_center(pts)
cands.append({"obj": oi, "idx": fi, "kind": "face",
"d": 0.0, "depth": depth_of(fc),
"point": mouse_world(mp, depth_of(fc)),
"normal": n_axis()})
return _frontmost(cands)
func _pick_object(mp: Vector2) -> int:
var hit := _pick_face(mp)
if not hit.is_empty():
return hit["obj"]
var v := _pick_vert(mp)
if not v.is_empty():
return v["obj"]
var e := _pick_edge(mp)
if not e.is_empty():
return e["obj"]
return -1
func _set_hover(h: Dictionary) -> void:
if hover != h:
hover = h
queue_redraw()
func _update_hover(mp: Vector2) -> void:
match doc.mode:
PdDocument.Mode.VERTEX:
_set_hover(_pick_vert(mp))
PdDocument.Mode.EDGE:
_set_hover(_pick_edge(mp))
PdDocument.Mode.FACE:
_set_hover(_pick_face(mp))
PdDocument.Mode.OBJECT:
var oi := _pick_object(mp)
_set_hover({} if oi < 0 else {"obj": oi, "kind": "obj"})
_:
_set_hover({})
func _gizmo_hit(mp: Vector2) -> int:
if not doc.gizmo_on or not _gizmo_valid_mode() \
or doc.gizmo_anchor_w() == Vector3.INF:
return -1
var c := gizmo_center_px()
if doc.gizmo_kind == 2:
# ROTATE: a single ring - hit-test the ring's circumference,
# not a filled disc, so it doesn't swallow clicks meant for
# whatever element is sitting at the gizmo center
return -3 if absf(mp.distance_to(c) - GIZMO_LEN) < 9.0 else -1
if mp.distance_to(c) < 10.0:
return -2 # center zone: SCALE = uniform handle, MOVE = direct drag
for a in gizmo_arrows():
if PdGeo.dist_to_seg(mp, a["from"], a["to"]) < 9.0:
return a["axis"]
return -1
# -------------------------------------------------------------- input ---
func _gui_input(event: InputEvent) -> void:
if event is InputEventMouseButton:
_mi(event)
elif event is InputEventMouseMotion:
_mm(event)
func _mi(e: InputEventMouseButton) -> void:
var mp := e.position
match e.button_index:
MOUSE_BUTTON_RIGHT:
if e.pressed:
# right-drag pans; a BARE right-click (press
# and release within a few px) opens the
# mesh-ops context menu - the same one the 3D
# view offers (extrude, merge, delete, ...).
# Erasing stays the dedicated Eraser TOOL in
# the texture editor canvas.
op = Op.PAN
pan_last = mp
press_px = mp
rmb_press_px = mp
accept_event()
elif op == Op.PAN:
op = Op.NONE
if mp.distance_to(rmb_press_px) < 6.0:
_open_ctx_menu(mp)
accept_event()
MOUSE_BUTTON_MIDDLE:
if e.pressed:
op = Op.PAN
pan_last = mp
accept_event()
elif op == Op.PAN:
op = Op.NONE
accept_event()
MOUSE_BUTTON_LEFT:
if e.pressed:
_press_left(mp)
else:
_release_left(mp)
MOUSE_BUTTON_WHEEL_UP:
if e.pressed:
_zoom_at(mp, 1.12)
accept_event()
MOUSE_BUTTON_WHEEL_DOWN:
if e.pressed:
_zoom_at(mp, 1.0 / 1.12)
accept_event()
# ---------------------------------------------------- context menu ---
## Right-click mesh-ops menu in the 2D views (same as the 3D editor's,
## picocad-style): extrude faces/edges, merge vertices, fill/clear paint,
## delete - per mode. Built fresh on every open so enable states are live.
## A right-DRAG pans; only a bare right-click lands here (see _mi).
func _open_ctx_menu(mp: Vector2) -> void:
if doc.mode == PdDocument.Mode.DRAW \
or doc.mode == PdDocument.Mode.TEXTURE:
return
if _ctx_menu != null and is_instance_valid(_ctx_menu):
_ctx_menu.queue_free()
_ctx_menu = PopupMenu.new()
_ctx_menu.add_theme_font_size_override("font_size", 12)
var oi := doc.active_obj
var o := doc.obj(oi)
var entries: Array = []
match doc.mode:
PdDocument.Mode.OBJECT:
entries = [[0, "Duplicate", doc.sel_objs.size() > 0],
[1, "Delete", doc.sel_objs.size() > 0],
[-1, "", true],
[2, "Select All", doc.objects.size() > 0],
[3, "Deselect", doc.sel_objs.size() > 0]]
PdDocument.Mode.VERTEX:
entries = [[10, "Merge Vertices", doc.sel_verts.size() >= 2],
[11, "Delete Vertex(es)", doc.sel_verts.size() > 0],
[-1, "", true],
[12, "Select All", o != null],
[13, "Deselect", doc.sel_verts.size() > 0]]
PdDocument.Mode.EDGE:
entries = [[20, "Extrude Edges", doc.sel_edges.size() > 0],
[21, "Delete Edge(s)", doc.sel_edges.size() > 0],
[-1, "", true],
[22, "Select All", o != null],
[23, "Deselect", doc.sel_edges.size() > 0]]
PdDocument.Mode.FACE:
entries = [[30, "Extrude Face(s)", doc.sel_faces.size() > 0],
[31, "Fill Face(s)", doc.sel_faces.size() > 0],
[32, "Clear Face Paint", doc.sel_faces.size() > 0],
[33, "Delete Face(s)", doc.sel_faces.size() > 0],
[-1, "", true],
[34, "Select All", o != null],
[35, "Deselect", doc.sel_faces.size() > 0]]
_:
return
var any := false
for e in entries:
if int(e[0]) < 0:
_ctx_menu.add_separator()
continue
_ctx_menu.add_item(e[1], e[0])
_ctx_menu.set_item_disabled(_ctx_menu.get_item_count() - 1,
not e[2] or o == null)
any = true
if not any:
_ctx_menu.queue_free()
_ctx_menu = null
return
_ctx_menu.id_pressed.connect(func(id: int): _ctx_action(id))
add_child(_ctx_menu)
# popup at the mouse position, in SCREEN coordinates
_ctx_menu.position = Vector2i(get_global_rect().position + mp)
_ctx_menu.popup()
func _ctx_action(id: int) -> void:
var oi := doc.active_obj
match id:
0:
doc.duplicate_selected()
1:
doc.delete_selection()
2:
doc.select_all()
3:
doc.clear_all_sel()
10:
doc.merge_selected_verts()
11:
doc.delete_verts_list(oi, PackedInt32Array(doc.sel_verts))
12:
doc.select_all()
13:
doc.clear_element_sel()
doc.notify_sel()
20:
doc.extrude_selected_edges()
21:
doc.delete_edges_list(oi, doc.sel_edges.duplicate())
22:
doc.select_all()
23:
doc.clear_element_sel()
doc.notify_sel()
30:
doc.extrude_selected_faces()
31:
for fi in doc.sel_faces:
doc.tex_fill_island(oi, fi, false)
32:
for fi in doc.sel_faces:
doc.tex_fill_island(oi, fi, true)
33:
doc.delete_faces_list(oi, PackedInt32Array(doc.sel_faces))
34:
doc.select_all()
35:
doc.clear_element_sel()
doc.notify_sel()
func _zoom_at(mp: Vector2, factor: float) -> void:
var pl_before := center + (mp - size * 0.5) / zoom
zoom = clampf(zoom * factor, 6.0, 600.0)
center = pl_before - (mp - size * 0.5) / zoom
queue_redraw()
func _press_left(mp: Vector2) -> void:
press_px = mp
shift_square = Input.is_key_pressed(KEY_SHIFT)
grab_focus()
var gax := _gizmo_hit(mp)
var center_sel := doc.sel_center_w()
# The center zone (-2) only starts the gizmo for SCALE (the uniform
# handle); for MOVE it stays a DIRECT element drag like before -
# routing MOVE center-presses into the gizmo left gizmo_dir0/
# gizmo_len0 unfrozen, so a plain drag on the selection moved it by
# raw pixel amounts along a stale axis. ROTATE's hit-test only
# returns -3 on the ring circumference, never -2.
var start_gizmo := gax >= 0 \
or (gax == -2 and doc.gizmo_kind == 1) \
or (gax == -3 and doc.gizmo_kind == 2)
if start_gizmo and center_sel != Vector3.INF:
op = Op.GIZMO
doc.begin_gesture()
gizmo_axis = gax
move_before = doc.snapshot()
_capture_origs()
if doc.gizmo_kind == 2:
# ROTATE: a 2D view only ever rotates around its own
# view-normal axis (n_axis) - freeze that axis, its
# in-plane basis, and the cursor's starting angle so
# every later frame measures against THIS, not the
# live (already-rotated) selection.
gizmo_rot_axis = n_axis()
var f := frame()
gizmo_rot_u = f[0]
gizmo_rot_v = f[1]
gizmo_rot_origs = _capture_rotate_origs()
var mw0 := mouse_world(mp, depth_of(center_sel))
var rel0: Vector3 = mw0 - center_sel
gizmo_angle0 = atan2(rel0.dot(gizmo_rot_v), rel0.dot(gizmo_rot_u))
gizmo_angle = 0.0
elif doc.gizmo_kind == 1:
# SCALE: freeze the reference length/distance so the
# factor maps 1:1 to the drag - axis handles measure
# along the arrow's own screen direction (already
# world-units-per-pixel corrected, see gizmo_arrows),
# the center handle measures radial screen distance
gizmo_ref_len = GIZMO_LEN
if gax == -2:
gizmo_d0 = maxf(1.0, mp.distance_to(gizmo_center_px()))
else:
for a in gizmo_arrows():
if a["axis"] == gax:
gizmo_dir0 = a["dir"]
gizmo_len0 = a["len_px"]
else:
for a in gizmo_arrows():
if a["axis"] == gax:
gizmo_dir0 = a["dir"]
gizmo_len0 = a["len_px"]
gizmo_scalar = 0.0
gizmo_c0 = center_sel
accept_event()
return
match doc.mode:
PdDocument.Mode.DRAW:
op = Op.SHAPE
doc.begin_gesture()
shape_pts = PackedVector2Array([mp])
accept_event()
PdDocument.Mode.TEXTURE:
op = Op.PAINT
doc.begin_gesture()
move_before = doc.snapshot()
_last_paint_key = ""
doc.pixel_stroke_begin()
_paint_gesture(mp, false)
accept_event()
_:
var picked := _pick_element(mp)
if picked.is_empty():
op = Op.BOX
box_now = mp
else:
_apply_click_selection(picked)
op = Op.MOVE
doc.begin_gesture()
move_before = doc.snapshot()
_capture_origs()
accept_event()
func _pick_element(mp: Vector2) -> Dictionary:
match doc.mode:
PdDocument.Mode.VERTEX:
return _pick_vert(mp)
PdDocument.Mode.EDGE:
return _pick_edge(mp)
PdDocument.Mode.FACE:
return _pick_face(mp)
PdDocument.Mode.OBJECT:
var oi := _pick_object(mp)
return {} if oi < 0 else {"obj": oi, "idx": oi, "kind": "obj"}
return {}
func _apply_click_selection(picked: Dictionary) -> void:
var add := Input.is_key_pressed(KEY_SHIFT)
var oi: int = picked["obj"]
match doc.mode:
PdDocument.Mode.OBJECT:
if add:
doc.toggle_object(oi)
elif not doc.sel_objs.has(oi):
doc.select_object(oi)
# clicking an already-selected object KEEPS the whole
# multi-selection so dragging it moves every part
_:
if oi != doc.active_obj:
doc.active_obj = oi
doc.clear_element_sel()
match doc.mode:
PdDocument.Mode.VERTEX:
var vi: int = picked["idx"]
var arr := PackedInt32Array(doc.sel_verts)
if add:
if arr.has(vi):
arr.remove_at(arr.find(vi))
else:
arr.append(vi)
elif not arr.has(vi):
arr = PackedInt32Array([vi])
doc.select_verts(arr)
PdDocument.Mode.EDGE:
var ei: Vector2i = picked["idx"]
var arr := doc.sel_edges.duplicate()
if add:
if arr.has(ei):
arr.erase(ei)
else:
arr.append(ei)
elif not arr.has(ei):
arr = [ei]
doc.select_edges(arr)
PdDocument.Mode.FACE:
var fi: int = picked["idx"]
var arr := PackedInt32Array(doc.sel_faces)
if add:
if arr.has(fi):
arr.remove_at(arr.find(fi))
else:
arr.append(fi)
elif not arr.has(fi):
arr = PackedInt32Array([fi])
doc.select_faces(arr)
doc.notify_sel()
func _capture_origs() -> void:
move_orig = {}
move_orig_pos = {}
move_orig_scale = {}
if doc.mode == PdDocument.Mode.OBJECT:
for oi in doc.sel_objs:
var o := doc.obj(oi)
if o != null:
move_orig_pos[oi] = o.position
move_orig_scale[oi] = o.scale3
else:
var affected := doc.affected_verts()
for oi in affected:
var o := doc.obj(oi)
if o == null:
continue
var ids: PackedInt32Array = affected[oi]
var arr := PackedVector3Array()
arr.resize(ids.size())
for k in ids.size():
arr[k] = o.wvert(ids[k])
move_orig[oi] = {"verts": ids, "pos": arr}
if move_orig.is_empty() and doc.active_obj >= 0:
# element modes with NOTHING selected: the gizmo
# (e.g. after a hierarchy click) drags the whole
# active object instead - matches the 3D view
var o := doc.obj(doc.active_obj)
if o != null:
move_orig_pos[doc.active_obj] = o.position
move_orig_scale[doc.active_obj] = o.scale3
## See pd_view3d.gd's _capture_rotate_origs - rotate always writes actual
## vertex positions (there is no per-object rotation property), so OBJECT
## mode here captures every vertex of each selected object rather than a
## frozen position/scale3, in the same {"verts","pos"} shape as element modes.
func _capture_rotate_origs() -> Dictionary:
var out := {}
if doc.mode == PdDocument.Mode.OBJECT:
for oi in doc.sel_objs:
var o := doc.obj(oi)
if o != null:
out[oi] = _whole_object_verts(o)
else:
var affected := doc.affected_verts()
for oi in affected:
var o := doc.obj(oi)
if o == null:
continue
var ids: PackedInt32Array = affected[oi]
var arr := PackedVector3Array()
arr.resize(ids.size())
for k in ids.size():
arr[k] = o.wvert(ids[k])
out[oi] = {"verts": ids, "pos": arr}
if out.is_empty() and doc.active_obj >= 0:
var o := doc.obj(doc.active_obj)
if o != null:
out[doc.active_obj] = _whole_object_verts(o)
return out
func _whole_object_verts(o: PdPolyObj) -> Dictionary:
var ids := PackedInt32Array()
var pos := PackedVector3Array()
ids.resize(o.nverts())
pos.resize(o.nverts())
for k in o.nverts():
ids[k] = k
pos[k] = o.wvert(k)
return {"verts": ids, "pos": pos}
func _apply_move_targets() -> void:
match op:
Op.MOVE:
var delta := basis_delta(mouse_px - press_px)
if doc.mode == PdDocument.Mode.OBJECT:
for oi in move_orig_pos:
var o := doc.obj(oi)
if o == null:
continue
var target: Vector3 = move_orig_pos[oi] + delta
if doc.snap_enabled:
var f := frame()
target += f[0] * (snappedf(target.dot(f[0]), doc.grid_size) - target.dot(f[0]))
target += f[1] * (snappedf(target.dot(f[1]), doc.grid_size) - target.dot(f[1]))
o.position = target
o.mark_geo_changed() # world-vert cache must follow
else:
for oi in move_orig:
var o := doc.obj(oi)
if o == null:
continue
var ids: PackedInt32Array = move_orig[oi]["verts"]
var orig: PackedVector3Array = move_orig[oi]["pos"]
for k in ids.size():
o.set_wvert(ids[k], _snap_planar(orig[k] + delta))
Op.GIZMO:
if doc.gizmo_kind == 2:
# ROTATE: angle of the cursor within the
# frozen view-plane, measured from the frozen
# press-time angle - see _press_left.
var mw := mouse_world(mouse_px, depth_of(gizmo_c0))
var rel: Vector3 = mw - gizmo_c0
var ang := atan2(rel.dot(gizmo_rot_v), rel.dot(gizmo_rot_u))
var delta := wrapf(ang - gizmo_angle0, -PI, PI)
# Handedness correction: atan2(v, u) grows
# counter-clockwise ON SCREEN, but Basis(n, +d)
# only rotates counter-clockwise when the frame
# (u, v, n) is right-handed (u x v = +n). Top's
# frame is right-handed; Front and Side's are
# left-handed (u x v = -n), which mirrored the
# drag - the object spun exactly opposite to
# the cursor on those views. Scaling the world
# angle by h = sign((u x v) . n) makes the
# grabbed point's measured angle track the
# cursor in EVERY view and every flipped
# variant, with no per-view special cases.
var hnd := signf(gizmo_rot_u.cross(gizmo_rot_v) \
.dot(gizmo_rot_axis))
delta *= hnd
if doc.snap_enabled:
delta = snappedf(delta, deg_to_rad(15.0))
gizmo_angle = delta
doc.apply_rotate_gizmo(gizmo_rot_axis, delta, gizmo_rot_origs, gizmo_c0)
elif doc.gizmo_kind == 1:
# SCALE: factor from the frozen press-time
# reference - axis drags measure along the
# arrow's own screen direction, uniform
# (center handle) measures radial distance
var factor := 1.0
if gizmo_axis == -2:
factor = mouse_px.distance_to(gizmo_center_px()) / gizmo_d0
else:
var raw := (mouse_px - press_px).dot(gizmo_dir0) / maxf(gizmo_len0, 0.0001)
factor = 1.0 + raw
if doc.snap_enabled:
factor = snappedf(factor, 0.05)
factor = clampf(factor, 0.001, 100.0)
var ax_apply := -1 if gizmo_axis == -2 else gizmo_axis
if doc.mode == PdDocument.Mode.OBJECT or move_orig.is_empty():
doc.apply_scale_gizmo(ax_apply, factor, move_orig_scale, gizmo_c0)
else:
doc.apply_scale_gizmo(ax_apply, factor, move_orig, gizmo_c0)
else:
var scalar := (mouse_px - press_px).dot(gizmo_dir0) / maxf(gizmo_len0, 0.0001)
if doc.snap_enabled and doc.grid_size > 0.001:
scalar = snappedf(scalar, doc.grid_size)
gizmo_scalar = scalar
var ax := Vector3.RIGHT
match gizmo_axis:
1: ax = Vector3.UP
2: ax = Vector3(0, 0, 1)
if doc.mode == PdDocument.Mode.OBJECT or move_orig.is_empty():
for oi in move_orig_pos:
var o := doc.obj(oi)
if o != null:
o.position = move_orig_pos[oi] + ax * scalar
o.mark_geo_changed() # world-vert cache must follow
else:
for oi in move_orig:
var o := doc.obj(oi)
if o == null:
continue
var ids: PackedInt32Array = move_orig[oi]["verts"]
var orig: PackedVector3Array = move_orig[oi]["pos"]
for k in ids.size():
o.set_wvert(ids[k], orig[k] + ax * scalar)
doc.notify_doc()
func _release_left(mp: Vector2) -> void:
var was_gesture := op == Op.MOVE or op == Op.GIZMO \
or op == Op.SHAPE or op == Op.PAINT
match op:
Op.MOVE, Op.GIZMO:
var label := "Move selection"
if op == Op.GIZMO:
label = "Rotate selection" if doc.gizmo_kind == 2 \
else ("Scale selection" if doc.gizmo_kind == 1 else "Move selection")
doc.commit(label, move_before)
doc.notify_sel()
Op.BOX:
_box_select(mp)
Op.SHAPE:
_finish_shape(mp)
Op.PAINT:
pass # painting happens on press + drag sweeps
_:
pass
if was_gesture:
doc.end_gesture()
op = Op.NONE
move_before = []
_last_paint_key = ""
accept_event()
func _box_select(mp: Vector2) -> void:
var r := Rect2(press_px, mp - press_px).abs()
if r.size.length() < 4.0:
queue_redraw()
return
var add := Input.is_key_pressed(KEY_SHIFT)
match doc.mode:
PdDocument.Mode.OBJECT:
var ids := PackedInt32Array(doc.sel_objs) if add else PackedInt32Array()
for oi in doc.objects.size():
var o := doc.obj(oi)
if o == null or not o.is_visible or o.is_locked:
continue
for vi in o.nverts():
if r.has_point(to_screen(o.wvert(vi))):
if not ids.has(oi):
ids.append(oi)
break
if not add:
doc.clear_all_sel()
doc.sel_objs = ids
doc.active_obj = ids[ids.size() - 1] if not ids.is_empty() else -1
doc.notify_sel()
_:
var o := doc.active()
if o == null:
return
match doc.mode:
PdDocument.Mode.VERTEX:
var arr := PackedInt32Array(doc.sel_verts) if add else PackedInt32Array()
for vi in o.nverts():
if r.has_point(to_screen(o.wvert(vi))):
arr.append(vi)
doc.select_verts(arr)
PdDocument.Mode.EDGE:
var arr: Array = doc.sel_edges.duplicate() if add else []
for e in o.edges():
if r.has_point(to_screen(o.wvert(e.x))) \
or r.has_point(to_screen(o.wvert(e.y))):
if not arr.has(e):
arr.append(e)
doc.select_edges(arr)
PdDocument.Mode.FACE:
var arr := PackedInt32Array(doc.sel_faces) if add else PackedInt32Array()
for fi in o.nfaces():
var pts := o.face_pts_w(fi)
if pts.size() < 3:
continue
if r.has_point(to_screen(PdGeo.face_center(pts))):
arr.append(fi)
doc.select_faces(arr)
func _mm(e: InputEventMouseMotion) -> void:
mouse_px = e.position
match op:
Op.PAN:
center -= (e.position - pan_last) / zoom
pan_last = e.position
Op.MOVE:
_apply_move_targets()
Op.GIZMO:
_apply_move_targets()
Op.BOX:
box_now = e.position
Op.SHAPE:
if doc.draw_kind == "Freehand":
if shape_pts.is_empty() \
or shape_pts[shape_pts.size() - 1].distance_to(e.position) > 3.0:
shape_pts.append(e.position)
else:
shape_pts = PackedVector2Array([press_px, e.position])
Op.PAINT:
_paint_gesture(e.position, false)
Op.NONE:
if mouse_in:
_update_hover(e.position)
queue_redraw()
func _draw_shape_preview() -> void:
var col := Color(PdDocument.ACCENT.r, PdDocument.ACCENT.g, PdDocument.ACCENT.b, 0.9)
if doc.draw_kind == "Freehand":
if shape_pts.size() >= 2:
draw_polyline(shape_pts, col, 1.6)
for p in shape_pts:
draw_circle(p, 2.0, col)
if not shape_pts.is_empty():
draw_circle(shape_pts[0], 3.0, Color(1, 1, 1, 0.9))
return
if shape_pts.size() != 2:
if not shape_pts.is_empty():
draw_circle(shape_pts[0], 3.0, Color(1, 1, 1, 0.9))
return
var r := _shape_rect()
# each outline is drawn CLOSED (last point joins back to the first)
# as separate loops - the rectangle's fourth edge and the torus's
# inner ring must all be visible while dragging
for gen in _preview_loops(r):
var poly := PackedVector2Array()
for p in gen:
poly.append(r.position + Vector2(p.x * r.size.x, p.y * r.size.y))
if poly.size() >= 2:
poly.append(poly[0])
draw_polyline(poly, col, 1.5)
draw_rect(r, Color(col.r, col.g, col.b, 0.06))
if not shape_pts.is_empty():
draw_circle(shape_pts[0], 3.0, Color(1, 1, 1, 0.9))
## Normalized outline loops (0..1 within the drag rect, y down). Every
## loop is open (the preview closes it visually); the torus yields two.
func _preview_loops(r: Rect2) -> Array:
match doc.draw_kind:
"Circle":
return [_open_loop(_norm_ellipse(48))]
"Triangle":
return [_open_loop(_norm_ngon(3))]
"Pentagon":
return [_open_loop(_norm_ngon(5))]
"Hexagon":
return [_open_loop(_norm_ngon(6))]
"Star":
return [_norm_star()] # already closed (i=10 repeats i=0)
"Torus":
var outer := _open_loop(_norm_ellipse(48))
var inner: Array = []
for i in 48:
var a := TAU * i / 48.0
inner.append(Vector2(0.5, 0.5)
+ Vector2(cos(a), sin(a)) * 0.18)
return [outer, inner]
_:
# Rectangle - exactly 4 corners, no closing repeat
return [PackedVector2Array([
Vector2(0, 0), Vector2(1, 0), Vector2(1, 1), Vector2(0, 1)])]
return []
## Strip a generator's closing repeat (circle / n-gon end with their
## start point; the preview re-closes the loop itself).
func _open_loop(gen: PackedVector2Array) -> PackedVector2Array:
var out := PackedVector2Array(gen)
if out.size() > 1 and out[0].is_equal_approx(out[out.size() - 1]):
out.resize(out.size() - 1)
return out
func _norm_ellipse(n: int) -> PackedVector2Array:
var out := PackedVector2Array()
for i in n + 1:
var a := TAU * i / n
out.append(Vector2(0.5, 0.5) + Vector2(cos(a), sin(a)) * 0.5)
return out
func _norm_ngon(n: int) -> PackedVector2Array:
var out := PackedVector2Array()
for i in n + 1:
var a := -PI * 0.5 + TAU * i / n
out.append(Vector2(0.5, 0.5) + Vector2(cos(a), sin(a)) * 0.5)
return out
func _norm_star() -> PackedVector2Array:
var out := PackedVector2Array()
for i in 11:
var a := -PI * 0.5 + PI * i / 5.0
var k := 0.5 if i % 2 == 0 else 0.21
out.append(Vector2(0.5, 0.5) + Vector2(cos(a), sin(a)) * k)
return out
func _shape_rect() -> Rect2:
var r := Rect2(shape_pts[0], shape_pts[shape_pts.size() - 1] - shape_pts[0]).abs()
if shift_square:
var s := maxf(r.size.x, r.size.y)
r = Rect2(r.position, Vector2(s, s))
return r
## Convert a normalized polygon (0..1 within the drag rect, y down) into
## world-space points on this view's work plane, snapped to the grid.
func _plane_pts_from_rect(r: Rect2, gen: PackedVector2Array) -> PackedVector3Array:
var f := frame()
var d := work_depth()
var cpl := center + (r.get_center() - size * 0.5) / zoom
var c_w := plane_world(cpl.x, -cpl.y, d)
var half := r.size * 0.5 / zoom
var pts := PackedVector3Array()
for p in gen:
var off := Vector2((p.x - 0.5) * half.x * 2.0, (p.y - 0.5) * half.y * 2.0)
pts.append(_snap_planar(c_w + f[0] * off.x - f[1] * off.y))
return pts
func _finish_shape(mp: Vector2) -> void:
match doc.draw_kind:
"Freehand":
if shape_pts.size() < 3:
doc.warn("Drag to draw an outline: hold the button and sketch the shape, then release.")
return
var simplified := PdGeo.rdp(shape_pts, 5.0)
if simplified.size() >= 3 \
and simplified[0].distance_to(simplified[simplified.size() - 1]) < 16.0:
simplified[simplified.size() - 1] = simplified[0]
if simplified.size() < 3:
doc.warn("That doodle was too small or too straight to make a shape. Sketch a larger closed outline.")
return
var pts := PackedVector3Array()
for p in simplified:
var pl := center + (p - size * 0.5) / zoom
pts.append(_snap_planar(plane_world(pl.x, -pl.y, work_depth())))
doc.add_polygon(_oriented(pts), "Doodle")
"Torus":
_finish_torus(mp)
_:
if shape_pts.size() != 2:
doc.warn("Drag to size the shape: hold the button, move, then release.")
return
var r := _shape_rect()
if r.size.length() < 6.0:
doc.warn("That shape is too small. Drag further to size it.")
return
var gen: PackedVector2Array = _preview_loops(r)[0]
# circle / n-gon generators end with a closing
# repeat; the plain rect corners do not
if gen.size() > 1 and gen[0].is_equal_approx(gen[gen.size() - 1]):
gen.resize(gen.size() - 1)
doc.add_polygon(_oriented(_plane_pts_from_rect(r, gen)),
doc.draw_kind)
shape_pts = PackedVector2Array()
## Torus solid drawn by dragging the outer radius on the work plane.
func _finish_torus(_mp: Vector2) -> void:
if shape_pts.size() != 2:
return
var r := _shape_rect()
if r.size.length() < 12.0:
doc.warn("That torus is too small. Drag further to set its size.")
return
var f := frame()
var cpl := center + (r.get_center() - size * 0.5) / zoom
var c_w := _snap_planar(plane_world(cpl.x, -cpl.y, work_depth()))
var R := maxf(r.size.x, r.size.y) * 0.5 / zoom
if doc.snap_enabled:
R = snappedf(R, doc.grid_size)
if R < 0.05:
return
var rmin := maxf(R * 0.36, 0.03)
var data := PdGeo.make_torus(R, rmin, 16, 8)
var out_v := PackedVector3Array()
for p in data["verts"]:
# local torus (XZ ring, Y axis) onto this view's plane basis
out_v.append(_snap_planar(
c_w + f[0] * p.x + f[1] * p.z + f[2] * p.y))
doc.add_mesh_data({"verts": out_v, "faces": data["faces"]}, "Torus")
## Flip the loop so its Newell normal points toward this view's viewer.
## The user may draw the shape in either direction; the face must end up
## front-facing in the 3D view either way.
func _oriented(pts: PackedVector3Array) -> PackedVector3Array:
if PdGeo.face_normal(pts).dot(n_axis()) < 0.0:
pts.reverse()
return pts
## Paint one hit under the cursor, honoring the active paint tool. During a
## sweep, repeats in the same spot are skipped: face tools key on the face
## (or pixel cell), the Brush keys on the hit point quantized to half the
## brush radius so a drag paints a continuous stroke.
func _paint_gesture(mp: Vector2, erase: bool) -> void:
var hit := _pick_face(mp)
if hit.is_empty() and doc.paint_tool == "Brush":
hit = _pick_edge(mp)
paint_hover = hit if hit.get("kind", "") == "face" else {}
if hit.is_empty():
return
var key := _paint_key(hit)
if key != "" and key == _last_paint_key:
return
_last_paint_key = key
doc.paint_apply(hit, erase)
func _paint_key(hit: Dictionary) -> String:
var o := doc.obj(hit.get("obj", -1))
if o == null:
return ""
if doc.paint_tool == "Brush" and hit.get("kind", "") == "face":
var p: Vector3 = doc.brush_point(hit)
var step := maxf(doc.brush_size * 0.5, 0.05)
var q := Vector3i((p / step).floor())
return "b%d_%d_%d" % [q.x, q.y, q.z]
if doc.paint_tool == "Pixel" and hit.get("kind", "") == "face":
# key on the TEXEL BLOCK under the cursor so a drag paints
# a trail of blocks instead of re-stamping the same one
var fi: int = hit["idx"]
if fi < 0 or fi >= o.nfaces():
return ""
var p: Vector3 = hit.get("point",
PdGeo.face_center(o.face_pts_w(fi)))
var t := o.world_to_texel(fi, p)
var n := maxi(1, int(doc.pixel_px))
var tl := Vector2i(int(floorf(t.x - (n - 1) * 0.5)),
int(floorf(t.y - (n - 1) * 0.5)))
return "px%d_%d_%d_%d" % [hit["obj"], fi, tl.x, tl.y]
return "%s_%s" % [hit["obj"], hit["idx"]]
func paint_click(mp: Vector2, erase: bool) -> void:
_last_paint_key = ""
_paint_gesture(mp, erase)