diff options
Diffstat (limited to 'src/addons/rmsmartshape/shapes')
| -rw-r--r-- | src/addons/rmsmartshape/shapes/edge.gd | 171 | ||||
| -rw-r--r-- | src/addons/rmsmartshape/shapes/mesh.gd | 91 | ||||
| -rw-r--r-- | src/addons/rmsmartshape/shapes/point.gd | 77 | ||||
| -rw-r--r-- | src/addons/rmsmartshape/shapes/point_array.gd | 415 | ||||
| -rw-r--r-- | src/addons/rmsmartshape/shapes/quad.gd | 201 | ||||
| -rw-r--r-- | src/addons/rmsmartshape/shapes/shape_anchor.gd | 201 | ||||
| -rw-r--r-- | src/addons/rmsmartshape/shapes/shape_base.gd | 1791 | ||||
| -rw-r--r-- | src/addons/rmsmartshape/shapes/shape_closed.gd | 365 | ||||
| -rw-r--r-- | src/addons/rmsmartshape/shapes/shape_combine_union.gd | 3 | ||||
| -rw-r--r-- | src/addons/rmsmartshape/shapes/shape_meta.gd | 118 | ||||
| -rw-r--r-- | src/addons/rmsmartshape/shapes/shape_open.gd | 60 | ||||
| -rw-r--r-- | src/addons/rmsmartshape/shapes/shape_render.gd | 27 |
12 files changed, 3520 insertions, 0 deletions
diff --git a/src/addons/rmsmartshape/shapes/edge.gd b/src/addons/rmsmartshape/shapes/edge.gd new file mode 100644 index 0000000..a1d01ca --- /dev/null +++ b/src/addons/rmsmartshape/shapes/edge.gd @@ -0,0 +1,171 @@ +tool +extends Reference +class_name SS2D_Edge + +var quads: Array = [] +var first_point_key: int = -1 +var last_point_key: int = -1 +var z_index: int = 0 +var z_as_relative: bool = false +# If final point is connected to first point +var wrap_around: bool = false +var material: Material = null + +static func different_render(q1: SS2D_Quad, q2: SS2D_Quad) -> bool: + """ + Will return true if the 2 quads must be drawn in two calls + """ + if q1.matches_quad(q2): + return false + return true + +static func get_consecutive_quads_for_mesh(_quads: Array) -> Array: + if _quads.empty(): + return [] + + var quad_ranges = [] + var quad_range = [] + quad_range.push_back(_quads[0]) + for i in range(1, _quads.size(), 1): + var quad_prev = _quads[i - 1] + var quad = _quads[i] + if different_render(quad, quad_prev): + quad_ranges.push_back(quad_range) + quad_range = [quad] + else: + quad_range.push_back(quad) + + quad_ranges.push_back(quad_range) + return quad_ranges + +static func generate_array_mesh_from_quad_sequence(_quads: Array, wrap_around: bool) -> ArrayMesh: + """ + Assumes each quad in the sequence is of the same render type + same textures, values, etc... + quads passed in as an argument should have been generated by get_consecutive_quads_for_mesh + """ + if _quads.empty(): + return ArrayMesh.new() + + var total_length: float = 0.0 + for q in _quads: + total_length += q.get_length_average() + if total_length == 0.0: + return ArrayMesh.new() + + var first_quad = _quads[0] + var tex: Texture = first_quad.texture + # The change in length required to apply to each quad + # to make the textures begin and end at the start and end of each texture + var change_in_length: float = -1.0 + if tex != null: + # How many times the texture is repeated + var texture_reps = round(total_length / tex.get_size().x) + # Length required to display all the reps with the texture's full width + var texture_full_length = texture_reps * tex.get_size().x + # How much each quad's texture must be offset to make up the difference in full length vs total length + change_in_length = (texture_full_length / total_length) + + if first_quad.fit_texture == SS2D_Material_Edge.FITMODE.CROP: + change_in_length = 1.0 + + var length_elapsed: float = 0.0 + var st = SurfaceTool.new() + st.begin(Mesh.PRIMITIVE_TRIANGLES) + for q in _quads: + var section_length: float = q.get_length_average() * change_in_length + var highest_value: float = max(q.get_height_left(), q.get_height_right()) + # 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/ + var uv_a = Vector2(0, 0) + var uv_b = Vector2(0, 1) + var uv_c = Vector2(1, 1) + var uv_d = Vector2(1, 0) + # If we have a valid texture and this quad isn't a corner + if tex != null and q.corner == q.CORNER.NONE: + var x_left = (length_elapsed) / tex.get_size().x + var x_right = (length_elapsed + section_length) / tex.get_size().x + uv_a.x = x_left + uv_b.x = x_left + uv_c.x = x_right + uv_d.x = x_right + if q.flip_texture: + var t = uv_a + uv_a = uv_b + uv_b = t + t = uv_c + uv_c = uv_d + uv_d = t + + # A + _add_uv_to_surface_tool(st, uv_a) + st.add_color(q.color) + st.add_vertex(SS2D_Common_Functions.to_vector3(q.pt_a)) + + # B + _add_uv_to_surface_tool(st, uv_b) + st.add_color(q.color) + st.add_vertex(SS2D_Common_Functions.to_vector3(q.pt_b)) + + # C + _add_uv_to_surface_tool(st, uv_c) + st.add_color(q.color) + st.add_vertex(SS2D_Common_Functions.to_vector3(q.pt_c)) + + # A + _add_uv_to_surface_tool(st, uv_a) + st.add_color(q.color) + st.add_vertex(SS2D_Common_Functions.to_vector3(q.pt_a)) + + # C + _add_uv_to_surface_tool(st, uv_c) + st.add_color(q.color) + st.add_vertex(SS2D_Common_Functions.to_vector3(q.pt_c)) + + # D + _add_uv_to_surface_tool(st, uv_d) + st.add_color(q.color) + st.add_vertex(SS2D_Common_Functions.to_vector3(q.pt_d)) + + length_elapsed += section_length + + st.index() + st.generate_normals() + return st.commit() + + +func get_meshes() -> Array: + """ + Returns an array of SS2D_Mesh + # Get Arrays of consecutive quads with the same mesh data + # For each array + ## Generate Mesh Data from the quad + """ + + var consecutive_quad_arrays = get_consecutive_quads_for_mesh(quads) + #print("Arrays: %s" % consecutive_quad_arrays.size()) + var meshes = [] + for consecutive_quads in consecutive_quad_arrays: + if consecutive_quads.empty(): + continue + var st: SurfaceTool = SurfaceTool.new() + var array_mesh: ArrayMesh = generate_array_mesh_from_quad_sequence( + consecutive_quads, wrap_around + ) + var tex: Texture = consecutive_quads[0].texture + var tex_normal: Texture = consecutive_quads[0].texture_normal + var flip = consecutive_quads[0].flip_texture + var transform = Transform2D() + var mesh_data = SS2D_Mesh.new(tex, tex_normal, flip, transform, [array_mesh], material) + mesh_data.z_index = z_index + mesh_data.z_as_relative = z_as_relative + meshes.push_back(mesh_data) + + return meshes + + +static func _add_uv_to_surface_tool(surface_tool: SurfaceTool, uv: Vector2): + surface_tool.add_uv(uv) + surface_tool.add_uv2(uv) diff --git a/src/addons/rmsmartshape/shapes/mesh.gd b/src/addons/rmsmartshape/shapes/mesh.gd new file mode 100644 index 0000000..1259c15 --- /dev/null +++ b/src/addons/rmsmartshape/shapes/mesh.gd @@ -0,0 +1,91 @@ +tool +extends Reference +class_name SS2D_Mesh + +""" +Used to organize all requested meshes to be rendered by their textures +""" + +var texture: Texture = null +var texture_normal: Texture = null +var flip_texture: bool = false +# Array of ArrayMesh +var meshes: Array = [] +var mesh_transform: Transform2D = Transform2D() +var material: Material = null +var z_index: int = 0 +var z_as_relative: bool = true + + +func _init( + t: Texture = null, + tn: Texture = null, + f: bool = false, + xform: Transform2D = Transform2D(), + m: Array = [], + mat: Material = null +): + texture = t + texture_normal = tn + flip_texture = f + meshes = m + mesh_transform = xform + material = mat + + +func duplicate(sub_resource: bool = false): + var _new = __new() + _new.texture = texture + _new.texture_normal = texture_normal + _new.flip_texture = flip_texture + _new.mesh_transform = mesh_transform + _new.material = material + _new.z_index = z_index + _new.z_as_relative = z_as_relative + _new.meshes = [] + if sub_resource: + for m in meshes: + _new.meshes.push_back(m.duplicate(true)) + return _new + + +func matches(tex: Texture, tex_n: Texture, f: bool, t: Transform2D, m: Material, zi: int, zb: bool) -> bool: + if ( + tex == texture + and tex_n == texture_normal + and f == flip_texture + and t == mesh_transform + and m == material + and zi == z_index + and zb == z_as_relative + ): + return true + return false + + +func mesh_matches(m) -> bool: + return matches( + m.texture, + m.texture_normal, + m.flip_texture, + m.mesh_transform, + m.material, + m.z_index, + m.z_as_relative + ) + + +func debug_print_array_mesh(am: ArrayMesh) -> String: + var s = "Faces:%s | Surfs:%s | " % [am.get_faces(), am.get_surface_count()] + return s + + +func render(ci: CanvasItem): + #print("mesh count %s" % meshes.size()) + for mesh in meshes: + ci.draw_mesh(mesh, texture, texture_normal) + + +# Workaround (class cannot reference itself) +func __new() -> SS2D_Point: + return get_script().new() diff --git a/src/addons/rmsmartshape/shapes/point.gd b/src/addons/rmsmartshape/shapes/point.gd new file mode 100644 index 0000000..836c6cf --- /dev/null +++ b/src/addons/rmsmartshape/shapes/point.gd @@ -0,0 +1,77 @@ +tool +extends Resource +class_name SS2D_Point + +export (Vector2) var position: Vector2 setget _set_position +export (Vector2) var point_in: Vector2 setget _set_point_in +export (Vector2) var point_out: Vector2 setget _set_point_out +export (Resource) var properties setget _set_properties + +# If class members are written to, the 'changed' signal may not be emitted +# Signal is only emitted when data is actually changed +# If assigned data is the same as the existing data, no signal is emitted + + +func _init(pos: Vector2 = Vector2(0, 0)): + position = pos + point_in = Vector2(0, 0) + point_out = Vector2(0, 0) + properties = SS2D_VertexProperties.new() + + +func equals(other: SS2D_Point) -> bool: + if position != other.position: + return false + if point_in != other.point_in: + return false + if point_out != other.point_out: + return false + print ("E! %s" % properties.equals(other.properties)) + if not properties.equals(other.properties): + return false + return true + + +func duplicate(sub_resource: bool = false): + var _new = __new() + _new.position = position + _new.point_in = point_in + _new.point_out = point_out + if sub_resource: + _new.properties = properties.duplicate(true) + else: + _new.properties = properties + return _new + + +func _set_position(v: Vector2): + if position != v: + position = v + emit_signal("changed") + property_list_changed_notify() + + +func _set_point_in(v: Vector2): + if point_in != v: + point_in = v + emit_signal("changed") + property_list_changed_notify() + + +func _set_point_out(v: Vector2): + if point_out != v: + point_out = v + emit_signal("changed") + property_list_changed_notify() + + +func _set_properties(other:SS2D_VertexProperties): + if not properties.equals(other): + properties = other.duplicate(true) + emit_signal("changed") + property_list_changed_notify() + + +# Workaround (class cannot reference itself) +func __new() -> SS2D_Point: + return get_script().new() diff --git a/src/addons/rmsmartshape/shapes/point_array.gd b/src/addons/rmsmartshape/shapes/point_array.gd new file mode 100644 index 0000000..34d9c1c --- /dev/null +++ b/src/addons/rmsmartshape/shapes/point_array.gd @@ -0,0 +1,415 @@ +tool +extends Resource +class_name SS2D_Point_Array + +enum CONSTRAINT { NONE = 0, AXIS_X = 1, AXIS_Y = 2, CONTROL_POINTS = 4, PROPERTIES = 8, ALL = 15 } + +# Maps a key to each point +export var _points: Dictionary = {} setget set_points +# Contains all keys; the order of the keys determines the order of the points +export var _point_order: Array = [] setget set_point_order +# Key is tuple of point_keys; Value is the CONSTRAINT enum +export var _constraints = {} setget set_constraints +# Next key value to generate +export var _next_key = 0 setget set_next_key + +var _constraints_enabled: bool = true + +signal constraint_removed(key1, key2) + +################### +# HANDLING POINTS # +################### + + +func _init(): + # Required by Godot to correctly make unique instances of this resource + _points = {} + _point_order = [] + _constraints = {} + _next_key = 0 + + +func set_points(ps: Dictionary): + # Called by Godot when loading from a saved scene + for k in ps: + var p = ps[k] + p.connect("changed", self, "_on_point_changed", [p]) + _points = ps + property_list_changed_notify() + + +func set_point_order(po: Array): + _point_order = po + property_list_changed_notify() + + +func set_constraints(cs: Dictionary): + _constraints = cs + property_list_changed_notify() + + +func set_next_key(i: int): + _next_key = i + property_list_changed_notify() + + +func __generate_key(next: int) -> int: + if not is_key_valid(next): + return __generate_key(max(next + 1, 0)) + return next + + +func _generate_key() -> int: + var next = __generate_key(_next_key) + _next_key = next + 1 + return next + + +func get_next_key() -> int: + """ + Will return the next key that will be used when adding a point + """ + return __generate_key(_next_key) + + +func is_key_valid(k: int) -> bool: + if k < 0: + return false + if _points.has(k): + return false + return true + + +func add_point(point: Vector2, idx: int = -1, use_key: int = -1) -> int: + var next_key = use_key + if next_key == -1 or not is_key_valid(next_key): + next_key = _generate_key() + var new_point = SS2D_Point.new(point) + new_point.connect("changed", self, "_on_point_changed", [new_point]) + _points[next_key] = new_point + _point_order.push_back(next_key) + if idx != -1: + set_point_index(next_key, idx) + return next_key + + +func is_index_in_range(idx: int) -> bool: + return idx > 0 and idx < _point_order.size() + + +func get_point_key_at_index(idx: int) -> int: + return _point_order[idx] + + +func get_point_at_index(idx: int) -> int: + return _points[_point_order[idx]].duplicate(true) + + +func get_point(key: int) -> int: + return _points[key].duplicate(true) + + +func set_point(key: int, value: SS2D_Point): + if has_point(key): + _points[key] = value.duplicate(true) + + +func get_point_count() -> int: + return _point_order.size() + + +func get_point_index(key: int) -> int: + if has_point(key): + var idx = 0 + for k in _point_order: + if key == k: + break + idx += 1 + return idx + return -1 + + +func invert_point_order(): + _point_order.invert() + + +func set_point_index(key: int, idx: int): + if not has_point(key): + return + var old_idx = get_point_index(key) + if idx < 0 or idx >= _points.size(): + idx = _points.size() - 1 + if idx == old_idx: + return + _point_order.remove(old_idx) + _point_order.insert(idx, key) + + +func has_point(key: int) -> bool: + return _points.has(key) + + +func get_all_point_keys() -> Array: + """ + _point_order should contain every single point ONLY ONCE + """ + return _point_order.duplicate(true) + + +func remove_point(key: int) -> bool: + if has_point(key): + remove_constraints(key) + var p = _points[key] + if p.is_connected("changed", self, "_on_point_changed"): + p.disconnect("changed", self, "_on_point_changed") + _point_order.remove(get_point_index(key)) + _points.erase(key) + return true + return false + + +func clear(): + _points.clear() + _point_order.clear() + _constraints.clear() + _next_key = 0 + emit_signal("changed") + + +func set_point_in(key: int, value: Vector2): + if has_point(key): + _points[key].point_in = value + + +func get_point_in(key: int) -> Vector2: + if has_point(key): + return _points[key].point_in + return Vector2(0, 0) + + +func set_point_out(key: int, value: Vector2): + if has_point(key): + _points[key].point_out = value + + +func get_point_out(key: int) -> Vector2: + if has_point(key): + return _points[key].point_out + return Vector2(0, 0) + + +func set_point_position(key: int, value: Vector2): + if has_point(key): + _points[key].position = value + + +func get_point_position(key: int) -> Vector2: + if has_point(key): + return _points[key].position + return Vector2(0, 0) + + +func set_point_properties(key: int, value: SS2D_VertexProperties): + if has_point(key): + _points[key].properties = value + + +func get_point_properties(key: int) -> SS2D_VertexProperties: + if has_point(key): + return _points[key].properties.duplicate(true) + var new_props = SS2D_VertexProperties.new() + return new_props + + +func get_key_from_point(p: SS2D_Point) -> int: + for k in _points: + if p == _points[k]: + return k + return -1 + + +func _on_point_changed(p: SS2D_Point): + var key = get_key_from_point(p) + if _updating_constraints: + _keys_to_update_constraints.push_back(key) + else: + update_constraints(key) + + +############### +# CONSTRAINTS # +############### + +var _updating_constraints = false +var _keys_to_update_constraints = [] + + +func disable_constraints(): + _constraints_enabled = false + + +func enable_constraints(): + _constraints_enabled = true + + +func _update_constraints(src: int): + if not _constraints_enabled: + return + var constraints = get_point_constraints(src) + for tuple in constraints: + var constraint = constraints[tuple] + if constraint == CONSTRAINT.NONE: + continue + var dst = get_other_value_from_tuple(tuple, src) + if constraint & CONSTRAINT.AXIS_X: + set_point_position(dst, Vector2(get_point_position(src).x, get_point_position(dst).y)) + if constraint & CONSTRAINT.AXIS_Y: + set_point_position(dst, Vector2(get_point_position(dst).x, get_point_position(src).y)) + if constraint & CONSTRAINT.CONTROL_POINTS: + set_point_in(dst, get_point_in(src)) + set_point_out(dst, get_point_out(src)) + if constraint & CONSTRAINT.PROPERTIES: + set_point_properties(dst, get_point_properties(src)) + + +func update_constraints(src: int): + """ + Will mutate points based on constraints + values from Passed key will be used to update constrained points + """ + if not has_point(src) or _updating_constraints: + return + _updating_constraints = true + # Initial pass of updating constraints + _update_constraints(src) + + # Subsequent required passes of updating constraints + while not _keys_to_update_constraints.empty(): + var key_set = _keys_to_update_constraints.duplicate(true) + _keys_to_update_constraints.clear() + for k in key_set: + _update_constraints(k) + + _updating_constraints = false + emit_signal("changed") + + +func get_point_constraints(key1: int) -> Dictionary: + """ + Will Return all constraints for a given key + """ + var constraints = {} + for tuple in _constraints: + if tuple.has(key1): + constraints[tuple] = _constraints[tuple] + return constraints + + +func get_point_constraint(key1: int, key2: int) -> int: + """ + Will Return the constraint for a pair of keys + """ + var t = create_tuple(key1, key2) + var keys = _constraints.keys() + var t_index = find_tuple_in_array_of_tuples(keys, t) + if t_index == -1: + return CONSTRAINT.NONE + var t_key = keys[t_index] + return _constraints[t_key] + + +func set_constraint(key1: int, key2: int, constraint: int): + var t = create_tuple(key1, key2) + var existing_tuples = _constraints.keys() + var existing_t_index = find_tuple_in_array_of_tuples(existing_tuples, t) + if existing_t_index != -1: + t = existing_tuples[existing_t_index] + _constraints[t] = constraint + if _constraints[t] == CONSTRAINT.NONE: + _constraints.erase(t) + emit_signal("constraint_removed", key1, key2) + else: + update_constraints(key1) + + +func remove_constraints(key1: int): + var constraints = get_point_constraints(key1) + for tuple in constraints: + var constraint = constraints[tuple] + var key2 = get_other_value_from_tuple(tuple, key1) + set_constraint(key1, key2, CONSTRAINT.NONE) + + +func remove_constraint(key1: int, key2: int): + set_constraint(key1, key2, CONSTRAINT.NONE) + + +func get_all_constraints_of_type(type: int) -> int: + var constraints = [] + for t in _constraints: + var c = _constraints[t] + if c == type: + constraints.push_back(t) + return constraints + + +######## +# MISC # +######## +func debug_print(): + for k in get_all_point_keys(): + var pos = get_point_position(k) + var _in = get_point_in(k) + var out = get_point_out(k) + print("%s = P:%s | I:%s | O:%s" % [k, pos, _in, out]) + + +func duplicate(sub_resource: bool = false): + var _new = __new() + _new._next_key = _next_key + if sub_resource: + var new_point_dict = {} + for k in _points: + new_point_dict[k] = _points[k].duplicate(true) + _new._points = new_point_dict + _new._point_order = _point_order.duplicate(true) + + _new._constraints = {} + for tuple in _constraints: + _new._constraints[tuple] = _constraints[tuple] + else: + _new._points = _points + _new._point_order = _point_order + _new._constraints = _constraints + return _new + + +# Workaround (class cannot reference itself) +func __new(): + return get_script().new() + + +######### +# TUPLE # +######### + +static func create_tuple(a: int, b: int) -> Array: + return [a, b] + +static func get_other_value_from_tuple(t: Array, value: int) -> int: + if t[0] == value: + return t[1] + elif t[1] == value: + return t[0] + return -1 + +static func tuples_are_equal(t1: Array, t2: Array) -> bool: + return (t1[0] == t2[0] and t1[1] == t2[1]) or (t1[0] == t2[1] and t1[1] == t2[0]) + +static func find_tuple_in_array_of_tuples(tuple_array: Array, t: Array) -> int: + for i in range(tuple_array.size()): + var other = tuple_array[i] + if tuples_are_equal(t, other): + return i + return -1 diff --git a/src/addons/rmsmartshape/shapes/quad.gd b/src/addons/rmsmartshape/shapes/quad.gd new file mode 100644 index 0000000..54249e7 --- /dev/null +++ b/src/addons/rmsmartshape/shapes/quad.gd @@ -0,0 +1,201 @@ +tool +extends Reference +class_name SS2D_Quad + +enum ORIENTATION { COLINEAR = 0, CCW, CW } +enum CORNER { NONE = 0, OUTER, INNER } + +var pt_a: Vector2 +var pt_b: Vector2 +var pt_c: Vector2 +var pt_d: Vector2 + +var texture: Texture = null +var texture_normal: Texture = null +var color: Color = Color(1.0, 1.0, 1.0, 1.0) + +var flip_texture: bool = false +# Deprecated, should remove control_point_index +var control_point_index: int +var fit_texture = SS2D_Material_Edge.FITMODE.SQUISH_AND_STRETCH + +# Contains value from CORNER enum +var corner: int = 0 + +# EXISTS FOR LEGACY REASONS, THIS PROPERTY IS DEPRECATED +var width_factor: float = 1.0 + + +func _to_string() -> String: + return "[Quad] A:%s B:%s C:%s D:%s | Corner: %s" % [pt_a, pt_b, pt_c, pt_d, corner] + + +func matches_quad(q: SS2D_Quad) -> bool: + if ( + texture == q.texture + and texture_normal == q.texture_normal + and color == q.color + and flip_texture == q.flip_texture + and fit_texture == q.fit_texture + ): + return true + return false + + +func duplicate() -> SS2D_Quad: + var q = __new() + q.pt_a = pt_a + q.pt_b = pt_b + q.pt_c = pt_c + q.pt_d = pt_d + + q.texture = texture + q.texture_normal = texture_normal + q.color = color + + q.flip_texture = flip_texture + q.width_factor = width_factor + q.control_point_index = control_point_index + + q.corner = corner + return q + + +func _init( + a: Vector2 = Vector2.ZERO, + b: Vector2 = Vector2.ZERO, + c: Vector2 = Vector2.ZERO, + d: Vector2 = Vector2.ZERO, + t: Texture = null, + tn: Texture = null, + f: bool = false +): + pt_a = a + pt_b = b + pt_c = c + pt_d = d + texture = t + texture_normal = tn + flip_texture = f + + +func get_rotation() -> float: + return SS2D_NormalRange.get_angle_from_vector(pt_c - pt_a) + + +""" +Given three colinear points p, q, r, the function checks if +point q lies on line segment 'pr' +""" + + +func on_segment(p: Vector2, q: Vector2, r: Vector2) -> bool: + if ( + (q.x <= max(p.x, r.x)) + and (q.x >= min(p.x, r.x)) + and (q.y <= max(p.y, r.y)) + and (q.y >= min(p.y, r.y)) + ): + return true + return false + + +""" +Returns CCW, CW, or colinear +see https://www.geeksforgeeks.org/check-if-two-given-line-segments-intersect/ +""" + + +func get_orientation(a: Vector2, b: Vector2, c: Vector2) -> int: + var val = (float(b.y - a.y) * (c.x - b.x)) - (float(b.x - a.x) * (c.y - b.y)) + if val > 0: + return ORIENTATION.CW + elif val < 0: + return ORIENTATION.CCW + return ORIENTATION.COLINEAR + + +""" +Return true if line segments p1q1 and p2q2 intersect +""" + + +func edges_intersect(p1: Vector2, q1: Vector2, p2: Vector2, q2: Vector2) -> bool: + var o1 = get_orientation(p1, q1, p2) + var o2 = get_orientation(p1, q1, q2) + var o3 = get_orientation(p2, q2, p1) + var o4 = get_orientation(p2, q2, q1) + # General case + if (o1 != o2) and (o3 != o4): + return true + + # Special Cases + # p1 , q1 and p2 are colinear and p2 lies on segment p1q1 + if (o1 == 0) and on_segment(p1, p2, q1): + return true + + # p1 , q1 and q2 are colinear and q2 lies on segment p1q1 + if (o2 == 0) and on_segment(p1, q2, q1): + return true + + # p2 , q2 and p1 are colinear and p1 lies on segment p2q2 + if (o3 == 0) and on_segment(p2, p1, q2): + return true + + # p2 , q2 and q1 are colinear and q1 lies on segment p2q2 + if (o4 == 0) and on_segment(p2, q1, q2): + return true + + return false + + +func self_intersects() -> bool: + return edges_intersect(pt_a, pt_d, pt_b, pt_c) or edges_intersect(pt_a, pt_b, pt_d, pt_c) + + +func render_lines(ci: CanvasItem): + ci.draw_line(pt_a, pt_b, color) + ci.draw_line(pt_b, pt_c, color) + ci.draw_line(pt_c, pt_d, color) + ci.draw_line(pt_d, pt_a, color) + + +func render_points(rad: float, intensity: float, ci: CanvasItem): + ci.draw_circle(pt_a, rad, Color(intensity, 0, 0)) + ci.draw_circle(pt_b, rad, Color(0, 0, intensity)) + ci.draw_circle(pt_c, rad, Color(0, intensity, 0)) + ci.draw_circle(pt_d, rad, Color(intensity, 0, intensity)) + + +# Workaround (class cannot reference itself) +func __new(): + return get_script().new() + + +func get_height_average() -> float: + return (get_height_left() + get_height_right()) / 2.0 + + +func get_height_left() -> float: + return pt_a.distance_to(pt_b) + + +func get_height_right() -> float: + return pt_d.distance_to(pt_c) + + +# Returns the difference in height between the left and right sides +func get_height_difference() -> float: + return get_height_left() - get_height_right() + + +func get_length_average() -> float: + return (get_length_top() + get_length_bottom()) / 2.0 + + +func get_length_top() -> float: + return pt_d.distance_to(pt_a) + + +func get_length_bottom() -> float: + return pt_c.distance_to(pt_b) diff --git a/src/addons/rmsmartshape/shapes/shape_anchor.gd b/src/addons/rmsmartshape/shapes/shape_anchor.gd new file mode 100644 index 0000000..f10fee6 --- /dev/null +++ b/src/addons/rmsmartshape/shapes/shape_anchor.gd @@ -0,0 +1,201 @@ +tool +extends Node2D + +const DEBUG_DRAW_LINE_LENGTH = 128.0 + +class_name SS2D_Shape_Anchor, "../assets/Anchor.svg" + +export (NodePath) var shape_path: NodePath setget set_shape_path +export (int) var shape_point_index: int = 0 setget set_shape_point_index +export (float, 0.0, 1.0) var shape_point_offset: float = 0.0 setget set_shape_point_offset +export (float, 0, 3.14) var child_rotation: float = 3.14 setget set_child_rotation +export (bool) var use_shape_scale: bool = false setget set_use_shape_scale + +export (bool) var debug_draw: bool = false setget set_debug_draw + +var cached_shape_transform:Transform2D = Transform2D.IDENTITY +var shape = null + + +########### +# SETTERS # +########### +func set_shape_path(value: NodePath): + # Assign path value + shape_path = value + set_shape() + + property_list_changed_notify() + refresh() + +func set_shape(): + # Disconnect old shape + if shape != null: + disconnect_shape(shape) + + # Set shape if path is valid and connect + shape = null + if has_node(shape_path): + var new_node = get_node(shape_path) + if not new_node is SS2D_Shape_Base: + push_error("Shape Path isn't a valid subtype of SS2D_Shape_Base! Aborting...") + return + shape = new_node + connect_shape(shape) + shape_point_index = get_shape_index_range(shape, shape_point_index) + + + +func get_shape_index_range(s:SS2D_Shape_Base, idx:int)->int: + var point_count = s.get_point_count() + # Subtract 2; + # 'point_count' is out of bounds; subtract 1 + # cannot use final idx as starting point_index; subtract another 1 + var final_idx = point_count - 2 + if idx < 0: + idx = final_idx + idx = idx % (final_idx + 1) + return idx + +func set_shape_point_index(value: int): + if value == shape_point_index: + return + + if shape == null: + shape_point_index = value + return + + shape_point_index = get_shape_index_range(shape, value) + #property_list_changed_notify() + refresh() + + +func set_shape_point_offset(value: float): + shape_point_offset = value + #property_list_changed_notify() + refresh() + + +func set_use_shape_scale(value: bool): + use_shape_scale = value + #property_list_changed_notify() + refresh() + + +func set_child_rotation(value: float): + child_rotation = value + #property_list_changed_notify() + refresh() + + +func set_debug_draw(v: bool): + debug_draw = v + #property_list_changed_notify() + refresh() + + +########## +# EVENTS # +########## +func _process(delta): + if shape == null: + set_shape() + return + if shape.is_queued_for_deletion(): + return + if shape.get_global_transform() != cached_shape_transform: + cached_shape_transform = shape.get_global_transform() + refresh() + + +func _monitored_node_leaving(): + set_shape_path("") + + +func _handle_point_change(): + refresh() + + +######### +# LOGIC # +######### +func _cubic_bezier(p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2, t: float) -> Vector2: + var q0 = p0.linear_interpolate(p1, t) + var q1 = p1.linear_interpolate(p2, t) + var q2 = p2.linear_interpolate(p3, t) + + var r0 = q0.linear_interpolate(q1, t) + var r1 = q1.linear_interpolate(q2, t) + + var s = r0.linear_interpolate(r1, t) + return s + + +func disconnect_shape(s: SS2D_Shape_Base): + s.disconnect("points_modified", self, "_handle_point_change") + s.disconnect("tree_exiting", self, "_monitored_node_leaving") + + +func connect_shape(s: SS2D_Shape_Base): + s.connect("points_modified", self, "_handle_point_change") + s.connect("tree_exiting", self, "_monitored_node_leaving") + + +func refresh(): + if shape == null: + return + if not is_instance_valid(shape): + return + if shape.is_queued_for_deletion(): + disconnect_shape(shape) + shape = null + return + + # Subtract one, cannot use final point as starting index + var point_count = shape.get_point_count() - 1 + + var pt_a_index = shape_point_index + var pt_b_index = shape_point_index + 1 + var pt_a_key = shape.get_point_key_at_index(pt_a_index) + var pt_b_key = shape.get_point_key_at_index(pt_b_index) + + var pt_a: Vector2 = shape.global_transform.xform(shape.get_point_position(pt_a_key)) + var pt_b: Vector2 = shape.global_transform.xform(shape.get_point_position(pt_b_key)) + + var pt_a_handle: Vector2 + var pt_b_handle: Vector2 + + var n_pt: Vector2 + var n_pt_a: Vector2 + var n_pt_b: Vector2 + + var angle = 0.0 + + pt_a_handle = shape.global_transform.xform( + shape.get_point_position(pt_a_key) + shape.get_point_out(pt_a_key) + ) + pt_b_handle = shape.global_transform.xform( + shape.get_point_position(pt_b_key) + shape.get_point_in(pt_b_key) + ) + + n_pt = _cubic_bezier(pt_a, pt_a_handle, pt_b_handle, pt_b, shape_point_offset) + n_pt_a = _cubic_bezier( + pt_a, pt_a_handle, pt_b_handle, pt_b, clamp(shape_point_offset - 0.1, 0.0, 1.0) + ) + n_pt_b = _cubic_bezier( + pt_a, pt_a_handle, pt_b_handle, pt_b, clamp(shape_point_offset + 0.1, 0.0, 1.0) + ) + + angle = atan2(n_pt_a.y - n_pt_b.y, n_pt_a.x - n_pt_b.x) + + self.global_transform = Transform2D(angle + child_rotation, n_pt) + + if use_shape_scale: + self.scale = shape.scale + + update() + + +func _draw(): + if Engine.editor_hint and debug_draw: + draw_line(Vector2.ZERO, Vector2(0, -DEBUG_DRAW_LINE_LENGTH), self.modulate) diff --git a/src/addons/rmsmartshape/shapes/shape_base.gd b/src/addons/rmsmartshape/shapes/shape_base.gd new file mode 100644 index 0000000..702ddab --- /dev/null +++ b/src/addons/rmsmartshape/shapes/shape_base.gd @@ -0,0 +1,1791 @@ +tool +extends Node2D +class_name SS2D_Shape_Base + +""" +Represents the base functionality for all smart shapes +Functions consist of the following categories + - Setters / Getters + - Curve + - Curve Wrapper + - Godot + - Misc + +To use search to jump between categories, use the regex: +# .+ # +""" + +################ +# DECLARATIONS # +################ +var _dirty: bool = true +var _edges: Array = [] +var _meshes: Array = [] +var _is_instantiable = false +var _curve: Curve2D = Curve2D.new() +# Used for calculating straight edges +var _curve_no_control_points: Curve2D = Curve2D.new() +# Whether or not the plugin should allow editing this shape +var can_edit = true + +signal points_modified +signal on_dirty_update + +enum ORIENTATION { COLINEAR, CLOCKWISE, C_CLOCKWISE } + +########### +# EXPORTS # +########### +export (bool) var editor_debug: bool = false setget _set_editor_debug +export (float, 1, 512) var curve_bake_interval: float = 20.0 setget set_curve_bake_interval + +export (Resource) var _points = SS2D_Point_Array.new() setget set_point_array, get_point_array +# Dictionary of (Array of 2 points) to (SS2D_Material_Edge_Metadata) +export (Dictionary) var material_overrides = null setget set_material_overrides + +#################### +# DETAILED EXPORTS # +#################### +export (Resource) var shape_material = SS2D_Material_Shape.new() setget _set_material +""" + { + "name": "shape_material", + "type": TYPE_OBJECT, + "usage": + PROPERTY_USAGE_SCRIPT_VARIABLE | PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_EDITOR, + "hint": PROPERTY_HINT_RESOURCE_TYPE, + "hint_string": "SS2D_Material_Shape" + }, +""" + +# COLLISION # +#export (float) +var collision_size: float = 32 setget set_collision_size +#export (float) +var collision_offset: float = 0.0 setget set_collision_offset +#export (NodePath) +var collision_polygon_node_path: NodePath = "" + +# EDGES # +#export (bool) +var flip_edges: bool = false setget set_flip_edges +#export (bool) +var render_edges: bool = true setget set_render_edges + +# TESSELLATION # +#export (int, 1, 8) +var tessellation_stages: int = 5 setget set_tessellation_stages +#export (float, 1, 8) +var tessellation_tolerence: float = 4.0 setget set_tessellation_tolerence + + +func _get_property_list(): + return [ + { + "name": "Edges", + "type": TYPE_NIL, + "hint_string": "edge_", + "usage": PROPERTY_USAGE_GROUP | PROPERTY_USAGE_SCRIPT_VARIABLE + }, + { + "name": "Tessellation", + "type": TYPE_NIL, + "hint_string": "tessellation_", + "usage": PROPERTY_USAGE_GROUP | PROPERTY_USAGE_SCRIPT_VARIABLE + }, + { + "name": "tessellation_stages", + "type": TYPE_INT, + "usage": + PROPERTY_USAGE_SCRIPT_VARIABLE | PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_EDITOR, + "hint": PROPERTY_HINT_RANGE, + "hint_string": "0,8,1" + }, + { + "name": "tessellation_tolerence", + "type": TYPE_REAL, + "usage": + PROPERTY_USAGE_SCRIPT_VARIABLE | PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_EDITOR, + "hint": PROPERTY_HINT_RANGE, + "hint_string": "0.1,8.0,1,or_greater,or_lesser" + }, + { + "name": "flip_edges", + "type": TYPE_BOOL, + "usage": + PROPERTY_USAGE_SCRIPT_VARIABLE | PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_EDITOR, + "hint": PROPERTY_HINT_NONE, + }, + { + "name": "render_edges", + "type": TYPE_BOOL, + "usage": + PROPERTY_USAGE_SCRIPT_VARIABLE | PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_EDITOR, + "hint": PROPERTY_HINT_NONE, + }, + { + "name": "Collision", + "type": TYPE_NIL, + "hint_string": "collision_", + "usage": PROPERTY_USAGE_GROUP | PROPERTY_USAGE_SCRIPT_VARIABLE + }, + { + "name": "collision_size", + "type": TYPE_REAL, + "usage": + PROPERTY_USAGE_SCRIPT_VARIABLE | PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_EDITOR, + "hint": PROPERTY_HINT_RANGE, + "hint_string": "0,64,1,or_greater" + }, + { + "name": "collision_offset", + "type": TYPE_REAL, + "usage": + PROPERTY_USAGE_SCRIPT_VARIABLE | PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_EDITOR, + "hint": PROPERTY_HINT_RANGE, + "hint_string": "-64,64,1,or_greater,or_lesser" + }, + { + "name": "collision_polygon_node_path", + "type": TYPE_NODE_PATH, + "usage": + PROPERTY_USAGE_SCRIPT_VARIABLE | PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_EDITOR, + "hint": PROPERTY_HINT_NONE + } + ] + + +##################### +# SETTERS / GETTERS # +##################### +func get_point_array() -> SS2D_Point_Array: + # Duplicating this causes Godot Editor to crash + return _points #.duplicate(true) + + +func set_point_array(a: SS2D_Point_Array, make_unique: bool = true): + if make_unique: + _points = a.duplicate(true) + else: + _points = a + clear_cached_data() + _update_curve(_points) + set_as_dirty() + property_list_changed_notify() + + +func set_flip_edges(b: bool): + flip_edges = b + set_as_dirty() + property_list_changed_notify() + + +func set_render_edges(b: bool): + render_edges = b + set_as_dirty() + property_list_changed_notify() + + +func set_collision_size(s: float): + collision_size = s + set_as_dirty() + property_list_changed_notify() + + +func set_collision_offset(s: float): + collision_offset = s + set_as_dirty() + property_list_changed_notify() + + +func _update_curve_no_control(): + _curve_no_control_points.clear_points() + for i in range(0, _curve.get_point_count(), 1): + _curve_no_control_points.add_point(_curve.get_point_position(i)) + + +func set_curve(value: Curve2D): + _curve = value + _points.clear() + for i in range(0, _curve.get_point_count(), 1): + _points.add_point(_curve.get_point_position(i)) + _update_curve_no_control() + set_as_dirty() + emit_signal("points_modified") + property_list_changed_notify() + + +func get_curve(): + return _curve.duplicate() + + +func _set_editor_debug(value: bool): + editor_debug = value + set_as_dirty() + property_list_changed_notify() + + +""" +Overriding this method to set the light mask of all render children +""" + + +func set_light_mask(value): + var render_parent = _get_rendering_nodes_parent() + for c in render_parent.get_children(): + c.light_mask = value + render_parent.light_mask = value + .set_light_mask(value) + + +func set_render_node_owners(v: bool): + if Engine.editor_hint: + # Force scene tree update + var render_parent = _get_rendering_nodes_parent() + var owner = null + if v: + owner = get_tree().edited_scene_root + render_parent.set_owner(owner) + + # Set owner recurisvely + for c in render_parent.get_children(): + c.set_owner(owner) + + # Force update + var dummy_name = "__DUMMY__" + if has_node(dummy_name): + var n = get_node(dummy_name) + remove_child(n) + n.queue_free() + + var dummy = Node2D.new() + dummy.name = dummy_name + add_child(dummy) + dummy.set_owner(owner) + + +func update_render_nodes(): + set_render_node_owners(editor_debug) + set_light_mask(light_mask) + + +func set_tessellation_stages(value: int): + tessellation_stages = value + set_as_dirty() + property_list_changed_notify() + + +func set_tessellation_tolerence(value: float): + tessellation_tolerence = value + set_as_dirty() + property_list_changed_notify() + + +func set_curve_bake_interval(f: float): + curve_bake_interval = f + _curve.bake_interval = f + property_list_changed_notify() + + +func _set_material(value: SS2D_Material_Shape): + 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() + property_list_changed_notify() + + +func set_material_overrides(dict: Dictionary): + for k in dict: + if not k is Array and k.size() == 2: + push_error("Material Override Dictionary KEY is not an Array with 2 points!") + var v = dict[k] + if not v is SS2D_Material_Edge_Metadata: + push_error("Material Override Dictionary VALUE is not SS2D_Material_Edge_Metadata!") + material_overrides = dict + + +func get_material_override_tuple(tuple: Array) -> Array: + var keys = material_overrides.keys() + var idx = SS2D_Point_Array.find_tuple_in_array_of_tuples(keys, tuple) + if idx != -1: + tuple = keys[idx] + return tuple + + +func has_material_override(tuple: Array) -> bool: + tuple = get_material_override_tuple(tuple) + return material_overrides.has(tuple) + + +func remove_material_override(tuple: Array): + if not has_material_override(tuple): + return + var old = get_material_override(tuple) + if old.is_connected("changed", self, "_handle_material_change"): + old.disconnect("changed", self, "_handle_material_change") + material_overrides.erase(get_material_override_tuple(tuple)) + set_as_dirty() + + +func set_material_override(tuple: Array, mat: SS2D_Material_Edge_Metadata): + if has_material_override(tuple): + var old = get_material_override(tuple) + if old == mat: + return + else: + if old.is_connected("changed", self, "_handle_material_change"): + old.disconnect("changed", self, "_handle_material_change") + mat.connect("changed", self, "_handle_material_change") + material_overrides[get_material_override_tuple(tuple)] = mat + set_as_dirty() + + +func get_material_override(tuple: Array) -> SS2D_Material_Edge_Metadata: + if not has_material_override(tuple): + return null + return material_overrides[get_material_override_tuple(tuple)] + + +func clear_all_material_overrides(): + material_overrides = {} + + +######### +# CURVE # +######### + + +func _update_curve(p_array: SS2D_Point_Array): + _curve.clear_points() + for p_key in p_array.get_all_point_keys(): + var pos = p_array.get_point_position(p_key) + var _in = p_array.get_point_in(p_key) + var out = p_array.get_point_out(p_key) + _curve.add_point(pos, _in, out) + _update_curve_no_control() + + +func get_vertices() -> Array: + var positions = [] + for p_key in _points.get_all_point_keys(): + positions.push_back(_points.get_point_position(p_key)) + return positions + + +func get_tessellated_points() -> PoolVector2Array: + if _curve.get_point_count() < 2: + return PoolVector2Array() + # Point 0 will be the same on both the curve points and the vertecies + # Point size - 1 will be the same on both the curve points and the vertecies + var points = _curve.tessellate(tessellation_stages, tessellation_tolerence) + points[0] = _curve.get_point_position(0) + points[points.size() - 1] = _curve.get_point_position(_curve.get_point_count() - 1) + return points + + +func invert_point_order(): + _points.invert_point_order() + _update_curve(_points) + set_as_dirty() + + +func clear_points(): + _points.clear() + _update_curve(_points) + set_as_dirty() + + +# Meant to override in subclasses +func adjust_add_point_index(index: int) -> int: + return index + + +# Meant to override in subclasses +func add_points(verts: Array, starting_index: int = -1, key: int = -1) -> Array: + var keys = [] + for i in range(0, verts.size(), 1): + var v = verts[i] + if starting_index != -1: + keys.push_back(_points.add_point(v, starting_index + i, key)) + else: + keys.push_back(_points.add_point(v, starting_index, key)) + _add_point_update() + return keys + + +# Meant to override in subclasses +func add_point(position: Vector2, index: int = -1, key: int = -1) -> int: + key = _points.add_point(position, index, key) + _add_point_update() + return key + + +func get_next_key() -> int: + return _points.get_next_key() + + +func _add_point_update(): + _update_curve(_points) + set_as_dirty() + emit_signal("points_modified") + + +func _is_array_index_in_range(a: Array, i: int) -> bool: + if a.size() > i and i >= 0: + return true + return false + + +func is_index_in_range(idx: int) -> bool: + return _points.is_index_in_range(idx) + + +func set_point_position(key: int, position: Vector2): + _points.set_point_position(key, position) + _update_curve(_points) + set_as_dirty() + emit_signal("points_modified") + + +func remove_point(key: int): + _points.remove_point(key) + _update_curve(_points) + set_as_dirty() + emit_signal("points_modified") + + +func remove_point_at_index(idx: int): + remove_point(get_point_key_at_index(idx)) + + +####################### +# POINT ARRAY WRAPPER # +####################### + + +func has_point(key: int) -> bool: + return _points.has_point(key) + + +func get_all_point_keys() -> Array: + return _points.get_all_point_keys() + + +func get_point_key_at_index(idx: int) -> int: + return _points.get_point_key_at_index(idx) + + +func get_point_at_index(idx: int) -> int: + return _points.get_point_at_index(idx) + + +func get_point_index(key: int) -> int: + return _points.get_point_index(key) + + +func set_point_in(key: int, v: Vector2): + """ + point_in controls the edge leading from the previous vertex to this one + """ + _points.set_point_in(key, v) + _update_curve(_points) + set_as_dirty() + emit_signal("points_modified") + + +func set_point_out(key: int, v: Vector2): + """ + point_out controls the edge leading from this vertex to the next + """ + _points.set_point_out(key, v) + _update_curve(_points) + set_as_dirty() + emit_signal("points_modified") + + +func get_point_in(key: int) -> Vector2: + return _points.get_point_in(key) + + +func get_point_out(key: int) -> Vector2: + return _points.get_point_out(key) + + +func get_closest_point(to_point: Vector2): + if _curve != null: + return _curve.get_closest_point(to_point) + return null + + +func get_closest_point_straight_edge(to_point: Vector2): + if _curve != null: + return _curve_no_control_points.get_closest_point(to_point) + return null + + +func get_closest_offset_straight_edge(to_point: Vector2): + if _curve != null: + return _curve_no_control_points.get_closest_offset(to_point) + return null + + +func get_closest_offset(to_point: Vector2): + if _curve != null: + return _curve.get_closest_offset(to_point) + return null + + +func disable_constraints(): + _points.disable_constraints() + + +func enable_constraints(): + _points.enable_constraints() + + +func get_point_count(): + return _points.get_point_count() + + +func get_edges() -> Array: + return _edges + + +func get_point_position(key: int): + return _points.get_point_position(key) + + +func get_point(key: int): + return _points.get_point(key) + + +func get_point_constraints(key: int): + return _points.get_point_constraints(key) + + +func get_point_constraint(key1: int, key2: int): + return _points.get_point_constraint(key1, key2) + + +func set_constraint(key1: int, key2: int, c: int): + return _points.set_constraint(key1, key2, c) + + +func set_point(key: int, value: SS2D_Point): + _points.set_point(key, value) + _update_curve(_points) + set_as_dirty() + + +func set_point_width(key: int, w: float): + var props = _points.get_point_properties(key) + props.width = w + _points.set_point_properties(key, props) + set_as_dirty() + + +func get_point_width(key: int) -> float: + return _points.get_point_properties(key).width + + +func set_point_texture_index(key: int, tex_idx: int): + var props = _points.get_point_properties(key) + props.texture_idx = tex_idx + _points.set_point_properties(key, props) + + +func get_point_texture_index(key: int) -> int: + return _points.get_point_properties(key).texture_idx + + +func set_point_texture_flip(key: int, flip: bool): + var props = _points.get_point_properties(key) + props.flip = flip + _points.set_point_properties(key, props) + + +func get_point_texture_flip(key: int) -> bool: + return _points.get_point_properties(key).flip + + +func get_point_properties(key: int): + return _points.get_point_properties(key) + + +func set_point_properties(key: int, properties): + return _points.set_point_properties(key, properties) + + +######### +# GODOT # +######### +func _init(): + # Assigning an empty dict to material_overrides this way + # instead of assigning in the declaration appears to bypass + # a weird Godot bug where material_overrides of one shape + # interfere with another + if material_overrides == null: + material_overrides = {} + + +func _ready(): + if _curve == null: + _curve = Curve2D.new() + _update_curve(_points) + for mat in material_overrides.values(): + mat.connect("changed", self, "_handle_material_change") + if not _is_instantiable: + push_error("'%s': SS2D_Shape_Base should not be instantiated! Use a Sub-Class!" % name) + queue_free() + + +func _get_rendering_nodes_parent() -> SS2D_Shape_Render: + var render_parent_name = "_SS2D_RENDER" + var render_parent = null + if not has_node(render_parent_name): + render_parent = SS2D_Shape_Render.new() + render_parent.name = render_parent_name + render_parent.light_mask = light_mask + add_child(render_parent) + if editor_debug and Engine.editor_hint: + render_parent.set_owner(get_tree().edited_scene_root) + else: + render_parent = get_node(render_parent_name) + return render_parent + + +""" +Returns true if the children have changed +""" + + +func _create_rendering_nodes(size: int) -> bool: + var render_parent = _get_rendering_nodes_parent() + var child_count = render_parent.get_child_count() + var delta = size - child_count + #print ("%s | %s | %s" % [child_count, size, delta]) + # Size and child_count match + if delta == 0: + return false + + # More children than needed + elif delta < 0: + var children = render_parent.get_children() + for i in range(0, abs(delta), 1): + var child = children[child_count - 1 - i] + render_parent.remove_child(child) + child.set_mesh(null) + child.queue_free() + + # Fewer children than needed + elif delta > 0: + for i in range(0, delta, 1): + var child = SS2D_Shape_Render.new() + child.light_mask = light_mask + render_parent.add_child(child) + if editor_debug and Engine.editor_hint: + child.set_owner(get_tree().edited_scene_root) + return true + + +""" +Takes an array of SS2D_Meshes and returns a flat array of SS2D_Meshes +If a SS2D_Mesh has n meshes, will return an array contain n SS2D_Mesh +The returned array will consist of SS2D_Meshes each with a SS2D_Mesh::meshes array of size 1 +""" + + +func _draw_flatten_meshes_array(meshes: Array) -> Array: + var flat_meshes = [] + for ss2d_mesh in meshes: + for godot_mesh in ss2d_mesh.meshes: + var new_mesh = ss2d_mesh.duplicate(false) + new_mesh.meshes = [godot_mesh] + flat_meshes.push_back(new_mesh) + return flat_meshes + + +func _draw(): + var flat_meshes = _draw_flatten_meshes_array(_meshes) + _create_rendering_nodes(flat_meshes.size()) + var render_parent = _get_rendering_nodes_parent() + var render_nodes = render_parent.get_children() + #print ("RENDER | %s" % [render_nodes]) + #print ("MESHES | %s" % [flat_meshes]) + for i in range(0, flat_meshes.size(), 1): + var m = flat_meshes[i] + var render_node = render_nodes[i] + render_node.set_mesh(m) + + if editor_debug and Engine.editor_hint: + _draw_debug(sort_by_z_index(_edges)) + + +func _draw_debug(edges: Array): + for e in edges: + for q in e.quads: + q.render_lines(self) + + var _range = range(0, e.quads.size(), 1) + for i in _range: + var q = e.quads[i] + if not (i % 3 == 0): + continue + q.render_points(3, 0.5, self) + + for i in _range: + var q = e.quads[i] + if not ((i + 1) % 3 == 0): + continue + q.render_points(2, 0.75, self) + + for i in _range: + var q = e.quads[i] + if not ((i + 2) % 3 == 0): + continue + q.render_points(1, 1.0, self) + + +func _process(delta): + _on_dirty_update() + + +func _exit_tree(): + 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: + # XOR operator + return not (are_points_clockwise() != flip_edges) + + +func generate_collision_points() -> PoolVector2Array: + var points: PoolVector2Array = PoolVector2Array() + var collision_width = 1.0 + var collision_extends = 0.0 + var verts = get_vertices() + var t_points = get_tessellated_points() + if t_points.size() < 2: + return points + var indicies = [] + for i in range(verts.size()): + indicies.push_back(i) + var edge_data = EdgeMaterialData.new(indicies, null) + var edge = _build_edge_without_material( + edge_data, Vector2(collision_size, collision_size), 1.0, collision_offset - 1.0, 0.0 + ) + # TODO, this belogns in _build_edge_without_material + _weld_quad_array(edge.quads, 1.0, false) + if not edge.quads.empty(): + # Top edge (typically point A unless corner quad) + for quad in edge.quads: + if quad.corner == SS2D_Quad.CORNER.NONE: + points.push_back(quad.pt_a) + elif quad.corner == SS2D_Quad.CORNER.OUTER: + points.push_back(quad.pt_d) + elif quad.corner == SS2D_Quad.CORNER.INNER: + pass + + # Right Edge (point d, the first or final quad will never be a corner) + points.push_back(edge.quads[edge.quads.size() - 1].pt_d) + + # Bottom Edge (typically point c) + for quad_index in edge.quads.size(): + var quad = edge.quads[edge.quads.size() - 1 - quad_index] + if quad.corner == SS2D_Quad.CORNER.NONE: + points.push_back(quad.pt_c) + elif quad.corner == SS2D_Quad.CORNER.OUTER: + pass + elif quad.corner == SS2D_Quad.CORNER.INNER: + points.push_back(quad.pt_b) + + # Left Edge (point b) + points.push_back(edge.quads[0].pt_b) + + return points + + +func bake_collision(): + if not has_node(collision_polygon_node_path): + return + var polygon = get_node(collision_polygon_node_path) + var points = generate_collision_points() + var transformed_points = PoolVector2Array() + var poly_transform = polygon.get_global_transform() + var shape_transform = get_global_transform() + for p in points: + transformed_points.push_back(poly_transform.xform_inv(shape_transform.xform(p))) + polygon.polygon = transformed_points + + +func cache_edges(): + if shape_material != null and render_edges: + _edges = _build_edges(shape_material, false) + else: + _edges = [] + + +func cache_meshes(): + if shape_material != null: + _meshes = _build_meshes(sort_by_z_index(_edges)) + + +func _build_meshes(edges: Array) -> Array: + var meshes = [] + + # Produce edge Meshes + for e in edges: + for m in e.get_meshes(): + meshes.push_back(m) + + return meshes + + +func _convert_local_space_to_uv(point: Vector2, size: Vector2) -> Vector2: + var pt: Vector2 = point + var rslt: Vector2 = Vector2(pt.x / size.x, pt.y / size.y) + return rslt + + +static func on_segment(p: Vector2, q: Vector2, r: Vector2) -> bool: + """ + Given three colinear points p, q, r, the function checks if point q lies on line segment 'pr' + See: https://www.geeksforgeeks.org/check-if-two-given-line-segments-intersect/ + """ + if ( + q.x <= max(p.x, r.x) + and q.x >= min(p.x, r.x) + and q.y <= max(p.y, r.y) + and q.y >= min(p.y, r.y) + ): + return true + return false + +static func get_points_orientation(points: Array) -> int: + var point_count = points.size() + if point_count < 3: + return ORIENTATION.COLINEAR + + var sum = 0.0 + for i in point_count: + var pt = points[i] + var pt2 = points[(i + 1) % point_count] + sum += pt.cross(pt2) + + # Colinear + if sum == 0: + return ORIENTATION.COLINEAR + + # Clockwise + if sum > 0.0: + return ORIENTATION.CLOCKWISE + return ORIENTATION.C_CLOCKWISE + + +func are_points_clockwise() -> bool: + var points = get_tessellated_points() + var orient = get_points_orientation(points) + return orient == ORIENTATION.CLOCKWISE + + +func _add_uv_to_surface_tool(surface_tool: SurfaceTool, uv: Vector2): + surface_tool.add_uv(uv) + surface_tool.add_uv2(uv) + + +func _build_quad_from_point( + pt: Vector2, + pt_next: Vector2, + tex: Texture, + tex_normal: Texture, + tex_size: Vector2, + width: float, + flip_x: bool, + flip_y: bool, + first_point: bool, + last_point: bool, + custom_scale: float, + custom_offset: float, + custom_extends: float, + fit_texture: int +) -> SS2D_Quad: + var quad = SS2D_Quad.new() + quad.texture = tex + quad.texture_normal = tex_normal + quad.color = Color(1.0, 1.0, 1.0, 1.0) + + var delta = pt_next - pt + var delta_normal = delta.normalized() + var normal = Vector2(delta.y, -delta.x).normalized() + var normal_rotation = Vector2(0, -1).angle_to(normal) + + # This will prevent the texture from rendering incorrectly if they differ + var vtx_len = tex_size.y + var vtx: Vector2 = normal * (vtx_len * 0.5) + if flip_y: + vtx *= -1 + + var offset = vtx * custom_offset + custom_scale = 1 + var width_scale = vtx * custom_scale * width + + if first_point: + pt -= (delta_normal * tex_size * custom_extends) + if last_point: + pt_next -= (delta_normal * tex_size * custom_extends) + + ######################################## + # QUAD POINT ILLUSTRATION # # + ######################################## + # pt_a -> O--------O <- pt_d # + # | | # + # | pt | # + # | | # + # pt_b -> O--------O <- pt_c # + ######################################## + quad.pt_a = pt + width_scale + offset + quad.pt_b = pt - width_scale + offset + quad.pt_c = pt_next - width_scale + offset + quad.pt_d = pt_next + width_scale + offset + quad.flip_texture = flip_x + quad.fit_texture = fit_texture + + return quad + + +func _build_edge_without_material( + edge_dat: EdgeMaterialData, size: Vector2, c_scale: float, c_offset: float, c_extends: float +) -> SS2D_Edge: + var edge = SS2D_Edge.new() + if not edge_dat.is_valid(): + return edge + + var first_idx = edge_dat.indicies[0] + var last_idx = edge_dat.indicies.back() + 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 t_points = get_tessellated_points() + var points = get_vertices() + var first_t_idx = get_tessellated_idx_from_point(points, t_points, first_idx) + var last_t_idx = get_tessellated_idx_from_point(points, t_points, last_idx) + var tess_points_covered: int = 0 + var wrap_around: bool = false + for i in range(edge_dat.indicies.size() - 1): + var this_idx = edge_dat.indicies[i] + var next_idx = edge_dat.indicies[i + 1] + # If closed shape and we wrap around + if this_idx > next_idx: + tess_points_covered += 1 + wrap_around = true + continue + var this_t_idx = get_tessellated_idx_from_point(points, t_points, this_idx) + var next_t_idx = get_tessellated_idx_from_point(points, t_points, next_idx) + var delta = next_t_idx - this_t_idx + tess_points_covered += delta + + for i in range(tess_points_covered): + var tess_idx = (first_t_idx + i) % t_points.size() + var tess_idx_next = _get_next_point_index(tess_idx, t_points, wrap_around) + var tess_idx_prev = _get_previous_point_index(tess_idx, t_points, wrap_around) + var vert_idx = get_vertex_idx_from_tessellated_point(points, t_points, tess_idx) + var next_vert_idx = vert_idx + 1 + var pt = t_points[tess_idx] + var pt_next = t_points[tess_idx_next] + var pt_prev = t_points[tess_idx_prev] + var generate_corner = SS2D_Quad.CORNER.NONE + if tess_idx != last_t_idx and tess_idx != first_t_idx: + var ab = pt - pt_prev + var bc = pt_next - pt + var dot_prod = ab.dot(bc) + var determinant = (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 = rad2deg(angle) + var dir = 0 + var corner_range = 10.0 + var corner_angle = 90.0 + if abs(deg) >= corner_angle - corner_range and abs(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 + + var width = _get_width_for_tessellated_point(points, t_points, tess_idx) + var is_first_point = vert_idx == first_idx + var is_last_point = vert_idx == last_idx - 1 + var is_first_tess_point = tess_idx == first_t_idx + var is_last_tess_point = tess_idx == last_t_idx - 1 + + var new_quad = _build_quad_from_point( + pt, + pt_next, + null, + null, + size, + width, + false, + should_flip_edges(), + is_first_point, + is_last_point, + c_scale, + c_offset, + c_extends, + SS2D_Material_Edge.FITMODE.SQUISH_AND_STRETCH + ) + var new_quads = [] + new_quads.push_back(new_quad) + + # Corner Quad + if generate_corner != SS2D_Quad.CORNER.NONE and not is_first_tess_point: + var tess_pt_next = t_points[tess_idx_next] + var tess_pt_prev = t_points[tess_idx_prev] + var tess_pt = t_points[tess_idx] + var prev_width = _get_width_for_tessellated_point(points, t_points, tess_idx_prev) + var corner_quad = build_quad_corner( + tess_pt_next, + tess_pt, + tess_pt_prev, + width, + prev_width, + generate_corner, + null, + null, + size, + c_scale, + c_offset + ) + new_quads.push_front(corner_quad) + + # Add new quads to edge + for q in new_quads: + edge.quads.push_back(q) + + return edge + + +func build_quad_corner( + pt_next: Vector2, + pt: Vector2, + pt_prev: Vector2, + pt_width: float, + pt_prev_width: float, + corner_status: int, + texture: Texture, + texture_normal: Texture, + size: Vector2, + custom_scale: float, + custom_offset: float +) -> SS2D_Quad: + var new_quad = SS2D_Quad.new() + + var extents = size / 2.0 + var delta_12 = pt - pt_prev + var delta_23 = pt_next - pt + var normal_23 = Vector2(delta_23.y, -delta_23.x).normalized() + var normal_12 = Vector2(delta_12.y, -delta_12.x).normalized() + var width = (pt_prev_width + pt_width) / 2.0 + var center = pt + (delta_12.normalized() * extents) + + var offset_12 = normal_12 * custom_scale * pt_width * extents + var offset_23 = normal_23 * custom_scale * pt_prev_width * extents + var custom_offset_13 = (normal_12 + normal_23) * custom_offset * extents + if flip_edges: + offset_12 *= -1 + offset_23 *= -1 + custom_offset_13 *= -1 + + var pt_d = pt + (offset_23) + (offset_12) + custom_offset_13 + var pt_a = pt - (offset_23) + (offset_12) + custom_offset_13 + var pt_c = pt + (offset_23) - (offset_12) + custom_offset_13 + var pt_b = pt - (offset_23) - (offset_12) + custom_offset_13 + new_quad.pt_a = pt_a + new_quad.pt_b = pt_b + new_quad.pt_c = pt_c + new_quad.pt_d = pt_d + + new_quad.corner = corner_status + new_quad.texture = texture + new_quad.texture_normal = texture_normal + + return new_quad + + +func _get_width_for_tessellated_point(points: Array, t_points: Array, t_idx) -> float: + var v_idx = get_vertex_idx_from_tessellated_point(points, t_points, t_idx) + var v_idx_next = _get_next_point_index(v_idx, points) + var w1 = _points.get_point_properties(_points.get_point_key_at_index(v_idx)).width + var w2 = _points.get_point_properties(_points.get_point_key_at_index(v_idx_next)).width + var ratio = get_ratio_from_tessellated_point_to_vertex(points, t_points, t_idx) + return lerp(w1, w2, ratio) + + +""" +Mutates two quads to be welded +returns the midpoint of the weld +""" + + +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 = (a.pt_d + b.pt_a) * 0.5 + var pt2 = (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, custom_scale: float, weld_first_and_last: bool, start_idx: int = 0 +): + if quads.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] + var mid_point = _weld_quads(this_quad, next_quad, custom_scale) + # 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(index) + if index < quads.size(): + var new_index = max(index - 1, 0) + _weld_quad_array(quads, custom_scale, weld_first_and_last, new_index) + return + + if weld_first_and_last: + _weld_quads(quads.back(), quads[0], 1.0) + + +func _build_edges(s_mat: SS2D_Material_Shape, wrap_around: bool) -> Array: + var edges: Array = [] + if s_mat == null: + return edges + + var emds = get_edge_material_data(s_mat, wrap_around) + for emd in emds: + var new_edge = _build_edge_with_material(emd, s_mat.render_offset, wrap_around) + edges.push_back(new_edge) + + return edges + + +""" +Will return an array of EdgeMaterialData from the current set of points +""" + + +func get_edge_material_data(s_material: SS2D_Material_Shape, wrap_around: bool) -> Array: + var points = get_vertices() + var final_edges: Array = [] + var edge_building: Dictionary = {} + for idx in range(0, points.size() - 1, 1): + var idx_next = _get_next_point_index(idx, points) + var pt = points[idx] + var pt_next = points[idx_next] + var delta = pt_next - pt + var delta_normal = delta.normalized() + var normal = Vector2(delta.y, -delta.x).normalized() + + # Get all valid edge_meta_materials for this normal value + var edge_meta_materials: Array = s_material.get_edge_meta_materials(normal) + + # Override the material for this point? + var keys = [get_point_key_at_index(idx), get_point_key_at_index(idx_next)] + var override_tuple = keys + var override = null + if has_material_override(override_tuple): + override = get_material_override(override_tuple) + if override != null: + if not override.render: + # Closeout all edge building + for e in edge_building.keys(): + final_edges.push_back(edge_building[e]) + edge_building.erase(e) + continue + # If a material is specified to be used, use it + if override.edge_material != null: + edge_meta_materials = [override] + + # Append to existing edges being built. Add new ones if needed + for e in edge_meta_materials: + if edge_building.has(e): + edge_building[e].indicies.push_back(idx_next) + else: + edge_building[e] = EdgeMaterialData.new([idx, idx_next], e) + + # Closeout and stop building edges that are no longer viable + for e 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 in edge_building.keys(): + final_edges.push_back(edge_building[e]) + + # See if edges that contain the final point can be merged with those that contain the first point + if wrap_around: + # Sort edges into two lists, those that contain the first point and those that contain the last point + var first_edges = [] + var last_edges = [] + for e in final_edges: + var has_first = e.indicies.has(get_first_point_index(points)) + var has_last = e.indicies.has(get_last_point_index(points)) + # XOR operator + if has_first != has_last: + if has_first: + first_edges.push_back(e) + elif has_last: + last_edges.push_back(e) + # Contains all points + elif has_first and has_last: + e.first_connected_to_final = true + + # Create new Edges with Merged points; Add created edges, delete edges used to for merging + var edges_to_add = [] + var edges_to_remove = [] + for first in first_edges: + for last in last_edges: + if first.meta_material == last.meta_material: + #print ("Orignal: %s | %s" % [first.indicies, last.indicies]) + var merged = SS2D_Common_Functions.merge_arrays([last.indicies, first.indicies]) + #print ("Merged: %s" % str(merged)) + var new_edge = EdgeMaterialData.new(merged, first.meta_material) + edges_to_add.push_back(new_edge) + if not edges_to_remove.has(first): + edges_to_remove.push_back(first) + if not edges_to_remove.has(last): + edges_to_remove.push_back(last) + + # Update final edges + for e in edges_to_remove: + var i = final_edges.find(e) + final_edges.remove(i) + for e in edges_to_add: + final_edges.push_back(e) + + return final_edges + + +######## +# MISC # +######## +func _handle_material_change(): + set_as_dirty() + + +func set_as_dirty(): + _dirty = true + + +func get_collision_polygon_node() -> Node: + if collision_polygon_node_path == null: + return null + if not has_node(collision_polygon_node_path): + return null + return get_node(collision_polygon_node_path) + + +static func sort_by_z_index(a: Array) -> Array: + a.sort_custom(SS2D_Common_Functions, "sort_z") + return a + + +func clear_cached_data(): + _edges = [] + _meshes = [] + + +func has_minimum_point_count() -> bool: + return get_point_count() >= 2 + + +func _on_dirty_update(): + if _dirty: + update_render_nodes() + clear_cached_data() + if has_minimum_point_count(): + bake_collision() + cache_edges() + cache_meshes() + update() + _dirty = false + emit_signal("on_dirty_update") + + +func get_first_point_index(points: Array) -> int: + return 0 + + +func get_last_point_index(points: Array) -> int: + return get_point_count() - 1 + + +func _get_next_point_index(idx: int, points: Array, wrap_around: bool = false) -> int: + if wrap_around: + return _get_next_point_index_wrap_around(idx, points) + return _get_next_point_index_no_wrap_around(idx, points) + + +func _get_previous_point_index(idx: int, points: Array, wrap_around: bool = false) -> int: + if wrap_around: + return _get_previous_point_index_wrap_around(idx, points) + return _get_previous_point_index_no_wrap_around(idx, points) + + +func _get_next_point_index_no_wrap_around(idx: int, points: Array) -> int: + return int(min(idx + 1, points.size() - 1)) + + +func _get_previous_point_index_no_wrap_around(idx: int, points: Array) -> int: + return int(max(idx - 1, 0)) + + +func _get_next_point_index_wrap_around(idx: int, points: Array) -> int: + return (idx + 1) % points.size() + + +func _get_previous_point_index_wrap_around(idx: int, points: Array) -> int: + var temp = idx - 1 + while temp < 0: + temp += points.size() + return temp + + +func get_ratio_from_tessellated_point_to_vertex(points: Array, t_points: Array, t_point_idx: int) -> float: + """ + Returns a float between 0.0 and 1.0 + 0.0 means that this tessellated point is at the same position as the vertex + 0.5 means that this tessellated point is half-way between this vertex and the next + 0.999 means that this tessellated point is basically at the next vertex + 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 + """ + if t_point_idx == 0: + return 0.0 + + var vertex_idx = 0 + # The total tessellated points betwen two verts + var tess_point_count = 0 + # The index of the passed t_point_idx relative to the starting vert + var tess_index_count = 0 + for i in range(0, t_points.size(), 1): + var tp = t_points[i] + var p = points[vertex_idx] + tess_point_count += 1 + + if i <= t_point_idx: + tess_index_count += 1 + + if tp == p: + if i < t_point_idx: + vertex_idx += 1 + tess_point_count = 0 + tess_index_count = 0 + else: + break + + var result = fmod(float(tess_index_count) / float(tess_point_count), 1.0) + return result + + +func get_vertex_idx_from_tessellated_point(points: Array, t_points: Array, t_point_idx: int) -> int: + if t_point_idx == 0: + return 0 + + var vertex_idx = -1 + for i in range(0, t_point_idx + 1, 1): + var tp = t_points[i] + var p = points[vertex_idx + 1] + if tp == p: + vertex_idx += 1 + return vertex_idx + + +func get_tessellated_idx_from_point(points: Array, t_points: Array, point_idx: int) -> int: + if point_idx == 0: + return 0 + + var vertex_idx = -1 + var tess_idx = 0 + for i in range(0, t_points.size(), 1): + tess_idx = i + var tp = t_points[i] + var p = points[vertex_idx + 1] + if tp == p: + vertex_idx += 1 + if vertex_idx == point_idx: + break + return tess_idx + + +# Workaround (class cannot reference itself) +func __new(): + return get_script().new() + + +func debug_print_points(): + _points.debug_print() + + +# Should be overridden by children +func import_from_legacy(legacy: RMSmartShape2D): + pass + + +################### +# EDGE GENERATION # +################### +class EdgeMaterialData: + var meta_material: SS2D_Material_Edge_Metadata + var indicies: Array = [] + var first_connected_to_final: bool = false + + func _init(i: Array, m: SS2D_Material_Edge_Metadata): + meta_material = m + indicies = i + + func _to_string() -> String: + return "[EMD] (%s) | %s" % [str(meta_material), indicies] + + func is_valid() -> bool: + return indicies.size() >= 2 + + +func _edge_data_get_tess_point_count(ed: EdgeMaterialData) -> int: + """ + Get Number of TessPoints from the start and end indicies of the ed parameter + """ + var count: int = 0 + var points = get_vertices() + var t_points = get_tessellated_points() + for i in range(ed.indicies.size() - 1): + var this_idx = ed.indicies[i] + var next_idx = ed.indicies[i + 1] + if this_idx > next_idx: + count += 1 + continue + var this_t_idx = get_tessellated_idx_from_point(points, t_points, this_idx) + var next_t_idx = get_tessellated_idx_from_point(points, t_points, next_idx) + var delta = next_t_idx - this_t_idx + count += delta + return count + + +func _edge_should_generate_corner(pt_prev: Vector2, pt: Vector2, pt_next: Vector2) -> bool: + var generate_corner = SS2D_Quad.CORNER.NONE + var ab = pt - pt_prev + var bc = pt_next - pt + var dot_prod = ab.dot(bc) + var determinant = (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 = rad2deg(angle) + var dir = 0 + var corner_range = 10.0 + var corner_angle = 90.0 + if abs(deg) >= corner_angle - corner_range and abs(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, + edge_material: SS2D_Material_Edge, + texture_idx: int, + c_scale: float, + c_offset: float +): + var generate_corner = _edge_should_generate_corner(pt_prev, pt, pt_next) + if generate_corner == SS2D_Quad.CORNER.NONE: + return null + var corner_texture = null + var corner_texture_normal = null + if generate_corner == SS2D_Quad.CORNER.OUTER: + corner_texture = edge_material.get_texture_corner_outer(texture_idx) + corner_texture_normal = edge_material.get_texture_normal_corner_outer(texture_idx) + elif generate_corner == SS2D_Quad.CORNER.INNER: + corner_texture = edge_material.get_texture_corner_inner(texture_idx) + corner_texture_normal = edge_material.get_texture_normal_corner_inner(texture_idx) + if corner_texture == null: + return null + var corner_quad = build_quad_corner( + pt_next, + pt, + pt_prev, + width, + width_prev, + generate_corner, + corner_texture, + corner_texture_normal, + corner_texture.get_size(), + c_scale, + c_offset + ) + return corner_quad + + +func _get_next_unique_point_idx(idx: int, pts: Array, wrap_around: bool): + var next_idx = _get_next_point_index(idx, pts, wrap_around) + if next_idx == idx: + return idx + var pt1 = pts[idx] + var pt2 = pts[next_idx] + if pt1 == pt2: + return _get_next_unique_point_idx(next_idx, pts, wrap_around) + return next_idx + + +func _get_previous_unique_point_idx(idx: int, pts: Array, wrap_around: bool): + var previous_idx = _get_previous_point_index(idx, pts, wrap_around) + if previous_idx == idx: + return idx + var pt1 = pts[idx] + var pt2 = pts[previous_idx] + if pt1 == pt2: + return _get_previous_unique_point_idx(previous_idx, pts, wrap_around) + return previous_idx + + +func _build_edge_with_material(edge_data: EdgeMaterialData, c_offset: float, wrap_around: bool) -> SS2D_Edge: + var edge = SS2D_Edge.new() + edge.z_index = edge_data.meta_material.z_index + edge.z_as_relative = edge_data.meta_material.z_as_relative + edge.material = edge_data.meta_material.edge_material.material + if not edge_data.is_valid(): + return edge + + var t_points = get_tessellated_points() + var points = get_vertices() + var first_idx = edge_data.indicies[0] + var last_idx = edge_data.indicies.back() + 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 first_t_idx = get_tessellated_idx_from_point(points, t_points, first_idx) + var last_t_idx = get_tessellated_idx_from_point(points, t_points, last_idx) + + var edge_material_meta: SS2D_Material_Edge_Metadata = edge_data.meta_material + if edge_material_meta == null: + return edge + if not edge_material_meta.render: + return edge + edge.z_index = edge_material_meta.z_index + + var edge_material: SS2D_Material_Edge = edge_material_meta.edge_material + if edge_material == null: + return edge + + var tess_point_count: int = _edge_data_get_tess_point_count(edge_data) + + var c_scale = 1.0 + c_offset += edge_material_meta.offset + var c_extends = 0.0 + var i = 0 + while i < tess_point_count: + var tess_idx = (first_t_idx + i) % t_points.size() + var tess_idx_next = _get_next_unique_point_idx(tess_idx, t_points, wrap_around) + var tess_idx_prev = _get_previous_unique_point_idx(tess_idx, t_points, wrap_around) + var next_point_delta = 0 + for j in range(t_points.size()): + if ((tess_idx + j) % t_points.size()) == tess_idx_next: + next_point_delta = j + break + + var vert_idx = get_vertex_idx_from_tessellated_point(points, t_points, tess_idx) + var vert_key = get_point_key_at_index(vert_idx) + var next_vert_idx = _get_next_point_index(vert_idx, points, wrap_around) + var pt = t_points[tess_idx] + var pt_next = t_points[tess_idx_next] + var pt_prev = t_points[tess_idx_prev] + + var texture_idx = get_point_texture_index(vert_key) + var flip_x = get_point_texture_flip(vert_key) + + var width = _get_width_for_tessellated_point(points, t_points, tess_idx) + var is_first_point = vert_idx == first_idx + var is_last_point = vert_idx == last_idx - 1 + var is_first_tess_point = tess_idx == first_t_idx + var is_last_tess_point = tess_idx == last_t_idx - 1 + + var tex = edge_material.get_texture(texture_idx) + var tex_normal = edge_material.get_texture_normal(texture_idx) + if tex == null: + i += next_point_delta + continue + var tex_size = tex.get_size() + var new_quad = _build_quad_from_point( + pt, + pt_next, + tex, + tex_normal, + tex_size, + width, + flip_x, + should_flip_edges(), + is_first_point, + is_last_point, + c_scale, + c_offset, + c_extends, + edge_material.fit_mode + ) + var new_quads = [] + new_quads.push_back(new_quad) + + # Corner Quad + if tess_idx != first_t_idx: + var prev_width = _get_width_for_tessellated_point(points, t_points, tess_idx_prev) + var q = _edge_generate_corner( + pt_prev, + pt, + pt_next, + prev_width, + width, + edge_material, + texture_idx, + c_scale, + c_offset + ) + if q != null: + new_quads.push_front(q) + + # Taper Quad + if is_first_tess_point or is_last_tess_point: + var taper_texture = null + var taper_texture_normal = null + if is_first_tess_point: + taper_texture = edge_material.get_texture_taper_left(texture_idx) + taper_texture_normal = edge_material.get_texture_normal_taper_left(texture_idx) + elif is_last_tess_point: + taper_texture = edge_material.get_texture_taper_right(texture_idx) + taper_texture_normal = edge_material.get_texture_normal_taper_right(texture_idx) + if taper_texture != null: + var taper_size = taper_texture.get_size() + var fit = abs(taper_size.x) <= new_quad.get_length_average() + if fit: + var taper_quad = new_quad.duplicate() + taper_quad.corner = 0 + taper_quad.texture = taper_texture + taper_quad.texture_normal = taper_texture_normal + var delta_normal = (taper_quad.pt_d - taper_quad.pt_a).normalized() + var offset = delta_normal * taper_size + + if is_first_tess_point: + taper_quad.pt_d = taper_quad.pt_a + offset + taper_quad.pt_c = taper_quad.pt_b + offset + new_quad.pt_a = taper_quad.pt_d + new_quad.pt_b = taper_quad.pt_c + new_quads.push_front(taper_quad) + elif is_last_tess_point: + taper_quad.pt_a = taper_quad.pt_d - offset + taper_quad.pt_b = taper_quad.pt_c - offset + new_quad.pt_d = taper_quad.pt_a + new_quad.pt_c = taper_quad.pt_b + new_quads.push_back(taper_quad) + # If a new taper quad doesn't fit, re-texture the new_quad + else: + new_quad.texture = taper_texture + new_quad.texture_normal = taper_texture_normal + + # Final point for closed shapes fix + if is_last_point and edge_data.first_connected_to_final: + var idx_mid = t_points.size() - 1 + var idx_next = _get_next_unique_point_idx(idx_mid, t_points, true) + var idx_prev = _get_previous_unique_point_idx(idx_mid, t_points, true) + var p_p = t_points[idx_prev] + var p_m = t_points[idx_mid] + var p_n = t_points[idx_next] + var w_p = _get_width_for_tessellated_point(points, t_points, idx_prev) + var w_m = _get_width_for_tessellated_point(points, t_points, idx_mid) + var q = _edge_generate_corner( + p_p, p_m, p_n, w_p, w_m, 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 + if edge_material_meta.weld: + _weld_quad_array(edge.quads, 1.0, edge_data.first_connected_to_final) + edge.wrap_around = edge_data.first_connected_to_final + + return edge diff --git a/src/addons/rmsmartshape/shapes/shape_closed.gd b/src/addons/rmsmartshape/shapes/shape_closed.gd new file mode 100644 index 0000000..b6184ef --- /dev/null +++ b/src/addons/rmsmartshape/shapes/shape_closed.gd @@ -0,0 +1,365 @@ +tool +extends SS2D_Shape_Base +class_name SS2D_Shape_Closed, "../assets/closed_shape.png" + +########## +# CLOSED # +########## +""" +A Hole is a closed polygon +Orientation doesn't matter +Holes should not intersect each other +""" +var _holes = [] + + +func set_holes(holes: Array): + _holes = holes + + +func get_holes() -> Array: + return _holes + + +######### +# GODOT # +######### +func _init(): + ._init() + _is_instantiable = true + + +############ +# OVERRIDE # +############ +func remove_point(key: int): + _points.remove_point(key) + _close_shape() + _update_curve(_points) + set_as_dirty() + emit_signal("points_modified") + + +func set_point_array(a: SS2D_Point_Array, make_unique: bool = true): + if make_unique: + _points = a.duplicate(true) + else: + _points = a + _close_shape() + clear_cached_data() + _update_curve(_points) + set_as_dirty() + property_list_changed_notify() + + +func has_minimum_point_count() -> bool: + return _points.get_point_count() >= 3 + + +func duplicate_self(): + var _new = .duplicate() + return _new + + +# Workaround (class cannot reference itself) +func __new(): + return get_script().new() + + +func _build_meshes(edges: Array) -> Array: + var meshes = [] + + var produced_fill_mesh = false + for e in edges: + if not produced_fill_mesh: + if e.z_index > shape_material.fill_texture_z_index: + # Produce Fill Meshes + for m in _build_fill_mesh(get_tessellated_points(), shape_material): + meshes.push_back(m) + produced_fill_mesh = true + + # Produce edge Meshes + for m in e.get_meshes(): + meshes.push_back(m) + if not produced_fill_mesh: + for m in _build_fill_mesh(get_tessellated_points(), shape_material): + meshes.push_back(m) + produced_fill_mesh = true + return meshes + + +func do_edges_intersect(a1: Vector2, a2: Vector2, b1: Vector2, b2: Vector2) -> bool: + """ + Returns true if line segment 'a1a2' and 'b1b2' intersect. + Find the four orientations needed for general and special cases + """ + var o1: int = get_points_orientation([a1, a2, b1]) + var o2: int = get_points_orientation([a1, a2, b2]) + var o3: int = get_points_orientation([b1, b2, a1]) + var o4: int = get_points_orientation([b1, b2, a2]) + + # General case + if o1 != o2 and o3 != o4: + return true + + # Special Cases + # a1, a2 and b1 are colinear and b1 lies on segment p1q1 + if o1 == ORIENTATION.COLINEAR and on_segment(a1, b1, a2): + return true + + # a1, a2 and b2 are colinear and b2 lies on segment p1q1 + if o2 == ORIENTATION.COLINEAR and on_segment(a1, b2, a2): + return true + + # b1, b2 and a1 are colinear and a1 lies on segment p2q2 + if o3 == ORIENTATION.COLINEAR and on_segment(b1, a1, b2): + return true + + # b1, b2 and a2 are colinear and a2 lies on segment p2q2 + if o4 == ORIENTATION.COLINEAR and on_segment(b1, a2, b2): + return true + + # Doesn't fall in any of the above cases + return false + + +static func get_edge_intersection(a1: Vector2, a2: Vector2, b1: Vector2, b2: Vector2): + var den = (b2.y - b1.y) * (a2.x - a1.x) - (b2.x - b1.x) * (a2.y - a1.y) + + # Check if lines are parallel or coincident + if den == 0: + return null + + var ua = ((b2.x - b1.x) * (a1.y - b1.y) - (b2.y - b1.y) * (a1.x - b1.x)) / den + var ub = ((a2.x - a1.x) * (a1.y - b1.y) - (a2.y - a1.y) * (a1.x - b1.x)) / den + + if ua < 0 or ub < 0 or ua > 1 or ub > 1: + return null + + return Vector2(a1.x + ua * (a2.x - a1.x), a1.y + ua * (a2.y - a1.y)) + + +func _build_fill_mesh(points: Array, s_mat: SS2D_Material_Shape) -> Array: + var meshes = [] + if s_mat == null: + return meshes + if s_mat.fill_textures.empty(): + return meshes + if points.size() < 3: + return meshes + + var tex = null + if s_mat.fill_textures.empty(): + return meshes + tex = s_mat.fill_textures[0] + var tex_normal = null + if not s_mat.fill_texture_normals.empty(): + tex_normal = s_mat.fill_texture_normals[0] + var tex_size = tex.get_size() + + # Points to produce the fill mesh + var fill_points: PoolVector2Array = PoolVector2Array() + var polygons = Geometry.offset_polygon_2d( + PoolVector2Array(points), tex_size.x * s_mat.fill_mesh_offset + ) + points = polygons[0] + fill_points.resize(points.size()) + for i in range(points.size()): + fill_points[i] = points[i] + + # Produce the fill mesh + var fill_tris: PoolIntArray = Geometry.triangulate_polygon(fill_points) + if fill_tris.empty(): + push_error("'%s': Couldn't Triangulate shape" % name) + return [] + + var st: SurfaceTool + st = SurfaceTool.new() + st.begin(Mesh.PRIMITIVE_TRIANGLES) + + for i in range(0, fill_tris.size() - 1, 3): + st.add_color(Color.white) + _add_uv_to_surface_tool(st, _convert_local_space_to_uv(points[fill_tris[i]], tex_size)) + st.add_vertex(Vector3(points[fill_tris[i]].x, points[fill_tris[i]].y, 0)) + st.add_color(Color.white) + _add_uv_to_surface_tool(st, _convert_local_space_to_uv(points[fill_tris[i + 1]], tex_size)) + st.add_vertex(Vector3(points[fill_tris[i + 1]].x, points[fill_tris[i + 1]].y, 0)) + st.add_color(Color.white) + _add_uv_to_surface_tool(st, _convert_local_space_to_uv(points[fill_tris[i + 2]], tex_size)) + st.add_vertex(Vector3(points[fill_tris[i + 2]].x, points[fill_tris[i + 2]].y, 0)) + st.index() + st.generate_normals() + st.generate_tangents() + var array_mesh = st.commit() + var flip = false + var transform = Transform2D() + var mesh_data = SS2D_Mesh.new(tex, tex_normal, flip, transform, [array_mesh]) + mesh_data.material = s_mat.fill_mesh_material + mesh_data.z_index = s_mat.fill_texture_z_index + mesh_data.z_as_relative = true + meshes.push_back(mesh_data) + + return meshes + + +func _close_shape() -> bool: + """ + Will mutate the _points to ensure this is a closed_shape + last point will be constrained to first point + returns true if _points is modified + """ + if is_shape_closed(): + return false + if not has_minimum_point_count(): + return false + + var key_first = _points.get_point_key_at_index(0) + var key_last = _points.get_point_key_at_index(get_point_count() - 1) + + # If points are not the same pos, add new point + if get_point_position(key_first) != get_point_position(key_last): + key_last = _points.add_point(_points.get_point_position(key_first)) + + _points.set_constraint(key_first, key_last, SS2D_Point_Array.CONSTRAINT.ALL) + _add_point_update() + return true + + +func is_shape_closed() -> bool: + var point_count = _points.get_point_count() + if not has_minimum_point_count(): + return false + var key1 = _points.get_point_key_at_index(0) + var key2 = _points.get_point_key_at_index(point_count - 1) + return get_point_constraint(key1, key2) == SS2D_Point_Array.CONSTRAINT.ALL + + +func add_points(verts: Array, starting_index: int = -1, key: int = -1) -> Array: + for i in range(0, verts.size(), 1): + print("%s | %s" % [i, verts[i]]) + return .add_points(verts, adjust_add_point_index(starting_index), key) + + +func add_point(position: Vector2, index: int = -1, key: int = -1) -> int: + return .add_point(position, adjust_add_point_index(index), key) + + +func adjust_add_point_index(index: int) -> int: + # Don't allow a point to be added after the last point of the closed shape or before the first + if is_shape_closed(): + if index < 0 or (index > get_point_count() - 1): + index = max(get_point_count() - 1, 0) + if index < 1: + index = 1 + return index + + +func _add_point_update(): + # Return early if _close_shape() adds another point + # _add_point_update() will be called again by having another point added + if _close_shape(): + return + ._add_point_update() + + +func bake_collision(): + if not has_node(collision_polygon_node_path) or not is_shape_closed(): + return + var polygon = get_node(collision_polygon_node_path) + var collision_width = 1.0 + var collision_extends = 0.0 + var verts = get_vertices() + var t_points = get_tessellated_points() + if t_points.size() < 2: + return + var collision_quads = [] + for i in range(0, t_points.size() - 1, 1): + var tess_idx = i + var tess_idx_next = _get_next_point_index(i, t_points, true) + var tess_idx_prev = _get_previous_point_index(i, t_points, true) + var pt = t_points[tess_idx] + var pt_next = t_points[tess_idx_next] + var pt_prev = t_points[tess_idx_prev] + var width = _get_width_for_tessellated_point(verts, t_points, i) + collision_quads.push_back( + _build_quad_from_point( + pt, + pt_next, + null, + null, + Vector2(collision_size, collision_size), + width, + false, + should_flip_edges(), + i == 0, + i == t_points.size() - 1, + collision_width, + collision_offset - 1.0, + collision_extends, + SS2D_Material_Edge.FITMODE.SQUISH_AND_STRETCH + ) + ) + _weld_quad_array(collision_quads, 1.0, false) + var first_quad = collision_quads[0] + var last_quad = collision_quads.back() + _weld_quads(last_quad, first_quad, 1.0) + var points: PoolVector2Array = PoolVector2Array() + # PT A + for quad in collision_quads: + points.push_back( + polygon.get_global_transform().xform_inv(get_global_transform().xform(quad.pt_a)) + ) + + polygon.polygon = points + + +func _on_dirty_update(): + if _dirty: + update_render_nodes() + clear_cached_data() + # Close shape + _close_shape() + if has_minimum_point_count(): + bake_collision() + cache_edges() + cache_meshes() + update() + _dirty = false + emit_signal("on_dirty_update") + + +func cache_edges(): + if shape_material != null and render_edges: + _edges = _build_edges(shape_material, true) + else: + _edges = [] + + +func import_from_legacy(legacy: RMSmartShape2D): + # Sanity Check + if legacy == null: + push_error("LEGACY SHAPE IS NULL; ABORTING;") + return + if not legacy.closed_shape: + push_error("OPEN LEGACY SHAPE WAS SENT TO SS2D_SHAPE_CLOSED; ABORTING;") + return + + # Properties + editor_debug = legacy.editor_debug + flip_edges = legacy.flip_edges + render_edges = legacy.draw_edges + tessellation_stages = legacy.tessellation_stages + tessellation_tolerence = legacy.tessellation_tolerence + curve_bake_interval = legacy.collision_bake_interval + collision_polygon_node_path = legacy.collision_polygon_node + + # Points + _points.clear() + add_points(legacy.get_vertices()) + for i in range(0, legacy.get_point_count(), 1): + var key = get_point_key_at_index(i) + set_point_in(key, legacy.get_point_in(i)) + set_point_out(key, legacy.get_point_out(i)) + set_point_texture_index(key, legacy.get_point_texture_index(i)) + set_point_texture_flip(key, legacy.get_point_texture_flip(i)) + set_point_width(key, legacy.get_point_width(i)) diff --git a/src/addons/rmsmartshape/shapes/shape_combine_union.gd b/src/addons/rmsmartshape/shapes/shape_combine_union.gd new file mode 100644 index 0000000..d27a443 --- /dev/null +++ b/src/addons/rmsmartshape/shapes/shape_combine_union.gd @@ -0,0 +1,3 @@ +tool +extends Node2D +class_name SS2D_Shape_Combine_Union diff --git a/src/addons/rmsmartshape/shapes/shape_meta.gd b/src/addons/rmsmartshape/shapes/shape_meta.gd new file mode 100644 index 0000000..25ad9a9 --- /dev/null +++ b/src/addons/rmsmartshape/shapes/shape_meta.gd @@ -0,0 +1,118 @@ +tool +extends SS2D_Shape_Base +class_name SS2D_Shape_Meta, "../assets/meta_shape.png" + +""" +This shape will set the point_array data of all children shapes +""" + +export (bool) var press_to_update_cached_children = false setget _on_update_children +var _cached_shape_children: Array = [] + + +############# +# OVERRIDES # +############# +func _init(): + ._init() + _is_instantiable = true + + +func _ready(): + for s in _get_shapes(self): + _add_to_meta(s) + call_deferred("_update_cached_children") + ._ready() + + +func _draw(): + pass + + +func remove_child(node: Node): + _remove_from_meta(node) + call_deferred("_update_cached_children") + .remove_child(node) + + +func add_child(node: Node, legible_unique_name: bool = false): + _add_to_meta(node) + call_deferred("_update_cached_children") + .add_child(node, legible_unique_name) + + +func add_child_below_node(node: Node, child_node: Node, legible_unique_name: bool = false): + _add_to_meta(child_node) + call_deferred("_update_cached_children") + .add_child_below_node(node, child_node, legible_unique_name) + + +func _on_dirty_update(): + pass + + +func set_as_dirty(): + _update_shapes() + +######## +# META # +######## +func _on_update_children(ignore: bool): + #print("Updating Cached Children...") + _update_cached_children() + #print("...Updated") + + +func _update_cached_children(): + # TODO, need to be made aware when cached children's children change! + _cached_shape_children = _get_shapes(self) + if treat_as_closed(): + can_edit = false + if editor_debug: + print ("META Shape contains Closed shapes, edit the meta shape using the child closed shape; DO NOT EDIT META DIRECTLY") + else: + can_edit = true + if editor_debug: + print ("META Shape contains no Closed shapes, can edit META shape directly") + + +func _get_shapes(n: Node, a: Array = []) -> Array: + for c in n.get_children(): + if c is SS2D_Shape_Base: + a.push_back(c) + _get_shapes(c, a) + return a + + +func _add_to_meta(n: Node): + if not n is SS2D_Shape_Base: + return + # Assign node to have the same point array data as this meta shape + n.set_point_array(_points, false) + n.connect("points_modified", self, "_update_shapes", [[n]]) + + +func _update_shapes(except: Array = []): + _update_curve(_points) + for s in _cached_shape_children: + if not except.has(s): + s.set_as_dirty() + s._update_curve(s.get_point_array()) + + +func _remove_from_meta(n: Node): + if not n is SS2D_Shape_Base: + return + # Make Point Data Unique + n.set_point_array(n.get_point_array(), true) + n.disconnect("points_modified", self, "_update_shapes") + +func treat_as_closed()->bool: + var has_closed = false + for c in _cached_shape_children: + if c is SS2D_Shape_Closed: + has_closed = true + break + if has_closed: + return true + return false diff --git a/src/addons/rmsmartshape/shapes/shape_open.gd b/src/addons/rmsmartshape/shapes/shape_open.gd new file mode 100644 index 0000000..807d400 --- /dev/null +++ b/src/addons/rmsmartshape/shapes/shape_open.gd @@ -0,0 +1,60 @@ +tool +extends SS2D_Shape_Base +class_name SS2D_Shape_Open, "../assets/open_shape.png" + + +######### +# GODOT # +######### +func _init(): + ._init() + _is_instantiable = true + + + +############ +# OVERRIDE # +############ +func duplicate_self(): + var _new = .duplicate() + return _new + + +# Workaround (class cannot reference itself) +func __new(): + return get_script().new() + + +func should_flip_edges() -> bool: + return flip_edges + +func import_from_legacy(legacy:RMSmartShape2D): + # Sanity Check + if legacy == null: + push_error("LEGACY SHAPE IS NULL; ABORTING;") + return + if legacy.closed_shape: + push_error("CLOSED LEGACY SHAPE WAS SENT TO SS2D_SHAPE_OPEN; ABORTING;") + return + + # Properties + editor_debug = legacy.editor_debug + flip_edges = legacy.flip_edges + render_edges = legacy.draw_edges + tessellation_stages = legacy.tessellation_stages + tessellation_tolerence = legacy.tessellation_tolerence + curve_bake_interval = legacy.collision_bake_interval + collision_polygon_node_path = legacy.collision_polygon_node + + # Points + _points.clear() + add_points(legacy.get_vertices()) + for i in range(0, legacy.get_point_count(), 1): + var key = get_point_key_at_index(i) + set_point_in(key, legacy.get_point_in(i)) + set_point_out(key, legacy.get_point_out(i)) + set_point_texture_index(key, legacy.get_point_texture_index(i)) + set_point_texture_flip(key, legacy.get_point_texture_flip(i)) + set_point_width(key, legacy.get_point_width(i)) + + diff --git a/src/addons/rmsmartshape/shapes/shape_render.gd b/src/addons/rmsmartshape/shapes/shape_render.gd new file mode 100644 index 0000000..a102ab8 --- /dev/null +++ b/src/addons/rmsmartshape/shapes/shape_render.gd @@ -0,0 +1,27 @@ +tool +extends Node2D +class_name SS2D_Shape_Render + +""" +Node is used to render shape geometry +""" + +var mesh = null setget set_mesh + + +func set_mesh(m): + mesh = m + if m != null: + material = mesh.material + z_index = mesh.z_index + z_as_relative = mesh.z_as_relative + else: + material = null + z_index = 0 + z_as_relative = true + update() + + +func _draw(): + if mesh != null: + mesh.render(self) |