1667 lines
76 KiB
GDScript
Executable File
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)
|