Various fixes related to grid snapping and tilemap layers (#1340)

* Fix snapping on paste

* clear selection when using move tool and tool is placing tiles

* fix some issues

* Fix more stuff + as i am an idiot, i had to remove some useless code

* typo: fixed snapping to offset

* Fix tiles not updating when pasting, also fix errors popping up when selection bounds is zero

Author: Variable-ind

src/Autoload/DrawingAlgos.gd

@@ -343,6 +343,8 @@ func transform_image_with_viewport(
 
 	# Estimate new bounding box
 	var bounds := get_transformed_bounds(original_image.get_size(), full_transform)
+	if bounds.size.x == 0 or bounds.size.y == 0:
+		return
 	var viewport_size := bounds.size.ceil() as Vector2i
 	if viewport_size.x == 1:
 		viewport_size.x = 2

src/Autoload/Tools.gd

@@ -689,33 +689,44 @@ func get_closest_point_to_segment(
 
 
 func snap_to_rectangular_grid_boundary(
-	pos: Vector2, grid_size: Vector2i, grid_offset := Vector2i.ZERO, snapping_distance := 9999.0
+	pos: Vector2, grid_size: Vector2i, grid_offset: Vector2, snapping_distance := 9999.0
 ) -> Vector2:
-	var grid_pos := pos.snapped(grid_size)
-	grid_pos += Vector2(grid_offset)
-	# keeping grid_pos as is would have been fine but this adds extra accuracy as to
-	# which snap point (from the list below) is closest to mouse and occupy THAT point
-	# t_l is for "top left" and so on
-	var t_l := grid_pos + Vector2(-grid_size.x, -grid_size.y)
-	var t_c := grid_pos + Vector2(0, -grid_size.y)
-	var t_r := grid_pos + Vector2(grid_size.x, -grid_size.y)
-	var m_l := grid_pos + Vector2(-grid_size.x, 0)
-	var m_c := grid_pos
-	var m_r := grid_pos + Vector2(grid_size.x, 0)
-	var b_l := grid_pos + Vector2(-grid_size.x, grid_size.y)
-	var b_c := grid_pos + Vector2(0, grid_size.y)
-	var b_r := grid_pos + Vector2(grid_size)
-	var vec_arr: PackedVector2Array = [t_l, t_c, t_r, m_l, m_c, m_r, b_l, b_c, b_r]
-	for vec in vec_arr:
-		if vec.distance_to(pos) < grid_pos.distance_to(pos):
-			grid_pos = vec
-
+	## Get the closest grid intersection
+	var grid_pos := (pos - grid_offset).snapped(grid_size)  # Get closest box without offset
+	grid_pos += Vector2(grid_offset)  # apply offset
+	## Get the point on boundary of grid box (that contains the intersection)
 	var grid_point := _get_closest_point_to_grid(pos, snapping_distance, grid_pos)
 	if grid_point != Vector2.INF:
 		pos = grid_point.floor()
 	return pos
 
 
+func snap_to_rectangular_grid_center(
+	pos: Vector2, grid_size: Vector2i, grid_offset: Vector2i, snapping_distance := 9999.0
+) -> Vector2:
+	var grid_center := pos.snapped(grid_size) + Vector2(grid_size / 2)
+	grid_center += Vector2(grid_offset)
+	if snapping_distance < 0:
+		pos = grid_center.floor()
+	else:
+		if grid_center.distance_to(pos) <= snapping_distance:
+			pos = grid_center.floor()
+	return pos
+
+
+func snap_to_guide(
+	snap_to: Vector2, pos: Vector2, distance: float, s1: Vector2, s2: Vector2
+) -> Vector2:
+	var closest_point := Tools.get_closest_point_to_segment(pos, distance, s1, s2)
+	if closest_point == Vector2.INF:  # Is not close to a guide
+		return Vector2.INF
+	# Snap to the closest guide
+	if snap_to == Vector2.INF or (snap_to - pos).length() > (closest_point - pos).length():
+		snap_to = closest_point
+
+	return snap_to
+
+
 func set_button_size(button_size: int) -> void:
 	var size := Vector2(24, 24) if button_size == Global.ButtonSize.SMALL else Vector2(32, 32)
 	if not is_instance_valid(_tool_buttons):

src/Tools/BaseSelectionTool.gd

@@ -94,8 +94,8 @@ func set_spinbox_values() -> void:
 	_skip_slider_logic = false
 
 
-func draw_start(pos: Vector2i) -> void:
-	pos = snap_position(pos)
+func draw_start(mouse_pos: Vector2i) -> void:
+	var pos: Vector2i = snap_position(mouse_pos)
 	super(pos)
 	_transformation_status_changed = false
 	if transformation_handles.arrow_key_move:
@@ -108,8 +108,9 @@ func draw_start(pos: Vector2i) -> void:
 	_offset = pos
 
 	var quick_copy := Input.is_action_pressed("transform_copy_selection_content", true)
+	# we check if the un-snapped point was hovering a selection
 	if (
-		selection_node.preview_selection_map.is_pixel_selected(pos)
+		selection_node.preview_selection_map.is_pixel_selected(mouse_pos)
 		and (!_add and !_subtract and !_intersect or quick_copy)
 		and !_ongoing_selection
 	):
@@ -155,6 +156,7 @@ func draw_move(pos: Vector2i) -> void:
 		var cel := project.get_current_cel() as CelTileMap
 		var grid_size := cel.get_tile_size()
 		var offset := cel.offset % grid_size
+		_offset = Tools.snap_to_rectangular_grid_boundary(_offset, grid_size, offset)
 		pos = Tools.snap_to_rectangular_grid_boundary(pos, grid_size, offset)
 	if Input.is_action_pressed("transform_snap_axis"):  # Snap to axis
 		var angle := Vector2(pos).angle_to_point(_start_pos)

src/Tools/BaseTool.gd

@@ -144,7 +144,7 @@ func snap_position(pos: Vector2) -> Vector2:
 		)
 
 	if Global.snap_to_rectangular_grid_center:
-		pos = _snap_to_rectangular_grid_center(
+		pos = Tools.snap_to_rectangular_grid_center(
 			pos, Global.grids[0].grid_size, Global.grids[0].grid_offset, snapping_distance
 		)
 
@@ -155,7 +155,7 @@ func snap_position(pos: Vector2) -> Vector2:
 				continue
 			var s1: Vector2 = guide.points[0]
 			var s2: Vector2 = guide.points[1]
-			var snap := _snap_to_guide(snap_to, pos, snapping_distance, s1, s2)
+			var snap := Tools.snap_to_guide(snap_to, pos, snapping_distance, s1, s2)
 			if snap == Vector2.INF:
 				continue
 			snap_to = snap
@@ -171,7 +171,7 @@ func snap_position(pos: Vector2) -> Vector2:
 					var start := Vector2(point.pos_x, point.pos_y)
 					var s1 := start
 					var s2 := s1 + Vector2(length * cos(angle), length * sin(angle))
-					var snap := _snap_to_guide(snap_to, pos, snapping_distance, s1, s2)
+					var snap := Tools.snap_to_guide(snap_to, pos, snapping_distance, s1, s2)
 					if snap == Vector2.INF:
 						continue
 					snap_to = snap
@@ -212,48 +212,6 @@ func mirror_array(array: Array[Vector2i], callable := func(_array): pass) -> Arr
 	return new_array
 
 
-func _snap_to_rectangular_grid_center(
-	pos: Vector2, grid_size: Vector2i, grid_offset: Vector2i, snapping_distance: float
-) -> Vector2:
-	var grid_center := pos.snapped(grid_size) + Vector2(grid_size / 2)
-	grid_center += Vector2(grid_offset)
-	# keeping grid_center as is would have been fine but this adds extra accuracy as to
-	# which snap point (from the list below) is closest to mouse and occupy THAT point
-	# t_l is for "top left" and so on
-	var t_l := grid_center + Vector2(-grid_size.x, -grid_size.y)
-	var t_c := grid_center + Vector2(0, -grid_size.y)
-	var t_r := grid_center + Vector2(grid_size.x, -grid_size.y)
-	var m_l := grid_center + Vector2(-grid_size.x, 0)
-	var m_c := grid_center
-	var m_r := grid_center + Vector2(grid_size.x, 0)
-	var b_l := grid_center + Vector2(-grid_size.x, grid_size.y)
-	var b_c := grid_center + Vector2(0, grid_size.y)
-	var b_r := grid_center + Vector2(grid_size)
-	var vec_arr := [t_l, t_c, t_r, m_l, m_c, m_r, b_l, b_c, b_r]
-	for vec in vec_arr:
-		if vec.distance_to(pos) < grid_center.distance_to(pos):
-			grid_center = vec
-	if snapping_distance < 0:
-		pos = grid_center.floor()
-	else:
-		if grid_center.distance_to(pos) <= snapping_distance:
-			pos = grid_center.floor()
-	return pos
-
-
-func _snap_to_guide(
-	snap_to: Vector2, pos: Vector2, distance: float, s1: Vector2, s2: Vector2
-) -> Vector2:
-	var closest_point := Tools.get_closest_point_to_segment(pos, distance, s1, s2)
-	if closest_point == Vector2.INF:  # Is not close to a guide
-		return Vector2.INF
-	# Snap to the closest guide
-	if snap_to == Vector2.INF or (snap_to - pos).length() > (closest_point - pos).length():
-		snap_to = closest_point
-
-	return snap_to
-
-
 func _get_stabilized_position(normal_pos: Vector2) -> Vector2:
 	if not Tools.stabilizer_enabled:
 		return normal_pos

src/Tools/UtilityTools/Move.gd

@@ -27,6 +27,11 @@ func draw_start(pos: Vector2i) -> void:
 	_offset = pos
 	_undo_data = _get_undo_data()
 	if Tools.is_placing_tiles():
+		# Clear selection if it it present (i tried moving the selection proview only but the)
+		# code for it gets too complex so i chose to clear it instead
+		if project.has_selection:
+			Global.canvas.selection.clear_selection(true)
+			project.selection_map_changed()
 		for cel in _get_selected_draw_cels():
 			if cel is not CelTileMap:
 				continue

src/UI/Canvas/Measurements.gd

@@ -64,7 +64,7 @@ func _prepare_cel_rect() -> void:
 
 func _prepare_movement_rect() -> void:
 	var project := Global.current_project
-	if project.has_selection:
+	if project.has_selection and not Tools.is_placing_tiles():
 		rect_bounds = canvas.selection.preview_selection_map.get_used_rect()
 		rect_bounds.position = Vector2i(
 			canvas.selection.transformation_handles.preview_transform.origin

src/UI/Canvas/Selection.gd

@@ -110,7 +110,7 @@ func transform_content_confirm() -> void:
 			src.copy_from(cel.transformed_content)
 			cel.transformed_content = null
 		var transformation_origin := transformation_handles.get_transform_top_left(src.get_size())
-		if Tools.is_placing_tiles():
+		if Tools.is_placing_tiles() and not is_pasting:
 			if cel is not CelTileMap:
 				continue
 			var tilemap := cel as CelTileMap
@@ -149,7 +149,7 @@ func transform_content_cancel() -> void:
 	project.selection_map_changed()
 	for cel in get_selected_draw_cels():
 		var cel_image := cel.get_image()
-		if !is_pasting:
+		if !is_pasting and cel.transformed_content:
 			cel_image.blit_rect_mask(
 				cel.transformed_content,
 				cel.transformed_content,
@@ -170,7 +170,7 @@ func commit_undo(action: String, undo_data_tmp: Dictionary) -> void:
 		print("No undo data found!")
 		return
 	var project := Global.current_project
-	if Tools.is_placing_tiles():
+	if Tools.is_placing_tiles() and not is_pasting:
 		for cel in undo_data_tmp:
 			if cel is CelTileMap:
 				(cel as CelTileMap).re_index_all_cells(true)
@@ -373,19 +373,51 @@ func paste(in_place := false) -> void:
 		if Tools.is_placing_tiles():
 			var tilemap_cel := Global.current_project.get_current_cel() as CelTileMap
 			var grid_size := tilemap_cel.get_tile_size()
+			var offset := tilemap_cel.offset % grid_size
+			transform_origin = Vector2i(
+				Tools.snap_to_rectangular_grid_boundary(transform_origin, grid_size, offset)
+			)
+		elif Global.snap_to_rectangular_grid_center:
+			var grid_size := Global.grids[0].grid_size
+			var grid_offset := Global.grids[0].grid_offset
 			transform_origin = Vector2i(
-				Tools.snap_to_rectangular_grid_boundary(transform_origin, grid_size)
+				Tools.snap_to_rectangular_grid_center(transform_origin, grid_size, grid_offset)
+			)
+		elif Global.snap_to_rectangular_grid_boundary:
+			var grid_size := Global.grids[0].grid_size
+			var grid_offset := Global.grids[0].grid_offset
+			transform_origin = Vector2i(
+				Tools.snap_to_rectangular_grid_boundary(transform_origin, grid_size, grid_offset)
 			)
 		project.selection_map.move_bitmap_values(Global.current_project, false)
 	else:
 		if Tools.is_placing_tiles():
 			var tilemap_cel := Global.current_project.get_current_cel() as CelTileMap
 			var grid_size := tilemap_cel.get_tile_size()
+			var offset := tilemap_cel.offset % grid_size
+			project.selection_offset = Tools.snap_to_rectangular_grid_boundary(
+				project.selection_offset, grid_size, offset
+			)
+			transform_origin = Vector2i(
+				Tools.snap_to_rectangular_grid_boundary(transform_origin, grid_size, offset)
+			)
+		elif Global.snap_to_rectangular_grid_center:
+			var grid_size := Global.grids[0].grid_size
+			var grid_offset := Global.grids[0].grid_offset
+			project.selection_offset = Tools.snap_to_rectangular_grid_center(
+				project.selection_offset, grid_size, grid_offset
+			)
+			transform_origin = Vector2i(
+				Tools.snap_to_rectangular_grid_center(transform_origin, grid_size, grid_offset)
+			)
+		elif Global.snap_to_rectangular_grid_boundary:
+			var grid_size := Global.grids[0].grid_size
+			var grid_offset := Global.grids[0].grid_offset
 			project.selection_offset = Tools.snap_to_rectangular_grid_boundary(
-				project.selection_offset, grid_size
+				project.selection_offset, grid_size, grid_offset
 			)
 			transform_origin = Vector2i(
-				Tools.snap_to_rectangular_grid_boundary(transform_origin, grid_size)
+				Tools.snap_to_rectangular_grid_boundary(transform_origin, grid_size, grid_offset)
 			)
 
 	is_pasting = true

src/UI/Canvas/TransformationHandles.gd

@@ -308,6 +308,8 @@ func _on_preview_transform_changed() -> void:
 		var bounds := DrawingAlgos.get_transformed_bounds(
 			transformed_selection_map.get_size(), preview_transform
 		)
+		if bounds.size.x == 0 or bounds.size.y == 0:
+			return
 		if Tools.is_placing_tiles():
 			for cel in selection_node.get_selected_draw_cels():
 				if cel is not CelTileMap:
@@ -384,8 +386,10 @@ func begin_drag(mouse_pos: Vector2) -> void:
 func move_transform(pos: Vector2) -> void:
 	var final_pos := pos
 	if Tools.is_placing_tiles():
+		# NOTE: we don't use offset here because the [param pos] is expected to already have
+		# offseted coordinates.
 		var grid_size := (Global.current_project.get_current_cel() as CelTileMap).get_tile_size()
-		final_pos = Tools.snap_to_rectangular_grid_boundary(pos, grid_size)
+		final_pos = Tools.snap_to_rectangular_grid_boundary(pos, grid_size, Vector2.ZERO)
 	preview_transform = preview_transform.translated(final_pos)
 	queue_redraw()
 
@@ -684,6 +688,8 @@ func bake_transform_to_selection(map: SelectionMap, is_confirmed := false) -> vo
 	var bounds := DrawingAlgos.get_transformed_bounds(
 		transformed_selection_map.get_size(), preview_transform
 	)
+	if bounds.size.x == 0 or bounds.size.y == 0:
+		return
 	var transformation_origin := get_transform_top_left().max(Vector2.ZERO)
 	if is_confirmed:
 		var position_top_left := position + get_transform_top_left()