diff --git a/Marlin/src/HAL/LPC1768/tft/xpt2046.cpp b/Marlin/src/HAL/LPC1768/tft/xpt2046.cpp
index 6c00a4cae0b23..a737266c68114 100644
--- a/Marlin/src/HAL/LPC1768/tft/xpt2046.cpp
+++ b/Marlin/src/HAL/LPC1768/tft/xpt2046.cpp
@@ -78,7 +78,7 @@ bool XPT2046::getRawPoint(int16_t * const x, int16_t * const y) {
   if (isBusy() || !isTouched()) return false;
   *x = getRawData(XPT2046_X);
   *y = getRawData(XPT2046_Y);
-  return true;
+  return isTouched();
 }
 
 uint16_t XPT2046::getRawData(const XPTCoordinate coordinate) {
diff --git a/Marlin/src/HAL/STM32/tft/xpt2046.cpp b/Marlin/src/HAL/STM32/tft/xpt2046.cpp
index 57c50653c9ce9..c5645ad79c4a0 100644
--- a/Marlin/src/HAL/STM32/tft/xpt2046.cpp
+++ b/Marlin/src/HAL/STM32/tft/xpt2046.cpp
@@ -123,7 +123,7 @@ bool XPT2046::getRawPoint(int16_t * const x, int16_t * const y) {
   if (isBusy() || !isTouched()) return false;
   *x = getRawData(XPT2046_X);
   *y = getRawData(XPT2046_Y);
-  return true;
+  return isTouched();
 }
 
 uint16_t XPT2046::getRawData(const XPTCoordinate coordinate) {
diff --git a/Marlin/src/HAL/STM32F1/tft/xpt2046.cpp b/Marlin/src/HAL/STM32F1/tft/xpt2046.cpp
index 3428110c127e4..475290de45b24 100644
--- a/Marlin/src/HAL/STM32F1/tft/xpt2046.cpp
+++ b/Marlin/src/HAL/STM32F1/tft/xpt2046.cpp
@@ -90,7 +90,7 @@ bool XPT2046::getRawPoint(int16_t * const x, int16_t * const y) {
   if (isBusy() || !isTouched()) return false;
   *x = getRawData(XPT2046_X);
   *y = getRawData(XPT2046_Y);
-  return true;
+  return isTouched();
 }
 
 uint16_t XPT2046::getRawData(const XPTCoordinate coordinate) {
diff --git a/Marlin/src/lcd/e3v2/jyersui/dwin.cpp b/Marlin/src/lcd/e3v2/jyersui/dwin.cpp
index 6e7898a389f9d..be8605e3bba01 100644
--- a/Marlin/src/lcd/e3v2/jyersui/dwin.cpp
+++ b/Marlin/src/lcd/e3v2/jyersui/dwin.cpp
@@ -389,9 +389,9 @@ class TextScroller {
 
         // Draw value text on
         if (viewer_print_value) {
-          xy_uint_t offset { 0, cell_height_px / 2 - 6 };
+          const int8_t offset_y = cell_height_px / 2 - 6;
           if (isnan(bedlevel.z_values[x][y])) {  // undefined
-            dwinDrawString(false, font6x12, COLOR_WHITE, COLOR_BG_BLUE, start_x_px + cell_width_px / 2 - 5, start_y_px + offset.y, F("X"));
+            dwinDrawString(false, font6x12, COLOR_WHITE, COLOR_BG_BLUE, start_x_px + cell_width_px / 2 - 5, start_y_px + offset_y, F("X"));
           }
           else {                          // has value
             MString<12> msg;
@@ -399,10 +399,10 @@ class TextScroller {
               msg.set(p_float_t(abs(bedlevel.z_values[x][y]), 2));
             else
               msg.setf(F("%02i"), uint16_t(abs(bedlevel.z_values[x][y] - int16_t(bedlevel.z_values[x][y])) * 100));
-            offset.x = cell_width_px / 2 - 3 * msg.length() - 2;
+            const int8_t offset_x = cell_width_px / 2 - 3 * msg.length() - 2;
             if (GRID_MAX_POINTS_X >= 10)
-              dwinDrawString(false, font6x12, COLOR_WHITE, COLOR_BG_BLUE, start_x_px - 2 + offset.x, start_y_px + offset.y /*+ square / 2 - 6*/, F("."));
-            dwinDrawString(false, font6x12, COLOR_WHITE, COLOR_BG_BLUE, start_x_px + 1 + offset.x, start_y_px + offset.y /*+ square / 2 - 6*/, msg);
+              dwinDrawString(false, font6x12, COLOR_WHITE, COLOR_BG_BLUE, start_x_px - 2 + offset_x, start_y_px + offset_y /*+ square / 2 - 6*/, F("."));
+            dwinDrawString(false, font6x12, COLOR_WHITE, COLOR_BG_BLUE, start_x_px + 1 + offset_x, start_y_px + offset_y /*+ square / 2 - 6*/, msg);
           }
           safe_delay(10);
           LCD_SERIAL.flushTX();
diff --git a/Marlin/src/lcd/e3v2/proui/bedlevel_tools.cpp b/Marlin/src/lcd/e3v2/proui/bedlevel_tools.cpp
index f2fe008667c6e..64d145c95dfd3 100644
--- a/Marlin/src/lcd/e3v2/proui/bedlevel_tools.cpp
+++ b/Marlin/src/lcd/e3v2/proui/bedlevel_tools.cpp
@@ -247,9 +247,9 @@ bool BedLevelTools::meshValidate() {
       // Draw value text on
       const uint8_t fs = DWINUI::fontWidth(meshfont);
       if (viewer_print_value) {
-        xy_uint_t offset { 0, cell_height_px / 2 - fs };
+        const int8_t offset_y = cell_height_px / 2 - fs;
         if (isnan(bedlevel.z_values[x][y])) {  // undefined
-          dwinDrawString(false, meshfont, COLOR_WHITE, COLOR_BG_BLUE, start_x_px + cell_width_px / 2 - 5, start_y_px + offset.y, F("X"));
+          dwinDrawString(false, meshfont, COLOR_WHITE, COLOR_BG_BLUE, start_x_px + cell_width_px / 2 - 5, start_y_px + offset_y, F("X"));
         }
         else {                          // has value
           MString<12> msg;
@@ -257,10 +257,10 @@ bool BedLevelTools::meshValidate() {
             msg.set(p_float_t(abs(bedlevel.z_values[x][y]), 2));
           else
             msg.setf(F("%02i"), uint16_t(abs(bedlevel.z_values[x][y] - int16_t(bedlevel.z_values[x][y])) * 100));
-          offset.x = cell_width_px / 2 - (fs / 2) * msg.length() - 2;
+          const int8_t offset_x = cell_width_px / 2 - (fs / 2) * msg.length() - 2;
           if ((GRID_MAX_POINTS_X) >= TERN(TJC_DISPLAY, 8, 10))
-            dwinDrawString(false, meshfont, COLOR_WHITE, COLOR_BG_BLUE, start_x_px - 2 + offset.x, start_y_px + offset.y, F("."));
-          dwinDrawString(false, meshfont, COLOR_WHITE, COLOR_BG_BLUE, start_x_px + 1 + offset.x, start_y_px + offset.y, msg);
+            dwinDrawString(false, meshfont, COLOR_WHITE, COLOR_BG_BLUE, start_x_px - 2 + offset_x, start_y_px + offset_y, F("."));
+          dwinDrawString(false, meshfont, COLOR_WHITE, COLOR_BG_BLUE, start_x_px + 1 + offset_x, start_y_px + offset_y, msg);
         }
         safe_delay(10);
         LCD_SERIAL.flushTX();
diff --git a/Marlin/src/lcd/extui/mks_ui/tft_lvgl_configuration.cpp b/Marlin/src/lcd/extui/mks_ui/tft_lvgl_configuration.cpp
index 7adce94c2fa67..4ac3de7124348 100644
--- a/Marlin/src/lcd/extui/mks_ui/tft_lvgl_configuration.cpp
+++ b/Marlin/src/lcd/extui/mks_ui/tft_lvgl_configuration.cpp
@@ -305,33 +305,43 @@ uint16_t getTickDiff(const uint16_t curTick, const uint16_t lastTick) {
   return (TICK_CYCLE) * (lastTick <= curTick ? (curTick - lastTick) : (0xFFFFFFFF - lastTick + curTick));
 }
 
-static bool get_point(xy_int_t &point) {
-  if (!touch.getRawPoint(&point.x, &point.y)) return false;
+static bool get_point(int16_t * const x, int16_t * const y) {
+  if (!touch.getRawPoint(x, y)) return false;
 
   #if ENABLED(TOUCH_SCREEN_CALIBRATION)
     const calibrationState state = touch_calibration.get_calibration_state();
     if (WITHIN(state, CALIBRATION_TOP_LEFT, CALIBRATION_BOTTOM_LEFT)) {
-      if (touch_calibration.handleTouch(point)) lv_update_touch_calibration_screen();
+      if (touch_calibration.handleTouch(*x, *y)) lv_update_touch_calibration_screen();
       return false;
     }
   #endif
 
-  point.x = int16_t((int32_t(point.x) * _TOUCH_CALIBRATION_X) >> 16) + _TOUCH_OFFSET_X;
-  point.y = int16_t((int32_t(point.y) * _TOUCH_CALIBRATION_Y) >> 16) + _TOUCH_OFFSET_Y;
+  *x = int16_t((int32_t(*x) * _TOUCH_CALIBRATION_X) >> 16) + _TOUCH_OFFSET_X;
+  *y = int16_t((int32_t(*y) * _TOUCH_CALIBRATION_Y) >> 16) + _TOUCH_OFFSET_Y;
 
   return true;
 }
 
 bool my_touchpad_read(lv_indev_drv_t * indev_driver, lv_indev_data_t * data) {
-  static xy_int_t last { 0, 0 };
-  if (get_point(last)) {
-    data->point.x = (TFT_ROTATION == TFT_ROTATE_180) ? TFT_WIDTH  - last.x : last.x;
-    data->point.y = (TFT_ROTATION == TFT_ROTATE_180) ? TFT_HEIGHT - last.y : last.y;
+  static int16_t last_x = 0, last_y = 0;
+  if (get_point(&last_x, &last_y)) {
+    #if TFT_ROTATION == TFT_ROTATE_180
+      data->point.x = TFT_WIDTH - last_x;
+      data->point.y = TFT_HEIGHT - last_y;
+    #else
+      data->point.x = last_x;
+      data->point.y = last_y;
+    #endif
     data->state = LV_INDEV_STATE_PR;
   }
   else {
-    data->point.x = (TFT_ROTATION == TFT_ROTATE_180) ? TFT_WIDTH  - last.x : last.x;
-    data->point.y = (TFT_ROTATION == TFT_ROTATE_180) ? TFT_HEIGHT - last.y : last.y;
+    #if TFT_ROTATION == TFT_ROTATE_180
+      data->point.x = TFT_WIDTH - last_x;
+      data->point.y = TFT_HEIGHT - last_y;
+    #else
+      data->point.x = last_x;
+      data->point.y = last_y;
+    #endif
     data->state = LV_INDEV_STATE_REL;
   }
   return false; // Return `false` since no data is buffering or left to read
diff --git a/Marlin/src/lcd/tft/touch.cpp b/Marlin/src/lcd/tft/touch.cpp
index 8e79e397adeaf..adf6cf2521b9a 100644
--- a/Marlin/src/lcd/tft/touch.cpp
+++ b/Marlin/src/lcd/tft/touch.cpp
@@ -39,7 +39,7 @@
 #include "tft.h"
 
 bool Touch::enabled = true;
-xy_int_t Touch::point;
+int16_t Touch::x, Touch::y;
 touch_control_t Touch::controls[];
 touch_control_t *Touch::current_control;
 uint16_t Touch::controls_count;
@@ -67,13 +67,18 @@ void Touch::add_control(TouchControlType type, uint16_t x, uint16_t y, uint16_t
   if (controls_count == MAX_CONTROLS) return;
 
   controls[controls_count].type = type;
-  controls[controls_count].pos.set(x, y);
-  controls[controls_count].size.set(width, height);
+  controls[controls_count].x = x;
+  controls[controls_count].y = y;
+  controls[controls_count].width = width;
+  controls[controls_count].height = height;
   controls[controls_count].data = data;
   controls_count++;
 }
 
 void Touch::idle() {
+  uint16_t i;
+  int16_t _x, _y;
+
   if (!enabled) return;
 
   // Return if Touch::idle is called within the same millisecond
@@ -81,8 +86,7 @@ void Touch::idle() {
   if (now <= next_touch_ms) return;
   next_touch_ms = now;
 
-  xy_int_t got_point;
-  if (get_point(got_point)) {
+  if (get_point(&_x, &_y)) {
     #if HAS_RESUME_CONTINUE
       // UI is waiting for a click anywhere?
       if (wait_for_user) {
@@ -106,24 +110,19 @@ void Touch::idle() {
     if (time_to_hold == 0) time_to_hold = now + MINIMUM_HOLD_TIME;
     if (PENDING(now, time_to_hold)) return;
 
-    if (bool(point)) {
+    if (x != 0 && y != 0) {
       if (current_control) {
-        if ( WITHIN(point.x, current_control->pos.x - FREE_MOVE_RANGE, current_control->pos.x + current_control->size.x + FREE_MOVE_RANGE)
-          && WITHIN(point.y, current_control->pos.y - FREE_MOVE_RANGE, current_control->pos.y + current_control->size.y + FREE_MOVE_RANGE)
-        ) {
-          LIMIT(point.x, current_control->pos.x, current_control->pos.x + current_control->size.x);
-          LIMIT(point.y, current_control->pos.y, current_control->pos.y + current_control->size.y);
+        if (WITHIN(x, current_control->x - FREE_MOVE_RANGE, current_control->x + current_control->width + FREE_MOVE_RANGE) && WITHIN(y, current_control->y - FREE_MOVE_RANGE, current_control->y + current_control->height + FREE_MOVE_RANGE)) {
+          LIMIT(x, current_control->x, current_control->x + current_control->width);
+          LIMIT(y, current_control->y, current_control->y + current_control->height);
           touch(current_control);
         }
         else
           current_control = nullptr;
       }
       else {
-        for (uint16_t i = 0; i < controls_count; i++) {
-          if (TERN0(TOUCH_SCREEN_CALIBRATION, controls[i].type == CALIBRATE)
-            || ( WITHIN(point.x, controls[i].pos.x, controls[i].pos.x + controls[i].size.x)
-              && WITHIN(point.y, controls[i].pos.y, controls[i].pos.y + controls[i].size.y))
-          ) {
+        for (i = 0; i < controls_count; i++) {
+          if ((WITHIN(x, controls[i].x, controls[i].x + controls[i].width) && WITHIN(y, controls[i].y, controls[i].y + controls[i].height)) || (TERN(TOUCH_SCREEN_CALIBRATION, controls[i].type == CALIBRATE, false))) {
             touch_control_type = controls[i].type;
             touch(&controls[i]);
             break;
@@ -134,10 +133,11 @@ void Touch::idle() {
       if (!current_control)
         touch_time = now;
     }
-    point = got_point;
+    x = _x;
+    y = _y;
   }
   else {
-    point.reset();
+    x = y = 0;
     current_control = nullptr;
     touch_time = 0;
     touch_control_type = NONE;
@@ -150,7 +150,7 @@ void Touch::touch(touch_control_t *control) {
   switch (control->type) {
     #if ENABLED(TOUCH_SCREEN_CALIBRATION)
       case CALIBRATE:
-        if (touch_calibration.handleTouch(point)) ui.refresh();
+        if (touch_calibration.handleTouch(x, y)) ui.refresh();
         break;
     #endif
 
@@ -177,7 +177,7 @@ void Touch::touch(touch_control_t *control) {
       ui.encoderPosition = ui.encoderPosition + LCD_HEIGHT < (uint32_t)screen_items ? ui.encoderPosition + LCD_HEIGHT : screen_items;
       ui.refresh();
       break;
-    case SLIDER:    hold(control); ui.encoderPosition = (point.x - control->pos.x) * control->data / control->size.x; break;
+    case SLIDER:    hold(control); ui.encoderPosition = (x - control->x) * control->data / control->width; break;
     case INCREASE:  hold(control, repeat_delay - 5); TERN(AUTO_BED_LEVELING_UBL, ui.external_control ? bedlevel.encoder_diff++ : ui.encoderPosition++, ui.encoderPosition++); break;
     case DECREASE:  hold(control, repeat_delay - 5); TERN(AUTO_BED_LEVELING_UBL, ui.external_control ? bedlevel.encoder_diff-- : ui.encoderPosition--, ui.encoderPosition--); break;
     case HEATER:
@@ -263,17 +263,21 @@ void Touch::hold(touch_control_t *control, millis_t delay) {
   ui.refresh();
 }
 
-bool Touch::get_point(xy_int_t &point) {
-  bool is_touched = false;
-  #if ANY(TFT_TOUCH_DEVICE_XPT2046, TFT_TOUCH_DEVICE_GT911)
-    is_touched = (TOUCH_ORIENTATION_NONE != _TOUCH_ORIENTATION)
-                  && (TOUCH_PORTRAIT == _TOUCH_ORIENTATION
-                      ? io.getRawPoint(&point.y, &point.x)
-                      : io.getRawPoint(&point.x, &point.y));
-    #if ENABLED(TFT_TOUCH_DEVICE_XPT2046)
-      point.x = uint16_t((uint32_t(point.x) * _TOUCH_CALIBRATION_X) >> 16) + _TOUCH_OFFSET_X;
-      point.y = uint16_t((uint32_t(point.y) * _TOUCH_CALIBRATION_Y) >> 16) + _TOUCH_OFFSET_Y;
+bool Touch::get_point(int16_t * const x, int16_t * const y) {
+  #if ENABLED(TFT_TOUCH_DEVICE_XPT2046)
+    #if ENABLED(TOUCH_SCREEN_CALIBRATION)
+      const bool is_touched = (touch_calibration.calibration.orientation == TOUCH_PORTRAIT ? io.getRawPoint(y, x) : io.getRawPoint(x, y));
+      if (is_touched && touch_calibration.calibration.orientation != TOUCH_ORIENTATION_NONE) {
+        *x = int16_t((int32_t(*x) * touch_calibration.calibration.x) >> 16) + touch_calibration.calibration.offset_x;
+        *y = int16_t((int32_t(*y) * touch_calibration.calibration.y) >> 16) + touch_calibration.calibration.offset_y;
+      }
+    #else
+      const bool is_touched = (TOUCH_ORIENTATION == TOUCH_PORTRAIT ? io.getRawPoint(y, x) : io.getRawPoint(x, y));
+      *x = uint16_t((uint32_t(*x) * TOUCH_CALIBRATION_X) >> 16) + TOUCH_OFFSET_X;
+      *y = uint16_t((uint32_t(*y) * TOUCH_CALIBRATION_Y) >> 16) + TOUCH_OFFSET_Y;
     #endif
+  #elif ENABLED(TFT_TOUCH_DEVICE_GT911)
+    const bool is_touched = (TOUCH_ORIENTATION == TOUCH_PORTRAIT ? io.getRawPoint(y, x) : io.getRawPoint(x, y));
   #endif
 
   #if HAS_TOUCH_SLEEP
diff --git a/Marlin/src/lcd/tft/touch.h b/Marlin/src/lcd/tft/touch.h
index 6c0ff88f4674a..93f9327a15b38 100644
--- a/Marlin/src/lcd/tft/touch.h
+++ b/Marlin/src/lcd/tft/touch.h
@@ -57,8 +57,10 @@ enum TouchControlType : uint16_t {
 
 typedef struct __attribute__((__packed__)) {
   TouchControlType type;
-  xy_uint_t pos;
-  xy_uint_t size;
+  uint16_t x;
+  uint16_t y;
+  uint16_t width;
+  uint16_t height;
   intptr_t data;
 } touch_control_t;
 
@@ -75,7 +77,7 @@ typedef struct __attribute__((__packed__)) {
 class Touch {
   private:
     static TOUCH_DRIVER_CLASS io;
-    static xy_int_t point;
+    static int16_t x, y;
     static bool enabled;
 
     static touch_control_t controls[MAX_CONTROLS];
@@ -85,7 +87,7 @@ class Touch {
     static millis_t next_touch_ms, time_to_hold, repeat_delay, touch_time;
     static TouchControlType touch_control_type;
 
-    static bool get_point(xy_int_t &point);
+    static bool get_point(int16_t * const x, int16_t * const y);
     static void touch(touch_control_t *control);
     static void hold(touch_control_t *control, millis_t delay=0);
 
diff --git a/Marlin/src/lcd/tft_io/touch_calibration.cpp b/Marlin/src/lcd/tft_io/touch_calibration.cpp
index b1cdfe6cda943..f76c29eb49f2c 100644
--- a/Marlin/src/lcd/tft_io/touch_calibration.cpp
+++ b/Marlin/src/lcd/tft_io/touch_calibration.cpp
@@ -58,18 +58,18 @@ void TouchCalibration::validate_calibration() {
   #define CP(N) calibration_points[CALIBRATION_##N]
   if (landscape) {
     calibration_state = CALIBRATION_SUCCESS;
-    calibration.x = ((CP(TOP_RIGHT).x - CP(TOP_LEFT).x) << 17) / (CP(BOTTOM_RIGHT).raw.x + CP(TOP_RIGHT).raw.x - CP(BOTTOM_LEFT).raw.x - CP(TOP_LEFT).raw.x);
-    calibration.y = ((CP(BOTTOM_LEFT).y - CP(TOP_LEFT).y) << 17) / (CP(BOTTOM_RIGHT).raw.y - CP(TOP_RIGHT).raw.y + CP(BOTTOM_LEFT).raw.y - CP(TOP_LEFT).raw.y);
-    calibration.offset.x = CP(TOP_LEFT).x - int16_t(((CP(TOP_LEFT).raw.x + CP(BOTTOM_LEFT).raw.x) * calibration.x) >> 17);
-    calibration.offset.y = CP(TOP_LEFT).y - int16_t(((CP(TOP_LEFT).raw.y + CP(TOP_RIGHT).raw.y) * calibration.y) >> 17);
+    calibration.x = ((CP(TOP_RIGHT).x - CP(TOP_LEFT).x) << 17) / (CP(BOTTOM_RIGHT).raw_x + CP(TOP_RIGHT).raw_x - CP(BOTTOM_LEFT).raw_x - CP(TOP_LEFT).raw_x);
+    calibration.y = ((CP(BOTTOM_LEFT).y - CP(TOP_LEFT).y) << 17) / (CP(BOTTOM_RIGHT).raw_y - CP(TOP_RIGHT).raw_y + CP(BOTTOM_LEFT).raw_y - CP(TOP_LEFT).raw_y);
+    calibration.offset_x = CP(TOP_LEFT).x - int16_t(((CP(TOP_LEFT).raw_x + CP(BOTTOM_LEFT).raw_x) * calibration.x) >> 17);
+    calibration.offset_y = CP(TOP_LEFT).y - int16_t(((CP(TOP_LEFT).raw_y + CP(TOP_RIGHT).raw_y) * calibration.y) >> 17);
     calibration.orientation = TOUCH_LANDSCAPE;
   }
   else if (portrait) {
     calibration_state = CALIBRATION_SUCCESS;
-    calibration.x = ((CP(TOP_RIGHT).x - CP(TOP_LEFT).x) << 17) / (CP(BOTTOM_RIGHT).raw.y + CP(TOP_RIGHT).raw.y - CP(BOTTOM_LEFT).raw.y - CP(TOP_LEFT).raw.y);
-    calibration.y = ((CP(BOTTOM_LEFT).y - CP(TOP_LEFT).y) << 17) / (CP(BOTTOM_RIGHT).raw.x - CP(TOP_RIGHT).raw.x + CP(BOTTOM_LEFT).raw.x - CP(TOP_LEFT).raw.x);
-    calibration.offset.x = CP(TOP_LEFT).x - int16_t(((CP(TOP_LEFT).raw.y + CP(BOTTOM_LEFT).raw.y) * calibration.x) >> 17);
-    calibration.offset.y = CP(TOP_LEFT).y - int16_t(((CP(TOP_LEFT).raw.x + CP(TOP_RIGHT).raw.x) * calibration.y) >> 17);
+    calibration.x = ((CP(TOP_RIGHT).x - CP(TOP_LEFT).x) << 17) / (CP(BOTTOM_RIGHT).raw_y + CP(TOP_RIGHT).raw_y - CP(BOTTOM_LEFT).raw_y - CP(TOP_LEFT).raw_y);
+    calibration.y = ((CP(BOTTOM_LEFT).y - CP(TOP_LEFT).y) << 17) / (CP(BOTTOM_RIGHT).raw_x - CP(TOP_RIGHT).raw_x + CP(BOTTOM_LEFT).raw_x - CP(TOP_LEFT).raw_x);
+    calibration.offset_x = CP(TOP_LEFT).x - int16_t(((CP(TOP_LEFT).raw_y + CP(BOTTOM_LEFT).raw_y) * calibration.x) >> 17);
+    calibration.offset_y = CP(TOP_LEFT).y - int16_t(((CP(TOP_LEFT).raw_x + CP(TOP_RIGHT).raw_x) * calibration.y) >> 17);
     calibration.orientation = TOUCH_PORTRAIT;
   }
   else {
@@ -83,23 +83,23 @@ void TouchCalibration::validate_calibration() {
     SERIAL_ECHOLNPGM("Touch screen calibration completed");
     SERIAL_ECHOLN(F("#define TOUCH_"), F("CALIBRATION_X "), calibration.x);
     SERIAL_ECHOLN(F("#define TOUCH_"), F("CALIBRATION_Y "), calibration.y);
-    SERIAL_ECHOLN(F("#define TOUCH_"), F("OFFSET_X "), calibration.offset.x);
-    SERIAL_ECHOLN(F("#define TOUCH_"), F("OFFSET_Y "), calibration.offset.y);
+    SERIAL_ECHOLN(F("#define TOUCH_"), F("OFFSET_X "), calibration.offset_x);
+    SERIAL_ECHOLN(F("#define TOUCH_"), F("OFFSET_Y "), calibration.offset_y);
     SERIAL_ECHO(F("#define TOUCH_")); SERIAL_ECHO_TERNARY(calibration.orientation == TOUCH_LANDSCAPE, "ORIENTATION ", "TOUCH_LANDSCAPE", "TOUCH_PORTRAIT", "\n");
     TERN_(TOUCH_CALIBRATION_AUTO_SAVE, settings.save());
   }
 }
 
-bool TouchCalibration::handleTouch(const xy_int_t &point) {
+bool TouchCalibration::handleTouch(const uint16_t x, const uint16_t y) {
   const millis_t now = millis();
+
   if (next_touch_update_ms && PENDING(now, next_touch_update_ms)) return false;
   next_touch_update_ms = now + BUTTON_DELAY_MENU;
 
   if (calibration_state < CALIBRATION_SUCCESS) {
-    calibration_points[calibration_state].raw = point;
-    DEBUG_ECHOLNPGM("TouchCalibration - State: ", calibration_state,
-                    ", x: ", calibration_points[calibration_state].x, ", raw.x: ", point.x,
-                    ", y: ", calibration_points[calibration_state].y, ", raw.y: ", point.y);
+    calibration_points[calibration_state].raw_x = x;
+    calibration_points[calibration_state].raw_y = y;
+    DEBUG_ECHOLNPGM("TouchCalibration - State: ", calibration_state, ", x: ", calibration_points[calibration_state].x, ", raw_x: ", x, ", y: ", calibration_points[calibration_state].y, ", raw_y: ", y);
   }
 
   switch (calibration_state) {
diff --git a/Marlin/src/lcd/tft_io/touch_calibration.h b/Marlin/src/lcd/tft_io/touch_calibration.h
index be226db224cc8..ebfd489393169 100644
--- a/Marlin/src/lcd/tft_io/touch_calibration.h
+++ b/Marlin/src/lcd/tft_io/touch_calibration.h
@@ -27,8 +27,8 @@
 
 #define _TOUCH_CALIBRATION_X touch_calibration.calibration.x
 #define _TOUCH_CALIBRATION_Y touch_calibration.calibration.y
-#define _TOUCH_OFFSET_X      touch_calibration.calibration.offset.x
-#define _TOUCH_OFFSET_Y      touch_calibration.calibration.offset.y
+#define _TOUCH_OFFSET_X      touch_calibration.calibration.offset_x
+#define _TOUCH_OFFSET_Y      touch_calibration.calibration.offset_y
 #define _TOUCH_ORIENTATION   touch_calibration.calibration.orientation
 
 #ifndef TOUCH_SCREEN_CALIBRATION_PRECISION
@@ -38,22 +38,15 @@
   #define TOUCH_SCREEN_HOLD_TO_CALIBRATE_MS   2500
 #endif
 
-typedef struct __attribute__((__packed__)) TouchCal : xy_long_t {
-  xy_int_t offset;
+typedef struct __attribute__((__packed__)) {
+  int32_t x, y;
+  int16_t offset_x, offset_y;
   uint8_t orientation;
-  TouchCal() { set(xy_long_t({ 0, 0 }), xy_int_t({ 0, 0 }), TOUCH_ORIENTATION_NONE); }
-  void set(const xy_long_t &xy, const xy_int_t &hv, const uint8_t o) {
-    xy_long_t::set(xy); offset = hv; orientation = o;
-  }
-  void reset() {
-    set(xy_long_t({ TOUCH_CALIBRATION_X, TOUCH_CALIBRATION_Y }),
-        xy_int_t({ TOUCH_OFFSET_X, TOUCH_OFFSET_Y }),
-        TOUCH_ORIENTATION);
-  }
 } touch_calibration_t;
 
-typedef struct __attribute__((__packed__)) : xy_uint_t {
-  xy_int_t raw;
+typedef struct __attribute__((__packed__)) {
+  uint16_t x, y;
+  int16_t raw_x, raw_y;
 } touch_calibration_point_t;
 
 enum calibrationState : uint8_t {
@@ -72,24 +65,28 @@ class TouchCalibration {
   static touch_calibration_point_t calibration_points[4];
   static millis_t next_touch_update_ms;
 
-  static bool validate_precision(int32_t a, int32_t b) { return (a > b ? (100 * b) / a : (100 * a) / b) > (TOUCH_SCREEN_CALIBRATION_PRECISION); }
-  static bool validate_precision_x(uint8_t a, uint8_t b) { return validate_precision(calibration_points[a].raw.x, calibration_points[b].raw.x); }
-  static bool validate_precision_y(uint8_t a, uint8_t b) { return validate_precision(calibration_points[a].raw.y, calibration_points[b].raw.y); }
+  static bool validate_precision(int32_t a, int32_t b) { return (a > b ? (100 * b) / a :  (100 * a) / b) > TOUCH_SCREEN_CALIBRATION_PRECISION; }
+  static bool validate_precision_x(uint8_t a, uint8_t b) { return validate_precision(calibration_points[a].raw_x, calibration_points[b].raw_x); }
+  static bool validate_precision_y(uint8_t a, uint8_t b) { return validate_precision(calibration_points[a].raw_y, calibration_points[b].raw_y); }
   static void validate_calibration();
 
   static touch_calibration_t calibration;
   static uint8_t failed_count;
-  static void calibration_reset() { calibration.set(xy_long_t({ TOUCH_CALIBRATION_X, TOUCH_CALIBRATION_Y }), xy_int_t({ TOUCH_OFFSET_X, TOUCH_OFFSET_Y }), TOUCH_ORIENTATION); }
-  static bool need_calibration() { return !(calibration.offset.x || calibration.offset.y || calibration.x || calibration.y); }
+  static void calibration_reset() { calibration = { TOUCH_CALIBRATION_X, TOUCH_CALIBRATION_Y, TOUCH_OFFSET_X, TOUCH_OFFSET_Y, TOUCH_ORIENTATION }; }
+  static bool need_calibration() { return !calibration.offset_x && !calibration.offset_y && !calibration.x && !calibration.y; }
 
   static calibrationState calibration_start() {
     next_touch_update_ms = millis() + 750UL;
-    calibration.reset();
+    calibration = { 0, 0, 0, 0, TOUCH_ORIENTATION_NONE };
     calibration_state = CALIBRATION_TOP_LEFT;
-    calibration_points[CALIBRATION_TOP_LEFT].set(30, 30);
-    calibration_points[CALIBRATION_TOP_RIGHT].set(TFT_WIDTH - 31, 30);
-    calibration_points[CALIBRATION_BOTTOM_RIGHT].set(TFT_WIDTH - 31, TFT_HEIGHT - 31);
-    calibration_points[CALIBRATION_BOTTOM_LEFT].set(30, TFT_HEIGHT - 31);
+    calibration_points[CALIBRATION_TOP_LEFT].x = 30;
+    calibration_points[CALIBRATION_TOP_LEFT].y = 30;
+    calibration_points[CALIBRATION_TOP_RIGHT].x = TFT_WIDTH - 31;
+    calibration_points[CALIBRATION_TOP_RIGHT].y = 30;
+    calibration_points[CALIBRATION_BOTTOM_RIGHT].x = TFT_WIDTH - 31;
+    calibration_points[CALIBRATION_BOTTOM_RIGHT].y = TFT_HEIGHT - 31;
+    calibration_points[CALIBRATION_BOTTOM_LEFT].x = 30;
+    calibration_points[CALIBRATION_BOTTOM_LEFT].y = TFT_HEIGHT - 31;
     failed_count = 0;
     return calibration_state;
   }
@@ -100,7 +97,7 @@ class TouchCalibration {
     return !need_calibration();
   }
 
-  static bool handleTouch(const xy_int_t &point);
+  static bool handleTouch(const uint16_t x, const uint16_t y);
 };
 
 extern TouchCalibration touch_calibration;
diff --git a/Marlin/src/lcd/touch/touch_buttons.cpp b/Marlin/src/lcd/touch/touch_buttons.cpp
index 636a31dafa412..0780aff287a94 100644
--- a/Marlin/src/lcd/touch/touch_buttons.cpp
+++ b/Marlin/src/lcd/touch/touch_buttons.cpp
@@ -75,30 +75,23 @@ uint8_t TouchButtons::read_buttons() {
         else if (!isSleeping() && ELAPSED(millis(), next_sleep_ms) && ui.on_status_screen())
           sleepTimeout();
       #endif
-
-      #if ENABLED(TOUCH_SCREEN_CALIBRATION)
-        static bool no_touch = false;
-      #endif
-
-      if (!is_touched) {
-        TERN_(TOUCH_SCREEN_CALIBRATION, no_touch = false);
-        return 0;
-      }
+      if (!is_touched) return 0;
 
       #if ENABLED(TOUCH_SCREEN_CALIBRATION)
         const calibrationState state = touch_calibration.get_calibration_state();
         if (WITHIN(state, CALIBRATION_TOP_LEFT, CALIBRATION_BOTTOM_LEFT)) {
-          if (!no_touch && touch_calibration.handleTouch(xy_int_t({x, y}))) ui.refresh();
-          no_touch = true;
+          if (touch_calibration.handleTouch(x, y)) ui.refresh();
           return 0;
         }
+        x = int16_t((int32_t(x) * touch_calibration.calibration.x) >> 16) + touch_calibration.calibration.offset_x;
+        y = int16_t((int32_t(y) * touch_calibration.calibration.y) >> 16) + touch_calibration.calibration.offset_y;
+      #else
+        x = uint16_t((uint32_t(x) * TOUCH_CALIBRATION_X) >> 16) + TOUCH_OFFSET_X;
+        y = uint16_t((uint32_t(y) * TOUCH_CALIBRATION_Y) >> 16) + TOUCH_OFFSET_Y;
       #endif
-      x = uint16_t((uint32_t(x) * _TOUCH_CALIBRATION_X) >> 16) + _TOUCH_OFFSET_X;
-      y = uint16_t((uint32_t(y) * _TOUCH_CALIBRATION_Y) >> 16) + _TOUCH_OFFSET_Y;
-
     #elif ENABLED(TFT_TOUCH_DEVICE_GT911)
 
-      const bool is_touched = TOUCH_PORTRAIT == _TOUCH_ORIENTATION ? touchIO.getRawPoint(&y, &x) : touchIO.getRawPoint(&x, &y);
+      const bool is_touched = (TOUCH_ORIENTATION == TOUCH_PORTRAIT ? touchIO.getRawPoint(&y, &x) : touchIO.getRawPoint(&x, &y));
       if (!is_touched) return 0;
 
     #endif