Files
ECAL-Gymnases-Workshop/addons/polydoodle/editor/pd_view3d.gd
T
2026-11-02 19:38:04 +01:00

2262 lines
105 KiB
GDScript
Executable File

@tool
class_name PdView3D
extends SubViewportContainer
## Perspective 3D view: LMB-drag on empty space ORBITS (click deselects),
## RMB-drag PANS (right-click cancels a doodle; erasing is the
## dedicated Eraser tool), MMB-drag
## orbits (Shift+MMB pans), Alt+LMB-drag orbits while drawing/painting,
## wheel zooms. Shaded mesh with x-ray wireframe overlay, vertex handles,
## and the 3-arrow translate gizmo.
const GIZMO_LEN_PX := 90.0
enum Op { NONE, ORBIT, PAN, MOVE, GIZMO, PAINT, SHAPE, MARQUEE }
var doc: PdDocument
var main: Control
var sub: SubViewport
var root: Node3D
var cam: Camera3D
var mesh_root: Node3D
var overlay_mi: MeshInstance3D
var overlay_mesh: ImmediateMesh
var wire_mesh: ArrayMesh
var wire_mi: MeshInstance3D
var _wire_cache := {} # object id -> {k, pts, cols}
var _wire_ids: Array = [] # objects drawn from the cache last frame
var _wire_dirty := false
var overlay_mat: StandardMaterial3D
var grid_mi: MeshInstance3D
var grid_mesh: ImmediateMesh
var grid_mat: StandardMaterial3D
var target := Vector3.ZERO
var yaw := -0.6
var pitch := 0.5
var dist := 6.0
var _grid_key := Vector3(-1, -1, -1) # last built grid (visible, size, dist)
var op := Op.NONE
var pan_last := Vector2.ZERO
var press_px := Vector2.ZERO
var orbit_btn := 0 # mouse button that started an orbit
var press_moved := false # LMB press turned into a drag?
var move_before := []
var move_orig := {}
var move_orig_pos := {}
var move_hit0 := Vector3.ZERO
var move_valid := false
var gizmo_axis := -1
var gizmo_t0 := 0.0
var gizmo_c0 := Vector3.ZERO # selection center FROZEN at gizmo press
var gizmo_scalar := 0.0
var gizmo_ref_len := 1.0 # arm length (world) 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
var _gizmo_label := "Move selection"
# rotate gizmo: rings, not arms - axis is a plain Vector3 (the
# ring's own normal) rather than the 0/1/2 index the move/scale code
# uses, since apply_rotate_gizmo takes a world-space axis directly.
var gizmo_rot_axis := Vector3.UP
var gizmo_rot_u := Vector3.RIGHT # two vectors spanning the ring's plane,
var gizmo_rot_v := Vector3.FORWARD # used to measure the drag angle
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 mouse_px := Vector2(-1, -1)
var mouse_in := false
var _last_paint_key := "" # dedupes paint sweeps (face id or pixel cell)
var press_picked := false # this press picked something (UV-edit click-select)
var _ctx_menu: PopupMenu # right-click mesh-ops menu (edit modes)
var expand_btn: Button # fullscreen toggle for this view
# Ctrl+LMB rectangle multi-select (3D modeler viewports)
var marquee_start := Vector2.ZERO
var marquee_now := Vector2.ZERO
# 3D doodling (Draw mode): shapes are sketched on the plane under the
# cursor (a face) or a horizontal plane through the selection.
var shape_plane_n := Vector3.UP
var shape_plane_p := Vector3.ZERO
var shape_u := Vector3.RIGHT
var shape_v := Vector3.UP
var shape_pts := PackedVector2Array() # screen-space samples, like 2D
var _last_sides := true
var _ink_mat: StandardMaterial3D
var _last_shading := 0
var _last_filter := 0
static var _font: Font
func _init() -> void:
stretch = true
size_flags_horizontal = Control.SIZE_EXPAND_FILL
size_flags_vertical = Control.SIZE_EXPAND_FILL
mouse_filter = Control.MOUSE_FILTER_STOP
focus_mode = Control.FOCUS_ALL
func _ready() -> void:
sub = SubViewport.new()
sub.own_world_3d = true
sub.msaa_3d = Viewport.MSAA_2X
sub.gui_disable_input = true
sub.transparent_bg = false
add_child(sub)
var world := sub.find_world_3d()
var env := Environment.new()
env.background_mode = Environment.BG_COLOR
env.background_color = doc.bg_color if doc else Color("23262e")
env.ambient_light_source = Environment.AMBIENT_SOURCE_COLOR
env.ambient_light_color = Color(0.82, 0.82, 0.88)
env.ambient_light_energy = 0.85
world.environment = env
root = Node3D.new()
sub.add_child(root)
var light := DirectionalLight3D.new()
light.rotation_degrees = Vector3(-52, 38, 0)
light.light_energy = 1.1
light.shadow_enabled = false
root.add_child(light)
var fill := DirectionalLight3D.new()
fill.rotation_degrees = Vector3(-24, -145, 0)
fill.light_energy = 0.35
root.add_child(fill)
cam = Camera3D.new()
cam.fov = 55.0
cam.near = 0.05
cam.far = 500.0
root.add_child(cam)
mesh_root = Node3D.new()
root.add_child(mesh_root)
grid_mesh = ImmediateMesh.new()
grid_mat = StandardMaterial3D.new()
grid_mat.shading_mode = BaseMaterial3D.SHADING_MODE_UNSHADED
grid_mat.vertex_color_use_as_albedo = true
grid_mi = MeshInstance3D.new()
grid_mi.mesh = grid_mesh
grid_mi.material_override = grid_mat
grid_mi.cast_shadow = GeometryInstance3D.SHADOW_CASTING_SETTING_OFF
root.add_child(grid_mi)
overlay_mesh = ImmediateMesh.new()
overlay_mat = StandardMaterial3D.new()
overlay_mat.shading_mode = BaseMaterial3D.SHADING_MODE_UNSHADED
overlay_mat.vertex_color_use_as_albedo = true
overlay_mat.no_depth_test = true
overlay_mat.transparency = BaseMaterial3D.TRANSPARENCY_ALPHA
overlay_mat.cull_mode = BaseMaterial3D.CULL_DISABLED
overlay_mat.render_priority = 10
overlay_mi = MeshInstance3D.new()
overlay_mi.mesh = overlay_mesh
overlay_mi.material_override = overlay_mat
overlay_mi.cast_shadow = GeometryInstance3D.SHADOW_CASTING_SETTING_OFF
root.add_child(overlay_mi)
wire_mesh = ArrayMesh.new()
var wire_mat := overlay_mat.duplicate() as StandardMaterial3D
wire_mat.render_priority = 9
wire_mi = MeshInstance3D.new()
wire_mi.mesh = wire_mesh
wire_mi.material_override = wire_mat
wire_mi.cast_shadow = GeometryInstance3D.SHADOW_CASTING_SETTING_OFF
root.add_child(wire_mi)
doc.doc_changed.connect(_flag_meshes_dirty)
doc.settings_changed.connect(_on_settings)
_last_sides = doc.both_sides if doc else true
_update_cam()
_rebuild_grid()
## See pd_view2d.gd's _style_corner_btn - same flat, transparent-at-rest
## look for this view's own corner button, for consistency.
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) -> void:
doc = d
main = m
# expand/retract toggle in the top-right corner: pressed = this
# viewport alone fills the whole view area
expand_btn = Button.new()
expand_btn.icon = PdIcons.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 = -28.0
expand_btn.offset_top = 5.0
expand_btn.offset_right = -6.0
expand_btn.offset_bottom = 27.0
expand_btn.pressed.connect(func(): main._toggle_expand(self))
if main.has_method("_sync_expand_btns"):
main._sync_expand_btns.call_deferred()
# in-viewport hint chip - child Control, drawn above the
# SubViewport, ignores the mouse so it never blocks the camera
_hint_panel = PanelContainer.new()
var hsb := StyleBoxFlat.new()
hsb.bg_color = Color(0, 0, 0, 0.45)
hsb.set_corner_radius_all(4)
hsb.content_margin_left = 7.0
hsb.content_margin_right = 7.0
hsb.content_margin_top = 3.0
hsb.content_margin_bottom = 3.0
_hint_panel.add_theme_stylebox_override("panel", hsb)
_hint_panel.mouse_filter = Control.MOUSE_FILTER_IGNORE
_hint_label = Label.new()
_hint_label.add_theme_font_size_override("font_size", 11)
_hint_label.add_theme_color_override("font_color", Color(1, 1, 1, 0.72))
_hint_label.mouse_filter = Control.MOUSE_FILTER_IGNORE
_hint_panel.add_child(_hint_label)
add_child(_hint_panel)
_hint_panel.visible = false
func _on_settings() -> void:
var env := sub.find_world_3d().environment
if env:
env.background_color = doc.bg_color
if _last_sides != doc.both_sides or _last_shading != doc.view_shading \
or _last_filter != doc.tex_filter:
_last_sides = doc.both_sides
_last_shading = doc.view_shading
_last_filter = doc.tex_filter
_rebuild_meshes()
_rebuild_grid()
func _notification(what: int) -> void:
if what == NOTIFICATION_RESIZED:
_place_hint()
elif what == NOTIFICATION_MOUSE_ENTER:
mouse_in = true
# the 3D view has no per-control cursor override, so a
# stale global drag/split shape left by the panel splitter
# would keep showing here - reset it on entry
Input.set_default_cursor_shape(Input.CURSOR_ARROW)
elif what == NOTIFICATION_MOUSE_EXIT:
mouse_in = false
paint_hover = {}
# ------------------------------------------------------------- camera ---
func _wpp() -> float:
# world units per pixel at the target distance
var h := maxf(1.0, sub.size.y)
return 2.0 * dist * tan(deg_to_rad(cam.fov) * 0.5) / h
func _cam_right() -> Vector3: return cam.global_transform.basis.x
func _cam_up() -> Vector3: return cam.global_transform.basis.y
func _cam_fwd() -> Vector3: return -cam.global_transform.basis.z
func _update_cam() -> void:
var cp := cos(pitch)
var dir := Vector3(sin(yaw) * cp, sin(pitch), cos(yaw) * cp)
cam.position = target + dir * dist
cam.look_at(target, Vector3.UP)
func _project(v: Vector3) -> Vector2:
return cam.unproject_position(v)
func frame_selection() -> void:
var c := doc.sel_center_w()
if c == Vector3.INF:
target = Vector3.ZERO
dist = 6.0
else:
target = c
var ab := AABB(c, Vector3.ZERO)
var any := false
for oi in (doc.sel_objs if doc.mode == PdDocument.Mode.OBJECT else [doc.active_obj]):
var o := doc.obj(oi)
if o != null and o.is_visible:
ab = ab.merge(o.aabb_w())
any = true
dist = clampf(ab.get_longest_axis_size() * 1.8 + 1.0, 1.5, 60.0) if any else 6.0
_update_cam()
# ------------------------------------------------------- mesh rebuild ---
## Mesh instances are REUSED: a rebuild updates meshes on the existing
## children and only grows/shrinks the pool. Recreating nodes per change
## would spam the frame with dying MeshInstances on every paint stamp and
## drag step.
## SHADED mode renders ink edges (edge_color) as a DEPTH-TESTED lines
## surface baked into the object mesh: far-side edges hide behind the
## faces, matching a real shaded render. The no-depth overlay drew them
## straight through the geometry ("wireframe off but edge lines are still
## visible for some edges from behind faces").
func _ink_material() -> StandardMaterial3D:
if _ink_mat == null:
_ink_mat = StandardMaterial3D.new()
_ink_mat.shading_mode = BaseMaterial3D.SHADING_MODE_UNSHADED
_ink_mat.vertex_color_use_as_albedo = true
return _ink_mat
func _append_ink_surface(m: ArrayMesh, o: PdPolyObj) -> void:
var pts := PackedVector3Array()
var cols := PackedColorArray()
for e in o.edges():
var ec := o.edge_color(e)
if ec.a <= 0.01:
continue
var ca := Color(ec.r, ec.g, ec.b, 0.95)
pts.append(o.wvert(e.x))
cols.append(ca)
pts.append(o.wvert(e.y))
cols.append(ca)
if pts.size() < 2:
return
var arrays := []
arrays.resize(Mesh.ARRAY_MAX)
arrays[Mesh.ARRAY_VERTEX] = pts
arrays[Mesh.ARRAY_COLOR] = cols
m.add_surface_from_arrays(Mesh.PRIMITIVE_LINES, arrays)
m.surface_set_material(m.get_surface_count() - 1, _ink_material())
func _rebuild_meshes() -> void:
var kids := []
for c in mesh_root.get_children():
if not c.is_queued_for_deletion():
kids.append(c)
var ki := 0
if doc.view_shading != 2:
for oi in doc.objects.size():
var o := doc.obj(oi)
if o == null or not o.is_visible:
continue
var mi: MeshInstance3D
if ki < kids.size():
mi = kids[ki]
else:
mi = MeshInstance3D.new()
mesh_root.add_child(mi)
ki += 1
# Pool reuse: an object whose render state is
# unchanged (geometry/UV epoch, shading flags, the
# very mesh instance AND the very texture object it
# rendered through) keeps its built mesh - painting
# updates the shared ImageTexture in place, and the
# texture-id meta catches the placeholder -> real
# canvas swap on first paint.
var tex_obj := o.get_texture(doc.show_checker)
if mi.get_meta("oid", 0) == o.get_instance_id() \
and mi.get_meta("ve", -1) == o.visual_epoch \
and mi.get_meta("sh", -1) == doc.view_shading \
and mi.get_meta("bs", true) == doc.both_sides \
and mi.get_meta("tf", -1) == doc.tex_filter \
and mi.get_meta("hc", true) == doc.show_checker \
and mi.get_meta("sm", false) == o.shade_smooth \
and mi.get_meta("tx", 0) == tex_obj.get_instance_id():
continue
var m := PdIo.build_mesh(o, PdPolyObj.BASE,
doc.both_sides, true, doc.tex_filter == 1,
not doc.show_checker)
if m == null:
mi.mesh = null
mi.set_meta("oid", 0)
continue
mi.mesh = m
mi.name = "obj%d" % oi
if doc.view_shading == 1:
_append_ink_surface(m, o)
mi.set_meta("oid", o.get_instance_id())
mi.set_meta("ve", o.visual_epoch)
mi.set_meta("sh", doc.view_shading)
mi.set_meta("bs", doc.both_sides)
mi.set_meta("tf", doc.tex_filter)
mi.set_meta("tx", o.get_texture(
doc.show_checker).get_instance_id())
mi.set_meta("hc", doc.show_checker)
mi.set_meta("sm", o.shade_smooth)
while ki < kids.size():
kids[ki].queue_free()
ki += 1
_rebuild_grid()
func _rebuild_grid() -> void:
# the grid only depends on visibility, cell size and the camera
# distance (which drives the LOD step) - skip rebuilds while all
# three are unchanged
var key := Vector3(1.0 if doc.grid_visible else 0.0, doc.grid_size,
dist)
if key == _grid_key:
return
_grid_key = key
grid_mesh.clear_surfaces()
if not doc.grid_visible:
return
var step := doc.grid_size
while step < dist * 0.015:
step *= 2.0
var n := int(ceil(dist * 1.6 / step))
grid_mesh.surface_begin(Mesh.PRIMITIVE_LINES)
# DARK grid ink: dark lines read like Blender's grid on the
# default background and also survive a light background; faint
# white lines only work on dark scenes. The colored X/Z axis
# lines below are untouched.
var minor := Color(0, 0, 0, 0.20)
var major := Color(0, 0, 0, 0.38)
for i in range(-n, n + 1):
var a := i * step
var c := major if i % 4 == 0 else minor
grid_mesh.surface_set_color(c)
grid_mesh.surface_add_vertex(Vector3(a, -0.002, -n * step))
grid_mesh.surface_set_color(c)
grid_mesh.surface_add_vertex(Vector3(a, -0.002, n * step))
grid_mesh.surface_set_color(c)
grid_mesh.surface_add_vertex(Vector3(-n * step, -0.002, a))
grid_mesh.surface_set_color(c)
grid_mesh.surface_add_vertex(Vector3(n * step, -0.002, a))
# axes
grid_mesh.surface_set_color(Color(1.0, 0.37, 0.37, 0.55))
grid_mesh.surface_add_vertex(Vector3(-n * step, -0.002, 0))
grid_mesh.surface_set_color(Color(1.0, 0.37, 0.37, 0.55))
grid_mesh.surface_add_vertex(Vector3(n * step, -0.002, 0))
grid_mesh.surface_set_color(Color(0.37, 0.6, 1.0, 0.55))
grid_mesh.surface_add_vertex(Vector3(0, -0.002, -n * step))
grid_mesh.surface_set_color(Color(0.37, 0.6, 1.0, 0.55))
grid_mesh.surface_add_vertex(Vector3(0, -0.002, n * step))
grid_mesh.surface_end()
# ------------------------------------------------------ overlay draw ---
## Whether the texture workspace draws the selected faces' outline on the
## 3D model. The Brush hides it (a wireframe over the model while brushing
## hides the texels being painted); face lock and every other paint tool
## (Fill, Eraser, Picker, Replace, Pixel) show it as the selection marker.
static func tex_outline_visible(d: PdDocument) -> bool:
return d != null and (d.face_lock or d.paint_tool != "Brush")
# The overlay is BUFFERED: every draw helper appends to per-primitive
# buffers which are flushed into AT MOST ONE LINES + ONE TRIANGLES mesh
# surface per frame. ImmediateMesh adds a new mesh SURFACE for every
# begin/end pair - per-segment surfaces would pile up by the hundreds
# each frame and trip the renderer's MAX_MESH_SURFACES guard on busy
# scenes. Buffering also cuts draw-data overhead dramatically.
var _ov_lines: Array = [] # [a: Vector3, b: Vector3, col]
var _ov_quads: Array = [] # [a, b, px, col] screen-constant width
var _ov_tris: Array = [] # [v: Vector3, col] flat triangle soup
func _ov_reset() -> void:
_ov_lines = []
_ov_quads = []
_ov_tris = []
## Plain hairline between two world points.
func _line3(a: Vector3, b: Vector3, col: Color) -> void:
_ov_lines.append([a, b, col])
## Screen-constant-width line (a camera-facing quad).
func _quad_line(a: Vector3, b: Vector3, px: float, col: Color) -> void:
_ov_quads.append([a, b, px, col])
## Camera-facing dot (8-segment fan).
func _dot(p: Vector3, px: float, col: Color) -> void:
var r := px * _wpp() * 0.5
var u := _cam_up() * r
var rt := _cam_right() * r
for i in 8:
var a0 := TAU * i / 8.0
var a1 := TAU * (i + 1) / 8.0
_ov_tris.append([p, col])
_ov_tris.append([p + rt * cos(a0) + u * sin(a0), col])
_ov_tris.append([p + rt * cos(a1) + u * sin(a1), col])
func _ov_flush() -> void:
if not _ov_lines.is_empty():
overlay_mesh.surface_begin(Mesh.PRIMITIVE_LINES)
for l in _ov_lines:
overlay_mesh.surface_set_color(l[2])
overlay_mesh.surface_add_vertex(l[0])
overlay_mesh.surface_set_color(l[2])
overlay_mesh.surface_add_vertex(l[1])
overlay_mesh.surface_end()
_ov_lines = []
if not _ov_quads.is_empty() or not _ov_tris.is_empty():
overlay_mesh.surface_begin(Mesh.PRIMITIVE_TRIANGLES)
for q in _ov_quads:
var a: Vector3 = q[0]
var b: Vector3 = q[1]
var px: float = q[2]
var col: Color = q[3]
var off1 := _cam_right() * px * _wpp() * 0.5
var off2 := _cam_up() * px * _wpp() * 0.5
for v in [a - off1 - off2, b - off1 - off2,
b + off1 + off2, a - off1 - off2,
b + off1 + off2, a + off1 + off2]:
overlay_mesh.surface_set_color(col)
overlay_mesh.surface_add_vertex(v)
for t in _ov_tris:
overlay_mesh.surface_set_color(t[1])
overlay_mesh.surface_add_vertex(t[0])
overlay_mesh.surface_end()
_ov_quads = []
_ov_tris = []
func _process(_delta: float) -> void:
if not is_visible_in_tree():
return
_update_cam()
_rebuild_overlay()
# in-viewport hint chip: update when the contextual text
# changes (mode / selection / substate driven)
var h := PdMain.context_hint(doc, "3d") if doc != null else ""
if h != _last_hint:
_last_hint = h
_sync_hint()
## doc_changed marks the meshes stale and flushes ONCE per frame (at the
## frame's deferred point). A direct rebuild per signal made every motion
## event of a drag re-triangulate and re-upload EVERY object.
var _meshes_dirty := false
func _flag_meshes_dirty() -> void:
_meshes_dirty = true
_flush_meshes.call_deferred()
func _flush_meshes() -> void:
if not _meshes_dirty or not is_inside_tree():
return
_meshes_dirty = false
_rebuild_meshes()
## Small muted hint chip at the bottom-left of the 3D viewport:
## e.g. "Right-click: options (EXTRUDE faces, fill, delete and more)" once
## a face is selected - the viewport teaches itself, no docs required. It
## must be a Control CHILD (not the container's own _draw): a
## SubViewportContainer's own drawing renders UNDER its SubViewport child.
var _hint_panel: PanelContainer
var _hint_label: Label
var _last_hint := ""
func _sync_hint() -> void:
if _hint_label == null:
return
_hint_label.text = _last_hint
_hint_panel.visible = _last_hint != ""
_place_hint()
## Pin the chip to the bottom-left at its natural size. Runs on every text
## change AND every resize, so a view that goes full screen (or is resized
## by the splitter) keeps the chip at its bottom edge.
func _place_hint() -> void:
if _hint_panel == null:
return
_hint_panel.reset_size()
_hint_panel.position = Vector2(4.0, size.y - _hint_panel.size.y - 4.0)
func _gizmo_axes() -> Array:
# [{axis, dir(Vector3), from(Vector2), to(Vector2), col}]
var c := doc.gizmo_anchor_w()
if c == Vector3.INF:
return []
var out := []
for i in 3:
var ax := Vector3.RIGHT
match i:
1: ax = Vector3.UP
2: ax = Vector3(0, 0, 1)
var tip := c + ax * GIZMO_LEN_PX * _wpp()
out.append({
"axis": i, "dir": ax, "tip_w": tip,
"from": _project(c), "to": _project(tip),
"col": PdDocument.AXIS_COLORS[i],
})
return out
const ROT_RING_SEGS := 48
## Two unit vectors spanning the plane perpendicular to `n` - the fixed
## reference frame a rotate drag measures its angle against (drawing and
## hit-testing use the same pair, so the ring you see is the ring you hit).
func _ring_basis(n: Vector3) -> Array:
var u := n.cross(Vector3.UP)
if u.length() < 0.1:
u = n.cross(Vector3.RIGHT)
u = u.normalized()
var v := n.cross(u).normalized()
return [u, v]
## The three rotate rings (X/Y/Z), sampled as polylines in both world and
## projected screen space so _rebuild_overlay and _gizmo_hit share one
## source of truth for where each ring actually is.
func _gizmo_rings() -> Array:
var c := doc.gizmo_anchor_w()
if c == Vector3.INF:
return []
var r := GIZMO_LEN_PX * _wpp()
var out := []
for i in 3:
var ax := Vector3.RIGHT
match i:
1: ax = Vector3.UP
2: ax = Vector3(0, 0, 1)
var uv := _ring_basis(ax)
var pts_w := PackedVector3Array()
var pts_s := PackedVector2Array()
for s in ROT_RING_SEGS + 1:
var a := TAU * float(s) / ROT_RING_SEGS
var w: Vector3 = c + ((uv[0] as Vector3) * cos(a) + (uv[1] as Vector3) * sin(a)) * r
pts_w.append(w)
pts_s.append(_project(w))
out.append({"axis": i, "dir": ax, "u": uv[0], "v": uv[1],
"pts_w": pts_w, "pts_s": pts_s, "col": PdDocument.AXIS_COLORS[i]})
return out
var _wire_now: Array = []
func _wire_begin() -> void:
_wire_now = []
## Wireframe lines of one object, rebuilt only when its geometry, transform
## or highlight state changed. The key hashes the vertex and face arrays
## natively, so no edit path can leave a stale wire behind.
func _wire_use(o: PdPolyObj, is_active: bool) -> void:
var id := o.get_instance_id()
var key := [hash(o.verts), hash(o.faces), o.position, o.scale3, is_active]
_wire_now.append(id)
var hit: Variant = _wire_cache.get(id)
if hit != null and (hit as Dictionary)["k"] == key:
return
var es := o.edges()
var pts := PackedVector3Array()
pts.resize(es.size() * 2)
var wv := PackedVector3Array()
wv.resize(o.nverts())
for i in wv.size():
wv[i] = o.wvert(i)
var n := 0
for e in es:
pts[n] = wv[e.x]
pts[n + 1] = wv[e.y]
n += 2
var cols := PackedColorArray()
cols.resize(pts.size())
cols.fill(Color(1, 1, 1, 0.34 if is_active else 0.15))
_wire_cache[id] = {"k": key, "pts": pts, "cols": cols}
_wire_dirty = true
func _wire_end() -> void:
if _wire_now != _wire_ids:
_wire_dirty = true
_wire_ids = _wire_now
for id in _wire_cache.keys():
if not _wire_ids.has(id):
_wire_cache.erase(id)
if not _wire_dirty:
return
_wire_dirty = false
wire_mesh.clear_surfaces()
var pts := PackedVector3Array()
var cols := PackedColorArray()
for id in _wire_ids:
var ent: Dictionary = _wire_cache[id]
pts.append_array(ent["pts"])
cols.append_array(ent["cols"])
if pts.is_empty():
return
var arr := []
arr.resize(Mesh.ARRAY_MAX)
arr[Mesh.ARRAY_VERTEX] = pts
arr[Mesh.ARRAY_COLOR] = cols
wire_mesh.add_surface_from_arrays(Mesh.PRIMITIVE_LINES, arr)
func _rebuild_overlay() -> void:
if overlay_mesh == null:
return
overlay_mesh.clear_surfaces()
_ov_reset()
_wire_begin()
var accent := PdDocument.ACCENT
for oi in doc.objects.size():
var o := doc.obj(oi)
if o == null or not o.is_visible:
continue
var is_active := oi == doc.active_obj
var wire := Color(1, 1, 1, 0.34 if is_active else 0.15)
if o.edge_colors.is_empty():
# plain wireframe: cached per object and uploaded natively
if doc.view_shading != 1:
_wire_use(o, is_active)
else:
# shaded-only mode hides the x-ray edge overlay
if doc.view_shading != 1:
for e in o.edges():
if o.edge_color(e).a > 0.01:
continue
_line3(o.wvert(e.x), o.wvert(e.y), wire)
for e in o.edges():
var ec := o.edge_color(e)
if ec.a > 0.01:
if doc.view_shading == 1:
continue # depth-tested ink surface in the mesh
_quad_line(o.wvert(e.x), o.wvert(e.y), 1.6, Color(ec.r, ec.g, ec.b, 0.95))
# Selected-face outline. FACE mode shows the translucent
# accent fill + outline. TEXTURE mode shows ONLY the outline
# (edge highlight), and hides even that while the BRUSH is
# painting (a wireframe over the model while brushing hides
# the very texels the user is judging) - face lock brings it
# back, because the outline then marks the locked face, and
# every other tool (Fill, Eraser, Picker, Replace, Pixel)
# keeps it as the selection indicator.
if is_active and (doc.mode == PdDocument.Mode.FACE \
or (doc.mode == PdDocument.Mode.TEXTURE \
and tex_outline_visible(doc))):
for fi in doc.sel_faces:
if fi >= o.nfaces():
continue
var tr := o.face_triangulation(fi)
var pts: PackedVector3Array = tr["verts"]
var tris: PackedInt32Array = tr["tris"]
if pts.size() < 3 or tris.size() < 3:
continue
if doc.mode == PdDocument.Mode.FACE:
var fill := Color(accent.r,
accent.g, accent.b, 0.28)
for t in range(0, tris.size() - 2, 3):
for k in 3:
_ov_tris.append([
pts[tris[t + k]],
fill])
var n := o.face_loop(fi).size()
var loop := o.face_pts_w(fi)
for i in n:
_quad_line(loop[i], loop[(i + 1) % n],
2.0, accent)
# selected edges
if is_active and doc.mode == PdDocument.Mode.EDGE:
for e in doc.sel_edges:
_quad_line(o.wvert(e.x), o.wvert(e.y), 2.6, accent)
# object selection outline
if doc.mode == PdDocument.Mode.OBJECT and doc.sel_objs.has(oi):
var ab := o.aabb_w()
var p := ab.position
var s := ab.size
var c8 := [
p, p + Vector3(s.x, 0, 0), p + Vector3(s.x, 0, s.z), p + Vector3(0, 0, s.z),
p + Vector3(0, s.y, 0), p + Vector3(s.x, s.y, 0),
p + Vector3(s.x, s.y, s.z), p + Vector3(0, s.y, s.z)]
var lines := [[0,1],[1,2],[2,3],[3,0],[4,5],[5,6],[6,7],[7,4],[0,4],[1,5],[2,6],[3,7]]
for l in lines:
_quad_line(c8[l[0]], c8[l[1]], 1.6, accent)
# vertex handles
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 w := o.wvert(vi)
if doc.mode == PdDocument.Mode.VERTEX and doc.sel_verts.has(vi):
_dot(w, 7.0, Color(0, 0, 0, 0.85))
_dot(w, 5.0, PdDocument.SEL_VERT)
elif doc.mode == PdDocument.Mode.VERTEX:
_dot(w, 3.2, Color(1, 1, 1, 0.55))
if hover.get("kind") == "vert" and hover.get("obj") == oi \
and hover.get("idx") == vi:
_dot(w, 6.0, Color(1, 1, 1, 0.95))
elif doc.mode == PdDocument.Mode.EDGE and _edge_touches(vi):
_dot(w, 4.0, accent)
elif doc.mode == PdDocument.Mode.FACE and _face_touches(o, vi):
_dot(w, 4.0, PdDocument.SEL_VERT)
_wire_end()
# gizmo: only on a real, visible selection (see gizmo_anchor_w)
var gizmo_visible := doc.gizmo_on \
and doc.mode != PdDocument.Mode.DRAW \
and doc.mode != PdDocument.Mode.TEXTURE \
and doc.gizmo_anchor_w() != Vector3.INF
if gizmo_visible:
var c := doc.gizmo_anchor_w()
if c != Vector3.INF:
var scale_kind := doc.gizmo_kind == 1
var rotate_kind := doc.gizmo_kind == 2
if rotate_kind:
# rotate: three rings, no center handle (there is
# no uniform/free rotation - each ring is a single
# clean axis, same as Blender/Godot's own gizmo)
_dot(c, 4.0, Color(1, 1, 1, 0.55))
for rg in _gizmo_rings():
var hov: bool = (op == Op.GIZMO and gizmo_axis == rg["axis"]) \
or (op == Op.NONE and _gizmo_hit(mouse_px) == rg["axis"])
var col: Color = rg["col"]
var pts: PackedVector3Array = rg["pts_w"]
for s in pts.size() - 1:
_quad_line(pts[s], pts[s + 1], 4.0 if hov else 2.2, col)
else:
# center chip: MOVE shows a ring (direct element
# drag); SCALE shows a cube = uniform-scale handle
if scale_kind:
_cube(c, _wpp() * 5.0, Color(1, 1, 1, 0.85))
else:
_dot(c, 8.0, Color(0, 0, 0, 0.6))
_dot(c, 5.5, Color(1, 1, 1, 0.35))
for a in _gizmo_axes():
var hov: bool = (op == Op.GIZMO and gizmo_axis == a["axis"]) \
or (op == Op.NONE and _gizmo_hit(mouse_px) == a["axis"])
var col: Color = a["col"]
_quad_line(c, a["tip_w"], 4.0 if hov else 2.6, col)
var tip: Vector3 = a["tip_w"]
if scale_kind:
# axis handle: a solid CUBE tip (scale affordance)
_cube(tip, _wpp() * (8.0 if hov else 5.5), col)
else:
# cone head (move affordance)
var dn: Vector3 = (tip - c).normalized()
var perp := dn.cross(_cam_up()).normalized()
if perp.length() < 0.1:
perp = dn.cross(Vector3.UP).normalized()
var hr := _wpp() * 7.0
var hl := _wpp() * 15.0
var base := tip - dn * hl
for i in 7:
var a0 := PI * i / 3.0
var a1 := PI * (i + 1) / 3.0
var p1 := base + (perp * cos(a0) + _cam_up() * sin(a0)) * hr
var p2 := base + (perp * cos(a1) + _cam_up() * sin(a1)) * hr
_ov_tris.append([tip, col])
_ov_tris.append([p1, col])
_ov_tris.append([p2, col])
# Ctrl+drag marquee rectangle: a world quad at a fixed distance in
# front of the camera (the overlay material ignores depth)
if op == Op.MARQUEE:
_draw_marquee()
# brush / eraser ring cursor: shows the stamp footprint on the mesh
# surface (paint submode only - UV editing has no brush)
if doc.mode == PdDocument.Mode.TEXTURE and not doc.tex_edit \
and (doc.paint_tool == "Brush" \
or doc.paint_tool == "Eraser") \
and paint_hover.get("kind", "") == "face":
var bcol := Color(doc.paint_color.lightened(0.25), 0.95)
_ring(paint_hover["point"], paint_hover.get("normal", Vector3.UP),
doc.brush_size, 2.2, bcol)
_dot(paint_hover["point"], 2.5, Color(1, 1, 1, 0.85))
if doc.paint_tool == "Eraser":
_ring(paint_hover["point"],
paint_hover.get("normal", Vector3.UP),
doc.brush_size * 0.8, 1.2, Color(1, 1, 1, 0.5))
# pixel-art cursor: shows the exact world cell that will be painted
if doc.mode == PdDocument.Mode.TEXTURE and not doc.tex_edit \
and doc.paint_tool == "Pixel" \
and paint_hover.get("kind", "") == "face":
_pixel_cell_cursor(paint_hover["point"],
paint_hover.get("normal", Vector3.UP))
# picker / replace crosshair cursor
if doc.mode == PdDocument.Mode.TEXTURE and not doc.tex_edit \
and (doc.paint_tool == "Picker" \
or doc.paint_tool == "Replace") \
and paint_hover.get("kind", "") == "face":
var pcol := Color(doc.paint_color.lightened(0.25), 0.95)
_ring(paint_hover["point"],
paint_hover.get("normal", Vector3.UP),
maxf(0.06, doc.brush_size * 0.25), 1.6, pcol)
_dot(paint_hover["point"], 2.5, Color(1, 1, 1, 0.9))
if doc.paint_tool == "Replace":
_ring(paint_hover["point"],
paint_hover.get("normal", Vector3.UP),
maxf(0.09, doc.brush_size * 0.4), 1.0,
Color(1, 1, 1, 0.5))
# live doodle preview while dragging in Draw mode
if op == Op.SHAPE and not shape_pts.is_empty():
_draw_shape_preview_3d()
_ov_flush()
## The live Ctrl+drag selection rectangle, projected onto a camera-facing
## plane at half the orbit distance.
func _draw_marquee() -> void:
var r := Rect2(marquee_start, marquee_now - marquee_start).abs()
if r.size.length() < 2.0:
return
var d := maxf(0.5, dist * 0.5)
var c := [
r.position,
Vector2(r.end.x, r.position.y),
r.end,
Vector2(r.position.x, r.end.y)]
var w := PackedVector3Array()
for sp in c:
w.append(_ray(sp)[0] + _ray(sp)[1] * d)
var col := Color(PdDocument.ACCENT.r, PdDocument.ACCENT.g,
PdDocument.ACCENT.b, 0.16)
for idx in [[0, 1, 2], [0, 2, 3]]:
for k in 3:
_ov_tris.append([w[idx[k]], col])
var line := Color(PdDocument.ACCENT.r, PdDocument.ACCENT.g,
PdDocument.ACCENT.b, 0.85)
for i in 4:
_line3(w[i], w[(i + 1) % 4], line)
## The world-space texel block under the cursor, drawn as a quad on the
## face surface - what you see is exactly what the Pixel tool paints.
func _pixel_cell_cursor(point: Vector3, normal: Vector3) -> void:
var hit := paint_hover
if hit.get("kind", "") != "face":
return
var o := doc.obj(hit.get("obj", -1))
if o == null:
return
var fi: int = hit["idx"]
if fi < 0 or fi >= o.nfaces():
return
var n := maxi(1, int(doc.pixel_px))
var t := o.world_to_texel(fi, point)
var tl := Vector2(int(floorf(t.x - (n - 1) * 0.5)),
int(floorf(t.y - (n - 1) * 0.5)))
var nrm := normal.normalized() if normal.length() > 0.01 else Vector3.UP
var lift := nrm * 0.012
var col := Color(doc.paint_color.lightened(0.25), 0.95)
var corners := [
o.texel_to_world(fi, tl.x, tl.y),
o.texel_to_world(fi, tl.x + n, tl.y),
o.texel_to_world(fi, tl.x + n, tl.y + n),
o.texel_to_world(fi, tl.x, tl.y + n)]
for i in 4:
_quad_line(corners[i] + lift, corners[(i + 1) % 4] + lift, 1.8, col)
## A flat ring (annulus) lying on the surface around `center`, oriented to
## `normal` - the visible footprint of the Brush tool.
func _ring(center: Vector3, normal: Vector3, radius: float, px: float, col: Color) -> void:
var n := normal.normalized() if normal.length() > 0.01 else Vector3.UP
var t := Vector3.UP if absf(n.dot(Vector3.UP)) < 0.9 else Vector3.RIGHT
var u := n.cross(t).normalized()
var v := n.cross(u).normalized()
var c := center + n * 0.01
var w := maxf(radius * 0.03, _wpp() * px * 0.5)
var seg := 44
overlay_mesh.surface_begin(Mesh.PRIMITIVE_TRIANGLES)
for i in seg:
var a0 := TAU * i / seg
var a1 := TAU * (i + 1) / seg
var i0 := c + (u * cos(a0) + v * sin(a0)) * (radius - w)
var i1 := c + (u * cos(a1) + v * sin(a1)) * (radius - w)
var o0 := c + (u * cos(a0) + v * sin(a0)) * (radius + w)
var o1 := c + (u * cos(a1) + v * sin(a1)) * (radius + w)
for vtx in [i0, o0, o1, i0, o1, i1]:
overlay_mesh.surface_set_color(col)
overlay_mesh.surface_add_vertex(vtx)
overlay_mesh.surface_end()
func _edge_touches(vi: int) -> bool:
for e in doc.sel_edges:
if e.x == vi or e.y == vi:
return true
return false
func _face_touches(o: PdPolyObj, vi: int) -> bool:
for fi in doc.sel_faces:
if o.face_loop(fi).has(vi):
return true
return false
# ------------------------------------------------------- scale gizmo ---
## Draw a small 3D cube (12 edges) centered at `c` with half-size `h`.
func _cube(c: Vector3, h: float, col: Color) -> void:
var p := []
for i in 8:
var v := c
v.x += h if (i & 1) != 0 else -h
v.y += h if (i & 2) != 0 else -h
v.z += h if (i & 4) != 0 else -h
p.append(v)
var lines := [[0, 1], [2, 3], [4, 5], [6, 7], [0, 2], [1, 3],
[4, 6], [5, 7], [0, 4], [1, 5], [2, 6], [3, 7]]
for l in lines:
_quad_line(p[l[0]], p[l[1]], 1.8, col)
# ------------------------------------------------------------ picking ---
func _ray(mp: Vector2) -> Array:
return [cam.project_ray_origin(mp), cam.project_ray_normal(mp)]
func _pick_vert(mp: Vector2) -> Dictionary:
var best := {}
var best_d := 10.0
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)
if cam.is_position_behind(w):
continue
var sp := _project(w)
if sp.x < -20 or sp.y < -20 or sp.x > sub.size.x + 20 or sp.y > sub.size.y + 20:
continue
var d := mp.distance_to(sp)
if d < best_d:
best_d = d
best = {"obj": oi, "idx": vi, "kind": "vert"}
return best
func _pick_edge(mp: Vector2) -> Dictionary:
var best := {}
var best_d := 7.0
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)
if cam.is_position_behind(a) and cam.is_position_behind(b):
continue
var d := PdGeo.dist_to_seg(mp, _project(a), _project(b))
if d < best_d:
best_d = d
best = {"obj": oi, "idx": e, "kind": "edge"}
return best
func _pick_face(mp: Vector2) -> Dictionary:
var r := _ray(mp)
var best := {}
var best_t := INF
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():
# cached robust triangulation: matches what renders
# in both viewports, self-intersecting loops included
var tr := o.face_triangulation(fi)
var pts: PackedVector3Array = tr["verts"]
var tris: PackedInt32Array = tr["tris"]
if pts.size() < 3 or tris.size() < 3:
continue
for t in range(0, tris.size() - 2, 3):
var tt := PdGeo.ray_tri(r[0], r[1], pts[tris[t]], pts[tris[t + 1]], pts[tris[t + 2]])
if tt > 0.0 and tt < best_t:
best_t = tt
best = {"obj": oi, "idx": fi, "kind": "face", "dist": tt,
"point": r[0] + r[1] * tt,
"normal": o.face_normal_w(fi)}
return best
## A click that selects nothing because the shape under the cursor is
## locked would otherwise look like a dead click: say why.
func _explain_locked_click(mp: Vector2) -> void:
if not doc.has_visible_locked() or _pick_object(mp) >= 0:
return
var r := _ray(mp)
var best_t := INF
var best_name := ""
for oi in doc.objects.size():
var o := doc.obj(oi)
if o == null or not o.is_visible or not o.is_locked:
continue
for fi in o.nfaces():
var tr := o.face_triangulation(fi)
var pts: PackedVector3Array = tr["verts"]
var tris: PackedInt32Array = tr["tris"]
if pts.size() < 3 or tris.size() < 3:
continue
for t in range(0, tris.size() - 2, 3):
var tt := PdGeo.ray_tri(r[0], r[1], pts[tris[t]], pts[tris[t + 1]], pts[tris[t + 2]])
if tt > 0.0 and tt < best_t:
best_t = tt
best_name = o.obj_name
if best_name != "":
doc.warn("%s is locked. Unlock it (padlock in the hierarchy) to edit it." % best_name)
func _pick_object(mp: Vector2) -> int:
var f := _pick_face(mp)
if not f.is_empty():
return f["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 _gizmo_hit(mp: Vector2) -> int:
if not doc.gizmo_on or doc.mode == PdDocument.Mode.DRAW \
or doc.mode == PdDocument.Mode.TEXTURE \
or doc.gizmo_anchor_w() == Vector3.INF:
return -1
if doc.gizmo_kind == 2:
var best := -1
var best_d := 10.0
for rg in _gizmo_rings():
var pts: PackedVector2Array = rg["pts_s"]
for s in pts.size() - 1:
var d := PdGeo.dist_to_seg(mp, pts[s], pts[s + 1])
if d < best_d:
best_d = d
best = rg["axis"]
return best
var c := doc.gizmo_anchor_w()
var cp := _project(c)
if mp.distance_to(cp) < 10.0:
# -2 = center zone. SCALE gizmo: the center cube is the
# uniform-scale handle. MOVE gizmo: fall through to direct
# element dragging (the press handler checks gizmo_kind).
return -2
for a in _gizmo_axes():
if PdGeo.dist_to_seg(mp, cp, a["to"]) < 10.0:
return a["axis"]
return -1
func _update_hover(mp: Vector2) -> void:
if doc.mode == PdDocument.Mode.TEXTURE:
paint_hover = _pick_face(mp)
return
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 _set_hover(h: Dictionary) -> void:
if hover != h:
hover = h
# -------------------------------------------------------------- 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_MIDDLE:
if e.pressed:
# MMB orbits; Shift+MMB pans
op = Op.PAN if Input.is_key_pressed(KEY_SHIFT) else Op.ORBIT
orbit_btn = MOUSE_BUTTON_MIDDLE
pan_last = mp
accept_event()
elif op == Op.ORBIT or op == Op.PAN:
op = Op.NONE
accept_event()
MOUSE_BUTTON_RIGHT:
if e.pressed:
# right-click cancels an in-progress doodle
if op == Op.SHAPE:
op = Op.NONE
shape_pts = PackedVector2Array()
accept_event()
return
op = Op.PAN
pan_last = mp
press_px = mp
accept_event()
elif op == Op.PAN:
# a bare right-click opens the mesh-ops CONTEXT
# MENU in the edit modes; a right-DRAG pans the
# camera. In the texture editor right-click does
# nothing here - erasing is the dedicated Eraser
# TOOL now, and the canvas has its own gestures.
if doc.mode != PdDocument.Mode.TEXTURE \
and press_px.distance_to(mp) < 4.0:
_open_ctx_menu(mp)
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:
dist = clampf(dist * 0.9, 0.4, 120.0)
_update_cam()
accept_event()
MOUSE_BUTTON_WHEEL_DOWN:
if e.pressed:
dist = clampf(dist * 1.1, 0.4, 120.0)
_update_cam()
accept_event()
func _press_left(mp: Vector2) -> void:
press_px = mp
press_moved = false
grab_focus()
# Alt+LMB orbits in every mode - the way to turn the camera while
# a doodle or paint gesture owns plain LMB
if Input.is_key_pressed(KEY_ALT):
op = Op.ORBIT
orbit_btn = MOUSE_BUTTON_LEFT
pan_last = mp
accept_event()
return
# Ctrl+LMB drag = rectangle multi-select in the 3D modeler
# viewports (Draw and the texture editor keep their own gestures)
if Input.is_key_pressed(KEY_CTRL) \
and doc.mode != PdDocument.Mode.DRAW \
and doc.mode != PdDocument.Mode.TEXTURE:
op = Op.MARQUEE
marquee_start = mp
marquee_now = mp
accept_event()
return
var gax := _gizmo_hit(mp)
var center_sel := doc.sel_center_w()
if (gax >= 0 or gax == -2) and center_sel != Vector3.INF:
op = Op.GIZMO
doc.begin_gesture()
gizmo_axis = gax
_gizmo_label = "Scale selection" if doc.gizmo_kind == 1 \
else ("Rotate selection" if doc.gizmo_kind == 2 else "Move selection")
move_before = doc.snapshot()
_capture_origs()
if doc.gizmo_kind == 1:
# SCALE: freeze the arm length and (for uniform) the
# cursor distance from the center so the factor maps
# 1:1 to the drag and never feeds back on itself
gizmo_ref_len = maxf(0.0001, GIZMO_LEN_PX * _wpp())
if gax == -2:
var r0 := _ray(mp)
var pl := Plane(-_cam_fwd(), center_sel)
var hit0 = pl.intersects_ray(r0[0], r0[1])
gizmo_d0 = maxf(0.0001, (hit0 as Vector3)
.distance_to(center_sel) if hit0 != null \
else gizmo_ref_len)
else:
var ax0 := _axis_vec(gax)
var r1 := _ray(mp)
gizmo_t0 = PdGeo.closest_ray_line(
r1[0], r1[1], center_sel, ax0)["t_line"]
elif doc.gizmo_kind == 2:
# ROTATE: freeze the ring's own plane basis and the
# cursor's starting angle within it - every later
# frame measures the angle against THIS, never the
# live (already-rotated) selection, for the same
# anti-jitter reason move/scale freeze their refs.
gizmo_rot_axis = _axis_vec(gax)
var uv := _ring_basis(gizmo_rot_axis)
gizmo_rot_u = uv[0]
gizmo_rot_v = uv[1]
gizmo_rot_origs = _capture_rotate_origs()
var rpl := Plane(gizmo_rot_axis, center_sel)
var rr := _ray(mp)
var rhit = rpl.intersects_ray(rr[0], rr[1])
var rel0: Vector3 = (rhit as Vector3 - center_sel) if rhit != null else Vector3.ZERO
gizmo_angle0 = atan2(rel0.dot(gizmo_rot_v), rel0.dot(gizmo_rot_u))
gizmo_angle = 0.0
else:
var ax := _axis_vec(gax)
var r := _ray(mp)
# Freeze BOTH the reference point and the start parameter: every
# motion event is measured against this fixed line. Recomputing
# against the live (already moved) center fed the scalar back into
# itself and made the drag jitter in the 3D view.
gizmo_c0 = center_sel
gizmo_t0 = PdGeo.closest_ray_line(r[0], r[1], gizmo_c0, ax)["t_line"]
gizmo_scalar = 0.0
gizmo_c0 = center_sel
accept_event()
return
if doc.mode in [PdDocument.Mode.OBJECT, PdDocument.Mode.VERTEX,
PdDocument.Mode.EDGE, PdDocument.Mode.FACE]:
_explain_locked_click(mp)
match doc.mode:
PdDocument.Mode.DRAW:
op = Op.SHAPE
doc.begin_gesture()
_begin_shape(mp)
accept_event()
PdDocument.Mode.TEXTURE:
if doc.tex_edit:
# UV editing: NO brush is active - clicking a
# face just selects it so its island highlights
# in the texture canvas. Drag on empty space
# orbits; a plain click never deselects here.
var sel_hit := _pick_face(mp)
if sel_hit.is_empty():
op = Op.ORBIT
orbit_btn = MOUSE_BUTTON_LEFT
press_picked = false
else:
op = Op.ORBIT # drag orbits after the click
orbit_btn = MOUSE_BUTTON_LEFT
press_picked = true
# the face lives on the hit object: make
# THAT object active first, otherwise the
# selection is pruned to the previous
# active object and the click appears dead
doc.select_face_on(sel_hit["obj"],
sel_hit["idx"],
Input.is_key_pressed(KEY_SHIFT))
accept_event()
return
var hit := _pick_face(mp)
if hit.is_empty() and doc.paint_tool == "Brush":
hit = _pick_edge(mp)
if hit.is_empty():
# pressed on empty space: drag orbits, click
# does nothing
op = Op.ORBIT
orbit_btn = MOUSE_BUTTON_LEFT
else:
op = Op.PAINT
doc.begin_gesture()
move_before = doc.snapshot()
_last_paint_key = ""
doc.pixel_stroke_begin()
# clicking a face also SELECTS it, so its
# island highlights in the texture canvas
if hit.get("kind", "") == "face":
doc.select_face_on(hit["obj"], hit["idx"],
Input.is_key_pressed(KEY_SHIFT))
# FACE LOCK: remember the face the
# stroke started on (edge hits lock nothing)
var sfi := -1
if hit.get("kind", "") == "face" \
and hit.get("obj", -1) == doc.active_obj:
sfi = hit["idx"]
doc.paint_stroke_begin(doc.active_obj, sfi)
_paint_gesture(mp, false)
accept_event()
_:
var picked := _pick_element(mp)
if picked.is_empty():
# pressed on empty space: drag orbits, a
# plain click deselects (handled on release)
op = Op.ORBIT
orbit_btn = MOUSE_BUTTON_LEFT
else:
_apply_click_selection(picked)
op = Op.MOVE
doc.begin_gesture()
move_before = doc.snapshot()
_capture_origs()
# reference point: plane through selection center
var c := doc.sel_center_w()
if c == Vector3.INF:
move_valid = false
else:
var r := _ray(mp)
var plane := Plane(-_cam_fwd(), c)
var hit = plane.intersects_ray(r[0], r[1])
move_valid = hit != null
move_hit0 = hit if hit != null else Vector3.ZERO
accept_event()
func _axis_vec(i: int) -> Vector3:
match i:
1: return Vector3.UP
2: return Vector3(0, 0, 1)
return Vector3.RIGHT
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 (gizmo on or off)
# moves every selected 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
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
## Rotate always works on actual vertex positions (there is no per-object
## rotation property to write to - see apply_rotate_gizmo), so unlike
## _capture_origs, OBJECT mode here captures every vertex of each selected
## object rather than a frozen position/scale3, in the same {"verts",
## "pos"} shape the element-mode branch already uses.
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:
continue
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:
if not move_valid:
return
var r := _ray(mouse_px)
var plane := Plane(-_cam_fwd(), move_hit0)
var hit = plane.intersects_ray(r[0], r[1])
if hit == null:
return
var delta: Vector3 = hit - move_hit0
if doc.mode == PdDocument.Mode.OBJECT:
for oi in move_orig_pos:
var o := doc.obj(oi)
if o == null:
continue
o.position = doc.snap_v3(move_orig_pos[oi] + delta) if doc.snap_enabled \
else move_orig_pos[oi] + delta
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],
doc.snap_v3(orig[k] + delta) if doc.snap_enabled else orig[k] + delta)
Op.GIZMO:
if doc.gizmo_kind == 1:
# SCALE drag: factor from the frozen press-time
# reference - axis drags measure along the axis
# line, uniform (center cube) measures radial
# distance on the camera-facing plane
var factor := 1.0
if gizmo_axis == -2:
var r2 := _ray(mouse_px)
var pl2 := Plane(-_cam_fwd(), gizmo_c0)
var hit2 = pl2.intersects_ray(r2[0], r2[1])
if hit2 != null:
factor = (hit2 as Vector3) \
.distance_to(gizmo_c0) / gizmo_d0
else:
var ax2 := _axis_vec(gizmo_axis)
var r3 := _ray(mouse_px)
var t2: float = PdGeo.closest_ray_line(
r3[0], r3[1], gizmo_c0, ax2)["t_line"]
factor = 1.0 + (t2 - gizmo_t0) / gizmo_ref_len
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
# the FROZEN press-time center: recomputing the
# center from the live (already snapped) verts
# each step made snap + scale jitter badly
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)
elif doc.gizmo_kind == 2:
# ROTATE drag: angle of the cursor within the
# ring's own frozen plane, measured from the
# frozen press-time angle - never the live
# (already-rotated) selection, same anti-
# jitter rule as move/scale above.
var rpl := Plane(gizmo_rot_axis, gizmo_c0)
var rr := _ray(mouse_px)
var rhit = rpl.intersects_ray(rr[0], rr[1])
if rhit != null:
var rel: Vector3 = (rhit as Vector3) - gizmo_c0
var ang := atan2(rel.dot(gizmo_rot_v), rel.dot(gizmo_rot_u))
var delta := wrapf(ang - gizmo_angle0, -PI, PI)
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)
else:
var ax := _axis_vec(gizmo_axis)
var r := _ray(mouse_px)
# measured against the FROZEN press-time line, never
# the live selection center (which moves with the
# drag) - this is the anti-jitter fix
var t: float = PdGeo.closest_ray_line(r[0], r[1], gizmo_c0, ax)["t_line"]
gizmo_scalar = t - gizmo_t0
if doc.snap_enabled and doc.grid_size > 0.001:
gizmo_scalar = snappedf(gizmo_scalar, doc.grid_size)
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 * gizmo_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 * gizmo_scalar)
doc.notify_doc()
func _mm(e: InputEventMouseMotion) -> void:
mouse_px = e.position
if e.relative.length() > 1.0:
press_moved = true
match op:
Op.ORBIT:
yaw -= e.relative.x * 0.008
pitch = clampf(pitch + e.relative.y * 0.008, -1.55, 1.55)
_update_cam()
Op.PAN:
var k := _wpp()
target -= _cam_right() * e.relative.x * k
target += _cam_up() * e.relative.y * k
_update_cam()
Op.MOVE, Op.GIZMO:
_apply_move_targets()
Op.PAINT:
_paint_gesture(e.position, false)
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.MARQUEE:
marquee_now = e.position
Op.NONE:
if mouse_in:
_update_hover(e.position)
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:
doc.commit(_gizmo_label, move_before)
doc.notify_sel()
Op.SHAPE:
_finish_shape_3d()
Op.MARQUEE:
_marquee_select(mp)
Op.PAINT:
pass # painting happens on press + drag sweeps
Op.ORBIT:
# a bare LEFT click on empty space deselects (the
# drag itself was the orbit) - but never right after
# a UV-edit click that just SELECTED a face
if orbit_btn == MOUSE_BUTTON_LEFT and not press_moved \
and not press_picked \
and not Input.is_key_pressed(KEY_SHIFT):
doc.clear_all_sel()
_:
pass
doc.paint_stroke_end() # face-lock stroke memory (harmless if none)
if was_gesture:
doc.end_gesture()
op = Op.NONE
move_before = []
shape_pts = PackedVector2Array()
_last_paint_key = ""
press_picked = false
orbit_btn = 0
press_moved = false
marquee_start = Vector2.ZERO
marquee_now = Vector2.ZERO
## Ctrl+drag rectangle multi-select: every element whose screen position
## falls inside the marquee is selected. Shift adds to the existing
## selection, otherwise the rect replaces it.
func _marquee_select(mp: Vector2) -> void:
var r := Rect2(marquee_start, marquee_now - marquee_start).abs()
if r.size.length() < 4.0:
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(_project(o.wvert(vi))):
if not ids.has(oi):
ids.append(oi)
break
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(_project(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(_project(o.wvert(e.x))) \
or r.has_point(_project(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(_project(PdGeo.face_center(pts))):
arr.append(fi)
doc.select_faces(arr)
## 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" \
or doc.paint_tool == "Eraser"):
hit = _pick_edge(mp)
paint_hover = hit
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 theTEXEL 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_3d(mp: Vector2, erase: bool) -> void:
_last_paint_key = ""
_paint_gesture(mp, erase)
# --------------------------------------------------- 3D shape drawing ---
## Start a doodle on the plane under the cursor: a mesh face if one is
## hovered, otherwise a horizontal plane through the selection (or the
## ground). The plane stays fixed for the whole gesture.
func _begin_shape(mp: Vector2) -> void:
shape_pts = PackedVector2Array([mp])
var hit := _pick_face(mp)
if not hit.is_empty():
shape_plane_n = (hit.get("normal", Vector3.UP) as Vector3).normalized()
shape_plane_p = hit["point"]
else:
shape_plane_n = Vector3.UP
var c := doc.sel_center_w()
shape_plane_p = Vector3(0.0, c.y, 0.0) if c != Vector3.INF \
else Vector3.ZERO
if shape_plane_n.length() < 0.5:
shape_plane_n = Vector3.UP
if shape_plane_n.dot(_cam_fwd()) > 0.0:
shape_plane_n = -shape_plane_n
# basis: u = screen-right on the plane, v = screen-down on the plane
var up := _cam_up() - shape_plane_n * _cam_up().dot(shape_plane_n)
if up.length() < 0.05:
up = Vector3.UP if absf(shape_plane_n.dot(Vector3.UP)) < 0.9 \
else Vector3.RIGHT
up = up - shape_plane_n * up.dot(shape_plane_n)
shape_v = -up.normalized()
shape_u = shape_plane_n.cross(shape_v).normalized()
## Screen point -> 2D coords on the doodle plane (world units), or null
## when the ray misses (grazing angles).
func _shape_pt2(sp: Vector2):
var r := _ray(sp)
var pl := Plane(shape_plane_n, shape_plane_p.dot(shape_plane_n))
var hit = pl.intersects_ray(r[0], r[1])
if hit == null:
return null
var d: Vector3 = hit - shape_plane_p
return Vector2(d.dot(shape_u), d.dot(shape_v))
func _finish_shape_3d() -> void:
if shape_pts.is_empty():
return
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 sp in simplified:
var p2 = _shape_pt2(sp)
if p2 == null:
doc.warn("Aim the cursor at the grid or a surface to draw there.")
return
pts.append(doc.snap_v3(shape_plane_p
+ shape_u * p2.x + shape_v * p2.y))
doc.add_polygon(_orient_to_plane(pts), "Doodle")
"Torus":
_finish_torus_3d()
_:
if shape_pts.size() != 2:
doc.warn("Drag to size the shape: hold the button, move, then release.")
return
var r := Rect2(shape_pts[0], shape_pts[1] - shape_pts[0]).abs()
if Input.is_key_pressed(KEY_SHIFT):
var s := maxf(r.size.x, r.size.y)
r = Rect2(r.position, Vector2(s, s))
if r.size.length() < 6.0:
doc.warn("That shape is too small. Drag further to size it.")
return
var gen := _finish_gen(doc.draw_kind)
var pts := PackedVector3Array()
for gp in gen:
# normalized (0..1) generator -> screen -> plane
var sp := r.position + Vector2(gp.x * r.size.x, gp.y * r.size.y)
var p2 = _shape_pt2(sp)
if p2 == null:
doc.warn("Aim the cursor at the grid or a surface to draw there.")
return
pts.append(doc.snap_v3(shape_plane_p
+ shape_u * p2.x + shape_v * p2.y))
doc.add_polygon(_orient_to_plane(pts), doc.draw_kind)
## Normalized (0..1) outline used when FINISHING a 3D shape. It mirrors
## the live-preview generators exactly, so what the drag shows is what
## gets created (finishing a Rectangle through ngon_pts(4) would give a
## DIAMOND while the preview drew a rect).
func _finish_gen(kind: String) -> PackedVector2Array:
var out: PackedVector2Array
match kind:
"Circle":
out = _norm_ellipse3d(48)
"Triangle":
out = _norm_ngon3d(3)
"Pentagon":
out = _norm_ngon3d(5)
"Hexagon":
out = _norm_ngon3d(6)
"Star":
out = _norm_star3d()
_:
out = PackedVector2Array([Vector2(0, 0), Vector2(1, 0),
Vector2(1, 1), Vector2(0, 1)])
if out.size() > 1 and out[0].is_equal_approx(out[out.size() - 1]):
out.resize(out.size() - 1) # strip the closing repeat
return out
## Torus solid on the doodle plane: drag defines the outer radius.
func _finish_torus_3d() -> void:
if shape_pts.size() != 2:
doc.warn("Drag to size the torus: hold the button, move, then release.")
return
var r := Rect2(shape_pts[0], shape_pts[1] - shape_pts[0]).abs()
if Input.is_key_pressed(KEY_SHIFT):
var s := maxf(r.size.x, r.size.y)
r = Rect2(r.position, Vector2(s, s))
if r.size.length() < 12.0:
doc.warn("That torus is too small. Drag further to set its size.")
return
var c2 = _shape_pt2(r.get_center())
var e_top = _shape_pt2(r.position + Vector2(r.size.x * 0.5, 0))
var e_side = _shape_pt2(r.position + Vector2(r.size.x, r.size.y * 0.5))
if c2 == null or e_top == null or e_side == null:
return
# outer radius = the larger plane-space extent of the drag rect
var R: float = maxf((e_top as Vector2).distance_to(c2),
(e_side as Vector2).distance_to(c2))
if doc.snap_enabled and doc.grid_size > 0.001:
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 c_w: Vector3 = doc.snap_v3(shape_plane_p + shape_u * c2.x + shape_v * c2.y)
var out_v := PackedVector3Array()
for p in data["verts"]:
# local torus: XZ ring, Y axis -> plane basis (u, v, normal)
out_v.append(doc.snap_v3(
c_w + shape_u * p.x + shape_plane_n * p.y + shape_v * p.z))
doc.add_mesh_data({"verts": out_v, "faces": data["faces"]}, "Torus")
## Flip the loop so its normal agrees with the doodle plane (toward the
## viewer), keeping the face front-facing in the 3D view.
func _orient_to_plane(pts: PackedVector3Array) -> PackedVector3Array:
if PdGeo.face_normal(pts).dot(shape_plane_n) < 0.0:
pts.reverse()
return pts
## Live preview of the doodle while dragging (drawn into the overlay).
func _draw_shape_preview_3d() -> void:
var col := Color(PdDocument.ACCENT.r, PdDocument.ACCENT.g, PdDocument.ACCENT.b, 0.9)
if doc.draw_kind == "Freehand":
var pts := PackedVector3Array()
for sp in shape_pts:
var p2 = _shape_pt2(sp)
if p2 == null:
return
pts.append(shape_plane_p + shape_u * p2.x + shape_v * p2.y)
for i in range(1, pts.size()):
_quad_line(pts[i - 1], pts[i], 1.6, col)
if pts.size() > 2:
_quad_line(pts[pts.size() - 1], pts[0], 1.0,
Color(col.r, col.g, col.b, 0.4))
if not pts.is_empty():
_dot(pts[0], 3.0, Color(1, 1, 1, 0.9))
return
if shape_pts.size() != 2:
if not shape_pts.is_empty():
var p0 = _shape_pt2(shape_pts[0])
if p0 != null:
_dot(shape_plane_p + shape_u * p0.x + shape_v * p0.y,
3.0, Color(1, 1, 1, 0.9))
return
var r := Rect2(shape_pts[0], shape_pts[1] - shape_pts[0]).abs()
# Torus preview: outer and inner ring as two separate closed loops
if doc.draw_kind == "Torus":
var outer := PackedVector3Array()
for i in 49:
var a := TAU * i / 48.0
var gp := Vector2(0.5, 0.5) + Vector2(cos(a), sin(a)) * 0.5
var sp := r.position + Vector2(gp.x * r.size.x, gp.y * r.size.y)
var p2 = _shape_pt2(sp)
if p2 == null:
return
outer.append(shape_plane_p + shape_u * p2.x + shape_v * p2.y)
for i in range(1, outer.size()):
_quad_line(outer[i - 1], outer[i], 1.6, col)
var inner := PackedVector3Array()
for i in 49:
var a := TAU * i / 48.0
var gp := Vector2(0.5, 0.5) + Vector2(cos(a), sin(a)) * 0.18
var sp := r.position + Vector2(gp.x * r.size.x, gp.y * r.size.y)
var p2 = _shape_pt2(sp)
if p2 == null:
return
inner.append(shape_plane_p + shape_u * p2.x + shape_v * p2.y)
for i in range(1, inner.size()):
_quad_line(inner[i - 1], inner[i], 1.6, Color(col.r, col.g, col.b, 0.7))
if not outer.is_empty():
_dot(outer[0], 3.0, Color(1, 1, 1, 0.9))
return
var gen: PackedVector2Array
match doc.draw_kind:
"Circle":
gen = _norm_ellipse3d(48)
"Triangle":
gen = _norm_ngon3d(3)
"Pentagon":
gen = _norm_ngon3d(5)
"Hexagon":
gen = _norm_ngon3d(6)
"Star":
gen = _norm_star3d()
_:
gen = PackedVector2Array([Vector2(0, 0), Vector2(1, 0),
Vector2(1, 1), Vector2(0, 1)])
var pts := PackedVector3Array()
for gp in gen:
var sp := r.position + Vector2(gp.x * r.size.x, gp.y * r.size.y)
var p2 = _shape_pt2(sp)
if p2 == null:
return
pts.append(shape_plane_p + shape_u * p2.x + shape_v * p2.y)
var closed := pts.duplicate()
closed.append(pts[0])
for i in range(1, closed.size()):
_quad_line(closed[i - 1], closed[i], 1.6, col)
_dot(pts[0], 3.0, Color(1, 1, 1, 0.9))
func _norm_ellipse3d(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_ngon3d(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_star3d() -> 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
# ---------------------------------------------------- context menu ---
## Right-click mesh-ops menu in the 3D editor (picocad-style): extrude
## faces/edges, merge vertices, fill/clear paint, delete - per mode.
## Built fresh on every open so enable states are always live.
func _open_ctx_menu(mp: Vector2) -> void:
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:
# multi-face selection: BOTH extrude modes - each
# face along its own normal, or the whole selection
# as one region (shared edges get no walls)
if doc.sel_faces.size() > 1:
entries = [[30, "Extrude Faces (Individual)", true],
[36, "Extrude Faces (Combined)", true],
[37, "Inset Faces", true],
[38, "Outset Faces", true],
[31, "Fill Face(s)", true],
[32, "Clear Face Paint", true],
[33, "Delete Face(s)", true],
[-1, "", true],
[34, "Select All", o != null],
[35, "Deselect", true]]
else:
entries = [[30, "Extrude Face", doc.sel_faces.size() > 0],
[37, "Inset Face", doc.sel_faces.size() > 0],
[38, "Outset Face", 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()
36:
doc.extrude_selected_faces_combined()
37:
doc.inset_selected_faces(doc.inset_dist)
38:
doc.inset_selected_faces(-doc.inset_dist)
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()