SDL API renaming: SDL_rect.h

Fixes https://github.com/libsdl-org/SDL/issues/6887

docs/README-migration.md

@@ -379,6 +379,26 @@ The following functions have been renamed:
 
 The preprocessor symbol __MACOSX__ has been renamed __MACOS__, and __IPHONEOS__ has been renamed __IOS__
 
+## SDL_rect.h
+
+The following functions have been renamed:
+* SDL_EncloseFPoints => SDL_GetRectEnclosingPointsF
+* SDL_EnclosePoints => SDL_GetRectEnclosingPoints
+* SDL_FRectEmpty => SDL_IsRectEmptyF
+* SDL_FRectEqualsEpsilon => SDL_AreRectsEqualF
+* SDL_HasIntersection => SDL_HasRectIntersection
+* SDL_HasIntersectionF => SDL_HasRectIntersectionF
+* SDL_IntersectFRect => SDL_GetRectIntersectionF
+* SDL_IntersectFRectAndLine => SDL_GetRectAndLineIntersectionF
+* SDL_IntersectRect => SDL_GetRectIntersection
+* SDL_IntersectRectAndLine => SDL_GetRectAndLineIntersection
+* SDL_PointInFRect => SDL_IsPointInRectF
+* SDL_PointInRect => SDL_IsPointInRect
+* SDL_RectEmpty => SDL_IsRectEmpty
+* SDL_RectEquals => SDL_AreRectsEqual
+* SDL_UnionFRect => SDL_GetRectUnionF
+* SDL_UnionRect => SDL_GetRectUnion
+
 ## SDL_render.h
 
 SDL_GetRenderDriverInfo() has been removed, since most of the information it reported were

include/SDL3/SDL_oldnames.h

@@ -269,6 +269,24 @@
 #define __MACOSX__ __MACOS__
 #endif
 
+/* ##SDL_rect.h */
+#define SDL_EncloseFPoints SDL_GetRectEnclosingPointsF
+#define SDL_EnclosePoints SDL_GetRectEnclosingPoints
+#define SDL_FRectEmpty SDL_IsRectEmptyF
+#define SDL_FRectEqualsEpsilon SDL_AreRectsEqualF
+#define SDL_HasIntersection SDL_HasRectIntersection
+#define SDL_HasIntersectionF SDL_HasRectIntersectionF
+#define SDL_IntersectFRect SDL_GetRectIntersectionF
+#define SDL_IntersectFRectAndLine SDL_GetRectAndLineIntersectionF
+#define SDL_IntersectRect SDL_GetRectIntersection
+#define SDL_IntersectRectAndLine SDL_GetRectAndLineIntersection
+#define SDL_PointInFRect SDL_IsPointInRectF
+#define SDL_PointInRect SDL_IsPointInRect
+#define SDL_RectEmpty SDL_IsRectEmpty
+#define SDL_RectEquals SDL_AreRectsEqual
+#define SDL_UnionFRect SDL_GetRectUnionF
+#define SDL_UnionRect SDL_GetRectUnion
+
 /* ##SDL_render.h */
 #define SDL_RenderCopy SDL_RenderTexture
 #define SDL_RenderCopyEx SDL_RenderTextureRotated
@@ -575,6 +593,24 @@
 #define __MACOSX__ __MACOSX___renamed___MACOS__
 #endif
 
+/* ##SDL_rect.h */
+#define SDL_EncloseFPoints SDL_EncloseFPoints_renamed_SDL_GetRectEnclosingPointsF
+#define SDL_EnclosePoints SDL_EnclosePoints_renamed_SDL_GetRectEnclosingPoints
+#define SDL_FRectEmpty SDL_FRectEmpty_renamed_SDL_IsRectEmptyF
+#define SDL_FRectEqualsEpsilon SDL_FRectEqualsEpsilon_renamed_SDL_AreRectsEqualF
+#define SDL_HasIntersection SDL_HasIntersection_renamed_SDL_HasRectIntersection
+#define SDL_HasIntersectionF SDL_HasIntersectionF_renamed_SDL_HasRectIntersectionF
+#define SDL_IntersectFRect SDL_IntersectFRect_renamed_SDL_GetRectIntersectionF
+#define SDL_IntersectFRectAndLine SDL_IntersectFRectAndLine_renamed_SDL_GetRectAndLineIntersectionF
+#define SDL_IntersectRect SDL_IntersectRect_renamed_SDL_GetRectIntersection
+#define SDL_IntersectRectAndLine SDL_IntersectRectAndLine_renamed_SDL_GetRectAndLineIntersection
+#define SDL_PointInFRect SDL_PointInFRect_renamed_SDL_IsPointInRectF
+#define SDL_PointInRect SDL_PointInRect_renamed_SDL_IsPointInRect
+#define SDL_RectEmpty SDL_RectEmpty_renamed_SDL_IsRectEmpty
+#define SDL_RectEquals SDL_RectEquals_renamed_SDL_AreRectsEqual
+#define SDL_UnionFRect SDL_UnionFRect_renamed_SDL_GetRectUnionF
+#define SDL_UnionRect SDL_UnionRect_renamed_SDL_GetRectUnion
+
 /* ##SDL_render.h */
 #define SDL_RenderCopy SDL_RenderCopy_renamed_SDL_RenderTexture
 #define SDL_RenderCopyEx SDL_RenderCopyEx_renamed_SDL_RenderTextureRotated

include/SDL3/SDL_rect.h

@@ -42,8 +42,8 @@ extern "C" {
 /**
  * The structure that defines a point (integer)
  *
- * \sa SDL_EnclosePoints
- * \sa SDL_PointInRect
+ * \sa SDL_GetRectEnclosingPoints
+ * \sa SDL_IsPointInRect
  */
 typedef struct SDL_Point
 {
@@ -54,8 +54,8 @@ typedef struct SDL_Point
 /**
  * The structure that defines a point (floating point)
  *
- * \sa SDL_EncloseFPoints
- * \sa SDL_PointInFRect
+ * \sa SDL_GetRectEnclosingPointsF
+ * \sa SDL_IsPointInRectF
  */
 typedef struct SDL_FPoint
 {
@@ -67,13 +67,13 @@ typedef struct SDL_FPoint
 /**
  * A rectangle, with the origin at the upper left (integer).
  *
- * \sa SDL_RectEmpty
- * \sa SDL_RectEquals
- * \sa SDL_HasIntersection
- * \sa SDL_IntersectRect
- * \sa SDL_IntersectRectAndLine
- * \sa SDL_UnionRect
- * \sa SDL_EnclosePoints
+ * \sa SDL_IsRectEmpty
+ * \sa SDL_AreRectsEqual
+ * \sa SDL_HasRectIntersection
+ * \sa SDL_GetRectIntersection
+ * \sa SDL_GetRectAndLineIntersection
+ * \sa SDL_GetRectUnion
+ * \sa SDL_GetRectEnclosingPoints
  */
 typedef struct SDL_Rect
 {
@@ -85,15 +85,15 @@ typedef struct SDL_Rect
 /**
  * A rectangle, with the origin at the upper left (floating point).
  *
- * \sa SDL_FRectEmpty
+ * \sa SDL_IsRectEmptyF
  * \sa SDL_FRectEquals
- * \sa SDL_FRectEqualsEpsilon
- * \sa SDL_HasIntersectionF
- * \sa SDL_IntersectFRect
- * \sa SDL_IntersectFRectAndLine
- * \sa SDL_UnionFRect
- * \sa SDL_EncloseFPoints
- * \sa SDL_PointInFRect
+ * \sa SDL_AreRectsEqualF
+ * \sa SDL_HasRectIntersectionF
+ * \sa SDL_GetRectIntersectionF
+ * \sa SDL_GetRectAndLineIntersectionF
+ * \sa SDL_GetRectUnionF
+ * \sa SDL_GetRectEnclosingPointsF
+ * \sa SDL_IsPointInRectF
  */
 typedef struct SDL_FRect
 {
@@ -107,7 +107,7 @@ typedef struct SDL_FRect
 /**
  * Returns true if point resides inside a rectangle.
  */
-SDL_FORCE_INLINE SDL_bool SDL_PointInRect(const SDL_Point *p, const SDL_Rect *r)
+SDL_FORCE_INLINE SDL_bool SDL_IsPointInRect(const SDL_Point *p, const SDL_Rect *r)
 {
     return ( (p->x >= r->x) && (p->x < (r->x + r->w)) &&
              (p->y >= r->y) && (p->y < (r->y + r->h)) ) ? SDL_TRUE : SDL_FALSE;
@@ -116,7 +116,7 @@ SDL_FORCE_INLINE SDL_bool SDL_PointInRect(const SDL_Point *p, const SDL_Rect *r)
 /**
  * Returns true if the rectangle has no area.
  */
-SDL_FORCE_INLINE SDL_bool SDL_RectEmpty(const SDL_Rect *r)
+SDL_FORCE_INLINE SDL_bool SDL_IsRectEmpty(const SDL_Rect *r)
 {
     return ((!r) || (r->w <= 0) || (r->h <= 0)) ? SDL_TRUE : SDL_FALSE;
 }
@@ -124,7 +124,7 @@ SDL_FORCE_INLINE SDL_bool SDL_RectEmpty(const SDL_Rect *r)
 /**
  * Returns true if the two rectangles are equal.
  */
-SDL_FORCE_INLINE SDL_bool SDL_RectEquals(const SDL_Rect *a, const SDL_Rect *b)
+SDL_FORCE_INLINE SDL_bool SDL_AreRectsEqual(const SDL_Rect *a, const SDL_Rect *b)
 {
     return (a && b && (a->x == b->x) && (a->y == b->y) &&
             (a->w == b->w) && (a->h == b->h)) ? SDL_TRUE : SDL_FALSE;
@@ -141,9 +141,9 @@ SDL_FORCE_INLINE SDL_bool SDL_RectEquals(const SDL_Rect *a, const SDL_Rect *b)
  *
  * \since This function is available since SDL 3.0.0.
  *
- * \sa SDL_IntersectRect
+ * \sa SDL_GetRectIntersection
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasIntersection(const SDL_Rect * A,
+extern DECLSPEC SDL_bool SDLCALL SDL_HasRectIntersection(const SDL_Rect * A,
                                                      const SDL_Rect * B);
 
 /**
@@ -159,9 +159,9 @@ extern DECLSPEC SDL_bool SDLCALL SDL_HasIntersection(const SDL_Rect * A,
  *
  * \since This function is available since SDL 3.0.0.
  *
- * \sa SDL_HasIntersection
+ * \sa SDL_HasRectIntersection
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_IntersectRect(const SDL_Rect * A,
+extern DECLSPEC SDL_bool SDLCALL SDL_GetRectIntersection(const SDL_Rect * A,
                                                    const SDL_Rect * B,
                                                    SDL_Rect * result);
 
@@ -175,7 +175,7 @@ extern DECLSPEC SDL_bool SDLCALL SDL_IntersectRect(const SDL_Rect * A,
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC void SDLCALL SDL_UnionRect(const SDL_Rect * A,
+extern DECLSPEC void SDLCALL SDL_GetRectUnion(const SDL_Rect * A,
                                            const SDL_Rect * B,
                                            SDL_Rect * result);
 
@@ -196,7 +196,7 @@ extern DECLSPEC void SDLCALL SDL_UnionRect(const SDL_Rect * A,
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_EnclosePoints(const SDL_Point * points,
+extern DECLSPEC SDL_bool SDLCALL SDL_GetRectEnclosingPoints(const SDL_Point * points,
                                                    int count,
                                                    const SDL_Rect * clip,
                                                    SDL_Rect * result);
@@ -219,7 +219,7 @@ extern DECLSPEC SDL_bool SDLCALL SDL_EnclosePoints(const SDL_Point * points,
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_IntersectRectAndLine(const SDL_Rect *
+extern DECLSPEC SDL_bool SDLCALL SDL_GetRectAndLineIntersection(const SDL_Rect *
                                                           rect, int *X1,
                                                           int *Y1, int *X2,
                                                           int *Y2);
@@ -230,7 +230,7 @@ extern DECLSPEC SDL_bool SDLCALL SDL_IntersectRectAndLine(const SDL_Rect *
 /**
  * Returns true if point resides inside a rectangle.
  */
-SDL_FORCE_INLINE SDL_bool SDL_PointInFRect(const SDL_FPoint *p, const SDL_FRect *r)
+SDL_FORCE_INLINE SDL_bool SDL_IsPointInRectF(const SDL_FPoint *p, const SDL_FRect *r)
 {
     return ( (p->x >= r->x) && (p->x < (r->x + r->w)) &&
              (p->y >= r->y) && (p->y < (r->y + r->h)) ) ? SDL_TRUE : SDL_FALSE;
@@ -239,7 +239,7 @@ SDL_FORCE_INLINE SDL_bool SDL_PointInFRect(const SDL_FPoint *p, const SDL_FRect
 /**
  * Returns true if the rectangle has no area.
  */
-SDL_FORCE_INLINE SDL_bool SDL_FRectEmpty(const SDL_FRect *r)
+SDL_FORCE_INLINE SDL_bool SDL_IsRectEmptyF(const SDL_FRect *r)
 {
     return ((!r) || (r->w <= 0.0f) || (r->h <= 0.0f)) ? SDL_TRUE : SDL_FALSE;
 }
@@ -249,7 +249,7 @@ SDL_FORCE_INLINE SDL_bool SDL_FRectEmpty(const SDL_FRect *r)
  *
  * \since This function is available since SDL 2.0.22.
  */
-SDL_FORCE_INLINE SDL_bool SDL_FRectEqualsEpsilon(const SDL_FRect *a, const SDL_FRect *b, const float epsilon)
+SDL_FORCE_INLINE SDL_bool SDL_AreRectsEqualF(const SDL_FRect *a, const SDL_FRect *b, const float epsilon)
 {
     return (a && b && ((a == b) ||
             ((SDL_fabsf(a->x - b->x) <= epsilon) &&
@@ -266,7 +266,7 @@ SDL_FORCE_INLINE SDL_bool SDL_FRectEqualsEpsilon(const SDL_FRect *a, const SDL_F
  */
 SDL_FORCE_INLINE SDL_bool SDL_FRectEquals(const SDL_FRect *a, const SDL_FRect *b)
 {
-    return SDL_FRectEqualsEpsilon(a, b, SDL_FLT_EPSILON);
+    return SDL_AreRectsEqualF(a, b, SDL_FLT_EPSILON);
 }
 
 /**
@@ -280,9 +280,9 @@ SDL_FORCE_INLINE SDL_bool SDL_FRectEquals(const SDL_FRect *a, const SDL_FRect *b
  *
  * \since This function is available since SDL 3.0.0.
  *
- * \sa SDL_IntersectRect
+ * \sa SDL_GetRectIntersection
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasIntersectionF(const SDL_FRect * A,
+extern DECLSPEC SDL_bool SDLCALL SDL_HasRectIntersectionF(const SDL_FRect * A,
                                                       const SDL_FRect * B);
 
 /**
@@ -298,9 +298,9 @@ extern DECLSPEC SDL_bool SDLCALL SDL_HasIntersectionF(const SDL_FRect * A,
  *
  * \since This function is available since SDL 3.0.0.
  *
- * \sa SDL_HasIntersectionF
+ * \sa SDL_HasRectIntersectionF
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_IntersectFRect(const SDL_FRect * A,
+extern DECLSPEC SDL_bool SDLCALL SDL_GetRectIntersectionF(const SDL_FRect * A,
                                                     const SDL_FRect * B,
                                                     SDL_FRect * result);
 
@@ -314,7 +314,7 @@ extern DECLSPEC SDL_bool SDLCALL SDL_IntersectFRect(const SDL_FRect * A,
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC void SDLCALL SDL_UnionFRect(const SDL_FRect * A,
+extern DECLSPEC void SDLCALL SDL_GetRectUnionF(const SDL_FRect * A,
                                             const SDL_FRect * B,
                                             SDL_FRect * result);
 
@@ -336,7 +336,7 @@ extern DECLSPEC void SDLCALL SDL_UnionFRect(const SDL_FRect * A,
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_EncloseFPoints(const SDL_FPoint * points,
+extern DECLSPEC SDL_bool SDLCALL SDL_GetRectEnclosingPointsF(const SDL_FPoint * points,
                                                     int count,
                                                     const SDL_FRect * clip,
                                                     SDL_FRect * result);
@@ -360,7 +360,7 @@ extern DECLSPEC SDL_bool SDLCALL SDL_EncloseFPoints(const SDL_FPoint * points,
  *
  * \since This function is available since SDL 3.0.0.
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_IntersectFRectAndLine(const SDL_FRect *
+extern DECLSPEC SDL_bool SDLCALL SDL_GetRectAndLineIntersectionF(const SDL_FRect *
                                                            rect, float *X1,
                                                            float *Y1, float *X2,
                                                            float *Y2);

src/dynapi/SDL_dynapi.sym

@@ -395,16 +395,16 @@ SDL3_0.0.0 {
     SDL_SetYUVConversionMode;
     SDL_GetYUVConversionMode;
     SDL_GetYUVConversionModeForResolution;
-    SDL_HasIntersection;
-    SDL_IntersectRect;
-    SDL_UnionRect;
-    SDL_EnclosePoints;
-    SDL_IntersectRectAndLine;
-    SDL_HasIntersectionF;
-    SDL_IntersectFRect;
-    SDL_UnionFRect;
-    SDL_EncloseFPoints;
-    SDL_IntersectFRectAndLine;
+    SDL_HasRectIntersection;
+    SDL_GetRectIntersection;
+    SDL_GetRectUnion;
+    SDL_GetRectEnclosingPoints;
+    SDL_GetRectAndLineIntersection;
+    SDL_HasRectIntersectionF;
+    SDL_GetRectIntersectionF;
+    SDL_GetRectUnionF;
+    SDL_GetRectEnclosingPointsF;
+    SDL_GetRectAndLineIntersectionF;
     SDL_CreateShapedWindow;
     SDL_IsShapedWindow;
     SDL_SetWindowShape;

src/dynapi/SDL_dynapi_overrides.h

@@ -277,11 +277,11 @@
 #define SDL_GetRGBA SDL_GetRGBA_REAL
 #define SDL_GetPlatform SDL_GetPlatform_REAL
 #define SDL_GetPowerInfo SDL_GetPowerInfo_REAL
-#define SDL_HasIntersection SDL_HasIntersection_REAL
-#define SDL_IntersectRect SDL_IntersectRect_REAL
-#define SDL_UnionRect SDL_UnionRect_REAL
-#define SDL_EnclosePoints SDL_EnclosePoints_REAL
-#define SDL_IntersectRectAndLine SDL_IntersectRectAndLine_REAL
+#define SDL_HasRectIntersection SDL_HasRectIntersection_REAL
+#define SDL_GetRectIntersection SDL_GetRectIntersection_REAL
+#define SDL_GetRectUnion SDL_GetRectUnion_REAL
+#define SDL_GetRectEnclosingPoints SDL_GetRectEnclosingPoints_REAL
+#define SDL_GetRectAndLineIntersection SDL_GetRectAndLineIntersection_REAL
 #define SDL_GetNumRenderDrivers SDL_GetNumRenderDrivers_REAL
 #define SDL_CreateWindowAndRenderer SDL_CreateWindowAndRenderer_REAL
 #define SDL_CreateRenderer SDL_CreateRenderer_REAL
@@ -828,11 +828,11 @@
 #define SDL_GetTouchName SDL_GetTouchName_REAL
 #define SDL_ClearComposition SDL_ClearComposition_REAL
 #define SDL_IsTextInputShown SDL_IsTextInputShown_REAL
-#define SDL_HasIntersectionF SDL_HasIntersectionF_REAL
-#define SDL_IntersectFRect SDL_IntersectFRect_REAL
-#define SDL_UnionFRect SDL_UnionFRect_REAL
-#define SDL_EncloseFPoints SDL_EncloseFPoints_REAL
-#define SDL_IntersectFRectAndLine SDL_IntersectFRectAndLine_REAL
+#define SDL_HasRectIntersectionF SDL_HasRectIntersectionF_REAL
+#define SDL_GetRectIntersectionF SDL_GetRectIntersectionF_REAL
+#define SDL_GetRectUnionF SDL_GetRectUnionF_REAL
+#define SDL_GetRectEnclosingPointsF SDL_GetRectEnclosingPointsF_REAL
+#define SDL_GetRectAndLineIntersectionF SDL_GetRectAndLineIntersectionF_REAL
 #define SDL_GetRenderWindow SDL_GetRenderWindow_REAL
 #define SDL_bsearch SDL_bsearch_REAL
 #define SDL_GetGamepadPathForIndex SDL_GetGamepadPathForIndex_REAL

src/dynapi/SDL_dynapi_procs.h

@@ -304,11 +304,11 @@ SDL_DYNAPI_PROC(void,SDL_GetRGB,(Uint32 a, const SDL_PixelFormat *b, Uint8 *c, U
 SDL_DYNAPI_PROC(void,SDL_GetRGBA,(Uint32 a, const SDL_PixelFormat *b, Uint8 *c, Uint8 *d, Uint8 *e, Uint8 *f),(a,b,c,d,e,f),)
 SDL_DYNAPI_PROC(const char*,SDL_GetPlatform,(void),(),return)
 SDL_DYNAPI_PROC(SDL_PowerState,SDL_GetPowerInfo,(int *a, int *b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_HasIntersection,(const SDL_Rect *a, const SDL_Rect *b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_IntersectRect,(const SDL_Rect *a, const SDL_Rect *b, SDL_Rect *c),(a,b,c),return)
-SDL_DYNAPI_PROC(void,SDL_UnionRect,(const SDL_Rect *a, const SDL_Rect *b, SDL_Rect *c),(a,b,c),)
-SDL_DYNAPI_PROC(SDL_bool,SDL_EnclosePoints,(const SDL_Point *a, int b, const SDL_Rect *c, SDL_Rect *d),(a,b,c,d),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_IntersectRectAndLine,(const SDL_Rect *a, int *b, int *c, int *d, int *e),(a,b,c,d,e),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_HasRectIntersection,(const SDL_Rect *a, const SDL_Rect *b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_GetRectIntersection,(const SDL_Rect *a, const SDL_Rect *b, SDL_Rect *c),(a,b,c),return)
+SDL_DYNAPI_PROC(void,SDL_GetRectUnion,(const SDL_Rect *a, const SDL_Rect *b, SDL_Rect *c),(a,b,c),)
+SDL_DYNAPI_PROC(SDL_bool,SDL_GetRectEnclosingPoints,(const SDL_Point *a, int b, const SDL_Rect *c, SDL_Rect *d),(a,b,c,d),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_GetRectAndLineIntersection,(const SDL_Rect *a, int *b, int *c, int *d, int *e),(a,b,c,d,e),return)
 SDL_DYNAPI_PROC(int,SDL_GetNumRenderDrivers,(void),(),return)
 SDL_DYNAPI_PROC(int,SDL_CreateWindowAndRenderer,(int a, int b, Uint32 c, SDL_Window **d, SDL_Renderer **e),(a,b,c,d,e),return)
 SDL_DYNAPI_PROC(SDL_Renderer*,SDL_CreateRenderer,(SDL_Window *a, const char *b, Uint32 c),(a,b,c),return)
@@ -895,11 +895,11 @@ SDL_DYNAPI_PROC(int,SDL_AndroidSendMessage,(Uint32 a, int b),(a,b),return)
 SDL_DYNAPI_PROC(const char*,SDL_GetTouchName,(int a),(a),return)
 SDL_DYNAPI_PROC(void,SDL_ClearComposition,(void),(),)
 SDL_DYNAPI_PROC(SDL_bool,SDL_IsTextInputShown,(void),(),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_HasIntersectionF,(const SDL_FRect *a, const SDL_FRect *b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_IntersectFRect,(const SDL_FRect *a, const SDL_FRect *b, SDL_FRect *c),(a,b,c),return)
-SDL_DYNAPI_PROC(void,SDL_UnionFRect,(const SDL_FRect *a, const SDL_FRect *b, SDL_FRect *c),(a,b,c),)
-SDL_DYNAPI_PROC(SDL_bool,SDL_EncloseFPoints,(const SDL_FPoint *a, int b, const SDL_FRect *c, SDL_FRect *d),(a,b,c,d),return)
-SDL_DYNAPI_PROC(SDL_bool,SDL_IntersectFRectAndLine,(const SDL_FRect *a, float *b, float *c, float *d, float *e),(a,b,c,d,e),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_HasRectIntersectionF,(const SDL_FRect *a, const SDL_FRect *b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_GetRectIntersectionF,(const SDL_FRect *a, const SDL_FRect *b, SDL_FRect *c),(a,b,c),return)
+SDL_DYNAPI_PROC(void,SDL_GetRectUnionF,(const SDL_FRect *a, const SDL_FRect *b, SDL_FRect *c),(a,b,c),)
+SDL_DYNAPI_PROC(SDL_bool,SDL_GetRectEnclosingPointsF,(const SDL_FPoint *a, int b, const SDL_FRect *c, SDL_FRect *d),(a,b,c,d),return)
+SDL_DYNAPI_PROC(SDL_bool,SDL_GetRectAndLineIntersectionF,(const SDL_FRect *a, float *b, float *c, float *d, float *e),(a,b,c,d,e),return)
 SDL_DYNAPI_PROC(SDL_Window*,SDL_GetRenderWindow,(SDL_Renderer *a),(a),return)
 SDL_DYNAPI_PROC(void*,SDL_bsearch,(const void *a, const void *b, size_t c, size_t d, int (SDLCALL *e)(const void *, const void *)),(a,b,c,d,e),return)
 SDL_DYNAPI_PROC(const char*,SDL_GetGamepadPathForIndex,(int a),(a),return)

src/events/SDL_mouse.c

@@ -567,7 +567,7 @@ static int SDL_PrivateSendMouseMotion(Uint64 timestamp, SDL_Window *window, SDL_
             window_rect.y = 0;
             window_rect.w = x_max + 1;
             window_rect.h = y_max + 1;
-            if (SDL_IntersectRect(confine, &window_rect, &mouse_rect)) {
+            if (SDL_GetRectIntersection(confine, &window_rect, &mouse_rect)) {
                 x_min = mouse_rect.x;
                 y_min = mouse_rect.y;
                 x_max = x_min + mouse_rect.w - 1;

src/render/SDL_render.c

@@ -1729,7 +1729,7 @@ int SDL_UpdateTexture(SDL_Texture *texture, const SDL_Rect *rect,
     real_rect.w = texture->w;
     real_rect.h = texture->h;
     if (rect) {
-        if (!SDL_IntersectRect(rect, &real_rect, &real_rect)) {
+        if (!SDL_GetRectIntersection(rect, &real_rect, &real_rect)) {
             return 0;
         }
     }
@@ -1895,7 +1895,7 @@ int SDL_UpdateYUVTexture(SDL_Texture *texture, const SDL_Rect *rect,
     real_rect.w = texture->w;
     real_rect.h = texture->h;
     if (rect) {
-        SDL_IntersectRect(rect, &real_rect, &real_rect);
+        SDL_GetRectIntersection(rect, &real_rect, &real_rect);
     }
 
     if (real_rect.w == 0 || real_rect.h == 0) {
@@ -1955,7 +1955,7 @@ int SDL_UpdateNVTexture(SDL_Texture *texture, const SDL_Rect *rect,
     real_rect.w = texture->w;
     real_rect.h = texture->h;
     if (rect) {
-        SDL_IntersectRect(rect, &real_rect, &real_rect);
+        SDL_GetRectIntersection(rect, &real_rect, &real_rect);
     }
 
     if (real_rect.w == 0 || real_rect.h == 0) {
@@ -2057,7 +2057,7 @@ int SDL_LockTextureToSurface(SDL_Texture *texture, const SDL_Rect *rect,
     real_rect.w = texture->w;
     real_rect.h = texture->h;
     if (rect) {
-        SDL_IntersectRect(rect, &real_rect, &real_rect);
+        SDL_GetRectIntersection(rect, &real_rect, &real_rect);
     }
 
     ret = SDL_LockTexture(texture, &real_rect, &pixels, &pitch);
@@ -3382,14 +3382,14 @@ int SDL_RenderTextureF(SDL_Renderer *renderer, SDL_Texture *texture,
     real_srcrect.w = texture->w;
     real_srcrect.h = texture->h;
     if (srcrect) {
-        if (!SDL_IntersectRect(srcrect, &real_srcrect, &real_srcrect)) {
+        if (!SDL_GetRectIntersection(srcrect, &real_srcrect, &real_srcrect)) {
             return 0;
         }
     }
 
     RenderGetViewportSize(renderer, &real_dstrect);
     if (dstrect) {
-        if (!SDL_HasIntersectionF(dstrect, &real_dstrect)) {
+        if (!SDL_HasRectIntersectionF(dstrect, &real_dstrect)) {
             return 0;
         }
         real_dstrect = *dstrect;
@@ -3522,7 +3522,7 @@ int SDL_RenderTextureRotatedF(SDL_Renderer *renderer, SDL_Texture *texture,
     real_srcrect.w = texture->w;
     real_srcrect.h = texture->h;
     if (srcrect) {
-        if (!SDL_IntersectRect(srcrect, &real_srcrect, &real_srcrect)) {
+        if (!SDL_GetRectIntersection(srcrect, &real_srcrect, &real_srcrect)) {
             return 0;
         }
     }
@@ -4158,7 +4158,7 @@ int SDL_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect,
     real_rect.w = (int)SDL_floor(renderer->viewport.w);
     real_rect.h = (int)SDL_floor(renderer->viewport.h);
     if (rect) {
-        if (!SDL_IntersectRect(rect, &real_rect, &real_rect)) {
+        if (!SDL_GetRectIntersection(rect, &real_rect, &real_rect)) {
             return 0;
         }
         if (real_rect.y > rect->y) {

src/render/metal/SDL_render_metal.m

@@ -1252,7 +1252,7 @@ static SDL_bool SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *cm
             METAL_GetOutputSize(renderer, &output.w, &output.h);
         }
 
-        if (SDL_IntersectRect(&output, &clip, &clip)) {
+        if (SDL_GetRectIntersection(&output, &clip, &clip)) {
             MTLScissorRect mtlrect;
             mtlrect.x = clip.x;
             mtlrect.y = clip.y;

src/render/software/SDL_blendfillrect.c

@@ -223,7 +223,7 @@ int SDL_BlendFillRect(SDL_Surface *dst, const SDL_Rect *rect,
     /* If 'rect' == NULL, then fill the whole surface */
     if (rect) {
         /* Perform clipping */
-        if (!SDL_IntersectRect(rect, &dst->clip_rect, &clipped)) {
+        if (!SDL_GetRectIntersection(rect, &dst->clip_rect, &clipped)) {
             return 0;
         }
         rect = &clipped;
@@ -335,7 +335,7 @@ int SDL_BlendFillRects(SDL_Surface *dst, const SDL_Rect *rects, int count,
 
     for (i = 0; i < count; ++i) {
         /* Perform clipping */
-        if (!SDL_IntersectRect(&rects[i], &dst->clip_rect, &rect)) {
+        if (!SDL_GetRectIntersection(&rects[i], &dst->clip_rect, &rect)) {
             continue;
         }
         status = func(dst, &rect, blendMode, r, g, b, a);

src/render/software/SDL_blendline.c

@@ -809,7 +809,7 @@ int SDL_BlendLine(SDL_Surface *dst, int x1, int y1, int x2, int y2,
 
     /* Perform clipping */
     /* FIXME: We don't actually want to clip, as it may change line slope */
-    if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
+    if (!SDL_GetRectAndLineIntersection(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
         return 0;
     }
 
@@ -843,7 +843,7 @@ int SDL_BlendLines(SDL_Surface *dst, const SDL_Point *points, int count,
 
         /* Perform clipping */
         /* FIXME: We don't actually want to clip, as it may change line slope */
-        if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
+        if (!SDL_GetRectAndLineIntersection(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
             continue;
         }
 

src/render/software/SDL_drawline.c

@@ -148,7 +148,7 @@ int SDL_DrawLine(SDL_Surface *dst, int x1, int y1, int x2, int y2, Uint32 color)
 
     /* Perform clipping */
     /* FIXME: We don't actually want to clip, as it may change line slope */
-    if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
+    if (!SDL_GetRectAndLineIntersection(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
         return 0;
     }
 
@@ -182,7 +182,7 @@ int SDL_DrawLines(SDL_Surface *dst, const SDL_Point *points, int count,
 
         /* Perform clipping */
         /* FIXME: We don't actually want to clip, as it may change line slope */
-        if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
+        if (!SDL_GetRectAndLineIntersection(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
             continue;
         }
 

src/render/software/SDL_render_sw.c

@@ -644,7 +644,7 @@ static void SetDrawState(SDL_Surface *surface, SW_DrawStateCache *drawstate)
             clip_rect.y = cliprect->y + viewport->y;
             clip_rect.w = cliprect->w;
             clip_rect.h = cliprect->h;
-            SDL_IntersectRect(viewport, &clip_rect, &clip_rect);
+            SDL_GetRectIntersection(viewport, &clip_rect, &clip_rect);
             SDL_SetSurfaceClipRect(surface, &clip_rect);
         } else {
             SDL_SetSurfaceClipRect(surface, drawstate->viewport);

src/render/software/SDL_triangle.c

@@ -251,14 +251,14 @@ int SDL_SW_FillTriangle(SDL_Surface *dst, SDL_Point *d0, SDL_Point *d1, SDL_Poin
         rect.y = 0;
         rect.w = dst->w;
         rect.h = dst->h;
-        SDL_IntersectRect(&dstrect, &rect, &dstrect);
+        SDL_GetRectIntersection(&dstrect, &rect, &dstrect);
     }
 
     {
         /* Clip triangle with surface clip rect */
         SDL_Rect rect;
         SDL_GetSurfaceClipRect(dst, &rect);
-        SDL_IntersectRect(&dstrect, &rect, &dstrect);
+        SDL_GetRectIntersection(&dstrect, &rect, &dstrect);
     }
 
     if (blend != SDL_BLENDMODE_NONE) {
@@ -547,14 +547,14 @@ int SDL_SW_BlitTriangle(
         rect.w = dst->w;
         rect.h = dst->h;
 
-        SDL_IntersectRect(&dstrect, &rect, &dstrect);
+        SDL_GetRectIntersection(&dstrect, &rect, &dstrect);
     }
 
     {
         /* Clip triangle with surface clip rect */
         SDL_Rect rect;
         SDL_GetSurfaceClipRect(dst, &rect);
-        SDL_IntersectRect(&dstrect, &rect, &dstrect);
+        SDL_GetRectIntersection(&dstrect, &rect, &dstrect);
     }
 
     /* Set destination pointer */

src/test/SDL_test_common.c

@@ -1303,7 +1303,7 @@ SDLTest_CommonInit(SDLTest_CommonState *state)
 
             SDL_ShowWindow(state->windows[i]);
 
-            if (!SDL_RectEmpty(&state->confine)) {
+            if (!SDL_IsRectEmpty(&state->confine)) {
                 SDL_SetWindowMouseRect(state->windows[i], &state->confine);
             }
 
@@ -1921,7 +1921,7 @@ void SDLTest_CommonEvent(SDLTest_CommonState *state, SDL_Event *event, int *done
                         SDL_Rect clip;
                         SDL_GetWindowSize(state->windows[i], &w, &h);
                         SDL_GetRenderClipRect(state->renderers[i], &clip);
-                        if (SDL_RectEmpty(&clip)) {
+                        if (SDL_IsRectEmpty(&clip)) {
                             clip.x = w / 4;
                             clip.y = h / 4;
                             clip.w = w / 2;

src/video/SDL_blit.c

@@ -59,7 +59,7 @@ static int SDLCALL SDL_SoftBlit(SDL_Surface *src, SDL_Rect *srcrect,
     }
 
     /* Set up source and destination buffer pointers, and BLIT! */
-    if (okay && !SDL_RectEmpty(srcrect)) {
+    if (okay && !SDL_IsRectEmpty(srcrect)) {
         SDL_BlitFunc RunBlit;
         SDL_BlitInfo *info = &src->map->info;
 

src/video/SDL_fillrect.c

@@ -240,7 +240,7 @@ int SDL_FillSurfaceRect(SDL_Surface *dst, const SDL_Rect *rect, Uint32 color)
     if (rect == NULL) {
         rect = &dst->clip_rect;
         /* Don't attempt to fill if the surface's clip_rect is empty */
-        if (SDL_RectEmpty(rect)) {
+        if (SDL_IsRectEmpty(rect)) {
             return 0;
         }
     }
@@ -427,7 +427,7 @@ int SDL_FillSurfaceRects(SDL_Surface *dst, const SDL_Rect *rects, int count,
     for (i = 0; i < count; ++i) {
         rect = &rects[i];
         /* Perform clipping */
-        if (!SDL_IntersectRect(rect, &dst->clip_rect, &clipped)) {
+        if (!SDL_GetRectIntersection(rect, &dst->clip_rect, &clipped)) {
             continue;
         }
         rect = &clipped;

src/video/SDL_rect.c

@@ -90,22 +90,22 @@ SDL_GetSpanEnclosingRect(int width, int height,
 #define POINTTYPE                SDL_Point
 #define SCALARTYPE               int
 #define COMPUTEOUTCODE           ComputeOutCode
-#define SDL_HASINTERSECTION      SDL_HasIntersection
-#define SDL_INTERSECTRECT        SDL_IntersectRect
-#define SDL_RECTEMPTY            SDL_RectEmpty
-#define SDL_UNIONRECT            SDL_UnionRect
-#define SDL_ENCLOSEPOINTS        SDL_EnclosePoints
-#define SDL_INTERSECTRECTANDLINE SDL_IntersectRectAndLine
+#define SDL_HASINTERSECTION      SDL_HasRectIntersection
+#define SDL_INTERSECTRECT        SDL_GetRectIntersection
+#define SDL_RECTEMPTY            SDL_IsRectEmpty
+#define SDL_UNIONRECT            SDL_GetRectUnion
+#define SDL_ENCLOSEPOINTS        SDL_GetRectEnclosingPoints
+#define SDL_INTERSECTRECTANDLINE SDL_GetRectAndLineIntersection
 #include "SDL_rect_impl.h"
 
 #define RECTTYPE                 SDL_FRect
 #define POINTTYPE                SDL_FPoint
 #define SCALARTYPE               float
 #define COMPUTEOUTCODE           ComputeOutCodeF
-#define SDL_HASINTERSECTION      SDL_HasIntersectionF
-#define SDL_INTERSECTRECT        SDL_IntersectFRect
-#define SDL_RECTEMPTY            SDL_FRectEmpty
-#define SDL_UNIONRECT            SDL_UnionFRect
-#define SDL_ENCLOSEPOINTS        SDL_EncloseFPoints
-#define SDL_INTERSECTRECTANDLINE SDL_IntersectFRectAndLine
+#define SDL_HASINTERSECTION      SDL_HasRectIntersectionF
+#define SDL_INTERSECTRECT        SDL_GetRectIntersectionF
+#define SDL_RECTEMPTY            SDL_IsRectEmptyF
+#define SDL_UNIONRECT            SDL_GetRectUnionF
+#define SDL_ENCLOSEPOINTS        SDL_GetRectEnclosingPointsF
+#define SDL_INTERSECTRECTANDLINE SDL_GetRectAndLineIntersectionF
 #include "SDL_rect_impl.h"

src/video/SDL_surface.c

@@ -607,7 +607,7 @@ SDL_SetSurfaceClipRect(SDL_Surface *surface, const SDL_Rect *rect)
         surface->clip_rect = full_rect;
         return SDL_TRUE;
     }
-    return SDL_IntersectRect(rect, &full_rect, &surface->clip_rect);
+    return SDL_GetRectIntersection(rect, &full_rect, &surface->clip_rect);
 }
 
 void SDL_GetSurfaceClipRect(SDL_Surface *surface, SDL_Rect *rect)
@@ -896,11 +896,11 @@ int SDL_PrivateUpperBlitScaled(SDL_Surface *src, const SDL_Rect *srcrect,
         tmp.y = 0;
         tmp.w = src->w;
         tmp.h = src->h;
-        SDL_IntersectRect(&tmp, &final_src, &final_src);
+        SDL_GetRectIntersection(&tmp, &final_src, &final_src);
     }
 
     /* Clip again */
-    SDL_IntersectRect(&dst->clip_rect, &final_dst, &final_dst);
+    SDL_GetRectIntersection(&dst->clip_rect, &final_dst, &final_dst);
 
     if (dstrect) {
         *dstrect = final_dst;

src/video/SDL_video.c

@@ -1108,7 +1108,7 @@ static int GetRectDisplayIndex(int x, int y, int w, int h)
             SDL_GetDisplayBounds(i, &display_rect);
 
             /* Check if the window is fully enclosed */
-            if (SDL_EnclosePoints(&center, 1, &display_rect, NULL)) {
+            if (SDL_GetRectEnclosingPoints(&center, 1, &display_rect, NULL)) {
                 return i;
             }
 
@@ -2900,7 +2900,7 @@ SDL_GetWindowMouseRect(SDL_Window *window)
 {
     CHECK_WINDOW_MAGIC(window, NULL);
 
-    if (SDL_RectEmpty(&window->mouse_rect)) {
+    if (SDL_IsRectEmpty(&window->mouse_rect)) {
         return NULL;
     } else {
         return &window->mouse_rect;

src/video/cocoa/SDL_cocoamouse.m

@@ -236,7 +236,7 @@ static SDL_Window *SDL_FindWindowAtPoint(const int x, const int y)
     SDL_Window *i;
     for (i = SDL_GetVideoDevice()->windows; i; i = i->next) {
         const SDL_Rect r = { i->x, i->y, i->w, i->h };
-        if (SDL_PointInRect(&pt, &r)) {
+        if (SDL_IsPointInRect(&pt, &r)) {
             return i;
         }
     }

src/video/cocoa/SDL_cocoawindow.m

@@ -381,7 +381,7 @@ static SDL_bool AdjustCoordinatesForGrab(SDL_Window *window, int x, int y, CGPoi
         window_rect.w = window->w;
         window_rect.h = window->h;
 
-        if (SDL_IntersectRect(&window->mouse_rect, &window_rect, &mouse_rect)) {
+        if (SDL_GetRectIntersection(&window->mouse_rect, &window_rect, &mouse_rect)) {
             int left = window->x + mouse_rect.x;
             int right = left + mouse_rect.w - 1;
             int top = window->y + mouse_rect.y;
@@ -428,16 +428,16 @@ static void Cocoa_UpdateClipCursor(SDL_Window *window)
             window_rect.h = window->h;
 
             if (window->mouse_rect.w > 0 && window->mouse_rect.h > 0) {
-                SDL_IntersectRect(&window->mouse_rect, &window_rect, &mouse_rect);
+                SDL_GetRectIntersection(&window->mouse_rect, &window_rect, &mouse_rect);
             }
 
             if ((window->flags & SDL_WINDOW_MOUSE_GRABBED) != 0 &&
-                SDL_RectEmpty(&mouse_rect)) {
+                SDL_IsRectEmpty(&mouse_rect)) {
                 SDL_memcpy(&mouse_rect, &window_rect, sizeof(mouse_rect));
             }
         }
 
-        if (SDL_RectEmpty(&mouse_rect)) {
+        if (SDL_IsRectEmpty(&mouse_rect)) {
             nswindow.mouseConfinementRect = NSZeroRect;
         } else {
             NSRect rect;

src/video/wayland/SDL_waylandevents.c

@@ -2758,11 +2758,11 @@ int Wayland_input_confine_pointer(struct SDL_WaylandInput *input, SDL_Window *wi
     }
 
     /* Don't confine the pointer if it shouldn't be confined. */
-    if (SDL_RectEmpty(&window->mouse_rect) && !(window->flags & SDL_WINDOW_MOUSE_GRABBED)) {
+    if (SDL_IsRectEmpty(&window->mouse_rect) && !(window->flags & SDL_WINDOW_MOUSE_GRABBED)) {
         return 0;
     }
 
-    if (SDL_RectEmpty(&window->mouse_rect)) {
+    if (SDL_IsRectEmpty(&window->mouse_rect)) {
         confine_rect = NULL;
     } else {
         SDL_Rect scaled_mouse_rect;

src/video/wayland/SDL_waylandkeyboard.c

@@ -76,7 +76,7 @@ void Wayland_StartTextInput(_THIS)
             zwp_text_input_v3_set_content_type(input->text_input->text_input,
                                                ZWP_TEXT_INPUT_V3_CONTENT_HINT_NONE,
                                                ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_NORMAL);
-            if (!SDL_RectEmpty(rect)) {
+            if (!SDL_IsRectEmpty(rect)) {
                 /* This gets reset on enable so we have to cache it */
                 zwp_text_input_v3_set_cursor_rectangle(input->text_input->text_input,
                                                        rect->x,
@@ -122,7 +122,7 @@ void Wayland_SetTextInputRect(_THIS, const SDL_Rect *rect)
     if (driverdata->text_input_manager) {
         struct SDL_WaylandInput *input = driverdata->input;
         if (input != NULL && input->text_input) {
-            if (!SDL_RectEquals(rect, &input->text_input->cursor_rect)) {
+            if (!SDL_AreRectsEqual(rect, &input->text_input->cursor_rect)) {
                 SDL_copyp(&input->text_input->cursor_rect, rect);
                 zwp_text_input_v3_set_cursor_rectangle(input->text_input->text_input,
                                                        rect->x,

src/video/wayland/SDL_waylandwindow.c

@@ -1841,7 +1841,7 @@ void Wayland_SetWindowMouseRect(_THIS, SDL_Window *window)
      * Just know that this call lets you confine with a rect, SetWindowGrab
      * lets you confine without a rect.
      */
-    if (SDL_RectEmpty(&window->mouse_rect) && !(window->flags & SDL_WINDOW_MOUSE_GRABBED)) {
+    if (SDL_IsRectEmpty(&window->mouse_rect) && !(window->flags & SDL_WINDOW_MOUSE_GRABBED)) {
         Wayland_input_unconfine_pointer(data->input, window);
     } else {
         Wayland_input_confine_pointer(data->input, window);
@@ -1854,7 +1854,7 @@ void Wayland_SetWindowMouseGrab(_THIS, SDL_Window *window, SDL_bool grabbed)
 
     if (grabbed) {
         Wayland_input_confine_pointer(data->input, window);
-    } else if (SDL_RectEmpty(&window->mouse_rect)) {
+    } else if (SDL_IsRectEmpty(&window->mouse_rect)) {
         Wayland_input_unconfine_pointer(data->input, window);
     }
 }

src/video/x11/SDL_x11modes.c

@@ -876,7 +876,7 @@ int X11_GetDisplayUsableBounds(_THIS, SDL_VideoDisplay *sdl_display, SDL_Rect *r
         const long *p = (long *)propdata;
         const SDL_Rect usable = { (int)p[0], (int)p[1], (int)p[2], (int)p[3] };
         retval = 0;
-        if (!SDL_IntersectRect(rect, &usable, rect)) {
+        if (!SDL_GetRectIntersection(rect, &usable, rect)) {
             SDL_zerop(rect);
         }
     }

src/video/x11/SDL_x11xfixes.c

@@ -71,7 +71,7 @@ int X11_XfixesIsInitialized()
 
 void X11_SetWindowMouseRect(_THIS, SDL_Window *window)
 {
-    if (SDL_RectEmpty(&window->mouse_rect)) {
+    if (SDL_IsRectEmpty(&window->mouse_rect)) {
         X11_ConfineCursorWithFlags(_this, window, NULL, 0);
     } else {
         if (window->flags & SDL_WINDOW_INPUT_FOCUS) {

test/testgamepad.c

@@ -443,7 +443,7 @@ static SDL_GamepadButton FindButtonAtPosition(int x, int y)
             rect.y = button_positions[i].y;
             rect.w = BUTTON_SIZE;
             rect.h = BUTTON_SIZE;
-            if (SDL_PointInRect(&point, &rect)) {
+            if (SDL_IsPointInRect(&point, &rect)) {
                 return (SDL_GamepadButton)i;
             }
         }
@@ -466,7 +466,7 @@ static SDL_GamepadAxis FindAxisAtPosition(int x, int y)
             rect.y = axis_positions[i].y;
             rect.w = AXIS_SIZE;
             rect.h = AXIS_SIZE;
-            if (SDL_PointInRect(&point, &rect)) {
+            if (SDL_IsPointInRect(&point, &rect)) {
                 return (SDL_GamepadAxis)i;
             }
         }

test/testhittesting.c

@@ -32,7 +32,7 @@ hitTest(SDL_Window *window, const SDL_Point *pt, void *data)
     int w, h;
 
     for (i = 0; i < numareas; i++) {
-        if (SDL_PointInRect(pt, &areas[i])) {
+        if (SDL_IsPointInRect(pt, &areas[i])) {
             SDL_Log("HIT-TEST: DRAGGABLE\n");
             return SDL_HITTEST_DRAGGABLE;
         }

test/testintersections.c

@@ -184,7 +184,7 @@ DrawRectLineIntersections(SDL_Renderer *renderer)
             x2 = lines[j].w;
             y2 = lines[j].h;
 
-            if (SDL_IntersectRectAndLine(&r, &x1, &y1, &x2, &y2)) {
+            if (SDL_GetRectAndLineIntersection(&r, &x1, &y1, &x2, &y2)) {
                 SDL_RenderLine(renderer, x1, y1, x2, y2);
             }
         }
@@ -201,7 +201,7 @@ DrawRectRectIntersections(SDL_Renderer *renderer)
     for (i = 0; i < num_rects; i++) {
         for (j = i + 1; j < num_rects; j++) {
             SDL_Rect r;
-            if (SDL_IntersectRect(&rects[i], &rects[j], &r)) {
+            if (SDL_GetRectIntersection(&rects[i], &rects[j], &r)) {
                 SDL_RenderFillRect(renderer, &r);
             }
         }

test/testwm2.c

@@ -120,7 +120,7 @@ draw_modes_menu(SDL_Window *window, SDL_Renderer *renderer, SDL_Rect viewport)
         cell_rect.w = text_length * FONT_CHARACTER_SIZE;
         cell_rect.h = lineHeight;
 
-        if (SDL_PointInRect(&mouse_pos, &cell_rect)) {
+        if (SDL_IsPointInRect(&mouse_pos, &cell_rect)) {
             SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
 
             /* Update cached mode under the mouse */