Add lever and jump pad components with activation logic

addons/rmsmartshape/materials/edge_material.gd

@@ -0,0 +1,156 @@
+@tool
+extends Resource
+class_name SS2D_Material_Edge
+
+## This material represents the set of textures used for a single edge.
+##
+## This consists of: [br]
+## - textures [br]
+## - corner_textures [br]
+## - taper_textures [br]
+
+## All variations of the main edge texture.[br]
+## _textures[0] is considered the "main" texture for the EdgeMaterial.[br][br]
+## [b]Note:[/b] Will be used to generate an icon representing an edge texture.[br]
+@export var textures: Array[Texture2D] = [] : set = _set_textures
+
+# Textures for the final left and right quad of the edge when the angle is steep
+@export var textures_corner_outer: Array[Texture2D] = [] : set = _set_textures_corner_outer
+@export var textures_corner_inner: Array[Texture2D] = [] : set = _set_textures_corner_inner
+
+# Textures for the final left and right quad of the edge when the angle is shallow
+# Named as such because the desired look is that the texture "tapers-off"
+@export var textures_taper_left: Array[Texture2D] = [] : set = _set_textures_taper_left
+@export var textures_taper_right: Array[Texture2D] = [] : set = _set_textures_taper_right
+
+## Textures that will be used for the sharp_corner_tapering feature
+@export var textures_taper_corner_left: Array[Texture2D] = [] : set = _set_textures_taper_corner_left
+@export var textures_taper_corner_right: Array[Texture2D] = [] : set = _set_textures_taper_corner_right
+
+## If the texture choice should be randomized instead of the choice by point setup
+@export var randomize_texture: bool = false : set = _set_randomize_texture
+## If corner textures should be used
+@export var use_corner_texture: bool = true : set = _set_use_corner
+## If taper textures should be used
+@export var use_taper_texture: bool = true : set = _set_use_taper
+
+## Whether squishing can occur when texture doesn't fit nicely into total length.
+enum FITMODE {SQUISH_AND_STRETCH, CROP}
+@export var fit_mode: FITMODE = FITMODE.SQUISH_AND_STRETCH : set = _set_fit_texture
+
+@export var material: Material = null : set = _set_material
+
+
+###########
+# SETTERS #
+###########
+func _set_textures(ta: Array[Texture2D]) -> void:
+	textures = ta
+	emit_changed()
+
+
+func _set_textures_corner_outer(a: Array[Texture2D]) -> void:
+	textures_corner_outer = a
+	emit_changed()
+
+
+func _set_textures_corner_inner(a: Array[Texture2D]) -> void:
+	textures_corner_inner = a
+	emit_changed()
+
+
+func _set_textures_taper_left(a: Array[Texture2D]) -> void:
+	textures_taper_left = a
+	emit_changed()
+
+
+func _set_textures_taper_right(a: Array[Texture2D]) -> void:
+	textures_taper_right = a
+	emit_changed()
+
+func _set_textures_taper_corner_left(a: Array[Texture2D]) -> void:
+	textures_taper_corner_left = a
+	emit_changed()
+
+func _set_textures_taper_corner_right(a: Array[Texture2D]) -> void:
+	textures_taper_corner_right = a
+	emit_changed()
+
+func _set_randomize_texture(b: bool) -> void:
+	randomize_texture = b
+	emit_changed()
+
+
+func _set_use_corner(b: bool) -> void:
+	use_corner_texture = b
+	emit_changed()
+
+
+func _set_use_taper(b: bool) -> void:
+	use_taper_texture = b
+	emit_changed()
+
+
+func _set_fit_texture(fitmode: FITMODE) -> void:
+	fit_mode = fitmode
+	emit_changed()
+
+
+func _set_material(m: Material) -> void:
+	material = m
+	emit_changed()
+
+
+###########
+# GETTERS #
+###########
+func get_texture(idx: int) -> Texture2D:
+	return _get_element(idx, textures)
+
+
+func get_texture_corner_inner(idx: int) -> Texture2D:
+	return _get_element(idx, textures_corner_inner)
+
+
+func get_texture_corner_outer(idx: int) -> Texture2D:
+	return _get_element(idx, textures_corner_outer)
+
+
+func get_texture_taper_left(idx: int) -> Texture2D:
+	return _get_element(idx, textures_taper_left)
+
+
+func get_texture_taper_right(idx: int) -> Texture2D:
+	return _get_element(idx, textures_taper_right)
+
+
+func get_texture_taper_corner_left(idx: int) -> Texture2D:
+	return _get_element(idx, textures_taper_corner_left)
+
+
+func get_texture_taper_corner_right(idx: int) -> Texture2D:
+	return _get_element(idx, textures_taper_corner_right)
+
+
+#########
+# USAGE #
+#########
+
+## Returns main texture used to visually identify this edge material
+func get_icon_texture() -> Texture2D:
+	if not textures.is_empty():
+		return textures[0]
+	return null
+
+
+############
+# INTERNAL #
+############
+func _get_element(idx: int, a: Array) -> Variant:
+	if a.is_empty():
+		return null
+	return a[_adjust_idx(idx, a)]
+
+
+func _adjust_idx(idx: int, a: Array) -> int:
+	return idx % a.size()

addons/rmsmartshape/materials/edge_material_metadata.gd

@@ -0,0 +1,81 @@
+@tool
+extends Resource
+class_name SS2D_Material_Edge_Metadata
+
+## Represents the metadata for an edge material.
+##
+## Used by Shape Material.
+
+@export var edge_material: SS2D_Material_Edge = null : set = set_edge_material
+## What range of normals can this edge be used on.
+@export var normal_range := SS2D_NormalRange.new(0, 360) : set = set_normal_range
+## If edge should be welded to the edges surrounding it.
+@export var weld: bool = true : set = set_weld
+## Whether or not the edges should use the taper corner textures and not be welded, if they are
+## too sharp to be welded without significant distortion. NOTE this will not work properly
+## in curved shapes
+@export var taper_sharp_corners: bool = false : set = set_taper_sharp_corners
+## If this edge should be visible.
+@export var render: bool = true : set = set_render
+## z index for an edge.
+@export var z_index: int = 0 : set = set_z_index
+## z index for an edge.
+@export var z_as_relative: bool = true : set = set_z_as_relative
+## Distance from center.
+@export_range (-1.5, 1.5, 0.1) var offset: float = 0.0 : set = set_offset
+
+
+func _to_string() -> String:
+	return "%s | %s" % [str(edge_material), normal_range]
+
+
+func set_render(b: bool) -> void:
+	render = b
+	emit_changed()
+
+
+func set_edge_material(m: SS2D_Material_Edge) -> void:
+	if edge_material != null:
+		if edge_material.is_connected("changed", self._on_edge_changed):
+			edge_material.disconnect("changed", self._on_edge_changed)
+	edge_material = m
+	if edge_material != null:
+		edge_material.connect("changed", self._on_edge_changed)
+	emit_changed()
+
+
+func set_normal_range(nr: SS2D_NormalRange) -> void:
+	if nr == null:
+		return
+	if normal_range.is_connected("changed", self._on_edge_changed):
+		normal_range.disconnect("changed", self._on_edge_changed)
+	normal_range = nr
+	normal_range.connect("changed", self._on_edge_changed)
+	emit_changed()
+
+
+func set_weld(b: bool) -> void:
+	weld = b
+	emit_changed()
+
+func set_taper_sharp_corners(val: bool) -> void:
+	taper_sharp_corners = val
+	emit_changed()
+
+func set_z_index(z: int) -> void:
+	z_index = z
+	emit_changed()
+
+
+func set_z_as_relative(b: bool) -> void:
+	z_as_relative = b
+	emit_changed()
+
+
+func set_offset(f: float) -> void:
+	offset = f
+	emit_changed()
+
+
+func _on_edge_changed() -> void:
+	emit_changed()

addons/rmsmartshape/materials/shape_material.gd

@@ -0,0 +1,139 @@
+@tool
+extends Resource
+class_name SS2D_Material_Shape
+
+## This material represents the set of edge materials used for a smart shape.
+##
+## Each edge represents a set of textures used to render an edge.
+
+## List of materials this shape can use.
+@export var _edge_meta_materials: Array[SS2D_Material_Edge_Metadata] = [] : set = set_edge_meta_materials
+@export var fill_textures: Array[Texture2D] = [] : set = set_fill_textures
+@export var fill_texture_z_index: int = -10 : set = set_fill_texture_z_index
+@export var fill_texture_show_behind_parent: bool = false : set = set_fill_texture_show_behind_parent
+
+## Scale the fill texture
+@export_range(0.1, 4, 0.01, "or_greater") var fill_texture_scale: float = 1.0 : set = set_fill_texture_scale
+
+## Whether the fill texture should start at the global 0/0 instead of the node's 0/0
+@export var fill_texture_absolute_position: bool = false : set = set_fill_texture_absolute_position
+
+## Whether the fill texture should ignore the node's rotation
+@export var fill_texture_absolute_rotation: bool = false : set = set_fill_texture_absolute_rotation
+
+## How many pixels the fill texture should be shifted in x and y direction
+@export var fill_texture_offset: Vector2 = Vector2.ZERO : set = set_fill_texture_offset
+
+## Added rotation of the texture in degrees
+@export_range(-180, 180, 0.1) var fill_texture_angle_offset: float = 0.0 : set = set_fill_texture_angle_offset
+
+@export var fill_mesh_offset: float = 0.0 : set = set_fill_mesh_offset
+@export var fill_mesh_material: Material = null : set = set_fill_mesh_material
+
+## How much to offset all edges
+@export_range (-1.5, 1.5, 0.1) var render_offset: float = 0.0 : set = set_render_offset
+
+
+func set_fill_mesh_material(m: Material) -> void:
+	fill_mesh_material = m
+	emit_changed()
+
+
+func set_fill_mesh_offset(f: float) -> void:
+	fill_mesh_offset = f
+	emit_changed()
+
+
+func set_render_offset(f: float) -> void:
+	render_offset = f
+	emit_changed()
+
+
+## Get all valid edge materials for this normal.
+func get_edge_meta_materials(normal: Vector2) -> Array[SS2D_Material_Edge_Metadata]:
+	var materials: Array[SS2D_Material_Edge_Metadata] = []
+	for e in _edge_meta_materials:
+		if e == null:
+			continue
+		if e.normal_range.is_in_range(normal):
+			materials.push_back(e)
+	return materials
+
+
+func get_all_edge_meta_materials() -> Array[SS2D_Material_Edge_Metadata]:
+	return _edge_meta_materials
+
+
+func get_all_edge_materials() -> Array[SS2D_Material_Edge]:
+	var materials: Array[SS2D_Material_Edge] = []
+	for meta in _edge_meta_materials:
+		if meta.edge_material != null:
+			materials.push_back(meta.edge_material)
+	return materials
+
+
+func add_edge_material(e: SS2D_Material_Edge_Metadata) -> void:
+	var new_array := _edge_meta_materials.duplicate()
+	new_array.push_back(e)
+	set_edge_meta_materials(new_array)
+
+
+func _on_edge_material_changed() -> void:
+	emit_changed()
+
+
+func set_fill_textures(a: Array[Texture2D]) -> void:
+	fill_textures = a
+	emit_changed()
+
+
+func set_fill_texture_z_index(i: int) -> void:
+	fill_texture_z_index = i
+	emit_changed()
+
+
+func set_fill_texture_show_behind_parent(value: bool) -> void:
+	fill_texture_show_behind_parent = value
+	emit_changed()
+
+
+func set_edge_meta_materials(a: Array[SS2D_Material_Edge_Metadata]) -> void:
+	for e in _edge_meta_materials:
+		if e == null:
+			continue
+		if not a.has(e):
+			e.disconnect("changed", self._on_edge_material_changed)
+
+	for e in a:
+		if e == null:
+			continue
+		if not e.is_connected("changed", self._on_edge_material_changed):
+			e.connect("changed", self._on_edge_material_changed)
+
+	_edge_meta_materials = a
+	emit_changed()
+
+
+func set_fill_texture_offset(value: Vector2) -> void:
+	fill_texture_offset = value
+	emit_changed()
+
+
+func set_fill_texture_scale(value:float) -> void:
+	fill_texture_scale = value
+	emit_changed()
+
+
+func set_fill_texture_absolute_rotation(value: bool) -> void:
+	fill_texture_absolute_rotation = value
+	emit_changed()
+
+
+func set_fill_texture_angle_offset(value: float) -> void:
+	fill_texture_angle_offset = value
+	emit_changed()
+
+
+func set_fill_texture_absolute_position(value: bool) -> void:
+	fill_texture_absolute_position = value
+	emit_changed()