Initial Commit

1 files changed, 1503 insertions, 0 deletions

diff --git a/src/addons/rmsmartshape/plugin.gd b/src/addons/rmsmartshape/plugin.gd
new file mode 100644
index 0000000..7c554d4
--- /dev/null
+++ b/src/addons/rmsmartshape/plugin.gd
@@ -0,0 +1,1503 @@
+tool
+extends EditorPlugin
+
+"""
+Common Abbreviations
+et = editor transform (viewport's canvas transform)
+
+- Snapping using the build in functionality isn't going to happen
+	- https://github.com/godotengine/godot/issues/11180
+	- https://godotengine.org/qa/18051/tool-script-in-3-0
+"""
+
+# Icons
+const ICON_HANDLE = preload("assets/icon_editor_handle.svg")
+const ICON_HANDLE_SELECTED = preload("assets/icon_editor_handle_selected.svg")
+const ICON_HANDLE_BEZIER = preload("assets/icon_editor_handle_bezier.svg")
+const ICON_HANDLE_CONTROL = preload("assets/icon_editor_handle_control.svg")
+const ICON_ADD_HANDLE = preload("assets/icon_editor_handle_add.svg")
+const ICON_CURVE_EDIT = preload("assets/icon_curve_edit.svg")
+const ICON_CURVE_CREATE = preload("assets/icon_curve_create.svg")
+const ICON_CURVE_DELETE = preload("assets/icon_curve_delete.svg")
+const ICON_PIVOT_POINT = preload("assets/icon_editor_position.svg")
+const ICON_COLLISION = preload("assets/icon_collision_polygon_2d.svg")
+const ICON_INTERP_LINEAR = preload("assets/InterpLinear.svg")
+const ICON_SNAP = preload("assets/icon_editor_snap.svg")
+const ICON_IMPORT_CLOSED = preload("assets/closed_shape.png")
+const ICON_IMPORT_OPEN = preload("assets/open_shape.png")
+const FUNC = preload("plugin-functionality.gd")
+
+enum MODE { EDIT_VERT, EDIT_EDGE, SET_PIVOT, CREATE_VERT }
+
+enum ACTION_VERT {
+	NONE = 0,
+	MOVE_VERT = 1,
+	MOVE_CONTROL = 2,
+	MOVE_CONTROL_IN = 3,
+	MOVE_CONTROL_OUT = 4,
+	MOVE_WIDTH_HANDLE = 5
+}
+
+
+# Data related to an action being taken on points
+class ActionDataVert:
+	#Type of Action from the ACTION_VERT enum
+	var type: int = ACTION_VERT.NONE
+	# The affected Verticies and their initial positions
+	var keys = []
+	var starting_width = []
+	var starting_positions = []
+	var starting_positions_control_in = []
+	var starting_positions_control_out = []
+
+	func _init(
+		_keys: Array,
+		positions: Array,
+		positions_in: Array,
+		positions_out: Array,
+		width: Array,
+		t: int
+	):
+		type = t
+		keys = _keys
+		starting_positions = positions
+		starting_positions_control_in = positions_in
+		starting_positions_control_out = positions_out
+		starting_width = width
+
+	func are_verts_selected() -> bool:
+		return keys.size() > 0
+
+	func to_string() -> String:
+		var s = "%s: %s = %s"
+		return s % [type, keys, starting_positions]
+
+	func is_single_vert_selected() -> bool:
+		if keys.size() == 1:
+			return true
+		return false
+
+	func current_point_key() -> int:
+		if not is_single_vert_selected():
+			return -1
+		return keys[0]
+
+	func current_point_index(s: SS2D_Shape_Base) -> int:
+		if not is_single_vert_selected():
+			return -1
+		return s.get_point_index(keys[0])
+
+
+# PRELOADS
+var GUI_SNAP_POPUP = preload("scenes/SnapPopup.tscn")
+var GUI_POINT_INFO_PANEL = preload("scenes/GUI_InfoPanel.tscn")
+var GUI_EDGE_INFO_PANEL = preload("scenes/GUI_Edge_InfoPanel.tscn")
+var gui_point_info_panel = GUI_POINT_INFO_PANEL.instance()
+var gui_edge_info_panel = GUI_EDGE_INFO_PANEL.instance()
+var gui_snap_settings = GUI_SNAP_POPUP.instance()
+
+# This is the shape node being edited
+var shape = null
+# For when a legacy shape is selected
+var legacy_shape = null
+
+# Toolbar Stuff
+var tb_hb: HBoxContainer = null
+var tb_hb_legacy_import: HBoxContainer = null
+var tb_import: ToolButton = null
+var tb_vert_create: ToolButton = null
+var tb_vert_edit: ToolButton = null
+var tb_edge_edit: ToolButton = null
+var tb_pivot: ToolButton = null
+var tb_collision: ToolButton = null
+var tb_snap: MenuButton = null
+# The PopupMenu that belongs to tb_snap
+var tb_snap_popup: PopupMenu = null
+
+# Edge Stuff
+var on_edge: bool = false
+var edge_point: Vector2
+var edge_data: SS2D_Edge = null
+
+# Width Handle Stuff
+var on_width_handle: bool = false
+const WIDTH_HANDLE_OFFSET: float = 60.0
+var closest_key: int
+var closest_edge_keys: Array = [-1, -1]
+var width_scaling: float
+
+# Track our mode of operation
+var current_mode: int = MODE.CREATE_VERT
+var previous_mode: int = MODE.CREATE_VERT
+
+# Undo stuff
+var undo: UndoRedo = null
+var undo_version: int = 0
+
+var current_action = ActionDataVert.new([], [], [], [], [], ACTION_VERT.NONE)
+var cached_shape_global_transform: Transform2D
+
+# Action Move Variables
+var _mouse_motion_delta_starting_pos = Vector2(0, 0)
+
+#######
+# GUI #
+#######
+
+
+func gui_display_snap_settings():
+	var win_size = OS.get_window_size()
+	gui_snap_settings.popup_centered_ratio(0.5)
+	gui_snap_settings.set_as_minsize()
+	# Get Centered
+	gui_snap_settings.rect_position = (win_size / 2.0) - gui_snap_settings.rect_size / 2.0
+	# Move up
+	gui_snap_settings.rect_position.y = (win_size.y / 8.0)
+
+
+func _snapping_item_selected(id: int):
+	if id == 0:
+		tb_snap_popup.set_item_checked(id, not tb_snap_popup.is_item_checked(id))
+	if id == 1:
+		tb_snap_popup.set_item_checked(id, not tb_snap_popup.is_item_checked(id))
+	elif id == 3:
+		gui_display_snap_settings()
+
+
+func _gui_build_toolbar():
+	tb_hb = HBoxContainer.new()
+	add_control_to_container(EditorPlugin.CONTAINER_CANVAS_EDITOR_MENU, tb_hb)
+	tb_hb_legacy_import = HBoxContainer.new()
+	add_control_to_container(EditorPlugin.CONTAINER_CANVAS_EDITOR_MENU, tb_hb_legacy_import)
+	tb_import = ToolButton.new()
+	tb_import.icon = ICON_IMPORT_CLOSED
+	tb_import.toggle_mode = false
+	tb_import.pressed = false
+	tb_import.hint_tooltip = SS2D_Strings.EN_TOOLTIP_IMPORT
+	tb_import.connect("pressed", self, "_import_legacy")
+	tb_hb_legacy_import.add_child(tb_import)
+
+	var sep = VSeparator.new()
+	tb_hb.add_child(sep)
+
+	tb_vert_create = create_tool_button(ICON_CURVE_CREATE, SS2D_Strings.EN_TOOLTIP_CREATE_VERT)
+	tb_vert_create.connect("pressed", self, "_enter_mode", [MODE.CREATE_VERT])
+	tb_vert_create.pressed = true
+
+	tb_vert_edit = create_tool_button(ICON_CURVE_EDIT, SS2D_Strings.EN_TOOLTIP_EDIT_VERT)
+	tb_vert_edit.connect("pressed", self, "_enter_mode", [MODE.EDIT_VERT])
+
+	tb_edge_edit = create_tool_button(ICON_INTERP_LINEAR, SS2D_Strings.EN_TOOLTIP_EDIT_EDGE)
+	tb_edge_edit.connect("pressed", self, "_enter_mode", [MODE.EDIT_EDGE])
+
+	tb_pivot = create_tool_button(ICON_PIVOT_POINT, SS2D_Strings.EN_TOOLTIP_EDIT_VERT)
+	tb_pivot.connect("pressed", self, "_enter_mode", [MODE.SET_PIVOT])
+
+	tb_collision = create_tool_button(ICON_COLLISION, SS2D_Strings.EN_TOOLTIP_COLLISION)
+	tb_collision.connect("pressed", self, "_add_collision")
+
+	tb_snap = MenuButton.new()
+	tb_snap.hint_tooltip = SS2D_Strings.EN_TOOLTIP_SNAP
+	tb_snap_popup = tb_snap.get_popup()
+	tb_snap.icon = ICON_SNAP
+	tb_snap_popup.add_check_item("Use Grid Snap")
+	tb_snap_popup.add_check_item("Snap Relative")
+	tb_snap_popup.add_separator()
+	tb_snap_popup.add_item("Configure Snap...")
+	tb_snap_popup.hide_on_checkable_item_selection = false
+	tb_hb.add_child(tb_snap)
+	tb_snap_popup.connect("id_pressed", self, "_snapping_item_selected")
+
+	tb_hb.hide()
+
+
+func create_tool_button(icon, tooltip):
+	var tb = ToolButton.new()
+	tb.toggle_mode = true
+	tb.icon = icon
+	tb.hint_tooltip = tooltip
+	tb_hb.add_child(tb)
+	return tb
+
+
+func _gui_update_vert_info_panel():
+	var idx = current_action.current_point_index(shape)
+	var key = current_action.current_point_key()
+	if not is_key_valid(shape, key):
+		gui_point_info_panel.visible = false
+		return
+	gui_point_info_panel.visible = true
+	# Shrink panel
+	gui_point_info_panel.rect_size = Vector2(1, 1)
+
+	var properties = shape.get_point_properties(key)
+	gui_point_info_panel.set_idx(idx)
+	gui_point_info_panel.set_texture_idx(properties.texture_idx)
+	gui_point_info_panel.set_width(properties.width)
+	gui_point_info_panel.set_flip(properties.flip)
+
+
+func _gui_update_edge_info_panel():
+	# Don't update if already visible
+	if gui_edge_info_panel.visible:
+		return
+	var indicies = [-1, -1]
+	var override = null
+	if on_edge:
+		var t: Transform2D = get_et() * shape.get_global_transform()
+		var offset = shape.get_closest_offset_straight_edge(t.affine_inverse().xform(edge_point))
+		var keys = _get_edge_point_keys_from_offset(offset, true)
+		indicies = [shape.get_point_index(keys[0]), shape.get_point_index(keys[1])]
+		if shape.has_material_override(keys):
+			override = shape.get_material_override(keys)
+	gui_edge_info_panel.set_indicies(indicies)
+	if override != null:
+		gui_edge_info_panel.set_material_override(true)
+		gui_edge_info_panel.load_values_from_meta_material(override)
+	else:
+		gui_edge_info_panel.set_material_override(false)
+
+	# Shrink panel to minimum size
+	gui_edge_info_panel.rect_size = Vector2(1, 1)
+
+
+func _gui_update_info_panels():
+	match current_mode:
+		MODE.EDIT_VERT:
+			_gui_update_vert_info_panel()
+			gui_edge_info_panel.visible = false
+		MODE.EDIT_EDGE:
+			_gui_update_edge_info_panel()
+			gui_point_info_panel.visible = false
+
+
+#########
+# GODOT #
+#########
+
+
+# Called when saving
+# https://docs.godotengine.org/en/3.2/classes/class_editorplugin.html?highlight=switch%20scene%20tab
+func apply_changes():
+	gui_point_info_panel.visible = false
+	gui_edge_info_panel.visible = false
+
+
+func _init():
+	pass
+
+
+func _ready():
+	undo = get_undo_redo()
+	# Support the undo-redo actions
+	_gui_build_toolbar()
+	add_child(gui_point_info_panel)
+	gui_point_info_panel.visible = false
+	add_child(gui_edge_info_panel)
+	gui_edge_info_panel.visible = false
+	gui_edge_info_panel.connect("set_material_override", self, "_on_set_edge_material_override")
+	gui_edge_info_panel.connect("set_render", self, "_on_set_edge_material_override_render")
+	gui_edge_info_panel.connect("set_weld", self, "_on_set_edge_material_override_weld")
+	gui_edge_info_panel.connect("set_z_index", self, "_on_set_edge_material_override_z_index")
+	gui_edge_info_panel.connect("set_edge_material", self, "_on_set_edge_material")
+	add_child(gui_snap_settings)
+
+
+func _enter_tree():
+	pass
+
+
+func _exit_tree():
+	gui_point_info_panel.visible = false
+	gui_edge_info_panel.visible = false
+	remove_control_from_container(EditorPlugin.CONTAINER_CANVAS_EDITOR_MENU, tb_hb)
+
+
+func forward_canvas_gui_input(event):
+	if not is_shape_valid(shape):
+		return false
+
+	var et = get_et()
+	var grab_threshold = get_editor_interface().get_editor_settings().get(
+		"editors/poly_editor/point_grab_radius"
+	)
+	var return_value = false
+
+	if event is InputEventKey:
+		return_value = _input_handle_keyboard_event(event)
+
+	elif event is InputEventMouseButton:
+		return_value = _input_handle_mouse_button_event(event, et, grab_threshold)
+
+	elif event is InputEventMouseMotion:
+		return_value = _input_handle_mouse_motion_event(event, et, grab_threshold)
+
+	_gui_update_info_panels()
+	return return_value
+
+
+func _process(delta):
+	if not Engine.editor_hint:
+		return
+
+	if not is_shape_valid(shape):
+		gui_point_info_panel.visible = false
+		gui_edge_info_panel.visible = false
+		shape = null
+		update_overlays()
+		return
+	# Force update if global transforma has been changed
+	if cached_shape_global_transform != shape.get_global_transform():
+		shape.set_as_dirty()
+		cached_shape_global_transform = shape.get_global_transform()
+
+
+func handles(object):
+	tb_hb.hide()
+	tb_hb_legacy_import.hide()
+	update_overlays()
+	gui_point_info_panel.visible = false
+	gui_edge_info_panel.visible = false
+
+	if object is Resource:
+		return false
+
+	var rslt: bool = object is SS2D_Shape_Base or object is RMSmartShape2D
+	return rslt
+
+
+func edit(object):
+	on_edge = false
+	deselect_verts()
+	if is_shape_valid(shape):
+		disconnect_shape(shape)
+	if is_shape_valid(legacy_shape):
+		disconnect_shape(legacy_shape)
+
+	shape = null
+	legacy_shape = null
+
+	if object is RMSmartShape2D:
+		tb_hb.hide()
+		tb_hb_legacy_import.show()
+		if object.closed_shape:
+			tb_import.icon = ICON_IMPORT_CLOSED
+		else:
+			tb_import.icon = ICON_IMPORT_OPEN
+
+		legacy_shape = object
+		connect_shape(legacy_shape)
+	else:
+		tb_hb.show()
+		tb_hb_legacy_import.hide()
+
+		shape = object
+		connect_shape(shape)
+
+	update_overlays()
+
+
+func make_visible(visible):
+	pass
+
+
+############
+# SNAPPING #
+############
+func use_global_snap() -> bool:
+	return ! tb_snap_popup.is_item_checked(1)
+
+
+func use_snap() -> bool:
+	return tb_snap_popup.is_item_checked(0)
+
+
+func get_snap_offset() -> Vector2:
+	return gui_snap_settings.get_snap_offset()
+
+
+func get_snap_step() -> Vector2:
+	return gui_snap_settings.get_snap_step()
+
+
+func snap(v: Vector2, force: bool = false) -> Vector2:
+	if not use_snap() and not force:
+		return v
+	var step = get_snap_step()
+	var offset = get_snap_offset()
+	var t = Transform2D.IDENTITY
+	if use_global_snap():
+		t = shape.get_global_transform()
+	return snap_position(v, offset, step, t)
+
+
+static func snap_position(
+	pos_global: Vector2, snap_offset: Vector2, snap_step: Vector2, local_t: Transform2D
+) -> Vector2:
+	# Move global position to local position to snap in local space
+	var pos_local = local_t * pos_global
+
+	# Snap in local space
+	var x = pos_local.x
+	if snap_step.x != 0:
+		var delta = fmod(pos_local.x, snap_step.x)
+		# Round up
+		if delta >= (snap_step.x / 2.0):
+			x = pos_local.x + (snap_step.x - delta)
+		# Round down
+		else:
+			x = pos_local.x - delta
+	var y = pos_local.y
+	if snap_step.y != 0:
+		var delta = fmod(pos_local.y, snap_step.y)
+		# Round up
+		if delta >= (snap_step.y / 2.0):
+			y = pos_local.y + (snap_step.y - delta)
+		# Round down
+		else:
+			y = pos_local.y - delta
+
+	# Transform local position to global position
+	var pos_global_snapped = (local_t.affine_inverse() * Vector2(x, y)) + snap_offset
+	#print ("%s | %s | %s | %s" % [pos_global, pos_local, Vector2(x,y), pos_global_snapped])
+	return pos_global_snapped
+
+
+##########
+# PLUGIN #
+##########
+func _import_legacy():
+	call_deferred("_import_legacy_impl")
+
+
+func _import_legacy_impl():
+	if legacy_shape == null:
+		push_error("LEGACY SHAPE IS NULL")
+		return
+	if not legacy_shape is RMSmartShape2D:
+		push_error("LEGACY SHAPE NOT VALID")
+		return
+	var par = legacy_shape.get_parent()
+	if par == null:
+		push_error("LEGACY SHAPE PARENT IS NULL")
+		return
+
+	# Make new shape and set values
+	var new_shape = null
+	if legacy_shape.closed_shape:
+		new_shape = SS2D_Shape_Closed.new()
+		new_shape.name = "SS2D_Shape_Closed"
+	else:
+		new_shape = SS2D_Shape_Open.new()
+		new_shape.name = "SS2D_Shape_Open"
+	new_shape.import_from_legacy(legacy_shape)
+	new_shape.transform = legacy_shape.transform
+
+	# Add new to scene tree
+	par.add_child(new_shape)
+	new_shape.owner = get_editor_interface().get_edited_scene_root()
+
+	# Remove Legacy from scene tree
+	disconnect_shape(legacy_shape)
+	par.remove_child(legacy_shape)
+	legacy_shape.queue_free()
+	legacy_shape = null
+
+	# Edit the new shape
+	#edit(new_shape)
+
+
+func _on_legacy_closed_changed():
+	if is_shape_valid(legacy_shape):
+		if legacy_shape is RMSmartShape2D:
+			if legacy_shape.closed_shape:
+				tb_import.icon = ICON_IMPORT_CLOSED
+			else:
+				tb_import.icon = ICON_IMPORT_OPEN
+
+
+func disconnect_shape(s):
+	if s.is_connected("points_modified", self, "_on_shape_point_modified"):
+		s.disconnect("points_modified", self, "_on_shape_point_modified")
+	# Legacy
+	if s is RMSmartShape2D:
+		if s.is_connected("on_closed_change", self, "_on_legacy_closed_changed"):
+			s.disconnect("on_closed_change", self, "_on_legacy_closed_changed")
+
+
+func connect_shape(s):
+	if not s.is_connected("points_modified", self, "_on_shape_point_modified"):
+		s.connect("points_modified", self, "_on_shape_point_modified")
+	if s is RMSmartShape2D:
+		if not s.is_connected("on_closed_change", self, "_on_legacy_closed_changed"):
+			s.connect("on_closed_change", self, "_on_legacy_closed_changed")
+
+
+static func get_material_override_from_indicies(shape: SS2D_Shape_Base, indicies: Array):
+	var keys = []
+	for i in indicies:
+		keys.push_back(shape.get_point_key_at_index(i))
+	if not shape.has_material_override(keys):
+		return null
+	return shape.get_material_override(keys)
+
+
+func _on_set_edge_material_override_render(enabled: bool):
+	var override = get_material_override_from_indicies(shape, gui_edge_info_panel.indicies)
+	if override != null:
+		override.render = enabled
+
+
+func _on_set_edge_material_override_weld(enabled: bool):
+	var override = get_material_override_from_indicies(shape, gui_edge_info_panel.indicies)
+	if override != null:
+		override.weld = enabled
+
+
+func _on_set_edge_material_override_z_index(z: int):
+	var override = get_material_override_from_indicies(shape, gui_edge_info_panel.indicies)
+	if override != null:
+		override.z_index = z
+
+
+func _on_set_edge_material(m: SS2D_Material_Edge):
+	var override = get_material_override_from_indicies(shape, gui_edge_info_panel.indicies)
+	if override != null:
+		override.edge_material = m
+
+
+func _on_set_edge_material_override(enabled: bool):
+	var indicies = gui_edge_info_panel.indicies
+	if indicies.has(-1) or indicies.size() != 2:
+		return
+	var keys = []
+	for i in indicies:
+		keys.push_back(shape.get_point_key_at_index(i))
+
+	# Get the relevant Override data if any exists
+	var override = null
+	if shape.has_material_override(keys):
+		override = shape.get_material_override(keys)
+
+	if enabled:
+		if override == null:
+			override = SS2D_Material_Edge_Metadata.new()
+			override.edge_material = null
+			shape.set_material_override(keys, override)
+
+		# Load override data into the info panel
+		gui_edge_info_panel.load_values_from_meta_material(override)
+	else:
+		if override != null:
+			shape.remove_material_override(keys)
+
+
+static func is_shape_valid(s) -> bool:
+	if s == null:
+		return false
+	if not is_instance_valid(s):
+		return false
+	if not s.is_inside_tree():
+		return false
+	return true
+
+
+func _on_shape_point_modified():
+	FUNC.action_invert_orientation(self, "update_overlays", undo, shape)
+
+
+func get_et() -> Transform2D:
+	return get_editor_interface().get_edited_scene_root().get_viewport().global_canvas_transform
+
+
+static func is_key_valid(s: SS2D_Shape_Base, key: int) -> bool:
+	if not is_shape_valid(s):
+		return false
+	return s.has_point(key)
+
+
+func _enter_mode(mode: int):
+	if current_mode == mode:
+		return
+	for tb in [tb_vert_edit, tb_edge_edit, tb_pivot, tb_vert_create]:
+		tb.pressed = false
+
+	previous_mode = current_mode
+	current_mode = mode
+	match mode:
+		MODE.CREATE_VERT:
+			tb_vert_create.pressed = true
+		MODE.EDIT_VERT:
+			tb_vert_edit.pressed = true
+		MODE.EDIT_EDGE:
+			tb_edge_edit.pressed = true
+		MODE.SET_PIVOT:
+			tb_pivot.pressed = true
+		_:
+			tb_vert_edit.pressed = true
+	update_overlays()
+
+
+func _set_pivot(point: Vector2):
+	var et = get_et()
+
+	var np: Vector2 = point
+	var ct: Transform2D = shape.get_global_transform()
+	ct.origin = np
+
+	shape.disable_constraints()
+	for i in shape.get_point_count():
+		var key = shape.get_point_key_at_index(i)
+		var pt = shape.get_global_transform().xform(shape.get_point_position(key))
+		shape.set_point_position(key, ct.affine_inverse().xform(pt))
+	shape.enable_constraints()
+
+	shape.position = shape.get_parent().get_global_transform().affine_inverse().xform(np)
+	_enter_mode(current_mode)
+	update_overlays()
+
+
+func _add_collision():
+	call_deferred("_add_deferred_collision")
+
+
+func _add_deferred_collision():
+	if not shape.get_parent() is StaticBody2D:
+		var static_body: StaticBody2D = StaticBody2D.new()
+		var t: Transform2D = shape.transform
+		static_body.position = shape.position
+		shape.position = Vector2.ZERO
+
+		shape.get_parent().add_child(static_body)
+		static_body.owner = get_editor_interface().get_edited_scene_root()
+
+		shape.get_parent().remove_child(shape)
+		static_body.add_child(shape)
+		shape.owner = get_editor_interface().get_edited_scene_root()
+
+		var poly: CollisionPolygon2D = CollisionPolygon2D.new()
+		static_body.add_child(poly)
+		poly.owner = get_editor_interface().get_edited_scene_root()
+		# TODO: Make this a option at some point
+		poly.modulate.a = 0.3
+		poly.visible = false
+		shape.collision_polygon_node_path = shape.get_path_to(poly)
+		shape.set_as_dirty()
+
+
+#############
+# RENDERING #
+#############
+func forward_canvas_draw_over_viewport(overlay: Control):
+	# Something might force a draw which we had no control over,
+	# in this case do some updating to be sure
+	if not is_shape_valid(shape) or not is_inside_tree():
+		return
+
+	if undo_version != undo.get_version():
+		if (
+			undo.get_current_action_name() == "Move CanvasItem"
+			or undo.get_current_action_name() == "Rotate CanvasItem"
+			or undo.get_current_action_name() == "Scale CanvasItem"
+		):
+			shape.set_as_dirty()
+			undo_version = undo.get_version()
+
+	match current_mode:
+		MODE.CREATE_VERT:
+			draw_mode_edit_vert(overlay)
+			if Input.is_key_pressed(KEY_ALT) and Input.is_key_pressed(KEY_SHIFT):
+				draw_new_shape_preview(overlay)
+			elif Input.is_key_pressed(KEY_ALT):
+				draw_new_point_close_preview(overlay)
+			else:
+				draw_new_point_preview(overlay)
+		MODE.EDIT_VERT:
+			draw_mode_edit_vert(overlay)
+			if Input.is_key_pressed(KEY_ALT):
+				if Input.is_key_pressed(KEY_SHIFT):
+					draw_new_shape_preview(overlay)
+				elif not on_edge:
+					draw_new_point_close_preview(overlay)
+		MODE.EDIT_EDGE:
+			draw_mode_edit_edge(overlay)
+
+	shape.update()
+
+
+func draw_mode_edit_edge(overlay: Control):
+	var t: Transform2D = get_et() * shape.get_global_transform()
+	var verts = shape.get_vertices()
+	var edges = shape.get_edges()
+
+	var color_highlight = Color(1.0, 0.75, 0.75, 1.0)
+	var color_normal = Color(1.0, 0.25, 0.25, 0.8)
+
+	draw_shape_outline(overlay, t, verts, color_normal, 3.0)
+	draw_vert_handles(overlay, t, verts, false)
+
+	if current_action.type == ACTION_VERT.MOVE_VERT:
+		var edge_point_keys = current_action.keys
+		var p1 = shape.get_point_position(edge_point_keys[0])
+		var p2 = shape.get_point_position(edge_point_keys[1])
+		overlay.draw_line(t.xform(p1), t.xform(p2), color_highlight, 5.0)
+	elif on_edge:
+		var offset = shape.get_closest_offset_straight_edge(t.affine_inverse().xform(edge_point))
+		var edge_point_keys = _get_edge_point_keys_from_offset(offset, true)
+		var p1 = shape.get_point_position(edge_point_keys[0])
+		var p2 = shape.get_point_position(edge_point_keys[1])
+		overlay.draw_line(t.xform(p1), t.xform(p2), color_highlight, 5.0)
+
+
+func draw_mode_edit_vert(overlay: Control):
+	var t: Transform2D = get_et() * shape.get_global_transform()
+	var verts = shape.get_vertices()
+	var points = shape.get_tessellated_points()
+	draw_shape_outline(overlay, t, points)
+	draw_vert_handles(overlay, t, verts, true)
+	if on_edge:
+		overlay.draw_texture(ICON_ADD_HANDLE, edge_point - ICON_ADD_HANDLE.get_size() * 0.5)
+
+	# Draw Highlighted Handle
+	if current_action.is_single_vert_selected():
+		var tex = ICON_HANDLE_SELECTED
+		overlay.draw_texture(
+			tex, t.xform(verts[current_action.current_point_index(shape)]) - tex.get_size() * 0.5
+		)
+
+
+func draw_shape_outline(overlay: Control, t: Transform2D, points, color = null, width = 2.0):
+	# Draw Outline
+	var prev_pt = null
+	if color == null:
+		color = shape.modulate
+	for i in range(0, points.size(), 1):
+		var pt = points[i]
+		if prev_pt != null:
+			overlay.draw_line(prev_pt, t.xform(pt), color, width, true)
+		prev_pt = t.xform(pt)
+
+
+func draw_vert_handles(overlay: Control, t: Transform2D, verts, control_points: bool):
+	for i in range(0, verts.size(), 1):
+		# Draw Vert handles
+		var key: int = shape.get_point_key_at_index(i)
+		var hp: Vector2 = t.xform(verts[i])
+		var icon = ICON_HANDLE_BEZIER if Input.is_key_pressed(KEY_SHIFT) else ICON_HANDLE
+		overlay.draw_texture(icon, hp - icon.get_size() * 0.5)
+
+		# Draw Width handles
+#		var normal = _get_vert_normal(t, verts, i)
+#		var width_handle_icon = WIDTH_HANDLES[int((normal.angle() + PI / 8 + TAU) / PI * 4) % 4]
+#		overlay.draw_texture(width_handle_icon, hp - width_handle_icon.get_size() * 0.5 + normal * WIDTH_HANDLE_OFFSET)
+
+	# Draw Width handle
+	var offset = WIDTH_HANDLE_OFFSET
+	var width_handle_key = closest_key
+	if (
+		Input.is_mouse_button_pressed(BUTTON_LEFT)
+		and current_action.type == ACTION_VERT.MOVE_WIDTH_HANDLE
+	):
+		offset *= width_scaling
+		width_handle_key = current_action.keys[0]
+	var width_handle_normal = _get_vert_normal(t, verts, shape.get_point_index(width_handle_key))
+	var vertex_position: Vector2 = t.xform(shape.get_point_position(width_handle_key))
+	var icon_position: Vector2 = vertex_position + width_handle_normal * offset
+	var rect_size: Vector2 = Vector2.ONE * 10.0
+	var width_handle_color = Color("f53351")
+	overlay.draw_line(vertex_position, icon_position, width_handle_color, 1.0, true)
+	overlay.draw_set_transform(icon_position, width_handle_normal.angle(), Vector2.ONE)
+	overlay.draw_rect(Rect2(-rect_size / 2.0, rect_size), width_handle_color, true, 1.0)
+	overlay.draw_set_transform(Vector2.ZERO, 0, Vector2.ONE)
+
+	# Draw Control point handles
+	if control_points:
+		for i in range(0, verts.size(), 1):
+			var normal = _get_vert_normal(t, verts, i)
+			var key = shape.get_point_key_at_index(i)
+			var hp = t.xform(verts[i])
+
+			# Drawing the point-out for the last point makes no sense, as there's no point ahead of it
+			if i < verts.size() - 1:
+				var pointout = t.xform(verts[i] + shape.get_point_out(key))
+				if hp != pointout:
+					_draw_control_point_line(overlay, hp, pointout, ICON_HANDLE_CONTROL)
+			# Drawing the point-in for point 0 makes no sense, as there's no point behind it
+			if i > 0:
+				var pointin = t.xform(verts[i] + shape.get_point_in(key))
+				if hp != pointin:
+					_draw_control_point_line(overlay, hp, pointin, ICON_HANDLE_CONTROL)
+
+
+func _draw_control_point_line(c: Control, vert: Vector2, cp: Vector2, tex: Texture):
+	# Draw the line with a dark and light color to be visible on all backgrounds
+	var color_dark = Color(0, 0, 0, 0.3)
+	var color_light = Color(1, 1, 1, .5)
+	var width = 2.0
+	var normal = (cp - vert).normalized()
+	c.draw_line(vert + normal * 4 + Vector2.DOWN, cp + Vector2.DOWN, color_dark, width, true)
+	c.draw_line(vert + normal * 4, cp, color_light, width, true)
+	c.draw_texture(tex, cp - tex.get_size() * 0.5)
+
+
+func draw_new_point_preview(overlay: Control):
+	# Draw lines to where a new point will be added
+	var verts = shape.get_vertices()
+	var t: Transform2D = get_et() * shape.get_global_transform()
+	var color = Color(1, 1, 1, .5)
+	var width = 2
+
+	var a
+	var mouse = overlay.get_local_mouse_position()
+	if is_shape_closed(shape):
+		a = t.xform(verts[verts.size() - 2])
+		var b = t.xform(verts[0])
+		overlay.draw_line(mouse, b, color, width * .5, true)
+	else:
+		a = t.xform(verts[verts.size() - 1])
+	overlay.draw_line(mouse, a, color, width, true)
+	overlay.draw_texture(ICON_ADD_HANDLE, mouse - ICON_ADD_HANDLE.get_size() * 0.5)
+
+
+func draw_new_point_close_preview(overlay: Control):
+	# Draw lines to where a new point will be added
+	var verts = shape.get_vertices()
+	var t: Transform2D = get_et() * shape.get_global_transform()
+	var color = Color(1, 1, 1, .5)
+	var width = 2
+
+	var mouse = overlay.get_local_mouse_position()
+	var a = t.xform(shape.get_point_position(closest_edge_keys[0]))
+	var b = t.xform(shape.get_point_position(closest_edge_keys[1]))
+#	var a = 
+#	var b = t.xform()
+	overlay.draw_line(mouse, b, color, width, true)
+	overlay.draw_line(mouse, a, color, width, true)
+	overlay.draw_texture(ICON_ADD_HANDLE, mouse - ICON_ADD_HANDLE.get_size() * 0.5)
+
+
+func draw_new_shape_preview(overlay: Control):
+	# Draw a plus where a new shape will be added
+	var mouse = overlay.get_local_mouse_position()
+	overlay.draw_texture(ICON_ADD_HANDLE, mouse - ICON_ADD_HANDLE.get_size() * 0.5)
+
+
+##########
+# PLUGIN #
+##########
+func deselect_verts():
+	current_action = ActionDataVert.new([], [], [], [], [], ACTION_VERT.NONE)
+
+
+func select_verticies(keys: Array, action: int) -> ActionDataVert:
+	var from_positions = []
+	var from_positions_c_in = []
+	var from_positions_c_out = []
+	var from_widths = []
+	for key in keys:
+		from_positions.push_back(shape.get_point_position(key))
+		from_positions_c_in.push_back(shape.get_point_in(key))
+		from_positions_c_out.push_back(shape.get_point_out(key))
+		from_widths.push_back(shape.get_point_width(key))
+	return ActionDataVert.new(
+		keys, from_positions, from_positions_c_in, from_positions_c_out, from_widths, action
+	)
+
+
+func select_vertices_to_move(keys: Array, _mouse_starting_pos_viewport: Vector2):
+	_mouse_motion_delta_starting_pos = _mouse_starting_pos_viewport
+	current_action = select_verticies(keys, ACTION_VERT.MOVE_VERT)
+
+
+func select_control_points_to_move(
+	keys: Array, _mouse_starting_pos_viewport: Vector2, action = ACTION_VERT.MOVE_CONTROL
+):
+	current_action = select_verticies(keys, action)
+	_mouse_motion_delta_starting_pos = _mouse_starting_pos_viewport
+
+
+func select_width_handle_to_move(keys: Array, _mouse_starting_pos_viewport: Vector2):
+	_mouse_motion_delta_starting_pos = _mouse_starting_pos_viewport
+	current_action = select_verticies(keys, ACTION_VERT.MOVE_WIDTH_HANDLE)
+
+
+#########
+# INPUT #
+#########
+func _input_handle_right_click_press(mb_position: Vector2, grab_threshold: float) -> bool:
+	if not shape.can_edit:
+		return false
+	if current_mode == MODE.EDIT_VERT or current_mode == MODE.CREATE_VERT:
+		# Mouse over a single vertex?
+		if current_action.is_single_vert_selected():
+			FUNC.action_delete_point(self, "update_overlays", undo, shape, current_action.keys[0])
+			undo_version = undo.get_version()
+			deselect_verts()
+			return true
+		else:
+			# Mouse over a control point?
+			var et = get_et()
+			var points_in = FUNC.get_intersecting_control_point_in(
+				shape, et, mb_position, grab_threshold
+			)
+			var points_out = FUNC.get_intersecting_control_point_out(
+				shape, et, mb_position, grab_threshold
+			)
+			if not points_in.empty():
+				FUNC.action_delete_point_in(self, "update_overlays", undo, shape, points_in[0])
+				undo_version = undo.get_version()
+				return true
+			elif not points_out.empty():
+				FUNC.action_delete_point_out(self, "update_overlays", undo, shape, points_out[0])
+				undo_version = undo.get_version()
+				return true
+	elif current_mode == MODE.EDIT_EDGE:
+		if on_edge:
+			gui_edge_info_panel.visible = not gui_edge_info_panel.visible
+			gui_edge_info_panel.rect_position = mb_position + Vector2(256, -24)
+	return false
+
+
+func _input_handle_left_click(
+	mb: InputEventMouseButton,
+	vp_m_pos: Vector2,
+	t: Transform2D,
+	et: Transform2D,
+	grab_threshold: float
+) -> bool:
+	# Set Pivot?
+	if current_mode == MODE.SET_PIVOT:
+		var local_position = et.affine_inverse().xform(mb.position)
+		if use_snap():
+			local_position = snap(local_position)
+		FUNC.action_set_pivot(self, "_set_pivot", undo, shape, et, local_position)
+		undo_version = undo.get_version()
+		return true
+	if current_mode == MODE.EDIT_VERT or current_mode == MODE.CREATE_VERT:
+		gui_edge_info_panel.visible = false
+
+		# Any nearby control points to move?
+		if not Input.is_key_pressed(KEY_ALT):
+			if _input_move_control_points(mb, vp_m_pos, grab_threshold):
+				return true
+
+			# Highlighting a vert to move or add control points to
+			if current_action.is_single_vert_selected():
+				if on_width_handle:
+					select_width_handle_to_move([current_action.current_point_key()], vp_m_pos)
+				elif Input.is_key_pressed(KEY_SHIFT):
+					select_control_points_to_move([current_action.current_point_key()], vp_m_pos)
+					return true
+				else:
+					select_vertices_to_move([current_action.current_point_key()], vp_m_pos)
+					return true
+
+		# Split the Edge?
+		if _input_split_edge(mb, vp_m_pos, t):
+			return true
+
+		if not on_edge:
+			# Create new point
+			if Input.is_key_pressed(KEY_ALT) or current_mode == MODE.CREATE_VERT:
+				var local_position = t.affine_inverse().xform(mb.position)
+				if use_snap():
+					local_position = snap(local_position)
+				if Input.is_key_pressed(KEY_SHIFT) and Input.is_key_pressed(KEY_ALT):
+					# Copy shape with a new single point
+					var copy = copy_shape(shape)
+
+					copy.set_point_array(SS2D_Point_Array.new())
+					copy.clear_all_material_overrides()
+					var new_key = FUNC.action_add_point(
+						self, "update_overlays", undo, copy, local_position
+					)
+					select_vertices_to_move([new_key], vp_m_pos)
+
+					_enter_mode(MODE.CREATE_VERT)
+
+					var selection := get_editor_interface().get_selection()
+					selection.clear()
+					selection.add_node(copy)
+				elif Input.is_key_pressed(KEY_ALT):
+					var new_key = FUNC.action_add_point(
+						self,
+						"update_overlays",
+						undo,
+						shape,
+						local_position,
+						shape.get_point_index(closest_edge_keys[1])
+					)
+				else:
+					var new_key = FUNC.action_add_point(
+						self, "update_overlays", undo, shape, local_position
+					)
+					select_vertices_to_move([new_key], vp_m_pos)
+				undo_version = undo.get_version()
+				return true
+	elif current_mode == MODE.EDIT_EDGE:
+		if gui_edge_info_panel.visible:
+			gui_edge_info_panel.visible = false
+			return true
+		if on_edge:
+			# Grab Edge (2 points)
+			var offset = shape.get_closest_offset_straight_edge(
+				t.affine_inverse().xform(edge_point)
+			)
+			var edge_point_keys = _get_edge_point_keys_from_offset(offset, true)
+			select_vertices_to_move([edge_point_keys[0], edge_point_keys[1]], vp_m_pos)
+		return true
+	return false
+
+
+func _input_handle_mouse_wheel(btn: int) -> bool:
+	if not shape.can_edit:
+		return false
+	var key = current_action.current_point_key()
+	if Input.is_key_pressed(KEY_SHIFT):
+		var width = shape.get_point_width(key)
+		var width_step = 0.1
+		if btn == BUTTON_WHEEL_DOWN:
+			width_step *= -1
+		var new_width = width + width_step
+		shape.set_point_width(key, new_width)
+
+	else:
+		var texture_idx_step = 1
+		if btn == BUTTON_WHEEL_DOWN:
+			texture_idx_step *= -1
+
+		var tex_idx: int = shape.get_point_texture_index(key) + texture_idx_step
+		shape.set_point_texture_index(key, tex_idx)
+
+	shape.set_as_dirty()
+	update_overlays()
+	_gui_update_info_panels()
+
+	return true
+
+
+func _input_handle_keyboard_event(event: InputEventKey) -> bool:
+	if not shape.can_edit:
+		return false
+	var kb: InputEventKey = event
+	if _is_valid_keyboard_scancode(kb):
+		if current_action.is_single_vert_selected():
+			if kb.pressed and kb.scancode == KEY_SPACE:
+				var key = current_action.current_point_key()
+				shape.set_point_texture_flip(key, not shape.get_point_texture_flip(key))
+				shape.set_as_dirty()
+				shape.update()
+				_gui_update_info_panels()
+
+		if kb.pressed and kb.scancode == KEY_ESCAPE:
+			# Hide edge_info_panel
+			if gui_edge_info_panel.visible:
+				gui_edge_info_panel.visible = false
+
+			if current_mode == MODE.CREATE_VERT:
+				_enter_mode(MODE.EDIT_VERT)
+
+		if kb.scancode == KEY_CONTROL:
+			if kb.pressed and not kb.echo:
+				on_edge = false
+				current_action = select_verticies([closest_key], ACTION_VERT.NONE)
+			else:
+				deselect_verts()
+			update_overlays()
+
+		if kb.scancode == KEY_ALT:
+			update_overlays()
+
+		return true
+	return false
+
+
+func _is_valid_keyboard_scancode(kb: InputEventKey) -> bool:
+	match kb.scancode:
+		KEY_ESCAPE:
+			return true
+		KEY_ENTER:
+			return true
+		KEY_SPACE:
+			return true
+		KEY_SHIFT:
+			return true
+		KEY_ALT:
+			return true
+		KEY_CONTROL:
+			return true
+	return false
+
+
+func _input_handle_mouse_button_event(
+	event: InputEventMouseButton, et: Transform2D, grab_threshold: float
+) -> bool:
+	if not shape.can_edit:
+		return false
+	var t: Transform2D = et * shape.get_global_transform()
+	var mb: InputEventMouseButton = event
+	var viewport_mouse_position = et.affine_inverse().xform(mb.position)
+	var mouse_wheel_spun = (
+		mb.pressed
+		and (mb.button_index == BUTTON_WHEEL_DOWN or mb.button_index == BUTTON_WHEEL_UP)
+	)
+
+	#######################################
+	# Mouse Button released
+	if not mb.pressed and mb.button_index == BUTTON_LEFT:
+		var rslt: bool = false
+		var type = current_action.type
+		var _in = type == ACTION_VERT.MOVE_CONTROL or type == ACTION_VERT.MOVE_CONTROL_IN
+		var _out = type == ACTION_VERT.MOVE_CONTROL or type == ACTION_VERT.MOVE_CONTROL_OUT
+		if type == ACTION_VERT.MOVE_VERT:
+			FUNC.action_move_verticies(self, "update_overlays", undo, shape, current_action)
+			undo_version = undo.get_version()
+			rslt = true
+		elif _in or _out:
+			FUNC.action_move_control_points(
+				self, "update_overlays", undo, shape, current_action, _in, _out
+			)
+			undo_version = undo.get_version()
+			rslt = true
+		deselect_verts()
+		return rslt
+
+	#########################################
+	# Mouse Wheel on valid point
+	elif mouse_wheel_spun and current_action.is_single_vert_selected():
+		return _input_handle_mouse_wheel(mb.button_index)
+
+	#########################################
+	# Mouse left click
+	elif mb.pressed and mb.button_index == BUTTON_LEFT:
+		return _input_handle_left_click(mb, viewport_mouse_position, t, et, grab_threshold)
+
+	#########################################
+	# Mouse right click
+	elif mb.pressed and mb.button_index == BUTTON_RIGHT:
+		return _input_handle_right_click_press(mb.position, grab_threshold)
+
+	return false
+
+
+func _input_split_edge(mb: InputEventMouseButton, vp_m_pos: Vector2, t: Transform2D) -> bool:
+	if not on_edge:
+		return false
+	var gpoint: Vector2 = mb.position
+	var insertion_point: int = -1
+	var mb_offset = shape.get_closest_offset(t.affine_inverse().xform(gpoint))
+
+	insertion_point = shape.get_point_index(_get_edge_point_keys_from_offset(mb_offset)[1])
+
+	if insertion_point == -1:
+		insertion_point = shape.get_point_count() - 1
+
+	var key = FUNC.action_split_curve(
+		self, "update_overlays", undo, shape, insertion_point, gpoint, t
+	)
+	undo_version = undo.get_version()
+	select_vertices_to_move([key], vp_m_pos)
+	on_edge = false
+
+	return true
+
+
+func _input_move_control_points(mb: InputEventMouseButton, vp_m_pos: Vector2, grab_threshold: float) -> bool:
+	var points_in = FUNC.get_intersecting_control_point_in(
+		shape, get_et(), mb.position, grab_threshold
+	)
+	var points_out = FUNC.get_intersecting_control_point_out(
+		shape, get_et(), mb.position, grab_threshold
+	)
+	if not points_in.empty():
+		select_control_points_to_move([points_in[0]], vp_m_pos, ACTION_VERT.MOVE_CONTROL_IN)
+		return true
+	elif not points_out.empty():
+		select_control_points_to_move([points_out[0]], vp_m_pos, ACTION_VERT.MOVE_CONTROL_OUT)
+		return true
+	return false
+
+
+func _get_edge_point_keys_from_offset(offset: float, straight: bool = false):
+	for i in range(0, shape.get_point_count() - 1, 1):
+		var key = shape.get_point_key_at_index(i)
+		var key_next = shape.get_point_key_at_index(i + 1)
+		var this_offset = 0
+		var next_offset = 0
+		if straight:
+			this_offset = shape.get_closest_offset_straight_edge(shape.get_point_position(key))
+			next_offset = shape.get_closest_offset_straight_edge(shape.get_point_position(key_next))
+		else:
+			this_offset = shape.get_closest_offset(shape.get_point_position(key))
+			next_offset = shape.get_closest_offset(shape.get_point_position(key_next))
+		if offset >= this_offset and offset <= next_offset:
+			return [key, key_next]
+		# for when the shape is closed and the final point has an offset of 0
+		if next_offset == 0 and offset >= this_offset:
+			return [key, key_next]
+	return [-1, -1]
+
+
+func _input_motion_is_on_edge(mm: InputEventMouseMotion, grab_threshold: float) -> bool:
+	var xform: Transform2D = get_et() * shape.get_global_transform()
+	if shape.get_point_count() < 2:
+		return false
+
+	# Find edge
+	var closest_point = null
+	if current_mode == MODE.EDIT_EDGE:
+		closest_point = shape.get_closest_point_straight_edge(
+			xform.affine_inverse().xform(mm.position)
+		)
+	else:
+		closest_point = shape.get_closest_point(xform.affine_inverse().xform(mm.position))
+	if closest_point != null:
+		edge_point = xform.xform(closest_point)
+		if edge_point.distance_to(mm.position) <= grab_threshold:
+			return true
+	return false
+
+
+func _input_find_closest_edge_keys(mm: InputEventMouseMotion):
+	var xform: Transform2D = get_et() * shape.get_global_transform()
+	if shape.get_point_count() < 2:
+		return false
+
+	# Find edge
+	var closest_point = null
+
+	closest_point = shape.get_closest_point_straight_edge(xform.affine_inverse().xform(mm.position))
+	var edge_point = xform.xform(closest_point)
+	var offset = shape.get_closest_offset_straight_edge(xform.affine_inverse().xform(edge_point))
+	closest_edge_keys = _get_edge_point_keys_from_offset(offset, true)
+
+
+func get_mouse_over_vert_key(mm: InputEventMouseMotion, grab_threshold: float) -> int:
+	var xform: Transform2D = get_et() * shape.get_global_transform()
+	# However, if near a control point or one of its handles then we are not on the edge
+	for k in shape.get_all_point_keys():
+		var pp: Vector2 = shape.get_point_position(k)
+		var p: Vector2 = xform.xform(pp)
+		if p.distance_to(mm.position) <= grab_threshold:
+			return k
+	return -1
+
+
+func get_mouse_over_width_handle(mm: InputEventMouseMotion, grab_threshold: float) -> int:
+	var xform: Transform2D = get_et() * shape.get_global_transform()
+	for k in shape.get_all_point_keys():
+		var pp: Vector2 = shape.get_point_position(k)
+		var normal: Vector2 = _get_vert_normal(
+			xform, shape.get_vertices(), shape.get_point_index(k)
+		)
+		var p: Vector2 = xform.xform(pp) + normal * WIDTH_HANDLE_OFFSET
+		if p.distance_to(mm.position) <= grab_threshold:
+			return k
+	return -1
+
+
+func _input_motion_move_control_points(delta: Vector2, _in: bool, _out: bool) -> bool:
+	var rslt = false
+	for i in range(0, current_action.keys.size(), 1):
+		var key = current_action.keys[i]
+		var from = current_action.starting_positions[i]
+		var out_multiplier = 1
+		# Invert the delta for position_out if moving both at once
+		if _out and _in:
+			out_multiplier = -1
+		var new_position_in = delta + current_action.starting_positions_control_in[i]
+		var new_position_out = (
+			(delta * out_multiplier)
+			+ current_action.starting_positions_control_out[i]
+		)
+		if use_snap():
+			new_position_in = snap(new_position_in)
+			new_position_out = snap(new_position_out)
+		if _in:
+			shape.set_point_in(key, new_position_in)
+			rslt = true
+		if _out:
+			shape.set_point_out(key, new_position_out)
+			rslt = true
+		shape.set_as_dirty()
+		update_overlays()
+	return false
+
+
+func _input_motion_move_verts(delta: Vector2) -> bool:
+	for i in range(0, current_action.keys.size(), 1):
+		var key = current_action.keys[i]
+		var from = current_action.starting_positions[i]
+		var new_position = from + delta
+		if use_snap():
+			new_position = snap(new_position)
+		shape.set_point_position(key, new_position)
+		update_overlays()
+	return true
+
+
+func _input_motion_move_width_handle(mouse_position: Vector2, scale: Vector2) -> bool:
+	for i in range(0, current_action.keys.size(), 1):
+		var key = current_action.keys[i]
+		var from_width = current_action.starting_width[i]
+		var from_position = current_action.starting_positions[i]
+		width_scaling = from_position.distance_to(mouse_position) / WIDTH_HANDLE_OFFSET * scale.x
+		shape.set_point_width(key, round(from_width * width_scaling * 10) / 10)
+		update_overlays()
+	return true
+
+
+func get_closest_vert_to_point(s: SS2D_Shape_Base, p: Vector2) -> int:
+	"""
+	Will Return index of closest vert to point
+	"""
+	var gt = shape.get_global_transform()
+	var verts = s.get_vertices()
+	var transformed_point = gt.affine_inverse() * p
+	var idx = -1
+	var closest_distance = -1
+	for i in verts.size():
+		var distance = verts[i].distance_to(transformed_point)
+		if distance < closest_distance or closest_distance == -1:
+			idx = s.get_point_key_at_index(i)
+			closest_distance = distance
+	return idx
+
+
+func _input_handle_mouse_motion_event(
+	event: InputEventMouseMotion, et: Transform2D, grab_threshold: float
+) -> bool:
+	var t: Transform2D = et * shape.get_global_transform()
+	var mm: InputEventMouseMotion = event
+	var delta_current_pos = et.affine_inverse().xform(mm.position)
+	gui_point_info_panel.rect_position = mm.position + Vector2(256, -24)
+	var delta = delta_current_pos - _mouse_motion_delta_starting_pos
+
+	closest_key = get_closest_vert_to_point(shape, delta_current_pos)
+
+	if current_mode == MODE.EDIT_VERT or current_mode == MODE.CREATE_VERT:
+		var type = current_action.type
+		var _in = type == ACTION_VERT.MOVE_CONTROL or type == ACTION_VERT.MOVE_CONTROL_IN
+		var _out = type == ACTION_VERT.MOVE_CONTROL or type == ACTION_VERT.MOVE_CONTROL_OUT
+
+		if type == ACTION_VERT.MOVE_VERT:
+			return _input_motion_move_verts(delta)
+		elif _in or _out:
+			return _input_motion_move_control_points(delta, _in, _out)
+		elif type == ACTION_VERT.MOVE_WIDTH_HANDLE:
+			return _input_motion_move_width_handle(
+				et.affine_inverse().xform(mm.position), et.get_scale()
+			)
+		var mouse_over_key = get_mouse_over_vert_key(event, grab_threshold)
+		var mouse_over_width_handle = get_mouse_over_width_handle(event, grab_threshold)
+
+		# Make the closest key grabable while holding down Control
+		if (
+			Input.is_key_pressed(KEY_CONTROL)
+			and not Input.is_key_pressed(KEY_ALT)
+			and mouse_over_width_handle == -1
+			and mouse_over_key == -1
+		):
+			mouse_over_key = closest_key
+
+		on_width_handle = false
+		if mouse_over_key != -1:
+			on_edge = false
+			current_action = select_verticies([mouse_over_key], ACTION_VERT.NONE)
+		elif mouse_over_width_handle != -1:
+			on_edge = false
+			on_width_handle = true
+			current_action = select_verticies([mouse_over_width_handle], ACTION_VERT.NONE)
+		elif Input.is_key_pressed(KEY_ALT):
+			_input_find_closest_edge_keys(mm)
+		else:
+			deselect_verts()
+			on_edge = _input_motion_is_on_edge(mm, grab_threshold)
+
+	elif current_mode == MODE.EDIT_EDGE:
+		# Don't update if edge panel is visible
+		if gui_edge_info_panel.visible:
+			return false
+		var type = current_action.type
+		if type == ACTION_VERT.MOVE_VERT:
+			return _input_motion_move_verts(delta)
+		else:
+			deselect_verts()
+		on_edge = _input_motion_is_on_edge(mm, grab_threshold)
+
+	update_overlays()
+	return false
+
+
+func _get_vert_normal(t: Transform2D, verts, i: int):
+	var point: Vector2 = t.xform(verts[i])
+	var prev_point: Vector2 = t.xform(verts[(i - 1) % verts.size()])
+	var next_point: Vector2 = t.xform(verts[(i + 1) % verts.size()])
+	return ((prev_point - point).normalized().rotated(PI / 2) + (point - next_point).normalized().rotated(PI / 2)).normalized()
+
+
+func copy_shape(shape):
+	var copy: SS2D_Shape_Base
+	if shape is SS2D_Shape_Closed:
+		copy = SS2D_Shape_Closed.new()
+	if shape is SS2D_Shape_Open:
+		copy = SS2D_Shape_Open.new()
+	if shape is SS2D_Shape_Meta:
+		copy = SS2D_Shape_Meta.new()
+	copy.position = shape.position
+	copy.scale = shape.scale
+	copy.modulate = shape.modulate
+	copy.shape_material = shape.shape_material
+	copy.editor_debug = shape.editor_debug
+	copy.flip_edges = shape.flip_edges
+	copy.editor_debug = shape.editor_debug
+	copy.collision_size = shape.collision_size
+	copy.collision_offset = shape.collision_offset
+	copy.tessellation_stages = shape.tessellation_stages
+	copy.tessellation_tolerence = shape.tessellation_tolerence
+	copy.curve_bake_interval = shape.curve_bake_interval
+	copy.material_overrides = shape.material_overrides
+
+	shape.get_parent().add_child(copy)
+	copy.set_owner(get_tree().get_edited_scene_root())
+
+	if (
+		shape.collision_polygon_node_path != ""
+		and shape.has_node(shape.collision_polygon_node_path)
+	):
+		var collision_polygon_original = shape.get_node(shape.collision_polygon_node_path)
+		var collision_polygon_new = CollisionPolygon2D.new()
+		collision_polygon_new.visible = collision_polygon_original.visible
+
+		collision_polygon_original.get_parent().add_child(collision_polygon_new)
+		collision_polygon_new.set_owner(get_tree().get_edited_scene_root())
+
+		copy.collision_polygon_node_path = copy.get_path_to(collision_polygon_new)
+
+	return copy
+
+
+func is_shape_closed(shape):
+	if shape is SS2D_Shape_Open:
+		return false
+	if shape is SS2D_Shape_Meta:
+		return shape.treat_as_closed()
+	return true
+
+
+#########
+# DEBUG #
+#########
+func _debug_mouse_positions(mm, t):
+	print("========================================")
+	print("MouseDelta:%s" % str(_mouse_motion_delta_starting_pos))
+	print("= MousePositions =")
+	print("Position:  %s" % str(mm.position))
+	print("Relative:  %s" % str(mm.relative))
+	print("= Transforms =")
+	print("Transform: %s" % str(t))
+	print("Inverse:   %s" % str(t.affine_inverse()))
+	print("= Transformed Mouse positions =")
+	print("Position:  %s" % str(t.affine_inverse().xform(mm.position)))
+	print("Relative:  %s" % str(t.affine_inverse().xform(mm.relative)))
+	print("MouseDelta:%s" % str(t.affine_inverse().xform(_mouse_motion_delta_starting_pos)))