Use functions defined in the their classes.

core/io/image.cpp

@@ -2506,7 +2506,7 @@ void Image::blit_rect(const Ref<Image> &p_src, const Rect2 &p_src_rect, const Po
 		clipped_src_rect.position.y = ABS(p_dest.y);
 	}
 
-	if (clipped_src_rect.size.x <= 0 || clipped_src_rect.size.y <= 0) {
+	if (clipped_src_rect.has_no_area()) {
 		return;
 	}
 
@@ -2561,7 +2561,7 @@ void Image::blit_rect_mask(const Ref<Image> &p_src, const Ref<Image> &p_mask, co
 		clipped_src_rect.position.y = ABS(p_dest.y);
 	}
 
-	if (clipped_src_rect.size.x <= 0 || clipped_src_rect.size.y <= 0) {
+	if (clipped_src_rect.has_no_area()) {
 		return;
 	}
 
@@ -2615,7 +2615,7 @@ void Image::blend_rect(const Ref<Image> &p_src, const Rect2 &p_src_rect, const P
 		clipped_src_rect.position.y = ABS(p_dest.y);
 	}
 
-	if (clipped_src_rect.size.x <= 0 || clipped_src_rect.size.y <= 0) {
+	if (clipped_src_rect.has_no_area()) {
 		return;
 	}
 
@@ -2664,7 +2664,7 @@ void Image::blend_rect_mask(const Ref<Image> &p_src, const Ref<Image> &p_mask, c
 		clipped_src_rect.position.y = ABS(p_dest.y);
 	}
 
-	if (clipped_src_rect.size.x <= 0 || clipped_src_rect.size.y <= 0) {
+	if (clipped_src_rect.has_no_area()) {
 		return;
 	}
 

editor/plugins/animation_blend_space_2d_editor.cpp

@@ -129,8 +129,7 @@ void AnimationNodeBlendSpace2DEditor::_blend_space_gui_input(const Ref<InputEven
 		add_point_pos += blend_space->get_min_space();
 
 		if (snap->is_pressed()) {
-			add_point_pos.x = Math::snapped(add_point_pos.x, blend_space->get_snap().x);
-			add_point_pos.y = Math::snapped(add_point_pos.y, blend_space->get_snap().y);
+			add_point_pos = add_point_pos.snapped(blend_space->get_snap());
 		}
 	}
 
@@ -215,8 +214,7 @@ void AnimationNodeBlendSpace2DEditor::_blend_space_gui_input(const Ref<InputEven
 			Vector2 point = blend_space->get_blend_point_position(selected_point);
 			point += drag_ofs;
 			if (snap->is_pressed()) {
-				point.x = Math::snapped(point.x, blend_space->get_snap().x);
-				point.y = Math::snapped(point.y, blend_space->get_snap().y);
+				point = point.snapped(blend_space->get_snap());
 			}
 
 			updating = true;
@@ -467,8 +465,7 @@ void AnimationNodeBlendSpace2DEditor::_blend_space_draw() {
 			if (dragging_selected && selected_point == point_idx) {
 				point += drag_ofs;
 				if (snap->is_pressed()) {
-					point.x = Math::snapped(point.x, blend_space->get_snap().x);
-					point.y = Math::snapped(point.y, blend_space->get_snap().y);
+					point = point.snapped(blend_space->get_snap());
 				}
 			}
 			point = (point - blend_space->get_min_space()) / (blend_space->get_max_space() - blend_space->get_min_space());
@@ -503,8 +500,7 @@ void AnimationNodeBlendSpace2DEditor::_blend_space_draw() {
 		if (dragging_selected && selected_point == i) {
 			point += drag_ofs;
 			if (snap->is_pressed()) {
-				point.x = Math::snapped(point.x, blend_space->get_snap().x);
-				point.y = Math::snapped(point.y, blend_space->get_snap().y);
+				point = point.snapped(blend_space->get_snap());
 			}
 		}
 		point = (point - blend_space->get_min_space()) / (blend_space->get_max_space() - blend_space->get_min_space());
@@ -702,8 +698,7 @@ void AnimationNodeBlendSpace2DEditor::_update_edited_point_pos() {
 		if (dragging_selected) {
 			pos += drag_ofs;
 			if (snap->is_pressed()) {
-				pos.x = Math::snapped(pos.x, blend_space->get_snap().x);
-				pos.y = Math::snapped(pos.y, blend_space->get_snap().y);
+				pos = pos.snapped(blend_space->get_snap());
 			}
 		}
 		updating = true;

editor/plugins/canvas_item_editor_plugin.cpp

@@ -4898,8 +4898,7 @@ void CanvasItemEditor::_focus_selection(int p_op) {
 	if (p_op == VIEW_CENTER_TO_SELECTION) {
 		center = rect.get_center();
 		Vector2 offset = viewport->get_size() / 2 - editor->get_scene_root()->get_global_canvas_transform().xform(center);
-		view_offset.x -= Math::round(offset.x / zoom);
-		view_offset.y -= Math::round(offset.y / zoom);
+		view_offset -= (offset / zoom).round();
 		update_viewport();
 
 	} else { // VIEW_FRAME_TO_SELECTION

editor/plugins/node_3d_editor_plugin.cpp

@@ -6280,7 +6280,7 @@ void Node3DEditor::update_grid() {
 	// Gets a orthogonal or perspective position correctly (for the grid comparison)
 	const Vector3 camera_position = get_editor_viewport(0)->camera->get_position();
 
-	if (!grid_init_draw || (camera_position - grid_camera_last_update_position).length() >= 10.0f) {
+	if (!grid_init_draw || grid_camera_last_update_position.distance_squared_to(camera_position) >= 100.0f) {
 		_finish_grid();
 		_init_grid();
 		grid_init_draw = true;

editor/plugins/texture_region_editor_plugin.cpp

@@ -50,7 +50,7 @@ void draw_margin_line(Control *edit_draw, Vector2 from, Vector2 to) {
 			EditorNode::get_singleton()->get_theme_base()->get_theme_color(SNAME("mono_color"), SNAME("Editor")).inverted() * Color(1, 1, 1, 0.5),
 			Math::round(2 * EDSCALE));
 
-	while ((to - from).length_squared() > 200) {
+	while (from.distance_squared_to(to) > 200) {
 		edit_draw->draw_line(
 				from,
 				from + line,
@@ -674,8 +674,7 @@ void TextureRegionEditor::_zoom_on_position(float p_zoom, Point2 p_position) {
 	draw_zoom = p_zoom;
 	Point2 ofs = p_position;
 	ofs = ofs / prev_zoom - ofs / draw_zoom;
-	draw_ofs.x = Math::round(draw_ofs.x + ofs.x);
-	draw_ofs.y = Math::round(draw_ofs.y + ofs.y);
+	draw_ofs = (draw_ofs + ofs).round();
 
 	edit_draw->update();
 }

editor/plugins/theme_editor_preview.cpp

@@ -126,8 +126,8 @@ void ThemeEditorPreview::_draw_picker_overlay() {
 		highlight_label_rect.size.x += margin_left + margin_right;
 		highlight_label_rect.size.y += margin_top + margin_bottom;
 
-		highlight_label_rect.position.x = CLAMP(highlight_label_rect.position.x, 0.0, picker_overlay->get_size().width);
-		highlight_label_rect.position.y = CLAMP(highlight_label_rect.position.y, 0.0, picker_overlay->get_size().height);
+		highlight_label_rect.position = highlight_label_rect.position.clamp(Vector2(), picker_overlay->get_size());
+
 		picker_overlay->draw_style_box(theme_cache.preview_picker_label, highlight_label_rect);
 
 		Point2 label_pos = highlight_label_rect.position;

editor/plugins/tiles/tile_map_editor.cpp

@@ -1041,7 +1041,7 @@ Map<Vector2i, TileMapCell> TileMapEditorTilesPlugin::_draw_bucket_fill(Vector2i
 			TypedArray<Vector2i> to_check;
 			if (source.source_id == TileSet::INVALID_SOURCE) {
 				Rect2i rect = tile_map->get_used_rect();
-				if (rect.size.x <= 0 || rect.size.y <= 0) {
+				if (rect.has_no_area()) {
 					rect = Rect2i(p_coords, Vector2i(1, 1));
 				}
 				for (int x = boundaries.position.x; x < boundaries.get_end().x; x++) {

modules/csg/csg.cpp

@@ -37,16 +37,16 @@
 // Static helper functions.
 
 inline static bool is_snapable(const Vector3 &p_point1, const Vector3 &p_point2, real_t p_distance) {
-	return (p_point1 - p_point2).length_squared() < p_distance * p_distance;
+	return p_point2.distance_squared_to(p_point1) < p_distance * p_distance;
 }
 
 inline static Vector2 interpolate_segment_uv(const Vector2 p_segment_points[2], const Vector2 p_uvs[2], const Vector2 &p_interpolation_point) {
-	float segment_length = (p_segment_points[1] - p_segment_points[0]).length();
 	if (p_segment_points[0].is_equal_approx(p_segment_points[1])) {
 		return p_uvs[0];
 	}
 
-	float distance = (p_interpolation_point - p_segment_points[0]).length();
+	float segment_length = p_segment_points[0].distance_to(p_segment_points[1]);
+	float distance = p_segment_points[0].distance_to(p_interpolation_point);
 	float fraction = distance / segment_length;
 
 	return p_uvs[0].lerp(p_uvs[1], fraction);
@@ -596,7 +596,7 @@ bool CSGBrushOperation::MeshMerge::_bvh_inside(FaceBVH *facebvhptr, int p_max_de
 									_add_distance(intersectionsA, intersectionsB, current_face.from_b, 0);
 								}
 							} else if (ray_intersects_triangle(face_center, face_normal, current_points, CMP_EPSILON, intersection_point)) {
-								real_t distance = (intersection_point - face_center).length();
+								real_t distance = face_center.distance_to(intersection_point);
 								_add_distance(intersectionsA, intersectionsB, current_face.from_b, distance);
 							}
 						}
@@ -781,7 +781,7 @@ void CSGBrushOperation::MeshMerge::add_face(const Vector3 p_points[], const Vect
 
 int CSGBrushOperation::Build2DFaces::_get_point_idx(const Vector2 &p_point) {
 	for (int vertex_idx = 0; vertex_idx < vertices.size(); ++vertex_idx) {
-		if ((p_point - vertices[vertex_idx].point).length_squared() < vertex_snap2) {
+		if (vertices[vertex_idx].point.distance_squared_to(p_point) < vertex_snap2) {
 			return vertex_idx;
 		}
 	}
@@ -961,7 +961,7 @@ void CSGBrushOperation::Build2DFaces::_merge_faces(const Vector<int> &p_segment_
 				// Check if point is existing face vertex.
 				bool existing = false;
 				for (int i = 0; i < 3; ++i) {
-					if ((point_2D - face_vertices[i].point).length_squared() < vertex_snap2) {
+					if (face_vertices[i].point.distance_squared_to(point_2D) < vertex_snap2) {
 						existing = true;
 						break;
 					}
@@ -978,7 +978,7 @@ void CSGBrushOperation::Build2DFaces::_merge_faces(const Vector<int> &p_segment_
 					};
 					Vector2 closest_point = Geometry2D::get_closest_point_to_segment(point_2D, edge_points);
 
-					if ((closest_point - point_2D).length_squared() < vertex_snap2) {
+					if (point_2D.distance_squared_to(closest_point) < vertex_snap2) {
 						int opposite_vertex_idx = face.vertex_idx[(face_edge_idx + 2) % 3];
 
 						// If new vertex snaps to degenerate vertex, just delete this face.
@@ -1041,7 +1041,7 @@ void CSGBrushOperation::Build2DFaces::_find_edge_intersections(const Vector2 p_s
 			bool on_edge = false;
 			for (int edge_point_idx = 0; edge_point_idx < 2; ++edge_point_idx) {
 				intersection_point = Geometry2D::get_closest_point_to_segment(p_segment_points[edge_point_idx], edge_points);
-				if ((intersection_point - p_segment_points[edge_point_idx]).length_squared() < vertex_snap2) {
+				if (p_segment_points[edge_point_idx].distance_squared_to(intersection_point) < vertex_snap2) {
 					on_edge = true;
 					break;
 				}
@@ -1050,8 +1050,8 @@ void CSGBrushOperation::Build2DFaces::_find_edge_intersections(const Vector2 p_s
 			// Else check if the segment intersects the edge.
 			if (on_edge || Geometry2D::segment_intersects_segment(p_segment_points[0], p_segment_points[1], edge_points[0], edge_points[1], &intersection_point)) {
 				// Check if intersection point is an edge point.
-				if ((intersection_point - edge_points[0]).length_squared() < vertex_snap2 ||
-						(intersection_point - edge_points[1]).length_squared() < vertex_snap2) {
+				if ((edge_points[0].distance_squared_to(intersection_point) < vertex_snap2) ||
+						(edge_points[1].distance_squared_to(intersection_point) < vertex_snap2)) {
 					continue;
 				}
 
@@ -1078,7 +1078,7 @@ void CSGBrushOperation::Build2DFaces::_find_edge_intersections(const Vector2 p_s
 
 				// If opposite point is on the segment, add its index to segment indices too.
 				Vector2 closest_point = Geometry2D::get_closest_point_to_segment(vertices[opposite_vertex_idx].point, p_segment_points);
-				if ((closest_point - vertices[opposite_vertex_idx].point).length_squared() < vertex_snap2) {
+				if (vertices[opposite_vertex_idx].point.distance_squared_to(closest_point) < vertex_snap2) {
 					_add_vertex_idx_sorted(r_segment_indices, opposite_vertex_idx);
 				}
 
@@ -1132,7 +1132,7 @@ int CSGBrushOperation::Build2DFaces::_insert_point(const Vector2 &p_point) {
 
 		// Check if point is existing face vertex.
 		for (int i = 0; i < 3; ++i) {
-			if ((p_point - face_vertices[i].point).length_squared() < vertex_snap2) {
+			if (face_vertices[i].point.distance_squared_to(p_point) < vertex_snap2) {
 				return face.vertex_idx[i];
 			}
 		}
@@ -1150,7 +1150,7 @@ int CSGBrushOperation::Build2DFaces::_insert_point(const Vector2 &p_point) {
 			};
 
 			Vector2 closest_point = Geometry2D::get_closest_point_to_segment(p_point, edge_points);
-			if ((closest_point - p_point).length_squared() < vertex_snap2) {
+			if (p_point.distance_squared_to(closest_point) < vertex_snap2) {
 				on_edge = true;
 
 				// Add the point as a new vertex.

modules/gltf/gltf_document.cpp

@@ -3757,10 +3757,7 @@ void GLTFDocument::spec_gloss_to_metal_base_color(const Color &p_specular_factor
 	r_base_color.g = Math::lerp(base_color_from_diffuse.g, base_color_from_specular.g, r_metallic * r_metallic);
 	r_base_color.b = Math::lerp(base_color_from_diffuse.b, base_color_from_specular.b, r_metallic * r_metallic);
 	r_base_color.a = p_diffuse.a;
-	r_base_color.r = CLAMP(r_base_color.r, 0.0f, 1.0f);
-	r_base_color.g = CLAMP(r_base_color.g, 0.0f, 1.0f);
-	r_base_color.b = CLAMP(r_base_color.b, 0.0f, 1.0f);
-	r_base_color.a = CLAMP(r_base_color.a, 0.0f, 1.0f);
+	r_base_color = r_base_color.clamp();
 }
 
 GLTFNodeIndex GLTFDocument::_find_highest_node(Ref<GLTFState> state, const Vector<GLTFNodeIndex> &subset) {

modules/gridmap/grid_map.cpp

@@ -377,10 +377,7 @@ int GridMap::get_cell_item_orientation(const Vector3i &p_position) const {
 }
 
 Vector3i GridMap::world_to_map(const Vector3 &p_world_position) const {
-	Vector3 map_position = p_world_position / cell_size;
-	map_position.x = floor(map_position.x);
-	map_position.y = floor(map_position.y);
-	map_position.z = floor(map_position.z);
+	Vector3 map_position = (p_world_position / cell_size).floor();
 	return Vector3i(map_position);
 }
 

modules/navigation/nav_map.cpp

@@ -664,7 +664,7 @@ void NavMap::sync() {
 				} else {
 					other1 = other_edge_p1.lerp(other_edge_p2, (1.0 - projected_p1_ratio) / (projected_p2_ratio - projected_p1_ratio));
 				}
-				if ((self1 - other1).length() > edge_connection_margin) {
+				if (other1.distance_to(self1) > edge_connection_margin) {
 					continue;
 				}
 
@@ -675,7 +675,7 @@ void NavMap::sync() {
 				} else {
 					other2 = other_edge_p1.lerp(other_edge_p2, (0.0 - projected_p1_ratio) / (projected_p2_ratio - projected_p1_ratio));
 				}
-				if ((self2 - other2).length() > edge_connection_margin) {
+				if (other2.distance_to(self2) > edge_connection_margin) {
 					continue;
 				}
 

scene/3d/skeleton_ik_3d.cpp

@@ -99,7 +99,7 @@ bool FabrikInverseKinematic::build_chain(Task *p_task, bool p_force_simple_chain
 				child_ci->current_pos = child_ci->initial_transform.origin;
 
 				if (child_ci->parent_item) {
-					child_ci->length = (child_ci->current_pos - child_ci->parent_item->current_pos).length();
+					child_ci->length = child_ci->parent_item->current_pos.distance_to(child_ci->current_pos);
 				}
 			}
 
@@ -140,7 +140,7 @@ void FabrikInverseKinematic::solve_simple(Task *p_task, bool p_solve_magnet, Vec
 		solve_simple_backwards(p_task->chain, p_solve_magnet);
 		solve_simple_forwards(p_task->chain, p_solve_magnet, p_origin_pos);
 
-		distance_to_goal = (p_task->chain.tips[0].chain_item->current_pos - p_task->chain.tips[0].end_effector->goal_transform.origin).length();
+		distance_to_goal = p_task->chain.tips[0].end_effector->goal_transform.origin.distance_to(p_task->chain.tips[0].chain_item->current_pos);
 	}
 }
 

scene/gui/graph_edit.cpp

@@ -1071,10 +1071,7 @@ void GraphEdit::gui_input(const Ref<InputEvent> &p_ev) {
 	if (mm.is_valid() && box_selecting) {
 		box_selecting_to = mm->get_position();
 
-		box_selecting_rect = Rect2(MIN(box_selecting_from.x, box_selecting_to.x),
-				MIN(box_selecting_from.y, box_selecting_to.y),
-				ABS(box_selecting_from.x - box_selecting_to.x),
-				ABS(box_selecting_from.y - box_selecting_to.y));
+		box_selecting_rect = Rect2(box_selecting_from.min(box_selecting_to), (box_selecting_from - box_selecting_to).abs());
 
 		for (int i = get_child_count() - 1; i >= 0; i--) {
 			GraphNode *gn = Object::cast_to<GraphNode>(get_child(i));

scene/resources/skeleton_modification_2d_fabrik.cpp

@@ -247,7 +247,7 @@ void SkeletonModification2DFABRIK::chain_backwards() {
 		}
 
 		float current_bone2d_node_length = current_bone2d_node->get_length() * MIN(current_bone2d_node->get_global_scale().x, current_bone2d_node->get_global_scale().y);
-		float length = current_bone2d_node_length / (previous_pose.get_origin() - current_pose.get_origin()).length();
+		float length = current_bone2d_node_length / (current_pose.get_origin().distance_to(previous_pose.get_origin()));
 		Vector2 finish_position = previous_pose.get_origin().lerp(current_pose.get_origin(), length);
 		current_pose.set_origin(finish_position);
 
@@ -268,7 +268,7 @@ void SkeletonModification2DFABRIK::chain_forwards() {
 		Transform2D next_pose = fabrik_transform_chain[i + 1];
 
 		float current_bone2d_node_length = current_bone2d_node->get_length() * MIN(current_bone2d_node->get_global_scale().x, current_bone2d_node->get_global_scale().y);
-		float length = current_bone2d_node_length / (current_pose.get_origin() - next_pose.get_origin()).length();
+		float length = current_bone2d_node_length / (next_pose.get_origin().distance_to(current_pose.get_origin()));
 		Vector2 finish_position = current_pose.get_origin().lerp(next_pose.get_origin(), length);
 		current_pose.set_origin(finish_position);
 

scene/resources/skeleton_modification_3d_fabrik.cpp

@@ -232,7 +232,7 @@ void SkeletonModification3DFABRIK::chain_backwards() {
 		int current_bone_idx = fabrik_data_chain[i].bone_idx;
 		Transform3D current_trans = stack->skeleton->local_pose_to_global_pose(current_bone_idx, stack->skeleton->get_bone_local_pose_override(current_bone_idx));
 
-		real_t length = fabrik_data_chain[i].length / (next_bone_trans.origin - current_trans.origin).length();
+		real_t length = fabrik_data_chain[i].length / (current_trans.origin.distance_to(next_bone_trans.origin));
 		current_trans.origin = next_bone_trans.origin.lerp(current_trans.origin, length);
 
 		// Apply it back to the skeleton
@@ -253,7 +253,7 @@ void SkeletonModification3DFABRIK::chain_forwards() {
 		int next_bone_idx = fabrik_data_chain[i + 1].bone_idx;
 		Transform3D next_bone_trans = stack->skeleton->local_pose_to_global_pose(next_bone_idx, stack->skeleton->get_bone_local_pose_override(next_bone_idx));
 
-		real_t length = fabrik_data_chain[i].length / (current_trans.origin - next_bone_trans.origin).length();
+		real_t length = fabrik_data_chain[i].length / (next_bone_trans.origin.distance_to(current_trans.origin));
 		next_bone_trans.origin = current_trans.origin.lerp(next_bone_trans.origin, length);
 
 		// Apply it back to the skeleton

scene/resources/tile_set.cpp

@@ -3558,8 +3558,7 @@ Vector2i TileSetAtlasSource::get_tile_effective_texture_offset(Vector2i p_atlas_
 	margin = Vector2i(MAX(0, margin.x), MAX(0, margin.y));
 	Vector2i effective_texture_offset = Object::cast_to<TileData>(get_tile_data(p_atlas_coords, p_alternative_tile))->get_texture_offset();
 	if (ABS(effective_texture_offset.x) > margin.x || ABS(effective_texture_offset.y) > margin.y) {
-		effective_texture_offset.x = CLAMP(effective_texture_offset.x, -margin.x, margin.x);
-		effective_texture_offset.y = CLAMP(effective_texture_offset.y, -margin.y, margin.y);
+		effective_texture_offset = effective_texture_offset.clamp(-margin, margin);
 	}
 
 	return effective_texture_offset;