Parity with 2.0.x bitmap functions

Based on #8565

Marlin/G26_Mesh_Validation_Tool.cpp

@@ -327,7 +327,7 @@
 
     for (uint8_t i = 0; i < GRID_MAX_POINTS_X; i++) {
       for (uint8_t j = 0; j < GRID_MAX_POINTS_Y; j++) {
-        if (!is_bit_set(circle_flags, i, j)) {
+        if (!is_bitmap_set(circle_flags, i, j)) {
           const float mx = _GET_MESH_X(i),  // We found a circle that needs to be printed
                       my = _GET_MESH_Y(j);
 
@@ -353,7 +353,7 @@
         }
       }
     }
-    bit_set(circle_flags, return_val.x_index, return_val.y_index);   // Mark this location as done.
+    bitmap_set(circle_flags, return_val.x_index, return_val.y_index);   // Mark this location as done.
     return return_val;
   }
 
@@ -418,8 +418,8 @@
         if (i < GRID_MAX_POINTS_X) { // We can't connect to anything to the right than GRID_MAX_POINTS_X.
                                      // This is already a half circle because we are at the edge of the bed.
 
-          if (is_bit_set(circle_flags, i, j) && is_bit_set(circle_flags, i + 1, j)) { // check if we can do a line to the left
+          if (is_bitmap_set(circle_flags, i, j) && is_bitmap_set(circle_flags, i + 1, j)) { // check if we can do a line to the left
-            if (!is_bit_set(horizontal_mesh_line_flags, i, j)) {
+            if (!is_bitmap_set(horizontal_mesh_line_flags, i, j)) {
 
               //
               // We found two circles that need a horizontal line to connect them
@@ -445,15 +445,15 @@
                 }
                 print_line_from_here_to_there(sx, sy, g26_layer_height, ex, ey, g26_layer_height);
               }
-              bit_set(horizontal_mesh_line_flags, i, j);   // Mark it as done so we don't do it again, even if we skipped it
+              bitmap_set(horizontal_mesh_line_flags, i, j);   // Mark it as done so we don't do it again, even if we skipped it
             }
           }
 
           if (j < GRID_MAX_POINTS_Y) { // We can't connect to anything further back than GRID_MAX_POINTS_Y.
                                            // This is already a half circle because we are at the edge  of the bed.
 
-            if (is_bit_set(circle_flags, i, j) && is_bit_set(circle_flags, i, j + 1)) { // check if we can do a line straight down
+            if (is_bitmap_set(circle_flags, i, j) && is_bitmap_set(circle_flags, i, j + 1)) { // check if we can do a line straight down
-              if (!is_bit_set( vertical_mesh_line_flags, i, j)) {
+              if (!is_bitmap_set( vertical_mesh_line_flags, i, j)) {
                 //
                 // We found two circles that need a vertical line to connect them
                 // Print it!
@@ -481,7 +481,7 @@
                   }
                   print_line_from_here_to_there(sx, sy, g26_layer_height, ex, ey, g26_layer_height);
                 }
-                bit_set(vertical_mesh_line_flags, i, j);   // Mark it as done so we don't do it again, even if skipped
+                bitmap_set(vertical_mesh_line_flags, i, j);   // Mark it as done so we don't do it again, even if skipped
               }
             }
           }

Marlin/bitmap_flags.h

@@ -31,8 +31,8 @@
  * to unsigned long will allow us to go to 32x32 if higher resolution meshes are needed
  * in the future.
  */
-FORCE_INLINE void bit_clear(uint16_t bits[16], const uint8_t x, const uint8_t y) { CBI(bits[y], x); }
+FORCE_INLINE void bitmap_clear(uint16_t bits[16], const uint8_t x, const uint8_t y) { CBI(bits[y], x); }
-FORCE_INLINE void bit_set(uint16_t bits[16], const uint8_t x, const uint8_t y) { SBI(bits[y], x); }
+FORCE_INLINE void bitmap_set(uint16_t bits[16], const uint8_t x, const uint8_t y) { SBI(bits[y], x); }
-FORCE_INLINE bool is_bit_set(uint16_t bits[16], const uint8_t x, const uint8_t y) { return TEST(bits[y], x); }
+FORCE_INLINE bool is_bitmap_set(uint16_t bits[16], const uint8_t x, const uint8_t y) { return TEST(bits[y], x); }
 
 #endif // _BITMAP_FLAGS_H_

Marlin/ubl_G29.cpp

@@ -1425,7 +1425,7 @@
 
         if ( (type == INVALID && isnan(z_values[i][j]))  // Check to see if this location holds the right thing
           || (type == REAL && !isnan(z_values[i][j]))
-          || (type == SET_IN_BITMAP && is_bit_set(bits, i, j))
+          || (type == SET_IN_BITMAP && is_bitmap_set(bits, i, j))
         ) {
           // We only get here if we found a Mesh Point of the specified type
 
@@ -1495,7 +1495,7 @@
 
         if (location.x_index < 0) break; // stop when we can't find any more reachable points.
 
-        bit_clear(not_done, location.x_index, location.y_index);  // Mark this location as 'adjusted' so we will find a
+        bitmap_clear(not_done, location.x_index, location.y_index);  // Mark this location as 'adjusted' so we will find a
                                                                   // different location the next time through the loop
 
         const float rawx = mesh_index_to_xpos(location.x_index),