@tool
@icon("../assets/closed_shape.png")
extends Node2D
class_name SS2D_Shape

## Represents the base functionality for all smart shapes.

# Functions consist of the following categories:[br]
#  - Setters / Getters
#  - Curve
#  - Curve Wrapper
#  - Godot
#  - Misc
#
# To use search to jump between categories, use the regex: # .+ #

################
#-DECLARATIONS-#
################

const CLICK_RECT_TAG := "__ss2d_click_rect__"

var _dirty: bool = false
var _edges: Array[SS2D_Edge] = []
var _collision_polygon_node: CollisionPolygon2D
# Whether or not the plugin should allow editing this shape
var can_edit: bool = true
var _renderer: SS2D_Renderer
var _click_rect: ColorRect
var _first_update: bool = true

signal points_modified
signal on_dirty_update
signal make_unique_pressed(shape: SS2D_Shape)

enum CollisionGenerationMethod {
	## Uses the shape curve to generate a collision polygon.
	Default,
	## Uses the edge generation algorithm to create a collision representation that sometimes
	## matches the shape's visuals more accurately.
	## This method is much slower and less consistent than [enum Default]. It should not be used
	## unless absolutely needed.
	Legacy,
	## Same as [enum Default] but only generates edge collisions and keeps the inside open.
	## Only relevant for closed shapes. Behaves the same as [enum Default] for open shapes.
	Hollow,
}

enum CollisionUpdateMode {
	## Only update collisions in editor. If the corresponding CollisionPolygon2D is part of the same
	## scene, it will be saved automatically by Godot, hence no additional regeneration at runtime
	## is necessary, which reduces the loading times.
	## Does not work if the CollisionPolygon2D is part of an instanced scene, as only the scene root
	## node will be saved by Godot.
	Editor,
	## Only update collisions during runtime. Improves the shape-editing performance in editor but
	## increases loading times as collision generation is deferred to runtime.
	Runtime,
	## Update collisions both in editor and during runtime. This is the default behavior in older
	## SS2D versions.
	EditorAndRuntime,
}

###########
#-EXPORTS-#
###########

# Execute to refresh shape rendered geometry and textures.
@warning_ignore("unused_private_class_variable")
@export_placeholder("ActionProperty") var _refresh: String = "" : set = _refresh_action
#   ActionProperty will add a button to inspector to execute this action.
#   When non-empty string is passed into setter, action is considerd executed.

## Visualize generated quads and edges.
@export var editor_debug: bool = false : set = _set_editor_debug

## @deprecated
@export_range(1, 512) var curve_bake_interval: float = 20.0 :
	set(value):
		if value != _points.curve_bake_interval:
			SS2D_PluginFunctionality.show_point_array_deprecation_warning("curve_bake_interval")
			_points.curve_bake_interval = value
	get:
		return _points.curve_bake_interval

## How to treat color data. See [enum SS2D_Edge.COLOR_ENCODING].
@export var color_encoding: SS2D_Edge.COLOR_ENCODING = SS2D_Edge.COLOR_ENCODING.COLOR : set = set_color_encoding

@export_group("Geometry")

# Execute to make shape point geometry unique (not materials).
@warning_ignore("unused_private_class_variable")
@export_placeholder("ActionProperty") var _make_unique: String = "" : set = _make_unique_action
#   ActionProperty will add a button to inspector to execute this action.
#   When non-empty string is passed into setter, action is considerd executed.

## Resource that holds shape point geometry (aka point array).
@export var _points: SS2D_Point_Array : set = set_point_array

## Caches generated meshes for faster loading times.
@export_storage var _meshes: Array[SS2D_Mesh] = []

@export_group("Edges")

@export var flip_edges: bool = false : set = set_flip_edges

## Enable/disable rendering of the edges.
@export var render_edges: bool = true : set = set_render_edges

@export_group("Materials")

## Contains textures and data on how to visualize the shape.
@export var shape_material := SS2D_Material_Shape.new() : set = _set_material

## Dictionary of (Array of 2 keys) to (SS2D_Material_Edge_Metadata)
## Deprecated, exists for Support of older versions
## @deprecated
@export var material_overrides: Dictionary = {} : set = set_material_overrides

@export_group("Tesselation")

## Controls how many subdivisions a curve segment may face before it is considered
## approximate enough.
## @deprecated
@export_range(0, 8, 1)
var tessellation_stages: int = 3 :
	set(value):
		if value != _points.tessellation_stages:
			SS2D_PluginFunctionality.show_point_array_deprecation_warning("tesselation_stages")
			_points.tessellation_stages = value
	get:
		return _points.tessellation_stages

## Controls how many degrees the midpoint of a segment may deviate from the real
## curve, before the segment has to be subdivided.
## @deprecated
@export_range(0.1, 16.0, 0.1, "or_greater", "or_lesser")
var tessellation_tolerence: float = 6.0 :
	set(value):
		if value != _points.tessellation_tolerance:
			SS2D_PluginFunctionality.show_point_array_deprecation_warning("tesselation_tolerance")
			_points.tessellation_tolerance = value
	get:
		return _points.tessellation_tolerance

@export_group("Collision")

## Controls which method should be used to generate the collision shape.
@export var collision_generation_method := CollisionGenerationMethod.Default : set = set_collision_generation_method

## Controls when to update collisions.
@export var collision_update_mode := CollisionUpdateMode.Editor : set = set_collision_update_mode

## Controls size of generated polygon for CollisionPolygon2D.
@export var collision_size: float = 32 : set = set_collision_size

## Controls offset of generated polygon for CollisionPolygon2D.
@export var collision_offset: float = 0.0 : set = set_collision_offset

## NodePath to CollisionPolygon2D node for which polygon data will be generated.
@export_node_path("CollisionPolygon2D") var collision_polygon_node_path: NodePath : set = set_collision_polygon_node_path

#####################
#-SETTERS / GETTERS-#
#####################

func set_collision_polygon_node_path(value: NodePath) -> void:
	collision_polygon_node_path = value
	set_as_dirty()

	if not is_inside_tree():
		return

	if collision_polygon_node_path.is_empty():
		_collision_polygon_node = null
		return

	_collision_polygon_node = get_node(collision_polygon_node_path) as CollisionPolygon2D

	if not _collision_polygon_node:
		push_error("collision_polygon_node_path should point to proper CollisionPolygon2D node.")


func get_collision_polygon_node() -> CollisionPolygon2D:
	return _collision_polygon_node


func get_point_array() -> SS2D_Point_Array:
	return _points


func set_point_array(a: SS2D_Point_Array) -> void:
	if _points != null:
		if _points.is_connected("update_finished", self._points_modified):
			_points.disconnect("update_finished", self._points_modified)
		if _points.material_override_changed.is_connected(_handle_material_override_change):
			_points.material_override_changed.disconnect(_handle_material_override_change)
	if a == null:
		a = SS2D_Point_Array.new()
	_points = a
	_points.connect("update_finished", self._points_modified)
	_points.material_override_changed.connect(_handle_material_override_change)
	set_as_dirty()
	notify_property_list_changed()


func _refresh_action(value: String) -> void:
	if value.length() > 0:
		_points_modified()


func _make_unique_action(value: String) -> void:
	if value.length() > 0:
		make_unique_pressed.emit(self)


func set_flip_edges(b: bool) -> void:
	flip_edges = b
	set_as_dirty()
	notify_property_list_changed()


func set_render_edges(b: bool) -> void:
	render_edges = b
	set_as_dirty()
	notify_property_list_changed()


func set_collision_generation_method(value: CollisionGenerationMethod) -> void:
	collision_generation_method = value
	set_as_dirty()


func set_collision_update_mode(value: CollisionUpdateMode) -> void:
	collision_update_mode = value
	set_as_dirty()


func set_collision_size(s: float) -> void:
	collision_size = s
	set_as_dirty()


func set_collision_offset(s: float) -> void:
	collision_offset = s
	set_as_dirty()


## Deprecated. Use get_point_array().set_from_curve() instead.
## @deprecated
func set_curve(curve: Curve2D) -> void:
	SS2D_PluginFunctionality.show_deprecation_warning("set_curve()", "get_point_array().set_from_curve()")
	_points.set_from_curve(curve)


## Deprecated. Use get_point_array().get_curve() instead.
## @deprecated
func get_curve() -> Curve2D:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("get_curve()")
	return _points.get_curve()


func _set_editor_debug(value: bool) -> void:
	editor_debug = value
	queue_redraw()


## Deprecated. Use get_point_array().tessellation_stages instead.
## @deprecated
func set_tessellation_stages(value: int) -> void:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("set_tessellation_stages()")
	_points.tessellation_stages = value


## Deprecated. Use get_point_array().tessellation_tolerance instead.
## @deprecated
func set_tessellation_tolerence(value: float) -> void:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("set_tessellation_tolerance()")
	_points.tessellation_tolerance = value


## Deprecated. Use get_point_array().curve_bake_interval instead.
## @deprecated
func set_curve_bake_interval(f: float) -> void:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("set_curve_bake_interval()")
	_points.curve_bake_interval = f


func set_color_encoding(i: SS2D_Edge.COLOR_ENCODING) -> void:
	color_encoding = i
	notify_property_list_changed()
	set_as_dirty()


func _set_material(value: SS2D_Material_Shape) -> void:
	if (
		shape_material != null
		and shape_material.is_connected("changed", self._handle_material_change)
	):
		shape_material.disconnect("changed", self._handle_material_change)

	shape_material = value
	if shape_material != null:
		shape_material.connect("changed", self._handle_material_change)
	set_as_dirty()
	notify_property_list_changed()


func set_material_overrides(dict: Dictionary) -> void:
	material_overrides = {}
	if dict.is_empty():
		return
	_points.set_material_overrides(dict)


#########
#-CURVE-#
#########

## Deprecated. Use get_point_array().get_vertices() instead.
## @deprecated
func get_vertices() -> PackedVector2Array:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("get_vertices()")
	return _points.get_vertices()


## Deprecated. Use get_point_array().get_tessellated_points() instead.
## @deprecated
func get_tessellated_points() -> PackedVector2Array:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("get_tessellated_points()")
	return _points.get_tessellated_points()


## Deprecated. Use get_point_array().invert_point_order() instead.
## @deprecated
func invert_point_order() -> void:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("invert_point_order()")
	_points.invert_point_order()


## Deprecated. Use get_point_array().clear() instead.
## @deprecated
func clear_points() -> void:
	SS2D_PluginFunctionality.show_deprecation_warning("clear_points()", "shape.get_point_array().clear()")
	_points.clear()


## Deprecated. This is now integrated in get_point_array().add_point().
## @deprecated
func adjust_add_point_index(index: int) -> int:
	SS2D_PluginFunctionality.show_deprecation_warning("adjust_add_point_index()", "")
	return _points._adjust_add_point_index(index)


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func add_points(verts: PackedVector2Array, starting_index: int = -1, key: int = -1) -> PackedInt32Array:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("add_points()")
	return _points.add_points(verts, starting_index, key)


## Deprecated. Use get_point_array().add_point() instead.
## @deprecated
func add_point(pos: Vector2, index: int = -1, key: int = -1) -> int:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("add_point()")
	return _points.add_point(pos, adjust_add_point_index(index), key)


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func is_shape_closed() -> bool:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("is_shape_closed()")
	return _points.is_shape_closed()


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func can_close() -> bool:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("can_close()")
	return _points.can_close()


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func close_shape(key: int = -1) -> int:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("close_shape()")
	return _points.close_shape(key)


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func open_shape_at_edge(edge_start_idx: int) -> void:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("open_shape_at_edge()")
	_points.open_shape_at_edge(edge_start_idx)


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func undo_open_shape_at_edge(edge_start_idx: int, closing_index: int) -> void:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("undo_open_shape_at_edge()")
	_points.undo_open_shape_at_edge(edge_start_idx, closing_index)


## Deprecated. Use get_point_array().begin_update() instead.
## @deprecated
func begin_update() -> void:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("begin_update()")
	_points.begin_update()


## Deprecated. Use get_point_array().end_update() instead.
## @deprecated
func end_update() -> void:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("end_update()")
	_points.end_update()


## Deprecated. Use get_point_array().is_updating() instead.
## @deprecated
func is_updating() -> bool:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("is_updating()")
	return _points.is_updating()


## Deprecated. Use get_point_array().get_next_key() instead.
## @deprecated
func get_next_key() -> int:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("get_next_key()")
	return _points.get_next_key()


## Deprecated. Use get_point_array().reserve_key() instead.
## @deprecated
func reserve_key() -> int:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("reserve_key()")
	return _points.reserve_key()


func _points_modified() -> void:
	set_as_dirty()
	points_modified.emit()


func _is_array_index_in_range(a: Array, i: int) -> bool:
	return a.size() > i and i >= 0;


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func is_index_in_range(idx: int) -> bool:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("is_index_in_range()")
	return _points.is_index_in_range(idx)


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func set_point_position(key: int, pos: Vector2) -> void:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("set_point_position()")
	_points.set_point_position(key, pos)


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func remove_point(key: int) -> void:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("remove_point()")
	_points.remove_point(key)


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func remove_point_at_index(idx: int) -> void:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("remove_point_at_index()")
	_points.remove_point_at_index(idx)


func clone(clone_point_array: bool = true) -> SS2D_Shape:
	var copy := SS2D_Shape.new()
	copy.transform = transform
	copy.modulate = modulate
	copy.shape_material = shape_material
	copy.editor_debug = editor_debug
	copy.flip_edges = flip_edges
	copy.collision_size = collision_size
	copy.collision_offset = collision_offset
	#copy.material_overrides = s.material_overrides
	copy.name = get_name().rstrip("0123456789")
	if clone_point_array:
		copy.set_point_array(_points.clone(true))
	return copy


#######################
#-POINT ARRAY WRAPPER-#
#######################

## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func has_point(key: int) -> bool:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("has_point()")
	return _points.has_point(key)


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func get_all_point_keys() -> PackedInt32Array:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("get_all_point_keys()")
	return _points.get_all_point_keys()


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func get_point_key_at_index(idx: int) -> int:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("get_point_key_at_index()")
	return _points.get_point_key_at_index(idx)


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func get_point_at_index(idx: int) -> SS2D_Point:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("get_point_at_index()")
	return _points.get_point_at_index(idx)


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func get_point_index(key: int) -> int:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("get_point_index()")
	return _points.get_point_index(key)


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func set_point_in(key: int, v: Vector2) -> void:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("set_point_in()")
	_points.set_point_in(key, v)


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func set_point_out(key: int, v: Vector2) -> void:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("set_point_out()")
	_points.set_point_out(key, v)


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func get_point_in(key: int) -> Vector2:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("get_point_in()")
	return _points.get_point_in(key)


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func get_point_out(key: int) -> Vector2:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("get_point_out()")
	return _points.get_point_out(key)


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func get_closest_point(to_point: Vector2) -> Vector2:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("get_closest_point()")
	return _points.get_closest_point(to_point)


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func get_closest_point_straight_edge(to_point: Vector2) -> Vector2:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("get_closest_point_straight_edge()")
	return _points.get_closest_point_straight_edge(to_point)


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func get_closest_offset_straight_edge(to_point: Vector2) -> float:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("get_closest_offset_straight_edge()")
	return _points.get_closest_offset_straight_edge(to_point)


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func get_closest_offset(to_point: Vector2) -> float:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("get_closest_offset()")
	return _points.get_closest_offset(to_point)


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func disable_constraints() -> void:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("disable_constraints()")
	_points.disable_constraints()


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func enable_constraints() -> void:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("enable_constraints()")
	_points.enable_constraints()


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func get_point_count() -> int:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("get_point_count()")
	return _points.get_point_count()


func get_edges() -> Array[SS2D_Edge]:
	return _edges


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func get_point_position(key: int) -> Vector2:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("get_point_position()")
	return _points.get_point_position(key)


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func get_point(key: int) -> SS2D_Point:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("get_point()")
	return _points.get_point(key)


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func get_point_constraints(key: int) -> Dictionary:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("get_point_constraints()")
	return _points.get_point_constraints(key)


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func get_point_constraint(key1: int, key2: int) -> SS2D_Point_Array.CONSTRAINT:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("get_point_constraint()")
	return _points.get_point_constraint(key1, key2)


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func set_constraint(key1: int, key2: int, c: SS2D_Point_Array.CONSTRAINT) -> void:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("set_constraint()")
	_points.set_constraint(key1, key2, c)


## Deprecated.
## @deprecated
func set_point(key: int, value: SS2D_Point) -> void:
	SS2D_PluginFunctionality.show_deprecation_warning("set_point()", "")
	_points.set_point(key, value)


## Deprecated. Use respective property in get_point_array().get_point() instead.
## @deprecated
func set_point_width(key: int, w: float) -> void:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("set_point_width()")
	_points.get_point(key).width = w


## Deprecated. Use respective property in get_point_array().get_point() instead.
## @deprecated
func get_point_width(key: int) -> float:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("get_point_width()")
	return _points.get_point(key).width


## Deprecated. Use respective property in get_point_array().get_point() instead.
## @deprecated
func set_point_texture_index(key: int, tex_idx: int) -> void:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("set_point_texture_index()")
	_points.get_point(key).texture_idx = tex_idx


## Deprecated. Use respective property in get_point_array().get_point() instead.
## @deprecated
func get_point_texture_index(key: int) -> int:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("get_point_texture_index()")
	return _points.get_point(key).texture_idx


## Deprecated. Use respective property in get_point_array().get_point() instead.
## @deprecated
func set_point_texture_flip(key: int, flip: bool) -> void:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("set_point_texture_flip()")
	_points.get_point(key).flip = flip


## Deprecated. Use respective property in get_point_array().get_point() instead.
## @deprecated
func get_point_texture_flip(key: int) -> bool:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("get_point_texture_flip()")
	return _points.get_point(key).flip


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func get_point_properties(key: int) -> SS2D_VertexProperties:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("get_point_properties()")
	return _points.get_point_properties(key)


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func set_point_properties(key: int, properties: SS2D_VertexProperties) -> void:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("set_point_properties()")
	_points.set_point_properties(key, properties)


#########
#-GODOT-#
#########

func _init() -> void:
	set_point_array(SS2D_Point_Array.new())


func _enter_tree() -> void:
	# Call this again because get_node() only works when the node is inside the tree
	set_collision_polygon_node_path(collision_polygon_node_path)

	# Handle material changes if scene is (re-)entered (e.g. after switching to another)
	if shape_material != null:
		if not shape_material.is_connected("changed", self._handle_material_change):
			shape_material.connect("changed", self._handle_material_change)


func _ready() -> void:
	# This must run in _ready() because the shape node itself must be ready and registered at the RenderingServer.
	_renderer = SS2D_Renderer.new(self)

	if Engine.is_editor_hint():
		_setup_click_rect()


func _draw() -> void:
	if editor_debug and Engine.is_editor_hint():
		_draw_debug(SS2D_Shape.sort_by_z_index(_edges))


func _draw_debug(edges: Array[SS2D_Edge]) -> void:
	for e in edges:
		for q in e.quads:
			q.render_lines(self)

		var _range := range(0, e.quads.size(), 1)
		for i: int in _range:
			var q := e.quads[i]
			if not (i % 3 == 0):
				continue
			q.render_points(3, 0.5, self)

		for i: int in _range:
			var q := e.quads[i]
			if not ((i + 1) % 3 == 0):
				continue
			q.render_points(2, 0.75, self)

		for i: int in _range:
			var q := e.quads[i]
			if not ((i + 2) % 3 == 0):
				continue
			q.render_points(1, 1.0, self)


func _exit_tree() -> void:
	if shape_material != null:
		if shape_material.is_connected("changed", self._handle_material_change):
			shape_material.disconnect("changed", self._handle_material_change)


############
#-GEOMETRY-#
############


func should_flip_edges() -> bool:
	if _points.is_shape_closed():
		return (_points.are_points_clockwise() == flip_edges)
	else:
		return flip_edges


func bake_collision() -> void:
	if not _collision_polygon_node:
		return

	if collision_update_mode == CollisionUpdateMode.Editor and not Engine.is_editor_hint() \
			or collision_update_mode == CollisionUpdateMode.Runtime and Engine.is_editor_hint():
		return

	if _points.get_point_count() < 2:
		_collision_polygon_node.polygon = PackedVector2Array()
		return

	var generated_points: PackedVector2Array
	var input_points := _points.get_tessellated_points()
	var gen := SS2D_CollisionGen.new()
	gen.collision_size = collision_size
	gen.collision_offset = collision_offset

	match collision_generation_method:
		CollisionGenerationMethod.Legacy:
			generated_points = gen.generate_legacy(self)

		CollisionGenerationMethod.Hollow:
			if _points.is_shape_closed():
				generated_points = gen.generate_hollow(input_points)
			else:
				generated_points = gen.generate_open(input_points)

		CollisionGenerationMethod.Default:
			if _points.is_shape_closed():
				generated_points = gen.generate_filled(input_points)
			else:
				generated_points = gen.generate_open(input_points)

	# Always apply xform afterwards so node scaling also affects collision offset and size
	var xform := _collision_polygon_node.get_global_transform().affine_inverse() * get_global_transform()
	generated_points = xform * generated_points

	if generated_points.size() > 1 and generated_points[0] == generated_points[-1]:
		generated_points.resize(generated_points.size() - 1)

	_collision_polygon_node.polygon = generated_points


func _build_meshes() -> void:
	if _points == null or shape_material == null or _points.get_point_count() < 2:
		_edges.clear()
		_meshes.clear()
		return

	# Reuse SS2D_Mesh objects to reduce VCS noise due to ever-changing IDs even if there was no change.
	var mesh_idx: int = 0

	mesh_idx = _build_fill_mesh(_points.get_tessellated_points(), shape_material, _meshes, mesh_idx)

	if render_edges:
		# TODO: Do not create individual meshes for each edge, corner, taper, etc. Merge meshes with same properties.
		_edges = _build_edges(shape_material, _points.get_vertices())

		for e in _edges:
			mesh_idx = e.get_meshes(color_encoding, _meshes, mesh_idx)
	else:
		_edges.clear()

	_meshes.resize(mesh_idx)  # Trim if larger


## Generates a fill mesh if applicable and stores it in the given mesh buffer.
## Only visible meshes are generated, meshes without a texture are skipped.
## Returns the resulting buffer index, i.e. the next index after the last added mesh.
func _build_fill_mesh(points: PackedVector2Array, s_mat: SS2D_Material_Shape, mesh_buffer: Array[SS2D_Mesh], buffer_idx: int) -> int:
	if not _points.is_shape_closed() or \
			s_mat == null or \
			s_mat.fill_textures.is_empty() or \
			points.size() < 3:
		return buffer_idx

	# TODO: Support all fill textures not just the first
	var tex: Texture2D = s_mat.fill_textures[0]

	if tex == null:
		return buffer_idx

	var tex_size: Vector2 = tex.get_size()
	points = Geometry2D.offset_polygon(points, tex_size.x * s_mat.fill_mesh_offset).front()
	var indices: PackedInt32Array = Geometry2D.triangulate_polygon(points)

	if indices.is_empty():
		push_error("'%s': Couldn't Triangulate shape" % name)
		return buffer_idx

	var arrays := []
	arrays.resize(Mesh.ARRAY_MAX)
	arrays[Mesh.ARRAY_VERTEX] = points
	arrays[Mesh.ARRAY_INDEX] = indices

	var uv_points: PackedVector2Array = _get_uv_points(points, s_mat, tex_size)
	arrays[Mesh.ARRAY_TEX_UV] = uv_points
	arrays[Mesh.ARRAY_TEX_UV2] = uv_points

	var colors := PackedColorArray()
	colors.resize(points.size())
	colors.fill(Color.WHITE)
	arrays[Mesh.ARRAY_COLOR] = colors

	var st := SurfaceTool.new()
	st.create_from_arrays(arrays, Mesh.PRIMITIVE_TRIANGLES)
	st.generate_normals()
	st.generate_tangents()

	var mesh := SS2D_Common_Functions.mesh_buffer_get_or_create(mesh_buffer, buffer_idx)
	st.commit(mesh.mesh)
	mesh.texture = tex
	mesh.material = s_mat.fill_mesh_material
	mesh.z_index = s_mat.fill_texture_z_index
	mesh.show_behind_parent = s_mat.fill_texture_show_behind_parent
	buffer_idx += 1

	return buffer_idx


func _get_uv_points(
	points: PackedVector2Array,
	s_material: SS2D_Material_Shape,
	tex_size: Vector2
) -> PackedVector2Array:
	var transformation: Transform2D = global_transform

	# If relative position ... undo translation from global_transform
	if not s_material.fill_texture_absolute_position:
		transformation = transformation.translated(-global_position)

	# Scale
	var tex_scale := 1.0 / s_material.fill_texture_scale
	transformation = transformation.scaled(Vector2(tex_scale, tex_scale))

	# If relative rotation ... undo rotation from global_transform
	if not s_material.fill_texture_absolute_rotation:
		transformation = transformation.rotated(-global_rotation)

	# Rotate the desired extra amount
	transformation = transformation.rotated(-deg_to_rad(s_material.fill_texture_angle_offset))

	# Shift the desired amount (adjusted so it's scale independent)
	transformation = transformation.translated(-s_material.fill_texture_offset / s_material.fill_texture_scale)

	# Convert local space to UV
	transformation = transformation.scaled(Vector2(1 / tex_size.x, 1 / tex_size.y))

	return transformation * points


## Given three colinear points p, q, r, the function checks if point q lies on line segment 'pr'.[br]
## See: https://www.geeksforgeeks.org/check-if-two-given-line-segments-intersect/
static func on_segment(p: Vector2, q: Vector2, r: Vector2) -> bool:
	return (
		q.x <= maxf(p.x, r.x)
		and q.x >= minf(p.x, r.x)
		and q.y <= maxf(p.y, r.y)
		and q.y >= minf(p.y, r.y)
	)


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
static func get_points_orientation(points: PackedVector2Array) -> SS2D_Point_Array.ORIENTATION:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("get_points_orientation()")
	return SS2D_Point_Array.get_points_orientation(points)


## Deprecated. Use respective function in get_point_array() instead.
## @deprecated
func are_points_clockwise() -> bool:
	SS2D_PluginFunctionality.show_point_array_deprecation_warning("are_points_clockwise()")
	return _points.are_points_clockwise()


static func build_quad_from_two_points(
	pt: Vector2,
	pt_next: Vector2,
	tex: Texture2D,
	width: float,
	flip_x: bool,
	flip_y: bool,
	first_point: bool,
	last_point: bool,
	custom_offset: float,
	custom_extends: float,
	fit_texture: SS2D_Material_Edge.FITMODE
) -> SS2D_Quad:
	# Create new quad
	var quad := SS2D_Quad.new()
	quad.texture = tex
	quad.color = Color(1.0, 1.0, 1.0, 1.0)
	quad.flip_texture = flip_x
	quad.fit_texture = fit_texture

	# Calculate the normal
	var delta: Vector2 = pt_next - pt
	var delta_normal := delta.normalized()
	var normal_direction := Vector2(delta.y, -delta.x).normalized()
	var normal_length: float = width
	var normal_with_magnitude: Vector2 = normal_direction * (normal_length * 0.5)
	if flip_y:
		normal_with_magnitude *= -1
	var offset: Vector2 = normal_with_magnitude * custom_offset

	# If is first or last point, extend past the normal boundary by 'custom_extends' pixels
	if first_point:
		pt -= (delta_normal * custom_extends)
	if last_point:
		pt_next += (delta_normal * custom_extends)

	##############################################
	# QUAD POINT ILLUSTRATION #                  #
	##############################################
	#                LENGTH                      #
	#           <-------------->                 #
	#      pt_a -> O--------O <- pt_d  ▲         #
	#              |        |          |         #
	#              |   pt   |          | WIDTH   #
	#              |        |          |         #
	#      pt_b -> O--------O <- pt_c  ▼         #
	##############################################
	##############################################

	quad.pt_a = pt + normal_with_magnitude + offset
	quad.pt_b = pt - normal_with_magnitude + offset
	quad.pt_c = pt_next - normal_with_magnitude + offset
	quad.pt_d = pt_next + normal_with_magnitude + offset

	return quad


## Builds a corner quad. [br]
## - [param pt] is the center of this corner quad. [br]
## - [param width] will scale the quad in line with the next point (one dimension). [br]
## - [param prev_width] will scale the quad in line with the prev point (hte other dimension). [br]
## - [param custom_scale] will scale the quad in both dimensions. [br]
static func build_quad_corner(
	pt_next: Vector2,
	pt: Vector2,
	pt_prev: Vector2,
	pt_width: float,
	pt_prev_width: float,
	flip_edges_: bool,
	corner_status: int,
	tex: Texture2D,
	size: Vector2,
	custom_scale: float,
	custom_offset: float
) -> SS2D_Quad:
	var new_quad := SS2D_Quad.new()

	#             :BUILD PLAN:
	#   OUTER CORNER        INNER CORNER
	#
	#   0------A-----D             0-----0
	#   |  1   :  2  |             |  3  :
	#   0......B.....C             |     :
	#          :     |     0-------D-----A
	#          :  3  |     |  1    |  2  :
	#          0-----0     0.......C.....B
	#
	#  1-previous, 2-current, 3-next (points)

	var quad_size: Vector2 = size * 0.5
	var dir_12: Vector2 = (pt - pt_prev).normalized()
	var dir_23: Vector2 = (pt_next - pt).normalized()
	var offset_12: Vector2 = dir_12 * custom_scale * pt_width * quad_size
	var offset_23: Vector2 = dir_23 * custom_scale * pt_prev_width * quad_size
	var custom_offset_13: Vector2 = (dir_12 - dir_23) * custom_offset * quad_size

	if flip_edges_:
		offset_12 *= -1
		offset_23 *= -1
		custom_offset_13 *= -1

	# Should we mirror internal ABCD vertices relative to quad center.
	# - Historically, quad internal vertices are flipped for inner corner quads (see illustration).
	# - Value: 1.0 for outer, -1.0 for inner (mirrored).
	var mirror: float = -1.0 if corner_status == SS2D_Quad.CORNER.INNER else 1.0

	new_quad.pt_a = pt + (-offset_12 - offset_23 + custom_offset_13) * mirror
	new_quad.pt_b = pt + (-offset_12 + offset_23 + custom_offset_13) * mirror
	new_quad.pt_c = pt + (offset_12 + offset_23 + custom_offset_13) * mirror
	new_quad.pt_d = pt + (offset_12 - offset_23 + custom_offset_13) * mirror

	new_quad.corner = corner_status
	new_quad.texture = tex

	return new_quad


func _get_width_for_tessellated_point(
	points: PackedVector2Array,
	t_idx: int
) -> float:
	var v_idx := _points.get_tesselation_vertex_mapping().tess_to_vertex_index(t_idx)
	var v_idx_next := SS2D_PluginFunctionality.get_next_point_index(v_idx, points)
	var w1: float = _points.get_point(_points.get_point_key_at_index(v_idx)).width
	var w2: float = _points.get_point(_points.get_point_key_at_index(v_idx_next)).width
	var ratio: float = get_ratio_from_tessellated_point_to_vertex(t_idx)
	return lerp(w1, w2, ratio)


## Mutates two quads to be welded.[br]
## Returns the midpoint of the weld.[br]
static func weld_quads(a: SS2D_Quad, b: SS2D_Quad, custom_scale: float = 1.0) -> Vector2:
	var midpoint := Vector2(0, 0)
	# If both quads are not a corner
	if a.corner == SS2D_Quad.CORNER.NONE and b.corner == SS2D_Quad.CORNER.NONE:
		var needed_height: float = (a.get_height_average() + b.get_height_average()) / 2.0

		var pt1: Vector2 = (a.pt_d + b.pt_a) * 0.5
		var pt2: Vector2 = (a.pt_c + b.pt_b) * 0.5

		midpoint = Vector2(pt1 + pt2) / 2.0
		var half_line: Vector2 = (pt2 - midpoint).normalized() * needed_height * custom_scale / 2.0

		if half_line != Vector2.ZERO:
			pt2 = midpoint + half_line
			pt1 = midpoint - half_line

		a.pt_d = pt1
		a.pt_c = pt2
		b.pt_a = pt1
		b.pt_b = pt2

	# If either quad is a corner
	else:
		if a.corner == SS2D_Quad.CORNER.OUTER:
			b.pt_a = a.pt_c
			b.pt_b = a.pt_b
			midpoint = (b.pt_a + b.pt_b) / 2.0

		elif a.corner == SS2D_Quad.CORNER.INNER:
			b.pt_a = a.pt_d
			b.pt_b = a.pt_a
			midpoint = (b.pt_a + b.pt_b) / 2.0

		elif b.corner == SS2D_Quad.CORNER.OUTER:
			a.pt_d = b.pt_a
			a.pt_c = b.pt_b
			midpoint = (a.pt_d + a.pt_c) / 2.0

		elif b.corner == SS2D_Quad.CORNER.INNER:
			a.pt_d = b.pt_d
			a.pt_c = b.pt_c
			midpoint = (a.pt_d + a.pt_c) / 2.0

	return midpoint


func _weld_quad_array(
	quads: Array[SS2D_Quad], weld_first_and_last: bool, start_idx: int = 0
) -> void:
	if quads.is_empty():
		return

	for index in range(start_idx, quads.size() - 1, 1):
		var this_quad: SS2D_Quad = quads[index]
		var next_quad: SS2D_Quad = quads[index + 1]
		if not this_quad.ignore_weld_next:
			SS2D_Shape.weld_quads(this_quad, next_quad)
		# If this quad self_intersects after welding, it's likely very small and can be removed
		# Usually happens when welding a very large and very small quad together
		# Generally looks better when simply being removed
		#
		# When welding and using different widths, quads can look a little weird
		# This is because they are no longer parallelograms
		# This is a tough problem to solve
		# See http://reedbeta.com/blog/quadrilateral-interpolation-part-1/
		if this_quad.self_intersects():
			quads.remove_at(index)
			if index < quads.size():
				var new_index: int = maxi(index - 1, 0)
				_weld_quad_array(quads, weld_first_and_last, new_index)
				return

	if weld_first_and_last:
		if not quads[-1].ignore_weld_next:
			SS2D_Shape.weld_quads(quads[-1], quads[0])


func _merge_index_maps(imaps: Array[SS2D_IndexMap], verts: PackedVector2Array) -> Array[SS2D_IndexMap]:
	if not _points.is_shape_closed():
		return imaps
	# See if any edges have both the first (0) and last idx (size)
	# Merge them into one if so
	var final_edges: Array[SS2D_IndexMap] = imaps.duplicate()
	var edges_by_material: Dictionary = SS2D_IndexMap.index_map_array_sort_by_object(final_edges)
	# Erase any with null material
	edges_by_material.erase(null)
	for mat: Variant in edges_by_material:
		var edge_first_idx: SS2D_IndexMap = null
		var edge_last_idx: SS2D_IndexMap = null
		for e: SS2D_IndexMap in edges_by_material[mat]:
			if e.indicies.has(0):
				edge_first_idx = e
			if e.indicies.has(verts.size()-1):
				edge_last_idx = e
			if edge_first_idx != null and edge_last_idx != null:
				break
		if edge_first_idx != null and edge_last_idx != null:
			if edge_first_idx == edge_last_idx:
				pass
			else:
				final_edges.erase(edge_last_idx)
				final_edges.erase(edge_first_idx)
				var indicies := edge_last_idx.indicies + edge_first_idx.indicies
				var merged_edge := SS2D_IndexMap.new(indicies, mat)
				final_edges.push_back(merged_edge)
	return final_edges


func _build_edges(s_mat: SS2D_Material_Shape, verts: PackedVector2Array) -> Array[SS2D_Edge]:
	var edges: Array[SS2D_Edge] = []
	if s_mat == null:
		return edges

	var index_maps: Array[SS2D_IndexMap] = _get_meta_material_index_mapping(s_mat, verts)
	var overrides: Array[SS2D_IndexMap] = SS2D_Shape.get_meta_material_index_mapping_for_overrides(s_mat, _points)

	# Remove the override indicies from the default index_maps
	for override in overrides:
		var old_to_new_imaps := {}
		for index_map in index_maps:
			var new_imaps: Array[SS2D_IndexMap] = index_map.remove_edges(override.indicies)
			old_to_new_imaps[index_map] = new_imaps
		for k: SS2D_IndexMap in old_to_new_imaps:
			index_maps.erase(k)
			for new_imap: SS2D_IndexMap in old_to_new_imaps[k]:
				index_maps.push_back(new_imap)

	# Merge index maps
	index_maps = _merge_index_maps(index_maps, verts)

	# Add the overrides to the mappings to be rendered
	index_maps.append_array(overrides)

	for index_map in index_maps:
		edges.push_back(_build_edge_with_material(index_map, s_mat.render_offset, 0.0))

	return edges


## Will return an array of SS2D_IndexMaps.[br]
## Each index map will map a set of indicies to a meta_material.[br]
static func get_meta_material_index_mapping_for_overrides(
	_s_material: SS2D_Material_Shape, pa: SS2D_Point_Array
) -> Array[SS2D_IndexMap]:
	var mappings: Array[SS2D_IndexMap] = []
	for key_tuple in pa.get_material_overrides():
		var indices := SS2D_IndexTuple.sort_ascending(Vector2i(pa.get_point_index(key_tuple.x), pa.get_point_index(key_tuple.y)))
		var m: SS2D_Material_Edge_Metadata = pa.get_material_override(key_tuple)
		var new_mapping := SS2D_IndexMap.new(PackedInt32Array([ indices.x, indices.y ]), m)
		mappings.push_back(new_mapping)

	return mappings


## Will return a dictionary containing array of SS2D_IndexMap.[br]
## Each element in the array is a contiguous sequence of indicies that fit inside
## the meta_material's normalrange.[br]
func _get_meta_material_index_mapping(
	s_material: SS2D_Material_Shape, verts: PackedVector2Array
) -> Array[SS2D_IndexMap]:
	return SS2D_Shape.get_meta_material_index_mapping(s_material, verts, _points.is_shape_closed())


static func get_meta_material_index_mapping(
	s_material: SS2D_Material_Shape, verts: PackedVector2Array, wrap_around: bool
) -> Array[SS2D_IndexMap]:
	var final_edges: Array[SS2D_IndexMap] = []
	var edge_building: Dictionary = {}  # Dict[SS2D_Material_Edge_Metadata, SS2D_IndexMap]
	for idx in range(0, verts.size() - 1, 1):
		var idx_next: int = SS2D_PluginFunctionality.get_next_point_index(idx, verts, wrap_around)
		var pt: Vector2 = verts[idx]
		var pt_next: Vector2 = verts[idx_next]
		var delta: Vector2 = pt_next - pt
		var normal := Vector2(delta.y, -delta.x).normalized()

		# Get all valid edge_meta_materials for this normal value
		var edge_meta_materials := s_material.get_edge_meta_materials(normal)

		# Append to existing edges being built. Add new ones if needed
		for e in edge_meta_materials:
			var imap: SS2D_IndexMap = edge_building.get(e)

			# Is exsiting, append
			if imap:
				if not idx_next in imap.indicies:
					imap.indicies.push_back(idx_next)
			# Isn't existing, make a new mapping
			else:
				edge_building[e] = SS2D_IndexMap.new([idx, idx_next], e)

		# Closeout and stop building edges that are no longer viable
		for e: SS2D_Material_Edge_Metadata in edge_building.keys():
			if not edge_meta_materials.has(e):
				final_edges.push_back(edge_building[e])
				edge_building.erase(e)

	# Closeout all edge building
	for e: SS2D_Material_Edge_Metadata in edge_building.keys():
		final_edges.push_back(edge_building[e])

	return final_edges

########
#-MISC-#
########
func _handle_material_change() -> void:
	set_as_dirty()


func _handle_material_override_change(_tuple: Vector2i) -> void:
	set_as_dirty()


func set_as_dirty() -> void:
	if not _dirty:
		call_deferred("_on_dirty_update")
	_dirty = true


static func sort_by_z_index(a: Array) -> Array:
	a.sort_custom(Callable(SS2D_Common_Functions, "sort_z"))
	return a


static func sort_by_int_ascending(a: Array) -> Array:
	a.sort_custom(Callable(SS2D_Common_Functions, "sort_int_ascending"))
	return a


func _on_dirty_update() -> void:
	if _dirty:
		force_update()
		on_dirty_update.emit()


func force_update() -> void:
	bake_collision()  # TODO: Get rid of CollisionUpdateMode and use _first_update as well.

	if not _first_update or not _meshes:
		_build_meshes()

	_renderer.render(_meshes)
	queue_redraw()  # Debug drawing
	_update_click_rect()

	_first_update = false
	_dirty = false


## Returns a float between 0.0 and 1.0.[br]
## 0.0 means that this tessellated point is at the same position as the vertex.[br]
## 0.5 means that this tessellated point is half-way between this vertex and the next.[br]
## 0.999 means that this tessellated point is basically at the next vertex.[br]
## 1.0 isn't going to happen; If a tess point is at the same position as a vert, it gets a ratio of 0.0.[br]
func get_ratio_from_tessellated_point_to_vertex(t_point_idx: int) -> float:
	# Index of the starting vertex
	var point_idx := _points.get_tesselation_vertex_mapping().tess_to_vertex_index(t_point_idx)
	# Index of the first tesselated point with the same vertex
	var tess_point_first_idx: int = _points.get_tesselation_vertex_mapping().vertex_to_tess_indices(point_idx)[0]
	# The total tessellated points with the same vertex
	var tess_point_count := _points.get_tesselation_vertex_mapping().vertex_to_tess_indices(point_idx).size()
	# The index of the passed t_point_idx relative to the starting vert
	var tess_index_count := t_point_idx - tess_point_first_idx
	return tess_index_count / float(tess_point_count)


func debug_print_points() -> void:
	_points.debug_print()


###################
#-EDGE GENERATION-#
###################

## Get Number of TessPoints from the start and end indicies of the index_map parameter.
func _edge_data_get_tess_point_count(index_map: SS2D_IndexMap) -> int:
	## TODO Test this function
	var count: int = 0
	for i in range(index_map.indicies.size() - 1):
		var this_idx := index_map.indicies[i]
		var next_idx := index_map.indicies[i + 1]
		if this_idx > next_idx:
			count += 1
			continue
		var this_t_idx: int = _points.get_tesselation_vertex_mapping().vertex_to_tess_indices(this_idx)[0]
		var next_t_idx: int = _points.get_tesselation_vertex_mapping().vertex_to_tess_indices(next_idx)[0]
		var delta: int = next_t_idx - this_t_idx
		count += delta
	return count


## This function determines if a corner quad should be generated.[br]
## if so, OUTER or INNER? [br]
## - The conditions deg < 0 and flip_edges are used to determine this.[br]
## - These conditions works correctly so long as the points are in Clockwise order.[br]
static func edge_should_generate_corner(pt_prev: Vector2, pt: Vector2, pt_next: Vector2, flip_edges_: bool) -> SS2D_Quad.CORNER:
	var generate_corner := SS2D_Quad.CORNER.NONE
	var ab: Vector2 = pt - pt_prev
	var bc: Vector2 = pt_next - pt
	var dot_prod: float = ab.dot(bc)
	var determinant: float = (ab.x * bc.y) - (ab.y * bc.x)
	var angle := atan2(determinant, dot_prod)
	# This angle has a range of 360 degrees
	# Is between 180 and - 180
	var deg := rad_to_deg(angle)
	var corner_range := 10.0
	var corner_angle := 90.0
	if absf(deg) >= corner_angle - corner_range and absf(deg) <= corner_angle + corner_range:
		var inner := false
		if deg < 0:
			inner = true
		if flip_edges_:
			inner = not inner
		if inner:
			generate_corner = SS2D_Quad.CORNER.INNER
		else:
			generate_corner = SS2D_Quad.CORNER.OUTER
	return generate_corner


func _edge_generate_corner(
	pt_prev: Vector2,
	pt: Vector2,
	pt_next: Vector2,
	width_prev: float,
	width: float,
	size: float,
	edge_material: SS2D_Material_Edge,
	texture_idx: int,
	c_scale: float,
	c_offset: float
) -> SS2D_Quad:
	var generate_corner := SS2D_Shape.edge_should_generate_corner(pt_prev, pt, pt_next, flip_edges)
	if generate_corner == SS2D_Quad.CORNER.NONE:
		return null
	var corner_texture: Texture2D = null
	if edge_material != null:
		if generate_corner == SS2D_Quad.CORNER.OUTER:
			corner_texture = edge_material.get_texture_corner_outer(texture_idx)
		elif generate_corner == SS2D_Quad.CORNER.INNER:
			corner_texture = edge_material.get_texture_corner_inner(texture_idx)
	var corner_quad: SS2D_Quad = SS2D_Shape.build_quad_corner(
		pt_next,
		pt,
		pt_prev,
		width,
		width_prev,
		flip_edges,
		generate_corner,
		corner_texture,
		Vector2(size, size),
		c_scale,
		c_offset
	)
	return corner_quad


func _imap_contains_all_points(imap: SS2D_IndexMap, verts: PackedVector2Array) -> bool:
	return imap.indicies[0] == 0 and imap.indicies[-1] == verts.size()-1


func _is_edge_contiguous(imap: SS2D_IndexMap, verts: PackedVector2Array) -> bool:
	if not _points.is_shape_closed():
		return false
	return _imap_contains_all_points(imap, verts)


# Will construct an SS2D_Edge from the passed parameters.
# index_map must be a SS2D_IndexMap with a SS2D_Material_Edge_Metadata for an object
# the indicies used by index_map should match up with the get_verticies() indicies
#
# default_quad_width is the quad width used if a texture isn't available
#
# c_offset is the magnitude to offset all of the points
# the direction of the offset is the surface_normal
func _build_edge_with_material(
	index_map: SS2D_IndexMap,  c_offset: float, default_quad_width: float
) -> SS2D_Edge:
	var verts_t: PackedVector2Array = _points.get_tessellated_points()
	var verts: PackedVector2Array = _points.get_vertices()
	var edge := SS2D_Edge.new()
	var is_edge_contiguous: bool = _is_edge_contiguous(index_map, verts)
	edge.wrap_around = is_edge_contiguous
	if not index_map.is_valid():
		return edge
	var c_scale := 1.0
	var c_extends := 0.0

	var edge_material_meta: SS2D_Material_Edge_Metadata = null
	var edge_material: SS2D_Material_Edge = null
	if index_map.object != null:
		edge_material_meta = index_map.object
		if edge_material_meta == null:
			return edge
		if not edge_material_meta.render:
			return edge
		edge_material = edge_material_meta.edge_material
		if edge_material == null:
			return edge
		c_offset += edge_material_meta.offset

		edge.z_index = edge_material_meta.z_index
		edge.z_as_relative = edge_material_meta.z_as_relative
		edge.material = edge_material_meta.edge_material.material

	var first_idx: int = index_map.indicies[0]
	var last_idx: int = index_map.indicies[-1]
	var first_idx_t: int = _points.get_tesselation_vertex_mapping().vertex_to_tess_indices(first_idx)[0]
	var last_idx_t: int = _points.get_tesselation_vertex_mapping().vertex_to_tess_indices(last_idx)[-1]
	edge.first_point_key = _points.get_point_key_at_index(first_idx)
	edge.last_point_key = _points.get_point_key_at_index(last_idx)

	var should_flip := should_flip_edges()

	# How many tessellated points are contained within this index map?
	var tess_point_count: int = _edge_data_get_tess_point_count(index_map)

	var i := 0
	var texture_idx := 0
	var sharp_taper_next: SS2D_Quad = null
	var is_not_corner: bool = true
	var taper_sharp: bool = edge_material_meta != null and edge_material_meta.taper_sharp_corners
	while i < tess_point_count:
		var tess_idx: int = (first_idx_t + i) % verts_t.size()
		var tess_idx_next: int = SS2D_PluginFunctionality.get_next_unique_point_idx(tess_idx, verts_t, true)
		var tess_idx_prev: int = SS2D_PluginFunctionality.get_previous_unique_point_idx(tess_idx, verts_t, true)

		# set next_point_delta
		# next_point_delta is the number of tess_pts from
		# the current tess_pt to the next unique tess_pt
		# unique meaning it has a different position from the current tess_pt
		var next_point_delta := 0
		for j in range(verts_t.size()):
			if ((tess_idx + j) % verts_t.size()) == tess_idx_next:
				next_point_delta = j
				break

		var vert_idx: int = _points.get_tesselation_vertex_mapping().tess_to_vertex_index(tess_idx)
		var vert_key: int = _points.get_point_key_at_index(vert_idx)
		var vert_props := _points.get_point(vert_key)
		var pt: Vector2 = verts_t[tess_idx]
		var pt_next: Vector2 = verts_t[tess_idx_next]
		var pt_prev: Vector2 = verts_t[tess_idx_prev]
		var flip_x: bool = vert_props.flip

		var width_scale: float = _get_width_for_tessellated_point(verts, tess_idx)
		var is_first_point: bool = (vert_idx == first_idx) and not is_edge_contiguous
		var is_last_point: bool = (vert_idx == last_idx - 1) and not is_edge_contiguous
		var is_first_tess_point: bool = (tess_idx == first_idx_t) and not is_edge_contiguous
		var is_last_tess_point: bool = (tess_idx == last_idx_t - 1) and not is_edge_contiguous

		var tex: Texture2D = null
		var tex_size := Vector2(default_quad_width, default_quad_width)
		var fitmode := SS2D_Material_Edge.FITMODE.SQUISH_AND_STRETCH
		if edge_material != null:
			if edge_material.randomize_texture:
				texture_idx = randi() % edge_material.textures.size()
			else :
				texture_idx = vert_props.texture_idx
			tex = edge_material.get_texture(texture_idx)
			tex_size = tex.get_size()
			fitmode = edge_material.fit_mode
			# Exit if we have an edge material defined but no texture to render
			if tex == null:
				i += next_point_delta
				continue

		var new_quad: SS2D_Quad = SS2D_Shape.build_quad_from_two_points(
			pt,
			pt_next,
			tex,
			width_scale * c_scale * tex_size.y,
			flip_x,
			should_flip,
			is_first_point,
			is_last_point,
			c_offset,
			c_extends,
			fitmode
		)
		var new_quads: Array[SS2D_Quad] = []
		new_quads.push_back(new_quad)

		# Corner Quad
		if edge_material != null and edge_material.use_corner_texture:
			if tess_idx != first_idx_t or is_edge_contiguous:
				var prev_width: float = _get_width_for_tessellated_point(verts, tess_idx_prev)
				var q: SS2D_Quad = _edge_generate_corner(
					pt_prev,
					pt,
					pt_next,
					prev_width,
					width_scale,
					tex_size.y,
					edge_material,
					texture_idx,
					c_scale,
					c_offset
				)
				if q != null:
					new_quads.push_front(q)
					is_not_corner = false
				else:
					is_not_corner = true

		# Taper Quad
		# Bear in mind, a point can be both first AND last
		# Consider an edge that consists of two points (one edge)
		# This first point is used to generate the quad; it is both first and last
		var did_taper_left: bool = false
		var did_taper_right: bool = false
		if is_first_tess_point and edge_material != null and edge_material.use_taper_texture:
			did_taper_left = true
			var taper_quad := _taper_quad(new_quad, edge_material, texture_idx, false, false)
			if taper_quad != null:
				new_quads.push_front(taper_quad)
		if is_last_tess_point and edge_material != null and edge_material.use_taper_texture:
			did_taper_right = true
			var taper_quad := _taper_quad(new_quad, edge_material, texture_idx, true, false)
			if taper_quad != null:
				new_quads.push_back(taper_quad)

		# Taper sharp corners
		if taper_sharp:
			var ang_threshold := PI * 0.5
			if sharp_taper_next != null and is_not_corner:
				var taper := _taper_quad(sharp_taper_next, edge_material, texture_idx, true, true)
				if taper != null:
					taper.ignore_weld_next = true
					edge.quads.push_back(taper)
				else:
					sharp_taper_next.ignore_weld_next = true
			sharp_taper_next = null
			var vert := verts[vert_idx]
			var prev_vert := verts[wrapi(vert_idx - 1, 0, verts.size() - 1)]
			var next_vert := verts[wrapi(vert_idx + 1, 0, verts.size() - 1)]
			if not did_taper_left and is_not_corner:
				var ang_from := prev_vert.angle_to_point(vert)
				var ang_to := vert.angle_to_point(next_vert)
				var ang_dif := angle_difference(ang_from, ang_to)
				if absf(ang_dif) > ang_threshold:
					var taper := _taper_quad(new_quad, edge_material, texture_idx, false, true)
					if taper != null:
						new_quads.push_front(taper)
			if not did_taper_right:
				var next_next_vert := verts[wrapi(vert_idx + 2, 0, verts.size() - 1)]
				var ang_from := vert.angle_to_point(next_vert)
				var ang_to := next_vert.angle_to_point(next_next_vert)
				var ang_dif := angle_difference(ang_from, ang_to)
				if absf(ang_dif) > ang_threshold:
					sharp_taper_next = new_quad

		# Final point for closed shapes fix
		# Corner quads aren't always correctly when the corner is between final and first pt
		if is_last_point and is_edge_contiguous:
			var idx_mid: int = verts_t.size() - 1
			var idx_next: int = SS2D_PluginFunctionality.get_next_unique_point_idx(idx_mid, verts_t, true)
			var idx_prev: int = SS2D_PluginFunctionality.get_previous_unique_point_idx(idx_mid, verts_t, true)
			var p_p: Vector2 = verts_t[idx_prev]
			var p_m: Vector2 = verts_t[idx_mid]
			var p_n: Vector2 = verts_t[idx_next]
			var w_p: float = _get_width_for_tessellated_point(verts, idx_prev)
			var w_m: float = _get_width_for_tessellated_point(verts, idx_mid)
			var q: SS2D_Quad = _edge_generate_corner(
				p_p, p_m, p_n, w_p, w_m, tex_size.y, edge_material, texture_idx, c_scale, c_offset
			)
			if q != null:
				new_quads.push_back(q)

		# Add new quads to edge
		for q in new_quads:
			edge.quads.push_back(q)
		i += next_point_delta

	# leftover final taper for the last sharp corner if required
	if taper_sharp:
		if sharp_taper_next != null and edge.quads[0].corner == SS2D_Quad.CORNER.NONE:
			var taper := _taper_quad(sharp_taper_next, edge_material, texture_idx, true, true)
			if taper != null:
				taper.ignore_weld_next = true
				edge.quads.push_back(taper)
			else:
				sharp_taper_next.ignore_weld_next = true
		sharp_taper_next = null

	if edge_material_meta != null:
		if edge_material_meta.weld:
			_weld_quad_array(edge.quads, edge.wrap_around)

	return edge


# get the appropriate tapering texture based on direction and whether the current taper is a sharp
# corner taper or normal material edge taper
func get_taper_tex(edge_mat: SS2D_Material_Edge, tex_idx: int, facing_right: bool, corner_taper: bool) -> Texture2D:
	if facing_right:
		if corner_taper:
			return edge_mat.get_texture_taper_corner_right(tex_idx)
		else:
			return edge_mat.get_texture_taper_right(tex_idx)
	else:
		if corner_taper:
			return edge_mat.get_texture_taper_corner_left(tex_idx)
		else:
			return edge_mat.get_texture_taper_left(tex_idx)


func _taper_quad(
	quad: SS2D_Quad,
	edge_mat: SS2D_Material_Edge,
	tex_idx: int,
	facing_right: bool,
	corner_taper: bool
) -> SS2D_Quad:
	var taper_texture: Texture2D = get_taper_tex(edge_mat, tex_idx, facing_right, corner_taper)
	if taper_texture != null:
		var taper_size: Vector2 = taper_texture.get_size()
		var fit: bool = absf(taper_size.x) <= quad.get_length_average()
		if fit:
			var taper_quad := quad.duplicate()
			taper_quad.corner = SS2D_Quad.CORNER.NONE
			taper_quad.texture = taper_texture
			var delta_normal: Vector2 = (taper_quad.pt_d - taper_quad.pt_a).normalized()
			var offset: Vector2 = delta_normal * taper_size
			if facing_right:
				taper_quad.pt_a = taper_quad.pt_d - offset
				taper_quad.pt_b = taper_quad.pt_c - offset
				quad.pt_d = taper_quad.pt_a
				quad.pt_c = taper_quad.pt_b
			else:
				taper_quad.pt_d = taper_quad.pt_a + offset
				taper_quad.pt_c = taper_quad.pt_b + offset
				quad.pt_a = taper_quad.pt_d
				quad.pt_b = taper_quad.pt_c

			taper_quad.is_tapered = true
			return taper_quad
		# If a new taper quad doesn't fit, re-texture the new_quad
		else:
			quad.is_tapered = true
			quad.texture = taper_texture
	return null


## Create an invisible rect that catches mouse clicks in editor so we can get clickable shapes.
## It is not very accurate but good enough. MeshInstance2D also only performs a bounding box check.
func _setup_click_rect() -> void:
	# NOTE: When duplicating the shape (ctrl+d), Godot will also duplicate the click rect node
	# and update its owner to current scene root, which makes it appear in editor.
	# Hence we need to check if the node already exists and delete it.
	# Updating its owner again to hide it, does not work for some reason.
	# add_child() with INTERNAL_MODE_FRONT seems to prevent this whole issue in 4.5 but not in 4.4.

	for i in get_child_count(true):
		var node := get_child(i)

		if node.has_meta(CLICK_RECT_TAG):
			node.queue_free()
			break

	_click_rect = ColorRect.new()
	_click_rect.modulate = Color.TRANSPARENT
	_click_rect.set_meta(CLICK_RECT_TAG, true)
	add_child(_click_rect, false, INTERNAL_MODE_FRONT)
	_click_rect.owner = self  # Needed to make it clickable


## Computes a bounding box of the tesselated curve and assigns it to the click rect.
func _update_click_rect() -> void:
	if not _click_rect:
		return

	if _points.get_point_count() == 0:
		_click_rect.size = Vector2.ZERO
		return

	var points := _points.get_tessellated_points()
	var rect_min: Vector2 = points[0]
	var rect_max: Vector2 = points[0]

	for i in range(1, points.size()):
		var p := points[i]
		rect_min.x = min(rect_min.x, p.x)
		rect_min.y = min(rect_min.y, p.y)
		rect_max.x = max(rect_max.x, p.x)
		rect_max.y = max(rect_max.y, p.y)

	_click_rect.size = rect_max - rect_min
	_click_rect.position = rect_min