@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)