Use C99 bool internally in SDL

2026-04-20 06:21:09 +00:00 · 2024-08-22 09:21:26 -07:00
parent 6501e90018
commit 8f546bb3c9
450 changed files with 6046 additions and 6033 deletions
--- a/src/render/SDL_render.c
+++ b/src/render/SDL_render.c
@@ -179,7 +179,7 @@ static float sRGBfromLinear(float v)
    return v <= 0.0031308f ? (v * 12.92f) : (SDL_powf(v, 1.0f / 2.4f) * 1.055f - 0.055f);
 }

-SDL_bool SDL_RenderingLinearSpace(SDL_Renderer *renderer)
+bool SDL_RenderingLinearSpace(SDL_Renderer *renderer)
 {
    SDL_Colorspace colorspace;

@@ -189,9 +189,9 @@ SDL_bool SDL_RenderingLinearSpace(SDL_Renderer *renderer)
        colorspace = renderer->output_colorspace;
    }
    if (colorspace == SDL_COLORSPACE_SRGB_LINEAR) {
-        return SDL_TRUE;
+        return true;
    }
-    return SDL_FALSE;
+    return false;
 }

 void SDL_ConvertToLinear(SDL_FColor *color)
@@ -332,10 +332,10 @@ static int FlushRenderCommands(SDL_Renderer *renderer)
    }
    renderer->vertex_data_used = 0;
    renderer->render_command_generation++;
-    renderer->color_queued = SDL_FALSE;
-    renderer->color_scale_queued = SDL_FALSE;
-    renderer->viewport_queued = SDL_FALSE;
-    renderer->cliprect_queued = SDL_FALSE;
+    renderer->color_queued = false;
+    renderer->color_scale_queued = false;
+    renderer->viewport_queued = false;
+    renderer->cliprect_queued = false;
    return retval;
 }

@@ -454,7 +454,7 @@ static int QueueCmdSetViewport(SDL_Renderer *renderer)
                cmd->command = SDL_RENDERCMD_NO_OP;
            } else {
                SDL_copyp(&renderer->last_queued_viewport, &viewport);
-                renderer->viewport_queued = SDL_TRUE;
+                renderer->viewport_queued = true;
            }
        } else {
            retval = -1;
@@ -488,7 +488,7 @@ static int QueueCmdSetClipRect(SDL_Renderer *renderer)
            SDL_copyp(&cmd->data.cliprect.rect, &clip_rect);
            SDL_copyp(&renderer->last_queued_cliprect, &clip_rect);
            renderer->last_queued_cliprect_enabled = renderer->view->clipping_enabled;
-            renderer->cliprect_queued = SDL_TRUE;
+            renderer->cliprect_queued = true;
        } else {
            retval = -1;
        }
@@ -518,7 +518,7 @@ static int QueueCmdSetDrawColor(SDL_Renderer *renderer, SDL_FColor *color)
                cmd->command = SDL_RENDERCMD_NO_OP;
            } else {
                renderer->last_queued_color = *color;
-                renderer->color_queued = SDL_TRUE;
+                renderer->color_queued = true;
            }
        }
    }
@@ -619,8 +619,8 @@ static int QueueCmdFillRects(SDL_Renderer *renderer, const SDL_FRect *rects, con

    if (cmd) {
        if (use_rendergeometry) {
-            SDL_bool isstack1;
-            SDL_bool isstack2;
+            bool isstack1;
+            bool isstack2;
            float *xy = SDL_small_alloc(float, 4 * 2 * count, &isstack1);
            int *indices = SDL_small_alloc(int, 6 * count, &isstack2);

@@ -781,9 +781,9 @@ static void UpdateHDRProperties(SDL_Renderer *renderer)
    }

    if (renderer->HDR_headroom > 1.0f) {
-        SDL_SetBooleanProperty(renderer_props, SDL_PROP_RENDERER_HDR_ENABLED_BOOLEAN, SDL_TRUE);
+        SDL_SetBooleanProperty(renderer_props, SDL_PROP_RENDERER_HDR_ENABLED_BOOLEAN, true);
    } else {
-        SDL_SetBooleanProperty(renderer_props, SDL_PROP_RENDERER_HDR_ENABLED_BOOLEAN, SDL_FALSE);
+        SDL_SetBooleanProperty(renderer_props, SDL_PROP_RENDERER_HDR_ENABLED_BOOLEAN, false);
    }
    SDL_SetFloatProperty(renderer_props, SDL_PROP_RENDERER_SDR_WHITE_POINT_FLOAT, renderer->SDR_white_point);
    SDL_SetFloatProperty(renderer_props, SDL_PROP_RENDERER_HDR_HEADROOM_FLOAT, renderer->HDR_headroom);
@@ -835,17 +835,17 @@ static SDL_bool SDLCALL SDL_RendererEventWatch(void *userdata, SDL_Event *event)
                UpdateMainViewDimensions(renderer);
                UpdateLogicalPresentation(renderer);
            } else if (event->type == SDL_EVENT_WINDOW_HIDDEN) {
-                renderer->hidden = SDL_TRUE;
+                renderer->hidden = true;
            } else if (event->type == SDL_EVENT_WINDOW_SHOWN) {
                if (!(SDL_GetWindowFlags(window) & SDL_WINDOW_MINIMIZED)) {
-                    renderer->hidden = SDL_FALSE;
+                    renderer->hidden = false;
                }
            } else if (event->type == SDL_EVENT_WINDOW_MINIMIZED) {
-                renderer->hidden = SDL_TRUE;
+                renderer->hidden = true;
            } else if (event->type == SDL_EVENT_WINDOW_RESTORED ||
                       event->type == SDL_EVENT_WINDOW_MAXIMIZED) {
                if (!(SDL_GetWindowFlags(window) & SDL_WINDOW_HIDDEN)) {
-                    renderer->hidden = SDL_FALSE;
+                    renderer->hidden = false;
                }
            } else if (event->type == SDL_EVENT_WINDOW_DISPLAY_CHANGED) {
                UpdateHDRProperties(renderer);
@@ -855,12 +855,12 @@ static SDL_bool SDLCALL SDL_RendererEventWatch(void *userdata, SDL_Event *event)
        UpdateHDRProperties(renderer);
    }

-    return SDL_TRUE;
+    return true;
 }

 int SDL_CreateWindowAndRenderer(const char *title, int width, int height, SDL_WindowFlags window_flags, SDL_Window **window, SDL_Renderer **renderer)
 {
-    SDL_bool hidden = (window_flags & SDL_WINDOW_HIDDEN) != 0;
+    bool hidden = (window_flags & SDL_WINDOW_HIDDEN) != 0;

    if (!window) {
        return SDL_InvalidParamError("window");
@@ -973,7 +973,7 @@ SDL_Renderer *SDL_CreateRendererWithProperties(SDL_PropertiesID props)
        goto error;
    }

-    SDL_SetObjectValid(renderer, SDL_OBJECT_TYPE_RENDERER, SDL_TRUE);
+    SDL_SetObjectValid(renderer, SDL_OBJECT_TYPE_RENDERER, true);

    if ((!window && !surface) || (window && surface)) {
        SDL_InvalidParamError("window");
@@ -992,7 +992,7 @@ SDL_Renderer *SDL_CreateRendererWithProperties(SDL_PropertiesID props)

    hint = SDL_GetHint(SDL_HINT_RENDER_VSYNC);
    if (hint && *hint) {
-        SDL_SetNumberProperty(props, SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_NUMBER, SDL_GetHintBoolean(SDL_HINT_RENDER_VSYNC, SDL_TRUE));
+        SDL_SetNumberProperty(props, SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_NUMBER, SDL_GetHintBoolean(SDL_HINT_RENDER_VSYNC, true));
    }

    if (surface) {
@@ -1087,11 +1087,11 @@ SDL_Renderer *SDL_CreateRendererWithProperties(SDL_PropertiesID props)

    if (window) {
        if (SDL_GetWindowFlags(window) & SDL_WINDOW_TRANSPARENT) {
-            renderer->transparent_window = SDL_TRUE;
+            renderer->transparent_window = true;
        }

        if (SDL_GetWindowFlags(window) & (SDL_WINDOW_HIDDEN | SDL_WINDOW_MINIMIZED)) {
-            renderer->hidden = SDL_TRUE;
+            renderer->hidden = true;
        }
    }

@@ -1256,7 +1256,7 @@ int SDL_GetCurrentRenderOutputSize(SDL_Renderer *renderer, int *w, int *h)
    return 0;
 }

-static SDL_bool IsSupportedBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
+static bool IsSupportedBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
 {
    switch (blendMode) {
    // These are required to be supported by all renderers
@@ -1267,23 +1267,23 @@ static SDL_bool IsSupportedBlendMode(SDL_Renderer *renderer, SDL_BlendMode blend
    case SDL_BLENDMODE_ADD_PREMULTIPLIED:
    case SDL_BLENDMODE_MOD:
    case SDL_BLENDMODE_MUL:
-        return SDL_TRUE;
+        return true;

    default:
        return renderer->SupportsBlendMode && renderer->SupportsBlendMode(renderer, blendMode);
    }
 }

-static SDL_bool IsSupportedFormat(SDL_Renderer *renderer, SDL_PixelFormat format)
+static bool IsSupportedFormat(SDL_Renderer *renderer, SDL_PixelFormat format)
 {
    int i;

    for (i = 0; i < renderer->num_texture_formats; ++i) {
        if (renderer->texture_formats[i] == format) {
-            return SDL_TRUE;
+            return true;
        }
    }
-    return SDL_FALSE;
+    return false;
 }

 static Uint32 GetClosestSupportedFormat(SDL_Renderer *renderer, SDL_PixelFormat format)
@@ -1311,7 +1311,7 @@ static Uint32 GetClosestSupportedFormat(SDL_Renderer *renderer, SDL_PixelFormat
            }
        }
    } else {
-        SDL_bool hasAlpha = SDL_ISPIXELFORMAT_ALPHA(format);
+        bool hasAlpha = SDL_ISPIXELFORMAT_ALPHA(format);

        // We just want to match the first format that has the same channels
        for (i = 0; i < renderer->num_texture_formats; ++i) {
@@ -1332,7 +1332,7 @@ SDL_Texture *SDL_CreateTextureWithProperties(SDL_Renderer *renderer, SDL_Propert
    int w = (int)SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_WIDTH_NUMBER, 0);
    int h = (int)SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_HEIGHT_NUMBER, 0);
    SDL_Colorspace default_colorspace;
-    SDL_bool texture_is_fourcc_and_target;
+    bool texture_is_fourcc_and_target;

    CHECK_RENDERER_MAGIC(renderer, NULL);

@@ -1365,7 +1365,7 @@ SDL_Texture *SDL_CreateTextureWithProperties(SDL_Renderer *renderer, SDL_Propert
    if (!texture) {
        return NULL;
    }
-    SDL_SetObjectValid(texture, SDL_OBJECT_TYPE_TEXTURE, SDL_TRUE);
+    SDL_SetObjectValid(texture, SDL_OBJECT_TYPE_TEXTURE, true);
    texture->colorspace = (SDL_Colorspace)SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_COLORSPACE_NUMBER, default_colorspace);
    texture->format = format;
    texture->access = access;
@@ -1498,7 +1498,7 @@ SDL_Texture *SDL_CreateTexture(SDL_Renderer *renderer, SDL_PixelFormat format, S
 static int SDL_UpdateTextureFromSurface(SDL_Texture *texture, SDL_Rect *rect, SDL_Surface *surface)
 {
    SDL_TextureAccess access;
-    SDL_bool direct_update;
+    bool direct_update;
    SDL_PixelFormat tex_format;
    SDL_PropertiesID surface_props;
    SDL_PropertiesID tex_props;
@@ -1544,14 +1544,14 @@ static int SDL_UpdateTextureFromSurface(SDL_Texture *texture, SDL_Rect *rect, SD
        if (SDL_ISPIXELFORMAT_ALPHA(surface->format) && SDL_SurfaceHasColorKey(surface)) {
            /* Surface and Renderer formats are identical.
             * Intermediate conversion is needed to convert color key to alpha (SDL_ConvertColorkeyToAlpha()). */
-            direct_update = SDL_FALSE;
+            direct_update = false;
        } else {
            // Update Texture directly
-            direct_update = SDL_TRUE;
+            direct_update = true;
        }
    } else {
        // Surface and Renderer formats are different, it needs an intermediate conversion.
-        direct_update = SDL_FALSE;
+        direct_update = false;
    }

    if (direct_update) {
@@ -1599,7 +1599,7 @@ static int SDL_UpdateTextureFromSurface(SDL_Texture *texture, SDL_Rect *rect, SD

 SDL_Texture *SDL_CreateTextureFromSurface(SDL_Renderer *renderer, SDL_Surface *surface)
 {
-    SDL_bool needAlpha;
+    bool needAlpha;
    int i;
    SDL_PixelFormat format = SDL_PIXELFORMAT_UNKNOWN;
    SDL_Palette *palette;
@@ -1617,18 +1617,18 @@ SDL_Texture *SDL_CreateTextureFromSurface(SDL_Renderer *renderer, SDL_Surface *s

    // See what the best texture format is
    if (SDL_ISPIXELFORMAT_ALPHA(surface->format) || SDL_SurfaceHasColorKey(surface)) {
-        needAlpha = SDL_TRUE;
+        needAlpha = true;
    } else {
-        needAlpha = SDL_FALSE;
+        needAlpha = false;
    }

    // If Palette contains alpha values, promotes to alpha format
    palette = SDL_GetSurfacePalette(surface);
    if (palette) {
-        SDL_bool is_opaque, has_alpha_channel;
+        bool is_opaque, has_alpha_channel;
        SDL_DetectPalette(palette, &is_opaque, &has_alpha_channel);
        if (!is_opaque) {
-            needAlpha = SDL_TRUE;
+            needAlpha = true;
        }
    }

@@ -3028,9 +3028,9 @@ SDL_bool SDL_RenderViewportSet(SDL_Renderer *renderer)

    if (renderer->view->viewport.w >= 0 &&
        renderer->view->viewport.h >= 0) {
-        return SDL_TRUE;
+        return true;
    }
-    return SDL_FALSE;
+    return false;
 }

 static void GetRenderViewportSize(SDL_Renderer *renderer, SDL_FRect *rect)
@@ -3101,10 +3101,10 @@ int SDL_SetRenderClipRect(SDL_Renderer *renderer, const SDL_Rect *rect)
    CHECK_RENDERER_MAGIC(renderer, -1)

    if (rect && rect->w >= 0 && rect->h >= 0) {
-        renderer->view->clipping_enabled = SDL_TRUE;
+        renderer->view->clipping_enabled = true;
        SDL_copyp(&renderer->view->clip_rect, rect);
    } else {
-        renderer->view->clipping_enabled = SDL_FALSE;
+        renderer->view->clipping_enabled = false;
        SDL_zero(renderer->view->clip_rect);
    }
    UpdatePixelClipRect(renderer, renderer->view);
@@ -3128,7 +3128,7 @@ int SDL_GetRenderClipRect(SDL_Renderer *renderer, SDL_Rect *rect)

 SDL_bool SDL_RenderClipEnabled(SDL_Renderer *renderer)
 {
-    CHECK_RENDERER_MAGIC(renderer, SDL_FALSE)
+    CHECK_RENDERER_MAGIC(renderer, false)
    return renderer->view->clipping_enabled;
 }

@@ -3340,7 +3340,7 @@ int SDL_RenderPoint(SDL_Renderer *renderer, float x, float y)
 static int RenderPointsWithRects(SDL_Renderer *renderer, const SDL_FPoint *fpoints, const int count)
 {
    int retval;
-    SDL_bool isstack;
+    bool isstack;
    SDL_FRect *frects;
    int i;

@@ -3405,7 +3405,7 @@ int SDL_RenderLine(SDL_Renderer *renderer, float x1, float y1, float x2, float y
    return SDL_RenderLines(renderer, points, 2);
 }

-static int RenderLineBresenham(SDL_Renderer *renderer, int x1, int y1, int x2, int y2, SDL_bool draw_last)
+static int RenderLineBresenham(SDL_Renderer *renderer, int x1, int y1, int x2, int y2, bool draw_last)
 {
    const int MAX_PIXELS = SDL_max(renderer->view->pixel_w, renderer->view->pixel_h) * 4;
    int i, deltax, deltay, numpixels;
@@ -3413,7 +3413,7 @@ static int RenderLineBresenham(SDL_Renderer *renderer, int x1, int y1, int x2, i
    int x, xinc1, xinc2;
    int y, yinc1, yinc2;
    int retval;
-    SDL_bool isstack;
+    bool isstack;
    SDL_FPoint *points;
    SDL_Rect viewport;

@@ -3509,9 +3509,9 @@ static int RenderLinesWithRectsF(SDL_Renderer *renderer,
    SDL_FRect *frects;
    int i, nrects = 0;
    int retval = 0;
-    SDL_bool isstack;
-    SDL_bool drew_line = SDL_FALSE;
-    SDL_bool draw_last = SDL_FALSE;
+    bool isstack;
+    bool drew_line = false;
+    bool draw_last = false;

    frects = SDL_small_alloc(SDL_FRect, count - 1, &isstack);
    if (!frects) {
@@ -3519,12 +3519,12 @@ static int RenderLinesWithRectsF(SDL_Renderer *renderer,
    }

    for (i = 0; i < count - 1; ++i) {
-        SDL_bool same_x = (points[i].x == points[i + 1].x);
-        SDL_bool same_y = (points[i].y == points[i + 1].y);
+        bool same_x = (points[i].x == points[i + 1].x);
+        bool same_y = (points[i].y == points[i + 1].y);

        if (i == (count - 2)) {
            if (!drew_line || points[i + 1].x != points[0].x || points[i + 1].y != points[0].y) {
-                draw_last = SDL_TRUE;
+                draw_last = true;
            }
        } else {
            if (same_x && same_y) {
@@ -3559,7 +3559,7 @@ static int RenderLinesWithRectsF(SDL_Renderer *renderer,
            retval += RenderLineBresenham(renderer, (int)SDL_roundf(points[i].x), (int)SDL_roundf(points[i].y),
                                              (int)SDL_roundf(points[i + 1].x), (int)SDL_roundf(points[i + 1].y), draw_last);
        }
-        drew_line = SDL_TRUE;
+        drew_line = true;
    }

    if (nrects) {
@@ -3597,8 +3597,8 @@ int SDL_RenderLines(SDL_Renderer *renderer, const SDL_FPoint *points, int count)
    if (renderer->line_method == SDL_RENDERLINEMETHOD_POINTS) {
        retval = RenderLinesWithRectsF(renderer, points, count);
    } else if (renderer->line_method == SDL_RENDERLINEMETHOD_GEOMETRY) {
-        SDL_bool isstack1;
-        SDL_bool isstack2;
+        bool isstack1;
+        bool isstack2;
        const float scale_x = renderer->view->scale.x;
        const float scale_y = renderer->view->scale.y;
        float *xy = SDL_small_alloc(float, 4 * 2 * count, &isstack1);
@@ -3798,7 +3798,7 @@ int SDL_RenderFillRects(SDL_Renderer *renderer, const SDL_FRect *rects, int coun
    SDL_FRect *frects;
    int i;
    int retval;
-    SDL_bool isstack;
+    bool isstack;

    CHECK_RENDERER_MAGIC(renderer, -1);

@@ -3837,7 +3837,7 @@ int SDL_RenderFillRects(SDL_Renderer *renderer, const SDL_FRect *rects, int coun
 static int SDL_RenderTextureInternal(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_FRect *srcrect, const SDL_FRect *dstrect)
 {
    int retval;
-    SDL_bool use_rendergeometry = (!renderer->QueueCopy);
+    bool use_rendergeometry = (!renderer->QueueCopy);

    if (use_rendergeometry) {
        float xy[8];
@@ -4998,7 +4998,7 @@ static void SDL_SimulateRenderVSync(SDL_Renderer *renderer)

 int SDL_RenderPresent(SDL_Renderer *renderer)
 {
-    SDL_bool presented = SDL_TRUE;
+    bool presented = true;

    CHECK_RENDERER_MAGIC(renderer, -1);

@@ -5016,11 +5016,11 @@ int SDL_RenderPresent(SDL_Renderer *renderer)
 #if DONT_DRAW_WHILE_HIDDEN
    // Don't present while we're hidden
    if (renderer->hidden) {
-        presented = SDL_FALSE;
+        presented = false;
    } else
 #endif
    if (renderer->RenderPresent(renderer) < 0) {
-        presented = SDL_FALSE;
+        presented = false;
    }

    if (renderer->logical_target) {
@@ -5034,7 +5034,7 @@ int SDL_RenderPresent(SDL_Renderer *renderer)
    return 0;
 }

-static int SDL_DestroyTextureInternal(SDL_Texture *texture, SDL_bool is_destroying)
+static int SDL_DestroyTextureInternal(SDL_Texture *texture, bool is_destroying)
 {
    SDL_Renderer *renderer;

@@ -5063,7 +5063,7 @@ static int SDL_DestroyTextureInternal(SDL_Texture *texture, SDL_bool is_destroyi
        renderer->logical_target = NULL;
    }

-    SDL_SetObjectValid(texture, SDL_OBJECT_TYPE_TEXTURE, SDL_FALSE);
+    SDL_SetObjectValid(texture, SDL_OBJECT_TYPE_TEXTURE, false);

    if (texture->next) {
        texture->next->prev = texture->prev;
@@ -5095,7 +5095,7 @@ static int SDL_DestroyTextureInternal(SDL_Texture *texture, SDL_bool is_destroyi

 void SDL_DestroyTexture(SDL_Texture *texture)
 {
-    SDL_DestroyTextureInternal(texture, SDL_FALSE /* is_destroying */);
+    SDL_DestroyTextureInternal(texture, false /* is_destroying */);
 }

 static void SDL_DiscardAllCommands(SDL_Renderer *renderer)
@@ -5125,7 +5125,7 @@ void SDL_DestroyRendererWithoutFreeing(SDL_Renderer *renderer)
    SDL_assert(renderer != NULL);
    SDL_assert(!renderer->destroyed);

-    renderer->destroyed = SDL_TRUE;
+    renderer->destroyed = true;

    SDL_DelEventWatch(SDL_RendererEventWatch, renderer);

@@ -5141,7 +5141,7 @@ void SDL_DestroyRendererWithoutFreeing(SDL_Renderer *renderer)
    // Free existing textures for this renderer
    while (renderer->textures) {
        SDL_Texture *tex = renderer->textures;
-        SDL_DestroyTextureInternal(renderer->textures, SDL_TRUE /* is_destroying */);
+        SDL_DestroyTextureInternal(renderer->textures, true /* is_destroying */);
        SDL_assert(tex != renderer->textures); // satisfy static analysis.
    }

@@ -5194,7 +5194,7 @@ void SDL_DestroyRenderer(SDL_Renderer *renderer)
        curr = curr->next;
    }

-    SDL_SetObjectValid(renderer, SDL_OBJECT_TYPE_RENDERER, SDL_FALSE);  // It's no longer magical...
+    SDL_SetObjectValid(renderer, SDL_OBJECT_TYPE_RENDERER, false);  // It's no longer magical...

    SDL_free(renderer);
 }
@@ -5333,7 +5333,7 @@ int SDL_SetRenderVSync(SDL_Renderer *renderer, int vsync)
 {
    CHECK_RENDERER_MAGIC(renderer, -1);

-    renderer->wanted_vsync = vsync ? SDL_TRUE : SDL_FALSE;
+    renderer->wanted_vsync = vsync ? true : false;

    // for the software renderer, forward the call to the WindowTexture renderer
 #if SDL_VIDEO_RENDER_SW
@@ -5346,7 +5346,7 @@ int SDL_SetRenderVSync(SDL_Renderer *renderer, int vsync)
            }
        }
        if (SDL_SetWindowTextureVSync(NULL, renderer->window, vsync) == 0) {
-            renderer->simulate_vsync = SDL_FALSE;
+            renderer->simulate_vsync = false;
            return 0;
        }
    }
@@ -5355,17 +5355,17 @@ int SDL_SetRenderVSync(SDL_Renderer *renderer, int vsync)
    if (!renderer->SetVSync) {
        switch (vsync) {
        case 0:
-            renderer->simulate_vsync = SDL_FALSE;
+            renderer->simulate_vsync = false;
            break;
        case 1:
-            renderer->simulate_vsync = SDL_TRUE;
+            renderer->simulate_vsync = true;
            break;
        default:
            return SDL_Unsupported();
        }
    } else if (renderer->SetVSync(renderer, vsync) < 0) {
        if (vsync == 1) {
-            renderer->simulate_vsync = SDL_TRUE;
+            renderer->simulate_vsync = true;
        } else {
            return -1;
        }
--- a/src/render/SDL_sysrender.h
+++ b/src/render/SDL_sysrender.h
@@ -61,7 +61,7 @@ typedef struct SDL_RenderViewState
    SDL_Rect pixel_viewport;
    SDL_Rect clip_rect;
    SDL_Rect pixel_clip_rect;
-    SDL_bool clipping_enabled;
+    bool clipping_enabled;
    SDL_FPoint scale;

 } SDL_RenderViewState;
@@ -128,7 +128,7 @@ typedef struct SDL_RenderCommand
        } viewport;
        struct
        {
-            SDL_bool enabled;
+            bool enabled;
            SDL_Rect rect;
        } cliprect;
        struct
@@ -169,7 +169,7 @@ struct SDL_Renderer
 {
    void (*WindowEvent)(SDL_Renderer *renderer, const SDL_WindowEvent *event);
    int (*GetOutputSize)(SDL_Renderer *renderer, int *w, int *h);
-    SDL_bool (*SupportsBlendMode)(SDL_Renderer *renderer, SDL_BlendMode blendMode);
+    bool (*SupportsBlendMode)(SDL_Renderer *renderer, SDL_BlendMode blendMode);
    int (*CreateTexture)(SDL_Renderer *renderer, SDL_Texture *texture, SDL_PropertiesID create_props);
    int (*QueueSetViewport)(SDL_Renderer *renderer, SDL_RenderCommand *cmd);
    int (*QueueSetDrawColor)(SDL_Renderer *renderer, SDL_RenderCommand *cmd);
@@ -227,15 +227,15 @@ struct SDL_Renderer
    const char *name;
    SDL_PixelFormat *texture_formats;
    int num_texture_formats;
-    SDL_bool software;
+    bool software;

    // The window associated with the renderer
    SDL_Window *window;
-    SDL_bool hidden;
+    bool hidden;

    // Whether we should simulate vsync
-    SDL_bool wanted_vsync;
-    SDL_bool simulate_vsync;
+    bool wanted_vsync;
+    bool simulate_vsync;
    Uint64 simulate_vsync_interval_ns;
    Uint64 last_present;

@@ -280,24 +280,24 @@ struct SDL_Renderer
    float last_queued_color_scale;
    SDL_Rect last_queued_viewport;
    SDL_Rect last_queued_cliprect;
-    SDL_bool last_queued_cliprect_enabled;
-    SDL_bool color_queued;
-    SDL_bool color_scale_queued;
-    SDL_bool viewport_queued;
-    SDL_bool cliprect_queued;
+    bool last_queued_cliprect_enabled;
+    bool color_queued;
+    bool color_scale_queued;
+    bool viewport_queued;
+    bool cliprect_queued;

    void *vertex_data;
    size_t vertex_data_used;
    size_t vertex_data_allocation;

    // Shaped window support
-    SDL_bool transparent_window;
+    bool transparent_window;
    SDL_Surface *shape_surface;
    SDL_Texture *shape_texture;

    SDL_PropertiesID props;

-    SDL_bool destroyed;   // already destroyed by SDL_DestroyWindow; just free this struct in SDL_DestroyRenderer.
+    bool destroyed;   // already destroyed by SDL_DestroyWindow; just free this struct in SDL_DestroyRenderer.

    void *internal;

@@ -335,7 +335,7 @@ extern int SDL_AddSupportedTextureFormat(SDL_Renderer *renderer, SDL_PixelFormat
 extern void SDL_SetupRendererColorspace(SDL_Renderer *renderer, SDL_PropertiesID props);

 // Colorspace conversion functions
-extern SDL_bool SDL_RenderingLinearSpace(SDL_Renderer *renderer);
+extern bool SDL_RenderingLinearSpace(SDL_Renderer *renderer);
 extern void SDL_ConvertToLinear(SDL_FColor *color);
 extern void SDL_ConvertFromLinear(SDL_FColor *color);

--- a/src/render/direct3d/SDL_render_d3d.c
+++ b/src/render/direct3d/SDL_render_d3d.c
@@ -39,13 +39,13 @@
 typedef struct
 {
    SDL_Rect viewport;
-    SDL_bool viewport_dirty;
+    bool viewport_dirty;
    SDL_Texture *texture;
    SDL_BlendMode blend;
-    SDL_bool cliprect_enabled;
-    SDL_bool cliprect_enabled_dirty;
+    bool cliprect_enabled;
+    bool cliprect_enabled_dirty;
    SDL_Rect cliprect;
-    SDL_bool cliprect_dirty;
+    bool cliprect_dirty;
    D3D9_Shader shader;
    const float *shader_params;
 } D3D_DrawStateCache;
@@ -59,9 +59,9 @@ typedef struct
    IDirect3DDevice9 *device;
    UINT adapter;
    D3DPRESENT_PARAMETERS pparams;
-    SDL_bool updateSize;
-    SDL_bool beginScene;
-    SDL_bool enableSeparateAlphaBlend;
+    bool updateSize;
+    bool beginScene;
+    bool enableSeparateAlphaBlend;
    D3DTEXTUREFILTERTYPE scaleMode[3];
    SDL_TextureAddressMode addressMode[3];
    IDirect3DSurface9 *defaultRenderTarget;
@@ -73,13 +73,13 @@ typedef struct
    LPDIRECT3DVERTEXBUFFER9 vertexBuffers[8];
    size_t vertexBufferSize[8];
    int currentVertexBuffer;
-    SDL_bool reportedVboProblem;
+    bool reportedVboProblem;
    D3D_DrawStateCache drawstate;
 } D3D_RenderData;

 typedef struct
 {
-    SDL_bool dirty;
+    bool dirty;
    int w, h;
    DWORD usage;
    Uint32 format;
@@ -97,7 +97,7 @@ typedef struct

 #if SDL_HAVE_YUV
    // YV12 texture support
-    SDL_bool yuv;
+    bool yuv;
    D3D_TextureRep utexture;
    D3D_TextureRep vtexture;
    Uint8 *pixels;
@@ -282,7 +282,7 @@ static void D3D_InitRenderState(D3D_RenderData *data)
    SDL_zeroa(data->addressMode);

    // Start the render with beginScene
-    data->beginScene = SDL_TRUE;
+    data->beginScene = true;
 }

 static int D3D_Reset(SDL_Renderer *renderer);
@@ -316,7 +316,7 @@ static int D3D_ActivateRenderer(SDL_Renderer *renderer)
            return -1;
        }

-        data->updateSize = SDL_FALSE;
+        data->updateSize = false;
    }
    if (data->beginScene) {
        result = IDirect3DDevice9_BeginScene(data->device);
@@ -329,7 +329,7 @@ static int D3D_ActivateRenderer(SDL_Renderer *renderer)
        if (FAILED(result)) {
            return D3D_SetError("BeginScene()", result);
        }
-        data->beginScene = SDL_FALSE;
+        data->beginScene = false;
    }
    return 0;
 }
@@ -339,7 +339,7 @@ static void D3D_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *event
    D3D_RenderData *data = (D3D_RenderData *)renderer->internal;

    if (event->type == SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED) {
-        data->updateSize = SDL_TRUE;
+        data->updateSize = true;
    }
 }

@@ -391,7 +391,7 @@ static D3DBLENDOP GetBlendEquation(SDL_BlendOperation operation)
    return (D3DBLENDOP)0;
 }

-static SDL_bool D3D_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
+static bool D3D_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
 {
    D3D_RenderData *data = (D3D_RenderData *)renderer->internal;
    SDL_BlendFactor srcColorFactor = SDL_GetBlendModeSrcColorFactor(blendMode);
@@ -405,22 +405,22 @@ static SDL_bool D3D_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blen
        !GetBlendEquation(colorOperation) ||
        !GetBlendFunc(dstColorFactor) || !GetBlendFunc(dstAlphaFactor) ||
        !GetBlendEquation(alphaOperation)) {
-        return SDL_FALSE;
+        return false;
    }

    if (!data->enableSeparateAlphaBlend) {
        if ((srcColorFactor != srcAlphaFactor) || (dstColorFactor != dstAlphaFactor) || (colorOperation != alphaOperation)) {
-            return SDL_FALSE;
+            return false;
        }
    }
-    return SDL_TRUE;
+    return true;
 }

 static int D3D_CreateTextureRep(IDirect3DDevice9 *device, D3D_TextureRep *texture, DWORD usage, Uint32 format, D3DFORMAT d3dfmt, int w, int h)
 {
    HRESULT result;

-    texture->dirty = SDL_FALSE;
+    texture->dirty = false;
    texture->w = w;
    texture->h = h;
    texture->usage = usage;
@@ -458,7 +458,7 @@ static int D3D_RecreateTextureRep(IDirect3DDevice9 *device, D3D_TextureRep *text
    }
    if (texture->staging) {
        IDirect3DTexture9_AddDirtyRect(texture->staging, NULL);
-        texture->dirty = SDL_TRUE;
+        texture->dirty = true;
    }
    return 0;
 }
@@ -508,7 +508,7 @@ static int D3D_UpdateTextureRep(IDirect3DDevice9 *device, D3D_TextureRep *textur
    if (FAILED(result)) {
        return D3D_SetError("UnlockRect()", result);
    }
-    texture->dirty = SDL_TRUE;
+    texture->dirty = true;

    return 0;
 }
@@ -551,7 +551,7 @@ static int D3D_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_P
 #if SDL_HAVE_YUV
    if (texture->format == SDL_PIXELFORMAT_YV12 ||
        texture->format == SDL_PIXELFORMAT_IYUV) {
-        texturedata->yuv = SDL_TRUE;
+        texturedata->yuv = true;

        if (D3D_CreateTextureRep(data->device, &texturedata->utexture, usage, texture->format, PixelFormatToD3DFMT(texture->format), (texture->w + 1) / 2, (texture->h + 1) / 2) < 0) {
            return -1;
@@ -727,7 +727,7 @@ static void D3D_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture)
 #endif
    {
        IDirect3DTexture9_UnlockRect(texturedata->texture.staging, 0);
-        texturedata->texture.dirty = SDL_TRUE;
+        texturedata->texture.dirty = true;
        if (data->drawstate.texture == texture) {
            data->drawstate.texture = NULL;
            data->drawstate.shader = SHADER_NONE;
@@ -788,7 +788,7 @@ static int D3D_SetRenderTargetInternal(SDL_Renderer *renderer, SDL_Texture *text
        if (FAILED(result)) {
            return D3D_SetError("UpdateTexture()", result);
        }
-        texturerep->dirty = SDL_FALSE;
+        texturerep->dirty = false;
    }

    result = IDirect3DTexture9_GetSurfaceLevel(texturedata->texture.texture, 0, &data->currentRenderTarget);
@@ -912,7 +912,7 @@ static int UpdateDirtyTexture(IDirect3DDevice9 *device, D3D_TextureRep *texture)
        if (FAILED(result)) {
            return D3D_SetError("UpdateTexture()", result);
        }
-        texture->dirty = SDL_FALSE;
+        texture->dirty = false;
    }
    return 0;
 }
@@ -1099,12 +1099,12 @@ static int SetDrawState(D3D_RenderData *data, const SDL_RenderCommand *cmd)
            IDirect3DDevice9_SetTransform(data->device, D3DTS_PROJECTION, &d3dmatrix);
        }

-        data->drawstate.viewport_dirty = SDL_FALSE;
+        data->drawstate.viewport_dirty = false;
    }

    if (data->drawstate.cliprect_enabled_dirty) {
        IDirect3DDevice9_SetRenderState(data->device, D3DRS_SCISSORTESTENABLE, data->drawstate.cliprect_enabled ? TRUE : FALSE);
-        data->drawstate.cliprect_enabled_dirty = SDL_FALSE;
+        data->drawstate.cliprect_enabled_dirty = false;
    }

    if (data->drawstate.cliprect_dirty) {
@@ -1116,7 +1116,7 @@ static int SetDrawState(D3D_RenderData *data, const SDL_RenderCommand *cmd)
        d3drect.right = (LONG)viewport->x + rect->x + rect->w;
        d3drect.bottom = (LONG)viewport->y + rect->y + rect->h;
        IDirect3DDevice9_SetScissorRect(data->device, &d3drect);
-        data->drawstate.cliprect_dirty = SDL_FALSE;
+        data->drawstate.cliprect_dirty = false;
    }

    return 0;
@@ -1125,9 +1125,9 @@ static int SetDrawState(D3D_RenderData *data, const SDL_RenderCommand *cmd)
 static void D3D_InvalidateCachedState(SDL_Renderer *renderer)
 {
    D3D_RenderData *data = (D3D_RenderData *)renderer->internal;
-    data->drawstate.viewport_dirty = SDL_TRUE;
-    data->drawstate.cliprect_enabled_dirty = SDL_TRUE;
-    data->drawstate.cliprect_dirty = SDL_TRUE;
+    data->drawstate.viewport_dirty = true;
+    data->drawstate.cliprect_enabled_dirty = true;
+    data->drawstate.cliprect_dirty = true;
    data->drawstate.blend = SDL_BLENDMODE_INVALID;
    data->drawstate.texture = NULL;
    data->drawstate.shader = SHADER_NONE;
@@ -1139,7 +1139,7 @@ static int D3D_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, v
    D3D_RenderData *data = (D3D_RenderData *)renderer->internal;
    const int vboidx = data->currentVertexBuffer;
    IDirect3DVertexBuffer9 *vbo = NULL;
-    const SDL_bool istarget = renderer->target != NULL;
+    const bool istarget = renderer->target != NULL;

    if (D3D_ActivateRenderer(renderer) < 0) {
        return -1;
@@ -1185,7 +1185,7 @@ static int D3D_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, v
            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "Dropping back to a slower method.");
            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "This might be a brief hiccup, but if performance is bad, this is probably why.");
            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "This error will not be logged again for this renderer.");
-            data->reportedVboProblem = SDL_TRUE;
+            data->reportedVboProblem = true;
        }
    }

@@ -1206,8 +1206,8 @@ static int D3D_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, v
            SDL_Rect *viewport = &data->drawstate.viewport;
            if (SDL_memcmp(viewport, &cmd->data.viewport.rect, sizeof(cmd->data.viewport.rect)) != 0) {
                SDL_copyp(viewport, &cmd->data.viewport.rect);
-                data->drawstate.viewport_dirty = SDL_TRUE;
-                data->drawstate.cliprect_dirty = SDL_TRUE;
+                data->drawstate.viewport_dirty = true;
+                data->drawstate.cliprect_dirty = true;
            }
            break;
        }
@@ -1217,12 +1217,12 @@ static int D3D_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, v
            const SDL_Rect *rect = &cmd->data.cliprect.rect;
            if (data->drawstate.cliprect_enabled != cmd->data.cliprect.enabled) {
                data->drawstate.cliprect_enabled = cmd->data.cliprect.enabled;
-                data->drawstate.cliprect_enabled_dirty = SDL_TRUE;
+                data->drawstate.cliprect_enabled_dirty = true;
            }

            if (SDL_memcmp(&data->drawstate.cliprect, rect, sizeof(*rect)) != 0) {
                SDL_copyp(&data->drawstate.cliprect, rect);
-                data->drawstate.cliprect_dirty = SDL_TRUE;
+                data->drawstate.cliprect_dirty = true;
            }
            break;
        }
@@ -1236,7 +1236,7 @@ static int D3D_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, v
            const SDL_Rect *viewport = &data->drawstate.viewport;
            const int backw = istarget ? renderer->target->w : data->pparams.BackBufferWidth;
            const int backh = istarget ? renderer->target->h : data->pparams.BackBufferHeight;
-            const SDL_bool viewport_equal = ((viewport->x == 0) && (viewport->y == 0) && (viewport->w == backw) && (viewport->h == backh));
+            const bool viewport_equal = ((viewport->x == 0) && (viewport->y == 0) && (viewport->w == backw) && (viewport->h == backh));

            if (data->drawstate.cliprect_enabled || data->drawstate.cliprect_enabled_dirty) {
                IDirect3DDevice9_SetRenderState(data->device, D3DRS_SCISSORTESTENABLE, FALSE);
@@ -1252,7 +1252,7 @@ static int D3D_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, v
                wholeviewport.Width = backw;
                wholeviewport.Height = backh;
                IDirect3DDevice9_SetViewport(data->device, &wholeviewport);
-                data->drawstate.viewport_dirty = SDL_TRUE; // we still need to (re)set orthographic projection, so always mark it dirty.
+                data->drawstate.viewport_dirty = true; // we still need to (re)set orthographic projection, so always mark it dirty.
                IDirect3DDevice9_Clear(data->device, 0, NULL, D3DCLEAR_TARGET, color, 0.0f, 0);
            }

@@ -1282,7 +1282,7 @@ static int D3D_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, v
            /* DirectX 9 has the same line rasterization semantics as GDI,
               so we need to close the endpoint of the line with a second draw call.
               NOLINTNEXTLINE(clang-analyzer-core.NullDereference): FIXME: Can verts truly not be NULL ? */
-            const SDL_bool close_endpoint = ((count == 2) || (verts[0].x != verts[count - 1].x) || (verts[0].y != verts[count - 1].y));
+            const bool close_endpoint = ((count == 2) || (verts[0].x != verts[count - 1].x) || (verts[0].y != verts[count - 1].y));

            SetDrawState(data, cmd);

@@ -1397,7 +1397,7 @@ static int D3D_RenderPresent(SDL_Renderer *renderer)

    if (!data->beginScene) {
        IDirect3DDevice9_EndScene(data->device);
-        data->beginScene = SDL_TRUE;
+        data->beginScene = true;
    }

    result = IDirect3DDevice9_TestCooperativeLevel(data->device);
@@ -1502,7 +1502,7 @@ static int D3D_Reset(SDL_Renderer *renderer)
    // Cancel any scene that we've started
    if (!data->beginScene) {
        IDirect3DDevice9_EndScene(data->device);
-        data->beginScene = SDL_TRUE;
+        data->beginScene = true;
    }

    // Release the default render target before reset
@@ -1713,7 +1713,7 @@ int D3D_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Propertie
        device_flags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
    }

-    if (SDL_GetHintBoolean(SDL_HINT_RENDER_DIRECT3D_THREADSAFE, SDL_FALSE)) {
+    if (SDL_GetHintBoolean(SDL_HINT_RENDER_DIRECT3D_THREADSAFE, false)) {
        device_flags |= D3DCREATE_MULTITHREADED;
    }

@@ -1743,7 +1743,7 @@ int D3D_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Propertie
    SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, SDL_min(caps.MaxTextureWidth, caps.MaxTextureHeight));

    if (caps.PrimitiveMiscCaps & D3DPMISCCAPS_SEPARATEALPHABLEND) {
-        data->enableSeparateAlphaBlend = SDL_TRUE;
+        data->enableSeparateAlphaBlend = true;
    }

    // Store the default render target
--- a/src/render/direct3d11/SDL_render_d3d11.c
+++ b/src/render/direct3d11/SDL_render_d3d11.c
@@ -145,14 +145,14 @@ typedef struct
    const float *YCbCr_matrix;
 #if SDL_HAVE_YUV
    // YV12 texture support
-    SDL_bool yuv;
+    bool yuv;
    ID3D11Texture2D *mainTextureU;
    ID3D11ShaderResourceView *mainTextureResourceViewU;
    ID3D11Texture2D *mainTextureV;
    ID3D11ShaderResourceView *mainTextureResourceViewV;

    // NV12 texture support
-    SDL_bool nv12;
+    bool nv12;
    ID3D11ShaderResourceView *mainTextureResourceViewNV;

    Uint8 *pixels;
@@ -193,7 +193,7 @@ typedef struct
    D3D11_BlendMode *blendModes;
    ID3D11SamplerState *samplers[SDL_NUM_D3D11_SAMPLERS];
    D3D_FEATURE_LEVEL featureLevel;
-    SDL_bool pixelSizeChanged;
+    bool pixelSizeChanged;

    // Rasterizers
    ID3D11RasterizerState *mainRasterizer;
@@ -212,12 +212,12 @@ typedef struct
    PixelShaderState currentShaderState[NUM_SHADERS];
    ID3D11ShaderResourceView *currentShaderResource;
    ID3D11SamplerState *currentSampler;
-    SDL_bool cliprectDirty;
-    SDL_bool currentCliprectEnabled;
+    bool cliprectDirty;
+    bool currentCliprectEnabled;
    SDL_Rect currentCliprect;
    SDL_Rect currentViewport;
    int currentViewportRotation;
-    SDL_bool viewportDirty;
+    bool viewportDirty;
    Float4X4 identity;
    int currentVertexBuffer;
 } D3D11_RenderData;
@@ -531,7 +531,7 @@ static HRESULT D3D11_CreateDeviceResources(SDL_Renderer *renderer)
    IDXGIDevice1 *dxgiDevice = NULL;
    HRESULT result = S_OK;
    UINT creationFlags = 0;
-    SDL_bool createDebug;
+    bool createDebug;

    /* This array defines the set of DirectX hardware feature levels this app will support.
     * Note the ordering should be preserved.
@@ -553,7 +553,7 @@ static HRESULT D3D11_CreateDeviceResources(SDL_Renderer *renderer)
    D3D11_RASTERIZER_DESC rasterDesc;

    // See if we need debug interfaces
-    createDebug = SDL_GetHintBoolean(SDL_HINT_RENDER_DIRECT3D11_DEBUG, SDL_FALSE);
+    createDebug = SDL_GetHintBoolean(SDL_HINT_RENDER_DIRECT3D11_DEBUG, false);

 #ifdef SDL_PLATFORM_WINRT
    CreateDXGIFactory2Func = CreateDXGIFactory2;
@@ -646,7 +646,7 @@ static HRESULT D3D11_CreateDeviceResources(SDL_Renderer *renderer)
    }

    // Create a single-threaded device unless the app requests otherwise.
-    if (!SDL_GetHintBoolean(SDL_HINT_RENDER_DIRECT3D_THREADSAFE, SDL_FALSE)) {
+    if (!SDL_GetHintBoolean(SDL_HINT_RENDER_DIRECT3D_THREADSAFE, false)) {
        creationFlags |= D3D11_CREATE_DEVICE_SINGLETHREADED;
    }

@@ -1200,7 +1200,7 @@ static HRESULT D3D11_CreateWindowSizeDependentResources(SDL_Renderer *renderer)
                                           &data->mainRenderTargetView,
                                           NULL);

-    data->viewportDirty = SDL_TRUE;
+    data->viewportDirty = true;

 done:
    SAFE_RELEASE(backBuffer);
@@ -1238,11 +1238,11 @@ static void D3D11_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *eve
    D3D11_RenderData *data = (D3D11_RenderData *)renderer->internal;

    if (event->type == SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED) {
-        data->pixelSizeChanged = SDL_TRUE;
+        data->pixelSizeChanged = true;
    }
 }

-static SDL_bool D3D11_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
+static bool D3D11_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
 {
    SDL_BlendFactor srcColorFactor = SDL_GetBlendModeSrcColorFactor(blendMode);
    SDL_BlendFactor srcAlphaFactor = SDL_GetBlendModeSrcAlphaFactor(blendMode);
@@ -1255,9 +1255,9 @@ static SDL_bool D3D11_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode bl
        !GetBlendEquation(colorOperation) ||
        !GetBlendFunc(dstColorFactor) || !GetBlendFunc(dstAlphaFactor) ||
        !GetBlendEquation(alphaOperation)) {
-        return SDL_FALSE;
+        return false;
    }
-    return SDL_TRUE;
+    return true;
 }

 static int GetTextureProperty(SDL_PropertiesID props, const char *name, ID3D11Texture2D **texture)
@@ -1349,7 +1349,7 @@ static int D3D11_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL
 #if SDL_HAVE_YUV
    if (texture->format == SDL_PIXELFORMAT_YV12 ||
        texture->format == SDL_PIXELFORMAT_IYUV) {
-        textureData->yuv = SDL_TRUE;
+        textureData->yuv = true;

        textureDesc.Width = (textureDesc.Width + 1) / 2;
        textureDesc.Height = (textureDesc.Height + 1) / 2;
@@ -1392,7 +1392,7 @@ static int D3D11_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL
        texture->format == SDL_PIXELFORMAT_P010) {
        int bits_per_pixel;

-        textureData->nv12 = SDL_TRUE;
+        textureData->nv12 = true;

        switch (texture->format) {
        case SDL_PIXELFORMAT_P010:
@@ -1958,7 +1958,7 @@ static int D3D11_QueueDrawPoints(SDL_Renderer *renderer, SDL_RenderCommand *cmd,
    VertexPositionColor *verts = (VertexPositionColor *)SDL_AllocateRenderVertices(renderer, count * sizeof(VertexPositionColor), 0, &cmd->data.draw.first);
    int i;
    SDL_FColor color = cmd->data.draw.color;
-    SDL_bool convert_color = SDL_RenderingLinearSpace(renderer);
+    bool convert_color = SDL_RenderingLinearSpace(renderer);

    if (!verts) {
        return -1;
@@ -1990,7 +1990,7 @@ static int D3D11_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, S
    int i;
    int count = indices ? num_indices : num_vertices;
    VertexPositionColor *verts = (VertexPositionColor *)SDL_AllocateRenderVertices(renderer, count * sizeof(VertexPositionColor), 0, &cmd->data.draw.first);
-    SDL_bool convert_color = SDL_RenderingLinearSpace(renderer);
+    bool convert_color = SDL_RenderingLinearSpace(renderer);
    D3D11_TextureData *textureData = texture ? (D3D11_TextureData *)texture->internal : NULL;
    float u_scale = textureData ? (float)texture->w / textureData->w : 0.0f;
    float v_scale = textureData ? (float)texture->h / textureData->h : 0.0f;
@@ -2194,7 +2194,7 @@ static int D3D11_UpdateViewport(SDL_Renderer *renderer)
    // SDL_Log("%s: D3D viewport = {%f,%f,%f,%f}\n", __FUNCTION__, d3dviewport.TopLeftX, d3dviewport.TopLeftY, d3dviewport.Width, d3dviewport.Height);
    ID3D11DeviceContext_RSSetViewports(data->d3dContext, 1, &d3dviewport);

-    data->viewportDirty = SDL_FALSE;
+    data->viewportDirty = false;

    return 0;
 }
@@ -2284,7 +2284,7 @@ static int D3D11_SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *c
    ID3D11ShaderResourceView *shaderResource;
    const SDL_BlendMode blendMode = cmd->data.draw.blend;
    ID3D11BlendState *blendState = NULL;
-    SDL_bool updateSubresource = SDL_FALSE;
+    bool updateSubresource = false;
    PixelShaderState *shader_state = &rendererData->currentShaderState[shader];
    PixelShaderConstants solid_constants;

@@ -2312,7 +2312,7 @@ static int D3D11_SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *c
    if (rendererData->viewportDirty) {
        if (D3D11_UpdateViewport(renderer) == 0) {
            // vertexShaderConstantsData.projectionAndView has changed
-            updateSubresource = SDL_TRUE;
+            updateSubresource = true;
        }
    }

@@ -2327,7 +2327,7 @@ static int D3D11_SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *c
            }
            ID3D11DeviceContext_RSSetScissorRects(rendererData->d3dContext, 1, &scissorRect);
        }
-        rendererData->cliprectDirty = SDL_FALSE;
+        rendererData->cliprectDirty = false;
    }

    if (!rendererData->currentCliprectEnabled) {
@@ -2410,7 +2410,7 @@ static int D3D11_SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *c
        rendererData->currentSampler = sampler;
    }

-    if (updateSubresource == SDL_TRUE || SDL_memcmp(&rendererData->vertexShaderConstantsData.model, newmatrix, sizeof(*newmatrix)) != 0) {
+    if (updateSubresource == true || SDL_memcmp(&rendererData->vertexShaderConstantsData.model, newmatrix, sizeof(*newmatrix)) != 0) {
        SDL_copyp(&rendererData->vertexShaderConstantsData.model, newmatrix);
        ID3D11DeviceContext_UpdateSubresource(rendererData->d3dContext,
                                              (ID3D11Resource *)rendererData->vertexShaderConstants,
@@ -2507,8 +2507,8 @@ static void D3D11_InvalidateCachedState(SDL_Renderer *renderer)
    data->currentShader = SHADER_NONE;
    data->currentShaderResource = NULL;
    data->currentSampler = NULL;
-    data->cliprectDirty = SDL_TRUE;
-    data->viewportDirty = SDL_TRUE;
+    data->cliprectDirty = true;
+    data->viewportDirty = true;
 }

 static int D3D11_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
@@ -2518,12 +2518,12 @@ static int D3D11_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd,

    if (rendererData->pixelSizeChanged) {
        D3D11_UpdateForWindowSizeChange(renderer);
-        rendererData->pixelSizeChanged = SDL_FALSE;
+        rendererData->pixelSizeChanged = false;
    }

    if (rendererData->currentViewportRotation != viewportRotation) {
        rendererData->currentViewportRotation = viewportRotation;
-        rendererData->viewportDirty = SDL_TRUE;
+        rendererData->viewportDirty = true;
    }

    if (D3D11_UpdateVertexBuffer(renderer, vertices, vertsize) < 0) {
@@ -2542,8 +2542,8 @@ static int D3D11_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd,
            SDL_Rect *viewport = &rendererData->currentViewport;
            if (SDL_memcmp(viewport, &cmd->data.viewport.rect, sizeof(cmd->data.viewport.rect)) != 0) {
                SDL_copyp(viewport, &cmd->data.viewport.rect);
-                rendererData->viewportDirty = SDL_TRUE;
-                rendererData->cliprectDirty = SDL_TRUE;
+                rendererData->viewportDirty = true;
+                rendererData->cliprectDirty = true;
            }
            break;
        }
@@ -2553,18 +2553,18 @@ static int D3D11_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd,
            const SDL_Rect *rect = &cmd->data.cliprect.rect;
            if (rendererData->currentCliprectEnabled != cmd->data.cliprect.enabled) {
                rendererData->currentCliprectEnabled = cmd->data.cliprect.enabled;
-                rendererData->cliprectDirty = SDL_TRUE;
+                rendererData->cliprectDirty = true;
            }
            if (SDL_memcmp(&rendererData->currentCliprect, rect, sizeof(*rect)) != 0) {
                SDL_copyp(&rendererData->currentCliprect, rect);
-                rendererData->cliprectDirty = SDL_TRUE;
+                rendererData->cliprectDirty = true;
            }
            break;
        }

        case SDL_RENDERCMD_CLEAR:
        {
-            SDL_bool convert_color = SDL_RenderingLinearSpace(renderer);
+            bool convert_color = SDL_RenderingLinearSpace(renderer);
            SDL_FColor color = cmd->data.color.color;
            if (convert_color) {
                SDL_ConvertToLinear(&color);
--- a/src/render/direct3d12/SDL_render_d3d12.c
+++ b/src/render/direct3d12/SDL_render_d3d12.c
@@ -129,7 +129,7 @@ typedef struct
    const float *YCbCr_matrix;
 #if SDL_HAVE_YUV
    // YV12 texture support
-    SDL_bool yuv;
+    bool yuv;
    ID3D12Resource *mainTextureU;
    D3D12_CPU_DESCRIPTOR_HANDLE mainTextureResourceViewU;
    D3D12_RESOURCE_STATES mainResourceStateU;
@@ -140,7 +140,7 @@ typedef struct
    SIZE_T mainSRVIndexV;

    // NV12 texture support
-    SDL_bool nv12;
+    bool nv12;
    D3D12_CPU_DESCRIPTOR_HANDLE mainTextureResourceViewNV;
    SIZE_T mainSRVIndexNV;

@@ -198,7 +198,7 @@ typedef struct
    UINT syncInterval;
    UINT presentFlags;
    DXGI_FORMAT renderTargetFormat;
-    SDL_bool pixelSizeChanged;
+    bool pixelSizeChanged;

    // Descriptor heaps
    ID3D12DescriptorHeap *rtvDescriptorHeap;
@@ -245,15 +245,15 @@ typedef struct
    D3D12_CPU_DESCRIPTOR_HANDLE currentRenderTargetView;
    D3D12_CPU_DESCRIPTOR_HANDLE currentShaderResource;
    D3D12_CPU_DESCRIPTOR_HANDLE currentSampler;
-    SDL_bool cliprectDirty;
-    SDL_bool currentCliprectEnabled;
+    bool cliprectDirty;
+    bool currentCliprectEnabled;
    SDL_Rect currentCliprect;
    SDL_Rect currentViewport;
    int currentViewportRotation;
-    SDL_bool viewportDirty;
+    bool viewportDirty;
    Float4X4 identity;
    int currentVertexBuffer;
-    SDL_bool issueBatch;
+    bool issueBatch;
 } D3D12_RenderData;

 // Define D3D GUIDs here so we don't have to include uuid.lib.
@@ -529,9 +529,9 @@ static void D3D12_ResetCommandList(D3D12_RenderData *data)
    ID3D12GraphicsCommandList2_Reset(data->commandList, commandAllocator, NULL);
    data->currentPipelineState = NULL;
    data->currentVertexBuffer = 0;
-    data->issueBatch = SDL_FALSE;
-    data->cliprectDirty = SDL_TRUE;
-    data->viewportDirty = SDL_TRUE;
+    data->issueBatch = false;
+    data->cliprectDirty = true;
+    data->viewportDirty = true;
    data->currentRenderTargetView.ptr = 0;
    // FIXME should we also clear currentSampler.ptr and currentRenderTargetView.ptr ? (and use D3D12_InvalidateCachedState() instead)

@@ -774,7 +774,7 @@ static HRESULT D3D12_CreateDeviceResources(SDL_Renderer *renderer)
    HRESULT result = S_OK;
    UINT creationFlags = 0;
    int i;
-    SDL_bool createDebug;
+    bool createDebug;

    D3D12_COMMAND_QUEUE_DESC queueDesc;
    D3D12_DESCRIPTOR_HEAP_DESC descriptorHeapDesc;
@@ -782,7 +782,7 @@ static HRESULT D3D12_CreateDeviceResources(SDL_Renderer *renderer)
    ID3D12DescriptorHeap *rootDescriptorHeaps[2];

    // See if we need debug interfaces
-    createDebug = SDL_GetHintBoolean(SDL_HINT_RENDER_DIRECT3D11_DEBUG, SDL_FALSE);
+    createDebug = SDL_GetHintBoolean(SDL_HINT_RENDER_DIRECT3D11_DEBUG, false);

 #ifdef SDL_PLATFORM_GDK
    CreateEventExFunc = CreateEventExW;
@@ -1473,7 +1473,7 @@ static HRESULT D3D12_CreateWindowSizeDependentResources(SDL_Renderer *renderer)
                             D3D12_RESOURCE_STATE_PRESENT,
                             D3D12_RESOURCE_STATE_RENDER_TARGET);

-    data->viewportDirty = SDL_TRUE;
+    data->viewportDirty = true;

 #if defined(SDL_PLATFORM_XBOXONE) || defined(SDL_PLATFORM_XBOXSERIES)
    D3D12_XBOX_StartFrame(data->d3dDevice, &data->frameToken);
@@ -1497,11 +1497,11 @@ static void D3D12_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *eve
    D3D12_RenderData *data = (D3D12_RenderData *)renderer->internal;

    if (event->type == SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED) {
-        data->pixelSizeChanged = SDL_TRUE;
+        data->pixelSizeChanged = true;
    }
 }

-static SDL_bool D3D12_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
+static bool D3D12_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
 {
    SDL_BlendFactor srcColorFactor = SDL_GetBlendModeSrcColorFactor(blendMode);
    SDL_BlendFactor srcAlphaFactor = SDL_GetBlendModeSrcAlphaFactor(blendMode);
@@ -1514,9 +1514,9 @@ static SDL_bool D3D12_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode bl
        !GetBlendEquation(colorOperation) ||
        !GetBlendFunc(dstColorFactor) || !GetBlendFunc(dstAlphaFactor) ||
        !GetBlendEquation(alphaOperation)) {
-        return SDL_FALSE;
+        return false;
    }
-    return SDL_TRUE;
+    return true;
 }

 static SIZE_T D3D12_GetAvailableSRVIndex(SDL_Renderer *renderer)
@@ -1634,7 +1634,7 @@ static int D3D12_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL
 #if SDL_HAVE_YUV
    if (texture->format == SDL_PIXELFORMAT_YV12 ||
        texture->format == SDL_PIXELFORMAT_IYUV) {
-        textureData->yuv = SDL_TRUE;
+        textureData->yuv = true;

        textureDesc.Width = (textureDesc.Width + 1) / 2;
        textureDesc.Height = (textureDesc.Height + 1) / 2;
@@ -1688,7 +1688,7 @@ static int D3D12_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL
        texture->format == SDL_PIXELFORMAT_P010) {
        int bits_per_pixel;

-        textureData->nv12 = SDL_TRUE;
+        textureData->nv12 = true;

        switch (texture->format) {
        case SDL_PIXELFORMAT_P010:
@@ -2297,7 +2297,7 @@ static int D3D12_QueueDrawPoints(SDL_Renderer *renderer, SDL_RenderCommand *cmd,
    VertexPositionColor *verts = (VertexPositionColor *)SDL_AllocateRenderVertices(renderer, count * sizeof(VertexPositionColor), 0, &cmd->data.draw.first);
    int i;
    SDL_FColor color = cmd->data.draw.color;
-    SDL_bool convert_color = SDL_RenderingLinearSpace(renderer);
+    bool convert_color = SDL_RenderingLinearSpace(renderer);

    if (!verts) {
        return -1;
@@ -2329,7 +2329,7 @@ static int D3D12_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, S
    int i;
    int count = indices ? num_indices : num_vertices;
    VertexPositionColor *verts = (VertexPositionColor *)SDL_AllocateRenderVertices(renderer, count * sizeof(VertexPositionColor), 0, &cmd->data.draw.first);
-    SDL_bool convert_color = SDL_RenderingLinearSpace(renderer);
+    bool convert_color = SDL_RenderingLinearSpace(renderer);
    D3D12_TextureData *textureData = texture ? (D3D12_TextureData *)texture->internal : NULL;
    float u_scale = textureData ? (float)texture->w / textureData->w : 0.0f;
    float v_scale = textureData ? (float)texture->h / textureData->h : 0.0f;
@@ -2421,7 +2421,7 @@ static int D3D12_UpdateVertexBuffer(SDL_Renderer *renderer,
    rendererData->currentVertexBuffer++;
    if (rendererData->currentVertexBuffer >= SDL_D3D12_NUM_VERTEX_BUFFERS) {
        rendererData->currentVertexBuffer = 0;
-        rendererData->issueBatch = SDL_TRUE;
+        rendererData->issueBatch = true;
    }

    return S_OK;
@@ -2513,7 +2513,7 @@ static int D3D12_UpdateViewport(SDL_Renderer *renderer)
    // SDL_Log("%s: D3D viewport = {%f,%f,%f,%f}\n", __FUNCTION__, d3dviewport.TopLeftX, d3dviewport.TopLeftY, d3dviewport.Width, d3dviewport.Height);
    ID3D12GraphicsCommandList_RSSetViewports(data->commandList, 1, &d3dviewport);

-    data->viewportDirty = SDL_FALSE;
+    data->viewportDirty = false;

    return 0;
 }
@@ -2590,7 +2590,7 @@ static int D3D12_SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *c
    const Float4X4 *newmatrix = matrix ? matrix : &rendererData->identity;
    D3D12_CPU_DESCRIPTOR_HANDLE renderTargetView = D3D12_GetCurrentRenderTargetView(renderer);
    const SDL_BlendMode blendMode = cmd->data.draw.blend;
-    SDL_bool updateSubresource = SDL_FALSE;
+    bool updateSubresource = false;
    int i;
    D3D12_CPU_DESCRIPTOR_HANDLE firstShaderResource;
    DXGI_FORMAT rtvFormat = rendererData->renderTargetFormat;
@@ -2640,7 +2640,7 @@ static int D3D12_SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *c
        ID3D12GraphicsCommandList2_SetGraphicsRootSignature(rendererData->commandList,
                 rendererData->rootSignatures[D3D12_GetRootSignatureType(currentPipelineState->shader)]);
        // When we change these we will need to re-upload the constant buffer and reset any descriptors
-        updateSubresource = SDL_TRUE;
+        updateSubresource = true;
        rendererData->currentSampler.ptr = 0;
        rendererData->currentShaderResource.ptr = 0;
        rendererData->currentPipelineState = currentPipelineState;
@@ -2654,7 +2654,7 @@ static int D3D12_SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *c
    if (rendererData->viewportDirty) {
        if (D3D12_UpdateViewport(renderer) == 0) {
            // vertexShaderConstantsData.projectionAndView has changed
-            updateSubresource = SDL_TRUE;
+            updateSubresource = true;
        }
    }

@@ -2665,7 +2665,7 @@ static int D3D12_SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *c
            return -1;
        }
        ID3D12GraphicsCommandList2_RSSetScissorRects(rendererData->commandList, 1, &scissorRect);
-        rendererData->cliprectDirty = SDL_FALSE;
+        rendererData->cliprectDirty = false;
    }

    if (numShaderResources > 0) {
@@ -2702,7 +2702,7 @@ static int D3D12_SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *c
        rendererData->currentSampler = *sampler;
    }

-    if (updateSubresource == SDL_TRUE || SDL_memcmp(&rendererData->vertexShaderConstantsData.model, newmatrix, sizeof(*newmatrix)) != 0) {
+    if (updateSubresource == true || SDL_memcmp(&rendererData->vertexShaderConstantsData.model, newmatrix, sizeof(*newmatrix)) != 0) {
        SDL_memcpy(&rendererData->vertexShaderConstantsData.model, newmatrix, sizeof(*newmatrix));
        ID3D12GraphicsCommandList2_SetGraphicsRoot32BitConstants(rendererData->commandList,
                 0,
@@ -2716,7 +2716,7 @@ static int D3D12_SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *c
        shader_constants = &solid_constants;
    }

-    if (updateSubresource == SDL_TRUE ||
+    if (updateSubresource == true ||
        SDL_memcmp(shader_constants, &currentPipelineState->shader_constants, sizeof(*shader_constants)) != 0) {
        ID3D12GraphicsCommandList2_SetGraphicsRoot32BitConstants(rendererData->commandList,
                 1,
@@ -2816,8 +2816,8 @@ static void D3D12_InvalidateCachedState(SDL_Renderer *renderer)
    data->currentRenderTargetView.ptr = 0;
    data->currentShaderResource.ptr = 0;
    data->currentSampler.ptr = 0;
-    data->cliprectDirty = SDL_TRUE;
-    data->viewportDirty = SDL_TRUE;
+    data->cliprectDirty = true;
+    data->viewportDirty = true;
 }

 static int D3D12_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
@@ -2827,12 +2827,12 @@ static int D3D12_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd,

    if (rendererData->pixelSizeChanged) {
        D3D12_UpdateForWindowSizeChange(renderer);
-        rendererData->pixelSizeChanged = SDL_FALSE;
+        rendererData->pixelSizeChanged = false;
    }

    if (rendererData->currentViewportRotation != viewportRotation) {
        rendererData->currentViewportRotation = viewportRotation;
-        rendererData->viewportDirty = SDL_TRUE;
+        rendererData->viewportDirty = true;
    }

    if (D3D12_UpdateVertexBuffer(renderer, vertices, vertsize) < 0) {
@@ -2851,8 +2851,8 @@ static int D3D12_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd,
            SDL_Rect *viewport = &rendererData->currentViewport;
            if (SDL_memcmp(viewport, &cmd->data.viewport.rect, sizeof(cmd->data.viewport.rect)) != 0) {
                SDL_copyp(viewport, &cmd->data.viewport.rect);
-                rendererData->viewportDirty = SDL_TRUE;
-                rendererData->cliprectDirty = SDL_TRUE;
+                rendererData->viewportDirty = true;
+                rendererData->cliprectDirty = true;
            }
            break;
        }
@@ -2863,7 +2863,7 @@ static int D3D12_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd,
            SDL_Rect viewport_cliprect;
            if (rendererData->currentCliprectEnabled != cmd->data.cliprect.enabled) {
                rendererData->currentCliprectEnabled = cmd->data.cliprect.enabled;
-                rendererData->cliprectDirty = SDL_TRUE;
+                rendererData->cliprectDirty = true;
            }
            if (!rendererData->currentCliprectEnabled) {
                /* If the clip rect is disabled, then the scissor rect should be the whole viewport,
@@ -2876,7 +2876,7 @@ static int D3D12_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd,
            }
            if (SDL_memcmp(&rendererData->currentCliprect, rect, sizeof(*rect)) != 0) {
                SDL_copyp(&rendererData->currentCliprect, rect);
-                rendererData->cliprectDirty = SDL_TRUE;
+                rendererData->cliprectDirty = true;
            }
            break;
        }
@@ -2884,7 +2884,7 @@ static int D3D12_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd,
        case SDL_RENDERCMD_CLEAR:
        {
            D3D12_CPU_DESCRIPTOR_HANDLE rtvDescriptor = D3D12_GetCurrentRenderTargetView(renderer);
-            SDL_bool convert_color = SDL_RenderingLinearSpace(renderer);
+            bool convert_color = SDL_RenderingLinearSpace(renderer);
            SDL_FColor color = cmd->data.color.color;
            if (convert_color) {
                SDL_ConvertToLinear(&color);
--- a/src/render/direct3d12/SDL_render_d3d12_xbox.cpp
+++ b/src/render/direct3d12/SDL_render_d3d12_xbox.cpp
@@ -36,7 +36,7 @@ static const GUID SDL_IID_ID3D12Resource = { 0x696442be, 0xa72e, 0x4059, { 0xbc,
 static const GUID SDL_IID_IDXGIDevice1 = { 0x77db970f, 0x6276, 0x48ba, { 0xba, 0x28, 0x07, 0x01, 0x43, 0xb4, 0x39, 0x2c } };

 extern "C" HRESULT
-D3D12_XBOX_CreateDevice(ID3D12Device **device, SDL_bool createDebug)
+D3D12_XBOX_CreateDevice(ID3D12Device **device, bool createDebug)
 {
    HRESULT result;
    D3D12XBOX_CREATE_DEVICE_PARAMETERS params;
--- a/src/render/direct3d12/SDL_render_d3d12_xbox.h
+++ b/src/render/direct3d12/SDL_render_d3d12_xbox.h
@@ -30,7 +30,7 @@
 extern "C" {
 #endif

-extern HRESULT D3D12_XBOX_CreateDevice(ID3D12Device **device, SDL_bool createDebug);
+extern HRESULT D3D12_XBOX_CreateDevice(ID3D12Device **device, bool createDebug);
 extern HRESULT D3D12_XBOX_CreateBackBufferTarget(ID3D12Device1 *device, int width, int height, void **resource);
 extern HRESULT D3D12_XBOX_StartFrame(ID3D12Device1 *device, UINT64 *outToken);
 extern HRESULT D3D12_XBOX_PresentFrame(ID3D12CommandQueue *commandQueue, UINT64 token, ID3D12Resource *renderTarget);
--- a/src/render/metal/SDL_render_metal.m
+++ b/src/render/metal/SDL_render_metal.m
@@ -171,16 +171,16 @@ typedef struct METAL_ShaderPipelines
@implementation SDL3METAL_TextureData
@end

-static SDL_bool IsMetalAvailable()
+static bool IsMetalAvailable()
 {
 #if (defined(SDL_PLATFORM_MACOS) && (MAC_OS_X_VERSION_MIN_REQUIRED < 101100))
    // this checks a weak symbol.
    if (MTLCreateSystemDefaultDevice == NULL) { // probably on 10.10 or lower.
        SDL_SetError("Metal framework not available on this system");
-        return SDL_FALSE;
+        return false;
    }
 #endif
-    return SDL_TRUE;
+    return true;
 }

 static const MTLBlendOperation invalidBlendOperation = (MTLBlendOperation)0xFFFFFFFF;
@@ -446,7 +446,7 @@ static inline id<MTLRenderPipelineState> ChoosePipelineState(SDL3METAL_RenderDat
    return MakePipelineState(data, cache, [NSString stringWithFormat:@" (blend=custom 0x%x)", blendmode], blendmode);
 }

-static SDL_bool METAL_ActivateRenderCommandEncoder(SDL_Renderer *renderer, MTLLoadAction load, MTLClearColor *clear_color, id<MTLBuffer> vertex_buffer)
+static bool METAL_ActivateRenderCommandEncoder(SDL_Renderer *renderer, MTLLoadAction load, MTLClearColor *clear_color, id<MTLBuffer> vertex_buffer)
 {
    SDL3METAL_RenderData *data = (__bridge SDL3METAL_RenderData *)renderer->internal;

@@ -475,7 +475,7 @@ static SDL_bool METAL_ActivateRenderCommandEncoder(SDL_Renderer *renderer, MTLLo
        /* mtltexture can be nil here if macOS refused to give us a drawable,
           which apparently can happen for minimized windows, etc. */
        if (mtltexture == nil) {
-            return SDL_FALSE;
+            return false;
        }

        if (load == MTLLoadActionClear) {
@@ -510,7 +510,7 @@ static SDL_bool METAL_ActivateRenderCommandEncoder(SDL_Renderer *renderer, MTLLo
        [data.mtlcmdbuffer enqueue];
    }

-    return SDL_TRUE;
+    return true;
 }

 static void METAL_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *event)
@@ -531,7 +531,7 @@ static int METAL_GetOutputSize(SDL_Renderer *renderer, int *w, int *h)
    }
 }

-static SDL_bool METAL_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
+static bool METAL_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
 {
    SDL_BlendFactor srcColorFactor = SDL_GetBlendModeSrcColorFactor(blendMode);
    SDL_BlendFactor srcAlphaFactor = SDL_GetBlendModeSrcAlphaFactor(blendMode);
@@ -546,9 +546,9 @@ static SDL_bool METAL_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode bl
        GetBlendFactor(dstColorFactor) == invalidBlendFactor ||
        GetBlendFactor(dstAlphaFactor) == invalidBlendFactor ||
        GetBlendOperation(alphaOperation) == invalidBlendOperation) {
-        return SDL_FALSE;
+        return false;
    }
-    return SDL_TRUE;
+    return true;
 }

 size_t GetBT601ConversionMatrix(SDL_Colorspace colorspace)
@@ -1153,7 +1153,7 @@ static int METAL_QueueNoOp(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
 static int METAL_QueueDrawPoints(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
 {
    SDL_FColor color = cmd->data.draw.color;
-    SDL_bool convert_color = SDL_RenderingLinearSpace(renderer);
+    bool convert_color = SDL_RenderingLinearSpace(renderer);

    const size_t vertlen = (2 * sizeof(float) + 4 * sizeof(float)) * count;
    float *verts = (float *)SDL_AllocateRenderVertices(renderer, vertlen, DEVICE_ALIGN(8), &cmd->data.draw.first);
@@ -1180,7 +1180,7 @@ static int METAL_QueueDrawPoints(SDL_Renderer *renderer, SDL_RenderCommand *cmd,
 static int METAL_QueueDrawLines(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
 {
    SDL_FColor color = cmd->data.draw.color;
-    SDL_bool convert_color = SDL_RenderingLinearSpace(renderer);
+    bool convert_color = SDL_RenderingLinearSpace(renderer);
    size_t vertlen;
    float *verts;

@@ -1238,7 +1238,7 @@ static int METAL_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, S
                               int num_vertices, const void *indices, int num_indices, int size_indices,
                               float scale_x, float scale_y)
 {
-    SDL_bool convert_color = SDL_RenderingLinearSpace(renderer);
+    bool convert_color = SDL_RenderingLinearSpace(renderer);
    int count = indices ? num_indices : num_vertices;
    const size_t vertlen = (2 * sizeof(float) + 4 * sizeof(float) + (texture ? 2 : 0) * sizeof(float)) * count;
    float *verts = (float *)SDL_AllocateRenderVertices(renderer, vertlen, DEVICE_ALIGN(8), &cmd->data.draw.first);
@@ -1324,13 +1324,13 @@ typedef struct
    __unsafe_unretained id<MTLBuffer> vertex_buffer;
    size_t constants_offset;
    SDL_Texture *texture;
-    SDL_bool cliprect_dirty;
-    SDL_bool cliprect_enabled;
+    bool cliprect_dirty;
+    bool cliprect_enabled;
    SDL_Rect cliprect;
-    SDL_bool viewport_dirty;
+    bool viewport_dirty;
    SDL_Rect viewport;
    size_t projection_offset;
-    SDL_bool shader_constants_dirty;
+    bool shader_constants_dirty;
    PixelShaderConstants shader_constants;
 } METAL_DrawStateCache;

@@ -1390,7 +1390,7 @@ static void SetupShaderConstants(SDL_Renderer *renderer, const SDL_RenderCommand
    }
 }

-static SDL_bool SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const SDL_MetalFragmentFunction shader, PixelShaderConstants *shader_constants, const size_t constants_offset, id<MTLBuffer> mtlbufvertex, METAL_DrawStateCache *statecache)
+static bool SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const SDL_MetalFragmentFunction shader, PixelShaderConstants *shader_constants, const size_t constants_offset, id<MTLBuffer> mtlbufvertex, METAL_DrawStateCache *statecache)
 {
    SDL3METAL_RenderData *data = (__bridge SDL3METAL_RenderData *)renderer->internal;
    const SDL_BlendMode blend = cmd->data.draw.blend;
@@ -1399,7 +1399,7 @@ static SDL_bool SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *cm
    PixelShaderConstants solid_constants;

    if (!METAL_ActivateRenderCommandEncoder(renderer, MTLLoadActionLoad, NULL, statecache->vertex_buffer)) {
-        return SDL_FALSE;
+        return false;
    }

    if (statecache->viewport_dirty) {
@@ -1412,7 +1412,7 @@ static SDL_bool SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *cm
        viewport.zfar = 1.0;
        [data.mtlcmdencoder setViewport:viewport];
        [data.mtlcmdencoder setVertexBuffer:mtlbufvertex offset:statecache->projection_offset atIndex:2]; // projection
-        statecache->viewport_dirty = SDL_FALSE;
+        statecache->viewport_dirty = false;
    }

    if (statecache->cliprect_dirty) {
@@ -1445,7 +1445,7 @@ static SDL_bool SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *cm
            [data.mtlcmdencoder setScissorRect:mtlrect];
        }

-        statecache->cliprect_dirty = SDL_FALSE;
+        statecache->cliprect_dirty = false;
    }

    newpipeline = ChoosePipelineState(data, data.activepipelines, shader, blend);
@@ -1467,7 +1467,7 @@ static SDL_bool SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *cm
        [data.mtlcmdencoder setFragmentBuffer:mtlbufconstants offset:0 atIndex:0];

        SDL_memcpy(&statecache->shader_constants, shader_constants, sizeof(*shader_constants));
-        statecache->shader_constants_dirty = SDL_FALSE;
+        statecache->shader_constants_dirty = false;
    }

    if (constants_offset != statecache->constants_offset) {
@@ -1478,10 +1478,10 @@ static SDL_bool SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *cm
    }

    [data.mtlcmdencoder setVertexBufferOffset:first atIndex:0]; // position/texcoords
-    return SDL_TRUE;
+    return true;
 }

-static SDL_bool SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const size_t constants_offset,
+static bool SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const size_t constants_offset,
                             id<MTLBuffer> mtlbufvertex, METAL_DrawStateCache *statecache)
 {
    SDL3METAL_RenderData *data = (__bridge SDL3METAL_RenderData *)renderer->internal;
@@ -1492,7 +1492,7 @@ static SDL_bool SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cm
    SetupShaderConstants(renderer, cmd, texture, &constants);

    if (!SetDrawState(renderer, cmd, texturedata.fragmentFunction, &constants, constants_offset, mtlbufvertex, statecache)) {
-        return SDL_FALSE;
+        return false;
    }

    if (texture != statecache->texture) {
@@ -1532,7 +1532,7 @@ static SDL_bool SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cm
 #endif
        statecache->texture = texture;
    }
-    return SDL_TRUE;
+    return true;
 }

 static void METAL_InvalidateCachedState(SDL_Renderer *renderer)
@@ -1552,9 +1552,9 @@ static int METAL_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd,
        statecache.vertex_buffer = nil;
        statecache.constants_offset = CONSTANTS_OFFSET_INVALID;
        statecache.texture = NULL;
-        statecache.shader_constants_dirty = SDL_TRUE;
-        statecache.cliprect_dirty = SDL_TRUE;
-        statecache.viewport_dirty = SDL_TRUE;
+        statecache.shader_constants_dirty = true;
+        statecache.cliprect_dirty = true;
+        statecache.viewport_dirty = true;
        statecache.projection_offset = 0;

        // !!! FIXME: have a ring of pre-made MTLBuffers we cycle through? How expensive is creation?
@@ -1584,8 +1584,8 @@ static int METAL_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd,
            {
                SDL_memcpy(&statecache.viewport, &cmd->data.viewport.rect, sizeof(statecache.viewport));
                statecache.projection_offset = cmd->data.viewport.first;
-                statecache.viewport_dirty = SDL_TRUE;
-                statecache.cliprect_dirty = SDL_TRUE;
+                statecache.viewport_dirty = true;
+                statecache.cliprect_dirty = true;
                break;
            }

@@ -1593,7 +1593,7 @@ static int METAL_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd,
            {
                SDL_memcpy(&statecache.cliprect, &cmd->data.cliprect.rect, sizeof(statecache.cliprect));
                statecache.cliprect_enabled = cmd->data.cliprect.enabled;
-                statecache.cliprect_dirty = SDL_TRUE;
+                statecache.cliprect_dirty = true;
                break;
            }

@@ -1620,12 +1620,12 @@ static int METAL_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd,
                statecache.pipeline = nil;
                statecache.constants_offset = CONSTANTS_OFFSET_INVALID;
                statecache.texture = NULL;
-                statecache.shader_constants_dirty = SDL_TRUE;
-                statecache.cliprect_dirty = SDL_TRUE;
-                statecache.viewport_dirty = SDL_TRUE;
+                statecache.shader_constants_dirty = true;
+                statecache.cliprect_dirty = true;
+                statecache.viewport_dirty = true;

                {
-                    SDL_bool convert_color = SDL_RenderingLinearSpace(renderer);
+                    bool convert_color = SDL_RenderingLinearSpace(renderer);
                    SDL_FColor color = cmd->data.color.color;
                    if (convert_color) {
                        SDL_ConvertToLinear(&color);
@@ -1758,7 +1758,7 @@ static int METAL_RenderPresent(SDL_Renderer *renderer)
 {
    @autoreleasepool {
        SDL3METAL_RenderData *data = (__bridge SDL3METAL_RenderData *)renderer->internal;
-        SDL_bool ready = SDL_TRUE;
+        bool ready = true;

        // If we don't have a command buffer, we can't present, so activate to get one.
        if (data.mtlcmdencoder == nil) {
@@ -1919,7 +1919,7 @@ static int METAL_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_
        id<MTLBuffer> mtlbufconstantstaging, mtlbufquadindicesstaging, mtlbufconstants, mtlbufquadindices;
        id<MTLCommandBuffer> cmdbuffer;
        id<MTLBlitCommandEncoder> blitcmd;
-        SDL_bool scRGB_supported = SDL_FALSE;
+        bool scRGB_supported = false;

        // Note: matrices are column major.
        float identitytransform[16] = {
@@ -1970,7 +1970,7 @@ static int METAL_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_

 #ifndef SDL_PLATFORM_TVOS
        if (@available(macos 10.11, iOS 16.0, *)) {
-            scRGB_supported = SDL_TRUE;
+            scRGB_supported = true;
        }
 #endif
        if (renderer->output_colorspace != SDL_COLORSPACE_SRGB) {
@@ -1982,7 +1982,7 @@ static int METAL_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_
        }

 #ifdef SDL_PLATFORM_MACOS
-        if (SDL_GetHintBoolean(SDL_HINT_RENDER_METAL_PREFER_LOW_POWER_DEVICE, SDL_TRUE)) {
+        if (SDL_GetHintBoolean(SDL_HINT_RENDER_METAL_PREFER_LOW_POWER_DEVICE, true)) {
            NSArray<id<MTLDevice>> *devices = MTLCopyAllDevices();

            for (id<MTLDevice> device in devices) {
--- a/src/render/opengl/SDL_render_gl.c
+++ b/src/render/opengl/SDL_render_gl.c
@@ -60,7 +60,7 @@ struct GL_FBOList

 typedef struct
 {
-    SDL_bool viewport_dirty;
+    bool viewport_dirty;
    SDL_Rect viewport;
    SDL_Texture *texture;
    SDL_Texture *target;
@@ -69,18 +69,18 @@ typedef struct
    SDL_BlendMode blend;
    GL_Shader shader;
    const float *shader_params;
-    SDL_bool cliprect_enabled_dirty;
-    SDL_bool cliprect_enabled;
-    SDL_bool cliprect_dirty;
+    bool cliprect_enabled_dirty;
+    bool cliprect_enabled;
+    bool cliprect_dirty;
    SDL_Rect cliprect;
-    SDL_bool texturing;
-    SDL_bool texturing_dirty;
-    SDL_bool vertex_array;
-    SDL_bool color_array;
-    SDL_bool texture_array;
-    SDL_bool color_dirty;
+    bool texturing;
+    bool texturing_dirty;
+    bool vertex_array;
+    bool color_array;
+    bool texture_array;
+    bool color_dirty;
    SDL_FColor color;
-    SDL_bool clear_color_dirty;
+    bool clear_color_dirty;
    SDL_FColor clear_color;
 } GL_DrawStateCache;

@@ -88,8 +88,8 @@ typedef struct
 {
    SDL_GLContext context;

-    SDL_bool debug_enabled;
-    SDL_bool GL_ARB_debug_output_supported;
+    bool debug_enabled;
+    bool GL_ARB_debug_output_supported;
    int errors;
    char **error_messages;
    GLDEBUGPROCARB next_error_callback;
@@ -97,9 +97,9 @@ typedef struct

    GLenum textype;

-    SDL_bool GL_ARB_texture_non_power_of_two_supported;
-    SDL_bool GL_ARB_texture_rectangle_supported;
-    SDL_bool GL_EXT_framebuffer_object_supported;
+    bool GL_ARB_texture_non_power_of_two_supported;
+    bool GL_ARB_texture_rectangle_supported;
+    bool GL_EXT_framebuffer_object_supported;
    GL_FBOList *framebuffers;

    // OpenGL functions
@@ -108,7 +108,7 @@ typedef struct
 #undef SDL_PROC

    // Multitexture support
-    SDL_bool GL_ARB_multitexture_supported;
+    bool GL_ARB_multitexture_supported;
    PFNGLACTIVETEXTUREARBPROC glActiveTextureARB;
    GLint num_texture_units;

@@ -127,7 +127,7 @@ typedef struct
 typedef struct
 {
    GLuint texture;
-    SDL_bool texture_external;
+    bool texture_external;
    GLfloat texw;
    GLfloat texh;
    GLenum format;
@@ -140,12 +140,12 @@ typedef struct

 #if SDL_HAVE_YUV
    // YUV texture support
-    SDL_bool yuv;
-    SDL_bool nv12;
+    bool yuv;
+    bool nv12;
    GLuint utexture;
-    SDL_bool utexture_external;
+    bool utexture_external;
    GLuint vtexture;
-    SDL_bool vtexture_external;
+    bool vtexture_external;
 #endif

    GL_FBOList *fbo;
@@ -330,7 +330,7 @@ static void GL_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *event)
    if (event->type == SDL_EVENT_WINDOW_RESIZED ||
        event->type == SDL_EVENT_WINDOW_MOVED) {
        GL_RenderData *data = (GL_RenderData *)renderer->internal;
-        data->drawstate.viewport_dirty = SDL_TRUE;
+        data->drawstate.viewport_dirty = true;
    }
 }

@@ -380,7 +380,7 @@ static GLenum GetBlendEquation(SDL_BlendOperation operation)
    }
 }

-static SDL_bool GL_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
+static bool GL_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
 {
    SDL_BlendFactor srcColorFactor = SDL_GetBlendModeSrcColorFactor(blendMode);
    SDL_BlendFactor srcAlphaFactor = SDL_GetBlendModeSrcAlphaFactor(blendMode);
@@ -395,15 +395,15 @@ static SDL_bool GL_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blend
        GetBlendFunc(dstColorFactor) == GL_INVALID_ENUM ||
        GetBlendFunc(dstAlphaFactor) == GL_INVALID_ENUM ||
        GetBlendEquation(alphaOperation) == GL_INVALID_ENUM) {
-        return SDL_FALSE;
+        return false;
    }
    if (colorOperation != alphaOperation) {
-        return SDL_FALSE;
+        return false;
    }
-    return SDL_TRUE;
+    return true;
 }

-static SDL_bool convert_format(Uint32 pixel_format, GLint *internalFormat, GLenum *format, GLenum *type)
+static bool convert_format(Uint32 pixel_format, GLint *internalFormat, GLenum *format, GLenum *type)
 {
    switch (pixel_format) {
    case SDL_PIXELFORMAT_ARGB8888:
@@ -434,9 +434,9 @@ static SDL_bool convert_format(Uint32 pixel_format, GLint *internalFormat, GLenu
        break;
 #endif
    default:
-        return SDL_FALSE;
+        return false;
    }
-    return SDL_TRUE;
+    return true;
 }

 static int GL_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_PropertiesID create_props)
@@ -452,7 +452,7 @@ static int GL_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_Pr
    GL_ActivateRenderer(renderer);

    renderdata->drawstate.texture = NULL; // we trash this state.
-    renderdata->drawstate.texturing_dirty = SDL_TRUE; // we trash this state.
+    renderdata->drawstate.texturing_dirty = true; // we trash this state.

    if (texture->access == SDL_TEXTUREACCESS_TARGET &&
        !renderdata->GL_EXT_framebuffer_object_supported) {
@@ -498,7 +498,7 @@ static int GL_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_Pr

    data->texture = (GLuint)SDL_GetNumberProperty(create_props, SDL_PROP_TEXTURE_CREATE_OPENGL_TEXTURE_NUMBER, 0);
    if (data->texture) {
-        data->texture_external = SDL_TRUE;
+        data->texture_external = true;
    } else {
        GL_CheckError("", renderer);
        renderdata->glGenTextures(1, &data->texture);
@@ -580,17 +580,17 @@ static int GL_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_Pr
 #if SDL_HAVE_YUV
    if (texture->format == SDL_PIXELFORMAT_YV12 ||
        texture->format == SDL_PIXELFORMAT_IYUV) {
-        data->yuv = SDL_TRUE;
+        data->yuv = true;

        data->utexture = (GLuint)SDL_GetNumberProperty(create_props, SDL_PROP_TEXTURE_CREATE_OPENGL_TEXTURE_U_NUMBER, 0);
        if (data->utexture) {
-            data->utexture_external = SDL_TRUE;
+            data->utexture_external = true;
        } else {
            renderdata->glGenTextures(1, &data->utexture);
        }
        data->vtexture = (GLuint)SDL_GetNumberProperty(create_props, SDL_PROP_TEXTURE_CREATE_OPENGL_TEXTURE_V_NUMBER, 0);
        if (data->vtexture) {
-            data->vtexture_external = SDL_TRUE;
+            data->vtexture_external = true;
        } else {
            renderdata->glGenTextures(1, &data->vtexture);
        }
@@ -616,11 +616,11 @@ static int GL_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_Pr

    if (texture->format == SDL_PIXELFORMAT_NV12 ||
        texture->format == SDL_PIXELFORMAT_NV21) {
-        data->nv12 = SDL_TRUE;
+        data->nv12 = true;

        data->utexture = (GLuint)SDL_GetNumberProperty(create_props, SDL_PROP_TEXTURE_CREATE_OPENGL_TEXTURE_UV_NUMBER, 0);
        if (data->utexture) {
-            data->utexture_external = SDL_TRUE;
+            data->utexture_external = true;
        } else {
            renderdata->glGenTextures(1, &data->utexture);
        }
@@ -646,13 +646,13 @@ static int GL_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_Pr
        if (data->yuv) {
            data->shader = SHADER_YUV;
        } else if (texture->format == SDL_PIXELFORMAT_NV12) {
-            if (SDL_GetHintBoolean("SDL_RENDER_OPENGL_NV12_RG_SHADER", SDL_FALSE)) {
+            if (SDL_GetHintBoolean("SDL_RENDER_OPENGL_NV12_RG_SHADER", false)) {
                data->shader = SHADER_NV12_RG;
            } else {
                data->shader = SHADER_NV12_RA;
            }
        } else {
-            if (SDL_GetHintBoolean("SDL_RENDER_OPENGL_NV12_RG_SHADER", SDL_FALSE)) {
+            if (SDL_GetHintBoolean("SDL_RENDER_OPENGL_NV12_RG_SHADER", false)) {
                data->shader = SHADER_NV21_RG;
            } else {
                data->shader = SHADER_NV21_RA;
@@ -866,7 +866,7 @@ static int GL_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
        return SDL_SetError("Render targets not supported by OpenGL");
    }

-    data->drawstate.viewport_dirty = SDL_TRUE;
+    data->drawstate.viewport_dirty = true;

    if (!texture) {
        data->glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
@@ -1012,12 +1012,12 @@ static int GL_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_
 static int SetDrawState(GL_RenderData *data, const SDL_RenderCommand *cmd, const GL_Shader shader, const float *shader_params)
 {
    const SDL_BlendMode blend = cmd->data.draw.blend;
-    SDL_bool vertex_array;
-    SDL_bool color_array;
-    SDL_bool texture_array;
+    bool vertex_array;
+    bool color_array;
+    bool texture_array;

    if (data->drawstate.viewport_dirty) {
-        const SDL_bool istarget = data->drawstate.target != NULL;
+        const bool istarget = data->drawstate.target != NULL;
        const SDL_Rect *viewport = &data->drawstate.viewport;
        data->glMatrixMode(GL_PROJECTION);
        data->glLoadIdentity();
@@ -1031,7 +1031,7 @@ static int SetDrawState(GL_RenderData *data, const SDL_RenderCommand *cmd, const
                          0.0, 1.0);
        }
        data->glMatrixMode(GL_MODELVIEW);
-        data->drawstate.viewport_dirty = SDL_FALSE;
+        data->drawstate.viewport_dirty = false;
    }

    if (data->drawstate.cliprect_enabled_dirty) {
@@ -1040,7 +1040,7 @@ static int SetDrawState(GL_RenderData *data, const SDL_RenderCommand *cmd, const
        } else {
            data->glEnable(GL_SCISSOR_TEST);
        }
-        data->drawstate.cliprect_enabled_dirty = SDL_FALSE;
+        data->drawstate.cliprect_enabled_dirty = false;
    }

    if (data->drawstate.cliprect_enabled && data->drawstate.cliprect_dirty) {
@@ -1049,7 +1049,7 @@ static int SetDrawState(GL_RenderData *data, const SDL_RenderCommand *cmd, const
        data->glScissor(viewport->x + rect->x,
                        data->drawstate.target ? viewport->y + rect->y : data->drawstate.drawableh - viewport->y - rect->y - rect->h,
                        rect->w, rect->h);
-        data->drawstate.cliprect_dirty = SDL_FALSE;
+        data->drawstate.cliprect_dirty = false;
    }

    if (blend != data->drawstate.blend) {
@@ -1076,12 +1076,12 @@ static int SetDrawState(GL_RenderData *data, const SDL_RenderCommand *cmd, const
    if (data->drawstate.texturing_dirty || ((cmd->data.draw.texture != NULL) != data->drawstate.texturing)) {
        if (!cmd->data.draw.texture) {
            data->glDisable(data->textype);
-            data->drawstate.texturing = SDL_FALSE;
+            data->drawstate.texturing = false;
        } else {
            data->glEnable(data->textype);
-            data->drawstate.texturing = SDL_TRUE;
+            data->drawstate.texturing = true;
        }
-        data->drawstate.texturing_dirty = SDL_FALSE;
+        data->drawstate.texturing_dirty = false;
    }

    vertex_array = cmd->command == SDL_RENDERCMD_DRAW_POINTS || cmd->command == SDL_RENDERCMD_DRAW_LINES || cmd->command == SDL_RENDERCMD_GEOMETRY;
@@ -1195,20 +1195,20 @@ static int SetCopyState(GL_RenderData *data, const SDL_RenderCommand *cmd)
 static void GL_InvalidateCachedState(SDL_Renderer *renderer)
 {
    GL_DrawStateCache *cache = &((GL_RenderData *)renderer->internal)->drawstate;
-    cache->viewport_dirty = SDL_TRUE;
+    cache->viewport_dirty = true;
    cache->texture = NULL;
    cache->drawablew = 0;
    cache->drawableh = 0;
    cache->blend = SDL_BLENDMODE_INVALID;
    cache->shader = SHADER_INVALID;
-    cache->cliprect_enabled_dirty = SDL_TRUE;
-    cache->cliprect_dirty = SDL_TRUE;
-    cache->texturing_dirty = SDL_TRUE;
-    cache->vertex_array = SDL_FALSE;  // !!! FIXME: this resets to false at the end of GL_RunCommandQueue, but we could cache this more aggressively.
-    cache->color_array = SDL_FALSE;  // !!! FIXME: this resets to false at the end of GL_RunCommandQueue, but we could cache this more aggressively.
-    cache->texture_array = SDL_FALSE;  // !!! FIXME: this resets to false at the end of GL_RunCommandQueue, but we could cache this more aggressively.
-    cache->color_dirty = SDL_TRUE;
-    cache->clear_color_dirty = SDL_TRUE;
+    cache->cliprect_enabled_dirty = true;
+    cache->cliprect_dirty = true;
+    cache->texturing_dirty = true;
+    cache->vertex_array = false;  // !!! FIXME: this resets to false at the end of GL_RunCommandQueue, but we could cache this more aggressively.
+    cache->color_array = false;  // !!! FIXME: this resets to false at the end of GL_RunCommandQueue, but we could cache this more aggressively.
+    cache->texture_array = false;  // !!! FIXME: this resets to false at the end of GL_RunCommandQueue, but we could cache this more aggressively.
+    cache->color_dirty = true;
+    cache->clear_color_dirty = true;
 }

 static int GL_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
@@ -1225,8 +1225,8 @@ static int GL_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, vo
        int w, h;
        SDL_GetWindowSizeInPixels(renderer->window, &w, &h);
        if ((w != data->drawstate.drawablew) || (h != data->drawstate.drawableh)) {
-            data->drawstate.viewport_dirty = SDL_TRUE; // if the window dimensions changed, invalidate the current viewport, etc.
-            data->drawstate.cliprect_dirty = SDL_TRUE;
+            data->drawstate.viewport_dirty = true; // if the window dimensions changed, invalidate the current viewport, etc.
+            data->drawstate.cliprect_dirty = true;
            data->drawstate.drawablew = w;
            data->drawstate.drawableh = h;
        }
@@ -1236,7 +1236,7 @@ static int GL_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, vo
    // On macOS on older systems, the OpenGL view change and resize events aren't
    // necessarily synchronized, so just always reset it.
    // Workaround for: https://discourse.libsdl.org/t/sdl-2-0-22-prerelease/35306/6
-    data->drawstate.viewport_dirty = SDL_TRUE;
+    data->drawstate.viewport_dirty = true;
 #endif

    while (cmd) {
@@ -1257,7 +1257,7 @@ static int GL_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, vo
                data->drawstate.color.g = g;
                data->drawstate.color.b = b;
                data->drawstate.color.a = a;
-                data->drawstate.color_dirty = SDL_FALSE;
+                data->drawstate.color_dirty = false;
            }
            break;
        }
@@ -1267,8 +1267,8 @@ static int GL_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, vo
            SDL_Rect *viewport = &data->drawstate.viewport;
            if (SDL_memcmp(viewport, &cmd->data.viewport.rect, sizeof(cmd->data.viewport.rect)) != 0) {
                SDL_copyp(viewport, &cmd->data.viewport.rect);
-                data->drawstate.viewport_dirty = SDL_TRUE;
-                data->drawstate.cliprect_dirty = SDL_TRUE;
+                data->drawstate.viewport_dirty = true;
+                data->drawstate.cliprect_dirty = true;
            }
            break;
        }
@@ -1278,12 +1278,12 @@ static int GL_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, vo
            const SDL_Rect *rect = &cmd->data.cliprect.rect;
            if (data->drawstate.cliprect_enabled != cmd->data.cliprect.enabled) {
                data->drawstate.cliprect_enabled = cmd->data.cliprect.enabled;
-                data->drawstate.cliprect_enabled_dirty = SDL_TRUE;
+                data->drawstate.cliprect_enabled_dirty = true;
            }

            if (SDL_memcmp(&data->drawstate.cliprect, rect, sizeof(*rect)) != 0) {
                SDL_copyp(&data->drawstate.cliprect, rect);
-                data->drawstate.cliprect_dirty = SDL_TRUE;
+                data->drawstate.cliprect_dirty = true;
            }
            break;
        }
@@ -1304,7 +1304,7 @@ static int GL_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, vo
                data->drawstate.clear_color.g = g;
                data->drawstate.clear_color.b = b;
                data->drawstate.clear_color.a = a;
-                data->drawstate.clear_color_dirty = SDL_FALSE;
+                data->drawstate.clear_color_dirty = false;
            }

            if (data->drawstate.cliprect_enabled || data->drawstate.cliprect_enabled_dirty) {
@@ -1445,15 +1445,15 @@ static int GL_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, vo
       relies on it being off. */
    if (data->drawstate.vertex_array) {
        data->glDisableClientState(GL_VERTEX_ARRAY);
-        data->drawstate.vertex_array = SDL_FALSE;
+        data->drawstate.vertex_array = false;
    }
    if (data->drawstate.color_array) {
        data->glDisableClientState(GL_COLOR_ARRAY);
-        data->drawstate.color_array = SDL_FALSE;
+        data->drawstate.color_array = false;
    }
    if (data->drawstate.texture_array) {
        data->glDisableClientState(GL_TEXTURE_COORD_ARRAY);
-        data->drawstate.texture_array = SDL_FALSE;
+        data->drawstate.texture_array = false;
    }

    return GL_CheckError("", renderer);
@@ -1495,7 +1495,7 @@ static SDL_Surface *GL_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *

    // Flip the rows to be top-down if necessary
    if (!renderer->target) {
-        SDL_bool isstack;
+        bool isstack;
        int length = rect->w * SDL_BYTESPERPIXEL(format);
        Uint8 *src = (Uint8 *)surface->pixels + (rect->h - 1) * surface->pitch;
        Uint8 *dst = (Uint8 *)surface->pixels;
@@ -1622,9 +1622,9 @@ static int GL_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Pro
    GLint value;
    SDL_WindowFlags window_flags;
    int profile_mask = 0, major = 0, minor = 0;
-    SDL_bool changed_window = SDL_FALSE;
+    bool changed_window = false;
    const char *hint;
-    SDL_bool non_power_of_two_supported = SDL_FALSE;
+    bool non_power_of_two_supported = false;

    SDL_GL_GetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, &profile_mask);
    SDL_GL_GetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, &major);
@@ -1636,7 +1636,7 @@ static int GL_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Pro
    if (!(window_flags & SDL_WINDOW_OPENGL) ||
        profile_mask == SDL_GL_CONTEXT_PROFILE_ES || major != RENDERER_CONTEXT_MAJOR || minor != RENDERER_CONTEXT_MINOR) {

-        changed_window = SDL_TRUE;
+        changed_window = true;
        SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, 0);
        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, RENDERER_CONTEXT_MAJOR);
        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, RENDERER_CONTEXT_MINOR);
@@ -1715,12 +1715,12 @@ static int GL_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Pro
    // Check for debug output support
    if (SDL_GL_GetAttribute(SDL_GL_CONTEXT_FLAGS, &value) == 0 &&
        (value & SDL_GL_CONTEXT_DEBUG_FLAG)) {
-        data->debug_enabled = SDL_TRUE;
+        data->debug_enabled = true;
    }
    if (data->debug_enabled && SDL_GL_ExtensionSupported("GL_ARB_debug_output")) {
        PFNGLDEBUGMESSAGECALLBACKARBPROC glDebugMessageCallbackARBFunc = (PFNGLDEBUGMESSAGECALLBACKARBPROC)SDL_GL_GetProcAddress("glDebugMessageCallbackARB");

-        data->GL_ARB_debug_output_supported = SDL_TRUE;
+        data->GL_ARB_debug_output_supported = true;
        data->glGetPointerv(GL_DEBUG_CALLBACK_FUNCTION_ARB, (GLvoid **)(char *)&data->next_error_callback);
        data->glGetPointerv(GL_DEBUG_CALLBACK_USER_PARAM_ARB, &data->next_error_userparam);
        glDebugMessageCallbackARBFunc(GL_HandleDebugMessage, renderer);
@@ -1731,7 +1731,7 @@ static int GL_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Pro

    hint = SDL_GetHint("GL_ARB_texture_non_power_of_two");
    if (!hint || *hint != '0') {
-        SDL_bool isGL2 = SDL_FALSE;
+        bool isGL2 = false;
        const char *verstr = (const char *)data->glGetString(GL_VERSION);
        if (verstr) {
            char verbuf[16];
@@ -1741,23 +1741,23 @@ static int GL_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Pro
            if (ptr) {
                *ptr = '\0';
                if (SDL_atoi(verbuf) >= 2) {
-                    isGL2 = SDL_TRUE;
+                    isGL2 = true;
                }
            }
        }
        if (isGL2 || SDL_GL_ExtensionSupported("GL_ARB_texture_non_power_of_two")) {
-            non_power_of_two_supported = SDL_TRUE;
+            non_power_of_two_supported = true;
        }
    }

    data->textype = GL_TEXTURE_2D;
    if (non_power_of_two_supported) {
-        data->GL_ARB_texture_non_power_of_two_supported = SDL_TRUE;
+        data->GL_ARB_texture_non_power_of_two_supported = true;
        data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
        SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, value);
    } else if (SDL_GL_ExtensionSupported("GL_ARB_texture_rectangle") ||
               SDL_GL_ExtensionSupported("GL_EXT_texture_rectangle")) {
-        data->GL_ARB_texture_rectangle_supported = SDL_TRUE;
+        data->GL_ARB_texture_rectangle_supported = true;
        data->textype = GL_TEXTURE_RECTANGLE_ARB;
        data->glGetIntegerv(GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB, &value);
        SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, value);
@@ -1770,7 +1770,7 @@ static int GL_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Pro
    if (SDL_GL_ExtensionSupported("GL_ARB_multitexture")) {
        data->glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)SDL_GL_GetProcAddress("glActiveTextureARB");
        if (data->glActiveTextureARB) {
-            data->GL_ARB_multitexture_supported = SDL_TRUE;
+            data->GL_ARB_multitexture_supported = true;
            data->glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &data->num_texture_units);
        }
    }
@@ -1804,7 +1804,7 @@ static int GL_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Pro
    renderer->rect_index_order[5] = 2;

    if (SDL_GL_ExtensionSupported("GL_EXT_framebuffer_object")) {
-        data->GL_EXT_framebuffer_object_supported = SDL_TRUE;
+        data->GL_EXT_framebuffer_object_supported = true;
        data->glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC)
            SDL_GL_GetProcAddress("glGenFramebuffersEXT");
        data->glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC)
--- a/src/render/opengl/SDL_shaders_gl.c
+++ b/src/render/opengl/SDL_shaders_gl.c
@@ -55,7 +55,7 @@ struct GL_ShaderContext
    PFNGLUNIFORM3FARBPROC glUniform3fARB;
    PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObjectARB;

-    SDL_bool GL_ARB_texture_rectangle_supported;
+    bool GL_ARB_texture_rectangle_supported;

    GL_ShaderData shaders[NUM_SHADERS];
    const float *shader_params[NUM_SHADERS];
@@ -330,7 +330,7 @@ static const char *shader_source[NUM_SHADERS][2] = {

 /* *INDENT-ON* */ // clang-format on

-static SDL_bool CompileShader(GL_ShaderContext *ctx, GLhandleARB shader, const char *defines, const char *source)
+static bool CompileShader(GL_ShaderContext *ctx, GLhandleARB shader, const char *defines, const char *source)
 {
    GLint status;
    const char *sources[2];
@@ -342,7 +342,7 @@ static SDL_bool CompileShader(GL_ShaderContext *ctx, GLhandleARB shader, const c
    ctx->glCompileShaderARB(shader);
    ctx->glGetObjectParameterivARB(shader, GL_OBJECT_COMPILE_STATUS_ARB, &status);
    if (status == 0) {
-        SDL_bool isstack;
+        bool isstack;
        GLint length;
        char *info;

@@ -357,13 +357,13 @@ static SDL_bool CompileShader(GL_ShaderContext *ctx, GLhandleARB shader, const c
 #endif
        SDL_small_free(info, isstack);

-        return SDL_FALSE;
+        return false;
    } else {
-        return SDL_TRUE;
+        return true;
    }
 }

-static SDL_bool CompileShaderProgram(GL_ShaderContext *ctx, int index, GL_ShaderData *data)
+static bool CompileShaderProgram(GL_ShaderContext *ctx, int index, GL_ShaderData *data)
 {
    const int num_tmus_bound = 4;
    const char *vert_defines = "";
@@ -372,7 +372,7 @@ static SDL_bool CompileShaderProgram(GL_ShaderContext *ctx, int index, GL_Shader
    GLint location;

    if (index == SHADER_NONE) {
-        return SDL_TRUE;
+        return true;
    }

    ctx->glGetError();
@@ -394,13 +394,13 @@ static SDL_bool CompileShaderProgram(GL_ShaderContext *ctx, int index, GL_Shader
    // Create the vertex shader
    data->vert_shader = ctx->glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
    if (!CompileShader(ctx, data->vert_shader, vert_defines, shader_source[index][0])) {
-        return SDL_FALSE;
+        return false;
    }

    // Create the fragment shader
    data->frag_shader = ctx->glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
    if (!CompileShader(ctx, data->frag_shader, frag_defines, shader_source[index][1])) {
-        return SDL_FALSE;
+        return false;
    }

    // ... and in the darkness bind them
@@ -433,7 +433,7 @@ static void DestroyShaderProgram(GL_ShaderContext *ctx, GL_ShaderData *data)
 GL_ShaderContext *GL_CreateShaderContext(void)
 {
    GL_ShaderContext *ctx;
-    SDL_bool shaders_supported;
+    bool shaders_supported;
    int i;

    ctx = (GL_ShaderContext *)SDL_calloc(1, sizeof(*ctx));
@@ -444,11 +444,11 @@ GL_ShaderContext *GL_CreateShaderContext(void)
    if (!SDL_GL_ExtensionSupported("GL_ARB_texture_non_power_of_two") &&
        (SDL_GL_ExtensionSupported("GL_ARB_texture_rectangle") ||
         SDL_GL_ExtensionSupported("GL_EXT_texture_rectangle"))) {
-        ctx->GL_ARB_texture_rectangle_supported = SDL_TRUE;
+        ctx->GL_ARB_texture_rectangle_supported = true;
    }

    // Check for shader support
-    shaders_supported = SDL_FALSE;
+    shaders_supported = false;
    if (SDL_GL_ExtensionSupported("GL_ARB_shader_objects") &&
        SDL_GL_ExtensionSupported("GL_ARB_shading_language_100") &&
        SDL_GL_ExtensionSupported("GL_ARB_vertex_shader") &&
@@ -483,7 +483,7 @@ GL_ShaderContext *GL_CreateShaderContext(void)
            ctx->glUniform1fARB &&
            ctx->glUniform3fARB &&
            ctx->glUseProgramObjectARB) {
-            shaders_supported = SDL_TRUE;
+            shaders_supported = true;
        }
    }

--- a/src/render/opengles2/SDL_render_gles2.c
+++ b/src/render/opengles2/SDL_render_gles2.c
@@ -62,7 +62,7 @@ struct GLES2_FBOList
 typedef struct GLES2_TextureData
 {
    GLuint texture;
-    SDL_bool texture_external;
+    bool texture_external;
    GLenum texture_type;
    GLenum pixel_format;
    GLenum pixel_type;
@@ -70,8 +70,8 @@ typedef struct GLES2_TextureData
    int pitch;
 #if SDL_HAVE_YUV
    // YUV texture support
-    SDL_bool yuv;
-    SDL_bool nv12;
+    bool yuv;
+    bool nv12;
    GLuint texture_v;
    GLuint texture_v_external;
    GLuint texture_u;
@@ -144,18 +144,18 @@ typedef enum
 typedef struct
 {
    SDL_Rect viewport;
-    SDL_bool viewport_dirty;
+    bool viewport_dirty;
    SDL_Texture *texture;
    SDL_Texture *target;
    SDL_BlendMode blend;
-    SDL_bool cliprect_enabled_dirty;
-    SDL_bool cliprect_enabled;
-    SDL_bool cliprect_dirty;
+    bool cliprect_enabled_dirty;
+    bool cliprect_enabled;
+    bool cliprect_dirty;
    SDL_Rect cliprect;
-    SDL_bool texturing;
-    SDL_bool texturing_dirty;
+    bool texturing;
+    bool texturing_dirty;
    SDL_FColor clear_color;
-    SDL_bool clear_color_dirty;
+    bool clear_color_dirty;
    int drawablew;
    int drawableh;
    GLES2_ProgramCacheEntry *program;
@@ -167,9 +167,9 @@ typedef struct GLES2_RenderData
 {
    SDL_GLContext context;

-    SDL_bool debug_enabled;
+    bool debug_enabled;

-    SDL_bool GL_EXT_blend_minmax_supported;
+    bool GL_EXT_blend_minmax_supported;

 #define SDL_PROC(ret, func, params) ret (APIENTRY *func) params;
 #include "SDL_gles2funcs.h"
@@ -373,7 +373,7 @@ static GLenum GetBlendEquation(SDL_BlendOperation operation)
    }
 }

-static SDL_bool GLES2_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
+static bool GLES2_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
 {
    GLES2_RenderData *data = (GLES2_RenderData *)renderer->internal;

@@ -390,17 +390,17 @@ static SDL_bool GLES2_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode bl
        GetBlendFunc(dstColorFactor) == GL_INVALID_ENUM ||
        GetBlendFunc(dstAlphaFactor) == GL_INVALID_ENUM ||
        GetBlendEquation(alphaOperation) == GL_INVALID_ENUM) {
-        return SDL_FALSE;
+        return false;
    }

    if (colorOperation == SDL_BLENDOPERATION_MINIMUM && !data->GL_EXT_blend_minmax_supported) {
-        return SDL_FALSE;
+        return false;
    }
    if (colorOperation == SDL_BLENDOPERATION_MAXIMUM && !data->GL_EXT_blend_minmax_supported) {
-        return SDL_FALSE;
+        return false;
    }

-    return SDL_TRUE;
+    return true;
 }

 static GLES2_ProgramCacheEntry *GLES2_CacheProgram(GLES2_RenderData *data, GLuint vertex, GLuint fragment)
@@ -636,7 +636,7 @@ static int GLES2_SelectProgram(GLES2_RenderData *data, GLES2_ImageSource source,
        }
        break;
    case GLES2_IMAGESOURCE_TEXTURE_NV12:
-        if (SDL_GetHintBoolean("SDL_RENDER_OPENGL_NV12_RG_SHADER", SDL_FALSE)) {
+        if (SDL_GetHintBoolean("SDL_RENDER_OPENGL_NV12_RG_SHADER", false)) {
            ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV12_RG;
        } else {
            ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV12_RA;
@@ -648,7 +648,7 @@ static int GLES2_SelectProgram(GLES2_RenderData *data, GLES2_ImageSource source,
        }
        break;
    case GLES2_IMAGESOURCE_TEXTURE_NV21:
-        if (SDL_GetHintBoolean("SDL_RENDER_OPENGL_NV12_RG_SHADER", SDL_FALSE)) {
+        if (SDL_GetHintBoolean("SDL_RENDER_OPENGL_NV12_RG_SHADER", false)) {
            ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV21_RG;
        } else {
            ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV21_RA;
@@ -740,7 +740,7 @@ static int GLES2_QueueNoOp(SDL_Renderer *renderer, SDL_RenderCommand *cmd)

 static int GLES2_QueueDrawPoints(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
 {
-    const SDL_bool colorswap = (renderer->target && (renderer->target->format == SDL_PIXELFORMAT_BGRA32 || renderer->target->format == SDL_PIXELFORMAT_BGRX32));
+    const bool colorswap = (renderer->target && (renderer->target->format == SDL_PIXELFORMAT_BGRA32 || renderer->target->format == SDL_PIXELFORMAT_BGRX32));
    SDL_VertexSolid *verts = (SDL_VertexSolid *)SDL_AllocateRenderVertices(renderer, count * sizeof(*verts), 0, &cmd->data.draw.first);
    int i;
    SDL_FColor color = cmd->data.draw.color;
@@ -773,7 +773,7 @@ static int GLES2_QueueDrawPoints(SDL_Renderer *renderer, SDL_RenderCommand *cmd,

 static int GLES2_QueueDrawLines(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
 {
-    const SDL_bool colorswap = (renderer->target && (renderer->target->format == SDL_PIXELFORMAT_BGRA32 || renderer->target->format == SDL_PIXELFORMAT_BGRX32));
+    const bool colorswap = (renderer->target && (renderer->target->format == SDL_PIXELFORMAT_BGRA32 || renderer->target->format == SDL_PIXELFORMAT_BGRX32));
    int i;
    GLfloat prevx, prevy;
    SDL_VertexSolid *verts = (SDL_VertexSolid *)SDL_AllocateRenderVertices(renderer, count * sizeof(*verts), 0, &cmd->data.draw.first);
@@ -834,7 +834,7 @@ static int GLES2_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, S
                               float scale_x, float scale_y)
 {
    int i;
-    const SDL_bool colorswap = (renderer->target && (renderer->target->format == SDL_PIXELFORMAT_BGRA32 || renderer->target->format == SDL_PIXELFORMAT_BGRX32));
+    const bool colorswap = (renderer->target && (renderer->target->format == SDL_PIXELFORMAT_BGRA32 || renderer->target->format == SDL_PIXELFORMAT_BGRX32));
    int count = indices ? num_indices : num_vertices;
    const float color_scale = cmd->data.draw.color_scale;

@@ -949,7 +949,7 @@ static int SetDrawState(GLES2_RenderData *data, const SDL_RenderCommand *cmd, co
            data->drawstate.projection[1][1] = (data->drawstate.target ? 2.0f : -2.0f) / viewport->h;
            data->drawstate.projection[3][1] = data->drawstate.target ? -1.0f : 1.0f;
        }
-        data->drawstate.viewport_dirty = SDL_FALSE;
+        data->drawstate.viewport_dirty = false;
    }

    if (data->drawstate.cliprect_enabled_dirty) {
@@ -958,7 +958,7 @@ static int SetDrawState(GLES2_RenderData *data, const SDL_RenderCommand *cmd, co
        } else {
            data->glEnable(GL_SCISSOR_TEST);
        }
-        data->drawstate.cliprect_enabled_dirty = SDL_FALSE;
+        data->drawstate.cliprect_enabled_dirty = false;
    }

    if (data->drawstate.cliprect_enabled && data->drawstate.cliprect_dirty) {
@@ -967,18 +967,18 @@ static int SetDrawState(GLES2_RenderData *data, const SDL_RenderCommand *cmd, co
        data->glScissor(viewport->x + rect->x,
                        data->drawstate.target ? viewport->y + rect->y : data->drawstate.drawableh - viewport->y - rect->y - rect->h,
                        rect->w, rect->h);
-        data->drawstate.cliprect_dirty = SDL_FALSE;
+        data->drawstate.cliprect_dirty = false;
    }

    if (data->drawstate.texturing_dirty || ((texture != NULL) != data->drawstate.texturing)) {
        if (!texture) {
            data->glDisableVertexAttribArray((GLenum)GLES2_ATTRIBUTE_TEXCOORD);
-            data->drawstate.texturing = SDL_FALSE;
+            data->drawstate.texturing = false;
        } else {
            data->glEnableVertexAttribArray((GLenum)GLES2_ATTRIBUTE_TEXCOORD);
-            data->drawstate.texturing = SDL_TRUE;
+            data->drawstate.texturing = true;
        }
-        data->drawstate.texturing_dirty = SDL_FALSE;
+        data->drawstate.texturing_dirty = false;
    }

    if (texture) {
@@ -1217,13 +1217,13 @@ static int SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, vo
 static void GLES2_InvalidateCachedState(SDL_Renderer *renderer)
 {
    GLES2_DrawStateCache *cache = &((GLES2_RenderData *)renderer->internal)->drawstate;
-    cache->viewport_dirty = SDL_TRUE;
+    cache->viewport_dirty = true;
    cache->texture = NULL;
    cache->blend = SDL_BLENDMODE_INVALID;
-    cache->cliprect_enabled_dirty = SDL_TRUE;
-    cache->cliprect_dirty = SDL_TRUE;
-    cache->texturing_dirty = SDL_TRUE;
-    cache->clear_color_dirty = SDL_TRUE;
+    cache->cliprect_enabled_dirty = true;
+    cache->cliprect_dirty = true;
+    cache->texturing_dirty = true;
+    cache->clear_color_dirty = true;
    cache->drawablew = 0;
    cache->drawableh = 0;
    cache->program = NULL;
@@ -1232,7 +1232,7 @@ static void GLES2_InvalidateCachedState(SDL_Renderer *renderer)
 static int GLES2_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
 {
    GLES2_RenderData *data = (GLES2_RenderData *)renderer->internal;
-    const SDL_bool colorswap = (renderer->target && (renderer->target->format == SDL_PIXELFORMAT_BGRA32 || renderer->target->format == SDL_PIXELFORMAT_BGRX32));
+    const bool colorswap = (renderer->target && (renderer->target->format == SDL_PIXELFORMAT_BGRA32 || renderer->target->format == SDL_PIXELFORMAT_BGRX32));

 #if USE_VERTEX_BUFFER_OBJECTS
    const int vboidx = data->current_vertex_buffer;
@@ -1248,8 +1248,8 @@ static int GLES2_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd,
        int w, h;
        SDL_GetWindowSizeInPixels(renderer->window, &w, &h);
        if ((w != data->drawstate.drawablew) || (h != data->drawstate.drawableh)) {
-            data->drawstate.viewport_dirty = SDL_TRUE; // if the window dimensions changed, invalidate the current viewport, etc.
-            data->drawstate.cliprect_dirty = SDL_TRUE;
+            data->drawstate.viewport_dirty = true; // if the window dimensions changed, invalidate the current viewport, etc.
+            data->drawstate.cliprect_dirty = true;
            data->drawstate.drawablew = w;
            data->drawstate.drawableh = h;
        }
@@ -1285,8 +1285,8 @@ static int GLES2_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd,
            SDL_Rect *viewport = &data->drawstate.viewport;
            if (SDL_memcmp(viewport, &cmd->data.viewport.rect, sizeof(cmd->data.viewport.rect)) != 0) {
                SDL_copyp(viewport, &cmd->data.viewport.rect);
-                data->drawstate.viewport_dirty = SDL_TRUE;
-                data->drawstate.cliprect_dirty = SDL_TRUE;
+                data->drawstate.viewport_dirty = true;
+                data->drawstate.cliprect_dirty = true;
            }
            break;
        }
@@ -1296,12 +1296,12 @@ static int GLES2_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd,
            const SDL_Rect *rect = &cmd->data.cliprect.rect;
            if (data->drawstate.cliprect_enabled != cmd->data.cliprect.enabled) {
                data->drawstate.cliprect_enabled = cmd->data.cliprect.enabled;
-                data->drawstate.cliprect_enabled_dirty = SDL_TRUE;
+                data->drawstate.cliprect_enabled_dirty = true;
            }

            if (SDL_memcmp(&data->drawstate.cliprect, rect, sizeof(*rect)) != 0) {
                SDL_copyp(&data->drawstate.cliprect, rect);
-                data->drawstate.cliprect_dirty = SDL_TRUE;
+                data->drawstate.cliprect_dirty = true;
            }
            break;
        }
@@ -1322,7 +1322,7 @@ static int GLES2_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd,
                data->drawstate.clear_color.g = g;
                data->drawstate.clear_color.b = b;
                data->drawstate.clear_color.a = a;
-                data->drawstate.clear_color_dirty = SDL_FALSE;
+                data->drawstate.clear_color_dirty = false;
            }

            if (data->drawstate.cliprect_enabled || data->drawstate.cliprect_enabled_dirty) {
@@ -1575,7 +1575,7 @@ static int GLES2_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL
    if (data->yuv) {
        data->texture_v = (GLuint)SDL_GetNumberProperty(create_props, SDL_PROP_TEXTURE_CREATE_OPENGLES2_TEXTURE_V_NUMBER, 0);
        if (data->texture_v) {
-            data->texture_v_external = SDL_TRUE;
+            data->texture_v_external = true;
        } else {
            renderdata->glGenTextures(1, &data->texture_v);
            if (GL_CheckError("glGenTexures()", renderer) < 0) {
@@ -1591,7 +1591,7 @@ static int GLES2_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL

        data->texture_u = (GLuint)SDL_GetNumberProperty(create_props, SDL_PROP_TEXTURE_CREATE_OPENGLES2_TEXTURE_U_NUMBER, 0);
        if (data->texture_u) {
-            data->texture_u_external = SDL_TRUE;
+            data->texture_u_external = true;
        } else {
            renderdata->glGenTextures(1, &data->texture_u);
            if (GL_CheckError("glGenTexures()", renderer) < 0) {
@@ -1614,7 +1614,7 @@ static int GLES2_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL
    } else if (data->nv12) {
        data->texture_u = (GLuint)SDL_GetNumberProperty(create_props, SDL_PROP_TEXTURE_CREATE_OPENGLES2_TEXTURE_UV_NUMBER, 0);
        if (data->texture_u) {
-            data->texture_u_external = SDL_TRUE;
+            data->texture_u_external = true;
        } else {
            renderdata->glGenTextures(1, &data->texture_u);
            if (GL_CheckError("glGenTexures()", renderer) < 0) {
@@ -1639,7 +1639,7 @@ static int GLES2_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL

    data->texture = (GLuint)SDL_GetNumberProperty(create_props, SDL_PROP_TEXTURE_CREATE_OPENGLES2_TEXTURE_NUMBER, 0);
    if (data->texture) {
-        data->texture_external = SDL_TRUE;
+        data->texture_external = true;
    } else {
        renderdata->glGenTextures(1, &data->texture);
        if (GL_CheckError("glGenTexures()", renderer) < 0) {
@@ -1938,7 +1938,7 @@ static int GLES2_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
    GLES2_TextureData *texturedata = NULL;
    GLenum status;

-    data->drawstate.viewport_dirty = SDL_TRUE;
+    data->drawstate.viewport_dirty = true;

    if (!texture) {
        data->glBindFramebuffer(GL_FRAMEBUFFER, data->window_framebuffer);
@@ -2012,7 +2012,7 @@ static SDL_Surface *GLES2_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rec

    // Flip the rows to be top-down if necessary
    if (!renderer->target) {
-        SDL_bool isstack;
+        bool isstack;
        int length = rect->w * SDL_BYTESPERPIXEL(format);
        Uint8 *src = (Uint8 *)surface->pixels + (rect->h - 1) * surface->pitch;
        Uint8 *dst = (Uint8 *)surface->pixels;
@@ -2077,7 +2077,7 @@ static int GLES2_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_
    GLint window_framebuffer;
    GLint value;
    int profile_mask = 0, major = 0, minor = 0;
-    SDL_bool changed_window = SDL_FALSE;
+    bool changed_window = false;

    if (SDL_GL_GetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, &profile_mask) < 0) {
        goto error;
@@ -2096,7 +2096,7 @@ static int GLES2_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_
    if (!(window_flags & SDL_WINDOW_OPENGL) ||
        profile_mask != SDL_GL_CONTEXT_PROFILE_ES || major < RENDERER_CONTEXT_MAJOR) {

-        changed_window = SDL_TRUE;
+        changed_window = true;
        SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, RENDERER_CONTEXT_MAJOR);
        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, RENDERER_CONTEXT_MINOR);
@@ -2147,7 +2147,7 @@ static int GLES2_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_
    // Check for debug output support
    if (SDL_GL_GetAttribute(SDL_GL_CONTEXT_FLAGS, &value) == 0 &&
        (value & SDL_GL_CONTEXT_DEBUG_FLAG)) {
-        data->debug_enabled = SDL_TRUE;
+        data->debug_enabled = true;
    }

    value = 0;
@@ -2208,7 +2208,7 @@ static int GLES2_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_
    renderer->rect_index_order[5] = 2;

    if (SDL_GL_ExtensionSupported("GL_EXT_blend_minmax")) {
-        data->GL_EXT_blend_minmax_supported = SDL_TRUE;
+        data->GL_EXT_blend_minmax_supported = true;
    }

    // Set up parameters for rendering
--- a/src/render/psp/SDL_render_psp.c
+++ b/src/render/psp/SDL_render_psp.c
@@ -68,7 +68,7 @@ typedef struct PSP_TextureData
    unsigned int bits;          /**< Image bits per pixel. */
    unsigned int format;        /**< Image format - one of ::pgePixelFormat. */
    unsigned int pitch;
-    SDL_bool swizzled;                /**< Is image swizzled. */
+    bool swizzled;                /**< Is image swizzled. */
    struct PSP_TextureData *prevhotw; /**< More recently used render target */
    struct PSP_TextureData *nexthotw; /**< Less recently used render target */
 } PSP_TextureData;
@@ -91,17 +91,17 @@ typedef struct
    void *frontbuffer;         /**< main screen buffer */
    void *backbuffer;          /**< buffer presented to display */
    SDL_Texture *boundTarget;  /**< currently bound rendertarget */
-    SDL_bool initialized;      /**< is driver initialized */
-    SDL_bool displayListAvail; /**< is the display list already initialized for this frame */
+    bool initialized;      /**< is driver initialized */
+    bool displayListAvail; /**< is the display list already initialized for this frame */
    unsigned int psm;          /**< format of the display buffers */
    unsigned int bpp;          /**< bits per pixel of the main display */

-    SDL_bool vsync;                       /**< whether we do vsync */
+    bool vsync;                       /**< whether we do vsync */
    PSP_BlendState blendState;            /**< current blend mode */
    PSP_TextureData *most_recent_target;  /**< start of render target LRU double linked list */
    PSP_TextureData *least_recent_target; /**< end of the LRU list */

-    SDL_bool vblank_not_reached; /**< whether vblank wasn't reached */
+    bool vblank_not_reached; /**< whether vblank wasn't reached */
 } PSP_RenderData;

 typedef struct
@@ -188,7 +188,7 @@ static int TextureNextPow2(unsigned int w)
 static void psp_on_vblank(u32 sub, PSP_RenderData *data)
 {
    if (data) {
-        data->vblank_not_reached = SDL_FALSE;
+        data->vblank_not_reached = false;
    }
 }

@@ -312,7 +312,7 @@ static int TextureSwizzle(PSP_TextureData *psp_texture, void *dst)

    TextureStorageFree(psp_texture->data);
    psp_texture->data = data;
-    psp_texture->swizzled = SDL_TRUE;
+    psp_texture->swizzled = true;

    sceKernelDcacheWritebackRange(psp_texture->data, psp_texture->size);
    return 1;
@@ -382,7 +382,7 @@ static int TextureUnswizzle(PSP_TextureData *psp_texture, void *dst)

    psp_texture->data = data;

-    psp_texture->swizzled = SDL_FALSE;
+    psp_texture->swizzled = false;

    sceKernelDcacheWritebackRange(psp_texture->data, psp_texture->size);
    return 1;
@@ -407,7 +407,7 @@ static int TextureSpillToSram(PSP_RenderData *data, PSP_TextureData *psp_texture
    }
 }

-static int TexturePromoteToVram(PSP_RenderData *data, PSP_TextureData *psp_texture, SDL_bool target)
+static int TexturePromoteToVram(PSP_RenderData *data, PSP_TextureData *psp_texture, bool target)
 {
    // Assumes texture in sram and a large enough continuous block in vram
    void *tdata = vramalloc(psp_texture->size);
@@ -455,7 +455,7 @@ static int TextureBindAsTarget(PSP_RenderData *data, PSP_TextureData *psp_textur
        if (TextureSpillTargetsForSpace(data, psp_texture->size) < 0) {
            return -1;
        }
-        if (TexturePromoteToVram(data, psp_texture, SDL_TRUE) < 0) {
+        if (TexturePromoteToVram(data, psp_texture, true) < 0) {
            return -1;
        }
    }
@@ -490,7 +490,7 @@ static int PSP_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_P
        return -1;
    }

-    psp_texture->swizzled = SDL_FALSE;
+    psp_texture->swizzled = false;
    psp_texture->width = texture->w;
    psp_texture->height = texture->h;
    psp_texture->textureHeight = TextureNextPow2(texture->h);
@@ -956,7 +956,7 @@ static void StartDrawing(SDL_Renderer *renderer)
    // Check if we need to start GU displaylist
    if (!data->displayListAvail) {
        sceGuStart(GU_DIRECT, DisplayList);
-        data->displayListAvail = SDL_TRUE;
+        data->displayListAvail = true;
        // ResetBlendState(&data->blendState);
    }

@@ -1229,14 +1229,14 @@ static int PSP_RenderPresent(SDL_Renderer *renderer)
        return -1;
    }

-    data->displayListAvail = SDL_FALSE;
+    data->displayListAvail = false;
    sceGuFinish();
    sceGuSync(0, 0);

    if ((data->vsync) && (data->vblank_not_reached)) {
        sceDisplayWaitVblankStart();
    }
-    data->vblank_not_reached = SDL_TRUE;
+    data->vblank_not_reached = true;

    data->backbuffer = data->frontbuffer;
    data->frontbuffer = vabsptr(sceGuSwapBuffers());
@@ -1279,8 +1279,8 @@ static void PSP_DestroyRenderer(SDL_Renderer *renderer)
        vfree(data->backbuffer);
        vfree(data->frontbuffer);

-        data->initialized = SDL_FALSE;
-        data->displayListAvail = SDL_FALSE;
+        data->initialized = false;
+        data->displayListAvail = false;
        SDL_free(data);
    }
 }
@@ -1341,7 +1341,7 @@ static int PSP_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Pr
    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR8888);
    SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 512);

-    data->initialized = SDL_TRUE;
+    data->initialized = true;
    data->most_recent_target = NULL;
    data->least_recent_target = NULL;

@@ -1394,7 +1394,7 @@ static int PSP_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Pr
    sceGuDisplay(GU_TRUE);

    // Improve performance when VSYC is enabled and it is not reaching the 60 FPS
-    data->vblank_not_reached = SDL_TRUE;
+    data->vblank_not_reached = true;
    sceKernelRegisterSubIntrHandler(PSP_VBLANK_INT, 0, psp_on_vblank, data);
    sceKernelEnableSubIntr(PSP_VBLANK_INT, 0);

--- a/src/render/software/SDL_blendline.c
+++ b/src/render/software/SDL_blendline.c
@@ -28,7 +28,7 @@

 static void SDL_BlendLine_RGB2(SDL_Surface *dst, int x1, int y1, int x2, int y2,
                               SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
-                               SDL_bool draw_end)
+                               bool draw_end)
 {
    const SDL_PixelFormatDetails *fmt = dst->internal->format;
    unsigned r, g, b, a, inva;
@@ -151,7 +151,7 @@ static void SDL_BlendLine_RGB2(SDL_Surface *dst, int x1, int y1, int x2, int y2,

 static void SDL_BlendLine_RGB555(SDL_Surface *dst, int x1, int y1, int x2, int y2,
                                 SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
-                                 SDL_bool draw_end)
+                                 bool draw_end)
 {
    unsigned r, g, b, a, inva;

@@ -273,7 +273,7 @@ static void SDL_BlendLine_RGB555(SDL_Surface *dst, int x1, int y1, int x2, int y

 static void SDL_BlendLine_RGB565(SDL_Surface *dst, int x1, int y1, int x2, int y2,
                                 SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
-                                 SDL_bool draw_end)
+                                 bool draw_end)
 {
    unsigned r, g, b, a, inva;

@@ -395,7 +395,7 @@ static void SDL_BlendLine_RGB565(SDL_Surface *dst, int x1, int y1, int x2, int y

 static void SDL_BlendLine_RGB4(SDL_Surface *dst, int x1, int y1, int x2, int y2,
                               SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
-                               SDL_bool draw_end)
+                               bool draw_end)
 {
    const SDL_PixelFormatDetails *fmt = dst->internal->format;
    unsigned r, g, b, a, inva;
@@ -518,7 +518,7 @@ static void SDL_BlendLine_RGB4(SDL_Surface *dst, int x1, int y1, int x2, int y2,

 static void SDL_BlendLine_RGBA4(SDL_Surface *dst, int x1, int y1, int x2, int y2,
                                SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
-                                SDL_bool draw_end)
+                                bool draw_end)
 {
    const SDL_PixelFormatDetails *fmt = dst->internal->format;
    unsigned r, g, b, a, inva;
@@ -641,7 +641,7 @@ static void SDL_BlendLine_RGBA4(SDL_Surface *dst, int x1, int y1, int x2, int y2

 static void SDL_BlendLine_XRGB8888(SDL_Surface *dst, int x1, int y1, int x2, int y2,
                                 SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
-                                 SDL_bool draw_end)
+                                 bool draw_end)
 {
    unsigned r, g, b, a, inva;

@@ -763,7 +763,7 @@ static void SDL_BlendLine_XRGB8888(SDL_Surface *dst, int x1, int y1, int x2, int

 static void SDL_BlendLine_ARGB8888(SDL_Surface *dst, int x1, int y1, int x2, int y2,
                                   SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
-                                   SDL_bool draw_end)
+                                   bool draw_end)
 {
    unsigned r, g, b, a, inva;

@@ -887,7 +887,7 @@ typedef void (*BlendLineFunc)(SDL_Surface *dst,
                              int x1, int y1, int x2, int y2,
                              SDL_BlendMode blendMode,
                              Uint8 r, Uint8 g, Uint8 b, Uint8 a,
-                              SDL_bool draw_end);
+                              bool draw_end);

 static BlendLineFunc SDL_CalculateBlendLineFunc(const SDL_PixelFormatDetails *fmt)
 {
@@ -939,7 +939,7 @@ int SDL_BlendLine(SDL_Surface *dst, int x1, int y1, int x2, int y2,
        return 0;
    }

-    func(dst, x1, y1, x2, y2, blendMode, r, g, b, a, SDL_TRUE);
+    func(dst, x1, y1, x2, y2, blendMode, r, g, b, a, true);
    return 0;
 }

@@ -949,7 +949,7 @@ int SDL_BlendLines(SDL_Surface *dst, const SDL_Point *points, int count,
    int i;
    int x1, y1;
    int x2, y2;
-    SDL_bool draw_end;
+    bool draw_end;
    BlendLineFunc func;

    if (!SDL_SurfaceValid(dst)) {
--- a/src/render/software/SDL_drawline.c
+++ b/src/render/software/SDL_drawline.c
@@ -27,7 +27,7 @@
 #include "SDL_drawpoint.h"

 static void SDL_DrawLine1(SDL_Surface *dst, int x1, int y1, int x2, int y2, Uint32 color,
-                          SDL_bool draw_end)
+                          bool draw_end)
 {
    if (y1 == y2) {
        int length;
@@ -54,7 +54,7 @@ static void SDL_DrawLine1(SDL_Surface *dst, int x1, int y1, int x2, int y2, Uint
 }

 static void SDL_DrawLine2(SDL_Surface *dst, int x1, int y1, int x2, int y2, Uint32 color,
-                          SDL_bool draw_end)
+                          bool draw_end)
 {
    if (y1 == y2) {
        HLINE(Uint16, DRAW_FASTSETPIXEL2, draw_end);
@@ -83,7 +83,7 @@ static void SDL_DrawLine2(SDL_Surface *dst, int x1, int y1, int x2, int y2, Uint
 }

 static void SDL_DrawLine4(SDL_Surface *dst, int x1, int y1, int x2, int y2, Uint32 color,
-                          SDL_bool draw_end)
+                          bool draw_end)
 {
    if (y1 == y2) {
        HLINE(Uint32, DRAW_FASTSETPIXEL4, draw_end);
@@ -115,7 +115,7 @@ static void SDL_DrawLine4(SDL_Surface *dst, int x1, int y1, int x2, int y2, Uint

 typedef void (*DrawLineFunc)(SDL_Surface *dst,
                             int x1, int y1, int x2, int y2,
-                             Uint32 color, SDL_bool draw_end);
+                             Uint32 color, bool draw_end);

 static DrawLineFunc SDL_CalculateDrawLineFunc(const SDL_PixelFormatDetails *fmt)
 {
@@ -152,7 +152,7 @@ int SDL_DrawLine(SDL_Surface *dst, int x1, int y1, int x2, int y2, Uint32 color)
        return 0;
    }

-    func(dst, x1, y1, x2, y2, color, SDL_TRUE);
+    func(dst, x1, y1, x2, y2, color, true);
    return 0;
 }

@@ -162,7 +162,7 @@ int SDL_DrawLines(SDL_Surface *dst, const SDL_Point *points, int count,
    int i;
    int x1, y1;
    int x2, y2;
-    SDL_bool draw_end;
+    bool draw_end;
    DrawLineFunc func;

    if (!SDL_SurfaceValid(dst)) {
--- a/src/render/software/SDL_render_sw.c
+++ b/src/render/software/SDL_render_sw.c
@@ -41,7 +41,7 @@ typedef struct
 {
    const SDL_Rect *viewport;
    const SDL_Rect *cliprect;
-    SDL_bool surface_cliprect_dirty;
+    bool surface_cliprect_dirty;
    SDL_Color color;
 } SW_DrawStateCache;

@@ -326,9 +326,9 @@ static int SW_RenderCopyEx(SDL_Renderer *renderer, SDL_Surface *surface, SDL_Tex
    int retval = 0;
    SDL_BlendMode blendmode;
    Uint8 alphaMod, rMod, gMod, bMod;
-    int applyModulation = SDL_FALSE;
-    int blitRequired = SDL_FALSE;
-    int isOpaque = SDL_FALSE;
+    int applyModulation = false;
+    int blitRequired = false;
+    int isOpaque = false;

    if (!SDL_SurfaceValid(surface)) {
        return -1;
@@ -365,29 +365,29 @@ static int SW_RenderCopyEx(SDL_Renderer *renderer, SDL_Surface *surface, SDL_Tex

    // SDLgfx_rotateSurface only accepts 32-bit surfaces with a 8888 layout. Everything else has to be converted.
    if (src->internal->format->bits_per_pixel != 32 || SDL_PIXELLAYOUT(src->format) != SDL_PACKEDLAYOUT_8888 || !SDL_ISPIXELFORMAT_ALPHA(src->format)) {
-        blitRequired = SDL_TRUE;
+        blitRequired = true;
    }

    // If scaling and cropping is necessary, it has to be taken care of before the rotation.
    if (!(srcrect->w == final_rect->w && srcrect->h == final_rect->h && srcrect->x == 0 && srcrect->y == 0)) {
-        blitRequired = SDL_TRUE;
+        blitRequired = true;
    }

    // srcrect is not selecting the whole src surface, so cropping is needed
    if (!(srcrect->w == src->w && srcrect->h == src->h && srcrect->x == 0 && srcrect->y == 0)) {
-        blitRequired = SDL_TRUE;
+        blitRequired = true;
    }

    // The color and alpha modulation has to be applied before the rotation when using the NONE, MOD or MUL blend modes.
    if ((blendmode == SDL_BLENDMODE_NONE || blendmode == SDL_BLENDMODE_MOD || blendmode == SDL_BLENDMODE_MUL) && (alphaMod & rMod & gMod & bMod) != 255) {
-        applyModulation = SDL_TRUE;
+        applyModulation = true;
        SDL_SetSurfaceAlphaMod(src_clone, alphaMod);
        SDL_SetSurfaceColorMod(src_clone, rMod, gMod, bMod);
    }

    // Opaque surfaces are much easier to handle with the NONE blend mode.
    if (blendmode == SDL_BLENDMODE_NONE && !SDL_ISPIXELFORMAT_ALPHA(src->format) && alphaMod == 255) {
-        isOpaque = SDL_TRUE;
+        isOpaque = true;
    }

    /* The NONE blend mode requires a mask for non-opaque surfaces. This mask will be used
@@ -437,7 +437,7 @@ static int SW_RenderCopyEx(SDL_Renderer *renderer, SDL_Surface *surface, SDL_Tex
        if (!retval && mask) {
            // The mask needed for the NONE blend mode gets rotated with the same parameters.
            mask_rotated = SDLgfx_rotateSurface(mask, angle,
-                                                SDL_FALSE, 0, 0,
+                                                false, 0, 0,
                                                &rect_dest, cangle, sangle, center);
            if (!mask_rotated) {
                retval = -1;
@@ -454,7 +454,7 @@ static int SW_RenderCopyEx(SDL_Renderer *renderer, SDL_Surface *surface, SDL_Tex
             * Other blend modes or opaque surfaces can be blitted directly.
             */
            if (blendmode != SDL_BLENDMODE_NONE || isOpaque) {
-                if (applyModulation == SDL_FALSE) {
+                if (applyModulation == false) {
                    // If the modulation wasn't already applied, make it happen now.
                    SDL_SetSurfaceAlphaMod(src_rotated, alphaMod);
                    SDL_SetSurfaceColorMod(src_rotated, rMod, gMod, bMod);
@@ -629,9 +629,9 @@ static void PrepTextureForCopy(const SDL_RenderCommand *cmd, SW_DrawStateCache *
    const SDL_BlendMode blend = cmd->data.draw.blend;
    SDL_Texture *texture = cmd->data.draw.texture;
    SDL_Surface *surface = (SDL_Surface *)texture->internal;
-    const SDL_bool colormod = ((r & g & b) != 0xFF);
-    const SDL_bool alphamod = (a != 0xFF);
-    const SDL_bool blending = ((blend == SDL_BLENDMODE_ADD) || (blend == SDL_BLENDMODE_MOD) || (blend == SDL_BLENDMODE_MUL));
+    const bool colormod = ((r & g & b) != 0xFF);
+    const bool alphamod = (a != 0xFF);
+    const bool blending = ((blend == SDL_BLENDMODE_ADD) || (blend == SDL_BLENDMODE_MOD) || (blend == SDL_BLENDMODE_MUL));

    if (colormod || alphamod || blending) {
        SDL_SetSurfaceRLE(surface, 0);
@@ -661,7 +661,7 @@ static void SetDrawState(SDL_Surface *surface, SW_DrawStateCache *drawstate)
        } else {
            SDL_SetSurfaceClipRect(surface, drawstate->viewport);
        }
-        drawstate->surface_cliprect_dirty = SDL_FALSE;
+        drawstate->surface_cliprect_dirty = false;
    }
 }

@@ -682,7 +682,7 @@ static int SW_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, vo

    drawstate.viewport = NULL;
    drawstate.cliprect = NULL;
-    drawstate.surface_cliprect_dirty = SDL_TRUE;
+    drawstate.surface_cliprect_dirty = true;
    drawstate.color.r = 0;
    drawstate.color.g = 0;
    drawstate.color.b = 0;
@@ -702,14 +702,14 @@ static int SW_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, vo
        case SDL_RENDERCMD_SETVIEWPORT:
        {
            drawstate.viewport = &cmd->data.viewport.rect;
-            drawstate.surface_cliprect_dirty = SDL_TRUE;
+            drawstate.surface_cliprect_dirty = true;
            break;
        }

        case SDL_RENDERCMD_SETCLIPRECT:
        {
            drawstate.cliprect = cmd->data.cliprect.enabled ? &cmd->data.cliprect.rect : NULL;
-            drawstate.surface_cliprect_dirty = SDL_TRUE;
+            drawstate.surface_cliprect_dirty = true;
            break;
        }

@@ -722,7 +722,7 @@ static int SW_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, vo
            // By definition the clear ignores the clip rect
            SDL_SetSurfaceClipRect(surface, NULL);
            SDL_FillSurfaceRect(surface, NULL, SDL_MapSurfaceRGBA(surface, r, g, b, a));
-            drawstate.surface_cliprect_dirty = SDL_TRUE;
+            drawstate.surface_cliprect_dirty = true;
            break;
        }

@@ -1120,7 +1120,7 @@ int SW_CreateRendererForSurface(SDL_Renderer *renderer, SDL_Surface *surface, SD
        return SDL_InvalidParamError("surface");
    }

-    renderer->software = SDL_TRUE;
+    renderer->software = true;

    data = (SW_RenderData *)SDL_calloc(1, sizeof(*data));
    if (!data) {
@@ -1171,7 +1171,7 @@ static int SW_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Pro
 {
    // Set the vsync hint based on our flags, if it's not already set
    const char *hint = SDL_GetHint(SDL_HINT_RENDER_VSYNC);
-    const SDL_bool no_hint_set = (!hint || !*hint);
+    const bool no_hint_set = (!hint || !*hint);

    if (no_hint_set) {
        if (SDL_GetBooleanProperty(create_props, SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_NUMBER, 0)) {
--- a/src/render/software/SDL_rotate.c
+++ b/src/render/software/SDL_rotate.c
@@ -492,7 +492,7 @@ SDL_Surface *SDLgfx_rotateSurface(SDL_Surface *src, double angle, int smooth, in
    int is8bit, angle90;
    SDL_BlendMode blendmode;
    Uint32 colorkey = 0;
-    int colorKeyAvailable = SDL_FALSE;
+    int colorKeyAvailable = false;
    double sangleinv, cangleinv;

    // Sanity check
@@ -502,7 +502,7 @@ SDL_Surface *SDLgfx_rotateSurface(SDL_Surface *src, double angle, int smooth, in

    if (SDL_SurfaceHasColorKey(src)) {
        if (SDL_GetSurfaceColorKey(src, &colorkey) == 0) {
-            colorKeyAvailable = SDL_TRUE;
+            colorKeyAvailable = true;
        }
    }
    // This function requires a 32-bit surface or 8-bit surface with a colorkey
@@ -538,9 +538,9 @@ SDL_Surface *SDLgfx_rotateSurface(SDL_Surface *src, double angle, int smooth, in

    SDL_GetSurfaceBlendMode(src, &blendmode);

-    if (colorKeyAvailable == SDL_TRUE) {
+    if (colorKeyAvailable == true) {
        // If available, the colorkey will be used to discard the pixels that are outside of the rotated area.
-        SDL_SetSurfaceColorKey(rz_dst, SDL_TRUE, colorkey);
+        SDL_SetSurfaceColorKey(rz_dst, true, colorkey);
        SDL_FillSurfaceRect(rz_dst, NULL, colorkey);
    } else if (blendmode == SDL_BLENDMODE_NONE) {
        blendmode = SDL_BLENDMODE_BLEND;
@@ -554,7 +554,7 @@ SDL_Surface *SDLgfx_rotateSurface(SDL_Surface *src, double angle, int smooth, in
         * all pixels outside of the rotated area. This doesn't interfere with anything because
         * white pixels are already a no-op and the MOD blend mode does not interact with alpha.
         */
-        SDL_SetSurfaceColorKey(rz_dst, SDL_TRUE, colorkey);
+        SDL_SetSurfaceColorKey(rz_dst, true, colorkey);
    }

    SDL_SetSurfaceBlendMode(rz_dst, blendmode);
--- a/src/render/software/SDL_triangle.c
+++ b/src/render/software/SDL_triangle.c
@@ -42,7 +42,7 @@ static void SDL_BlitTriangle_Slow(SDL_BlitInfo *info,
                                  SDL_Point s2_x_area, SDL_Rect dstrect, int area, int bias_w0, int bias_w1, int bias_w2,
                                  int d2d1_y, int d1d2_x, int d0d2_y, int d2d0_x, int d1d0_y, int d0d1_x,
                                  int s2s0_x, int s2s1_x, int s2s0_y, int s2s1_y, int w0_row, int w1_row, int w2_row,
-                                  SDL_Color c0, SDL_Color c1, SDL_Color c2, SDL_bool is_uniform, SDL_TextureAddressMode texture_address_mode);
+                                  SDL_Color c0, SDL_Color c1, SDL_Color c2, bool is_uniform, SDL_TextureAddressMode texture_address_mode);

 #if 0
 int SDL_BlitTriangle(SDL_Surface *src, const SDL_Point srcpoints[3], SDL_Surface *dst, const SDL_Point dstpoints[3])
@@ -241,7 +241,7 @@ int SDL_SW_FillTriangle(SDL_Surface *dst, SDL_Point *d0, SDL_Point *d1, SDL_Poin
    Sint64 w0_row, w1_row, w2_row;
    int bias_w0, bias_w1, bias_w2;

-    SDL_bool is_uniform;
+    bool is_uniform;

    SDL_Surface *tmp = NULL;

@@ -494,9 +494,9 @@ int SDL_SW_BlitTriangle(
    Sint64 w0_row, w1_row, w2_row;
    int bias_w0, bias_w1, bias_w2;

-    SDL_bool is_uniform;
+    bool is_uniform;

-    SDL_bool has_modulation;
+    bool has_modulation;

    if (!SDL_SurfaceValid(src)) {
        return SDL_InvalidParamError("src");
@@ -573,7 +573,7 @@ int SDL_SW_BlitTriangle(
        // SDL_GetSurfaceColorMod(src, &r, &g, &b);
        has_modulation = c0.r != 255 || c0.g != 255 || c0.b != 255 || c0.a != 255;
    } else {
-        has_modulation = SDL_TRUE;
+        has_modulation = true;
    }

    {
@@ -788,7 +788,7 @@ static void SDL_BlitTriangle_Slow(SDL_BlitInfo *info,
                                  SDL_Point s2_x_area, SDL_Rect dstrect, int area, int bias_w0, int bias_w1, int bias_w2,
                                  int d2d1_y, int d1d2_x, int d0d2_y, int d2d0_x, int d1d0_y, int d0d1_x,
                                  int s2s0_x, int s2s1_x, int s2s0_y, int s2s1_y, int w0_row, int w1_row, int w2_row,
-                                  SDL_Color c0, SDL_Color c1, SDL_Color c2, SDL_bool is_uniform, SDL_TextureAddressMode texture_address_mode)
+                                  SDL_Color c0, SDL_Color c1, SDL_Color c2, bool is_uniform, SDL_TextureAddressMode texture_address_mode)
 {
    SDL_Surface *src_surface = info->src_surface;
    const int flags = info->flags;
--- a/src/render/vitagxm/SDL_render_vita_gxm.c
+++ b/src/render/vitagxm/SDL_render_vita_gxm.c
@@ -46,7 +46,7 @@ static int VITA_GXM_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, S

 static void VITA_GXM_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *event);

-static SDL_bool VITA_GXM_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode);
+static bool VITA_GXM_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode);

 static int VITA_GXM_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_PropertiesID create_props);

@@ -143,7 +143,7 @@ void StartDrawing(SDL_Renderer *renderer)
    data->drawstate.vertex_program = NULL;
    data->drawstate.fragment_program = NULL;
    data->drawstate.last_command = -1;
-    data->drawstate.viewport_dirty = SDL_TRUE;
+    data->drawstate.viewport_dirty = true;

    // reset blend mode
    //    data->currentBlendMode = SDL_BLENDMODE_BLEND;
@@ -177,16 +177,16 @@ void StartDrawing(SDL_Renderer *renderer)

    //    unset_clip_rectangle(data);

-    data->drawing = SDL_TRUE;
+    data->drawing = true;
 }

 static int VITA_GXM_SetVSync(SDL_Renderer *renderer, const int vsync)
 {
    VITA_GXM_RenderData *data = renderer->internal;
    if (vsync) {
-        data->displayData.wait_vblank = SDL_TRUE;
+        data->displayData.wait_vblank = true;
    } else {
-        data->displayData.wait_vblank = SDL_FALSE;
+        data->displayData.wait_vblank = false;
    }
    return 0;
 }
@@ -246,7 +246,7 @@ static int VITA_GXM_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, S
    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_NV21);
    SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 4096);

-    data->initialized = SDL_TRUE;
+    data->initialized = true;

 #ifdef DEBUG_RAZOR
    sceSysmoduleLoadModule(SCE_SYSMODULE_RAZOR_HUD);
@@ -264,10 +264,10 @@ static void VITA_GXM_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *
 {
 }

-static SDL_bool VITA_GXM_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
+static bool VITA_GXM_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
 {
    // only for custom modes. we build all modes on init, so no custom modes, sorry
-    return SDL_FALSE;
+    return false;
 }

 static int VITA_GXM_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_PropertiesID create_props)
@@ -821,7 +821,7 @@ static int VITA_GXM_RenderClear(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
    sceGxmSetVertexStream(data->gxm_context, 0, data->clearVertices);
    sceGxmDraw(data->gxm_context, SCE_GXM_PRIMITIVE_TRIANGLES, SCE_GXM_INDEX_FORMAT_U16, data->linearIndices, 3);

-    data->drawstate.cliprect_dirty = SDL_TRUE;
+    data->drawstate.cliprect_dirty = true;
    return 0;
 }

@@ -831,8 +831,8 @@ static int SetDrawState(VITA_GXM_RenderData *data, const SDL_RenderCommand *cmd)
    const SDL_BlendMode blend = cmd->data.draw.blend;
    SceGxmFragmentProgram *fragment_program;
    SceGxmVertexProgram *vertex_program;
-    SDL_bool matrix_updated = SDL_FALSE;
-    SDL_bool program_updated = SDL_FALSE;
+    bool matrix_updated = false;
+    bool program_updated = false;

    if (data->drawstate.viewport_dirty) {
        const SDL_Rect *viewport = &data->drawstate.viewport;
@@ -854,23 +854,23 @@ static int SetDrawState(VITA_GXM_RenderData *data, const SDL_RenderCommand *cmd)
                                     (float)viewport->h,
                                     (float)0,
                                     0.0f, 1.0f);
-            matrix_updated = SDL_TRUE;
+            matrix_updated = true;
        }

-        data->drawstate.viewport_dirty = SDL_FALSE;
+        data->drawstate.viewport_dirty = false;
    }

    if (data->drawstate.cliprect_enabled_dirty) {
        if (!data->drawstate.cliprect_enabled) {
            unset_clip_rectangle(data);
        }
-        data->drawstate.cliprect_enabled_dirty = SDL_FALSE;
+        data->drawstate.cliprect_enabled_dirty = false;
    }

    if (data->drawstate.cliprect_enabled && data->drawstate.cliprect_dirty) {
        const SDL_Rect *rect = &data->drawstate.cliprect;
        set_clip_rectangle(data, rect->x, rect->y, rect->x + rect->w, rect->y + rect->h);
-        data->drawstate.cliprect_dirty = SDL_FALSE;
+        data->drawstate.cliprect_dirty = false;
    }

    VITA_GXM_SetBlendMode(data, blend); // do that first, to select appropriate shaders
@@ -886,13 +886,13 @@ static int SetDrawState(VITA_GXM_RenderData *data, const SDL_RenderCommand *cmd)
    if (data->drawstate.vertex_program != vertex_program) {
        data->drawstate.vertex_program = vertex_program;
        sceGxmSetVertexProgram(data->gxm_context, vertex_program);
-        program_updated = SDL_TRUE;
+        program_updated = true;
    }

    if (data->drawstate.fragment_program != fragment_program) {
        data->drawstate.fragment_program = fragment_program;
        sceGxmSetFragmentProgram(data->gxm_context, fragment_program);
-        program_updated = SDL_TRUE;
+        program_updated = true;
    }

    if (program_updated || matrix_updated) {
@@ -936,8 +936,8 @@ static int VITA_GXM_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *c
        int w, h;
        SDL_GetWindowSizeInPixels(renderer->window, &w, &h);
        if ((w != data->drawstate.drawablew) || (h != data->drawstate.drawableh)) {
-            data->drawstate.viewport_dirty = SDL_TRUE; // if the window dimensions changed, invalidate the current viewport, etc.
-            data->drawstate.cliprect_dirty = SDL_TRUE;
+            data->drawstate.viewport_dirty = true; // if the window dimensions changed, invalidate the current viewport, etc.
+            data->drawstate.cliprect_dirty = true;
            data->drawstate.drawablew = w;
            data->drawstate.drawableh = h;
        }
@@ -951,8 +951,8 @@ static int VITA_GXM_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *c
            SDL_Rect *viewport = &data->drawstate.viewport;
            if (SDL_memcmp(viewport, &cmd->data.viewport.rect, sizeof(cmd->data.viewport.rect)) != 0) {
                SDL_copyp(viewport, &cmd->data.viewport.rect);
-                data->drawstate.viewport_dirty = SDL_TRUE;
-                data->drawstate.cliprect_dirty = SDL_TRUE;
+                data->drawstate.viewport_dirty = true;
+                data->drawstate.cliprect_dirty = true;
            }
            break;
        }
@@ -962,12 +962,12 @@ static int VITA_GXM_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *c
            const SDL_Rect *rect = &cmd->data.cliprect.rect;
            if (data->drawstate.cliprect_enabled != cmd->data.cliprect.enabled) {
                data->drawstate.cliprect_enabled = cmd->data.cliprect.enabled;
-                data->drawstate.cliprect_enabled_dirty = SDL_TRUE;
+                data->drawstate.cliprect_enabled_dirty = true;
            }

            if (SDL_memcmp(&data->drawstate.cliprect, rect, sizeof(*rect)) != 0) {
                SDL_copyp(&data->drawstate.cliprect, rect);
-                data->drawstate.cliprect_dirty = SDL_TRUE;
+                data->drawstate.cliprect_dirty = true;
            }
            break;
        }
@@ -1048,7 +1048,7 @@ static int VITA_GXM_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *c
    }

    sceGxmEndScene(data->gxm_context, NULL, NULL);
-    data->drawing = SDL_FALSE;
+    data->drawing = false;

    return 0;
 }
@@ -1102,7 +1102,7 @@ static SDL_Surface *VITA_GXM_RenderReadPixels(SDL_Renderer *renderer, const SDL_
    // Flip the rows to be top-down if necessary

    if (!renderer->target) {
-        SDL_bool isstack;
+        bool isstack;
        int length = rect->w * SDL_BYTESPERPIXEL(format);
        Uint8 *src = (Uint8 *)surface->pixels + (rect->h - 1) * surface->pitch;
        Uint8 *dst = (Uint8 *)surface->pixels;
@@ -1198,8 +1198,8 @@ static void VITA_GXM_DestroyRenderer(SDL_Renderer *renderer)

        gxm_finish(renderer);

-        data->initialized = SDL_FALSE;
-        data->drawing = SDL_FALSE;
+        data->initialized = false;
+        data->drawing = false;
        SDL_free(data);
    }
 }
--- a/src/render/vitagxm/SDL_render_vita_gxm_tools.c
+++ b/src/render/vitagxm/SDL_render_vita_gxm_tools.c
@@ -1158,7 +1158,7 @@ void gxm_minimal_term_for_common_dialog(void)
 void gxm_init_for_common_dialog(void)
 {
    for (int i = 0; i < VITA_GXM_BUFFERS; i += 1) {
-        buffer_for_common_dialog[i].displayData.wait_vblank = SDL_TRUE;
+        buffer_for_common_dialog[i].displayData.wait_vblank = true;
        buffer_for_common_dialog[i].displayData.address = vita_mem_alloc(
            SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW,
            4 * VITA_GXM_SCREEN_STRIDE * VITA_GXM_SCREEN_HEIGHT,
--- a/src/render/vitagxm/SDL_render_vita_gxm_types.h
+++ b/src/render/vitagxm/SDL_render_vita_gxm_types.h
@@ -83,7 +83,7 @@ typedef struct gxm_texture
    SceGxmColorSurface gxm_colorsurface;
    SceGxmDepthStencilSurface gxm_depthstencil;
    SceUID depth_UID;
-    SDL_bool cdram;
+    bool cdram;
 } gxm_texture;

 typedef struct fragment_programs
@@ -104,7 +104,7 @@ typedef struct blend_fragment_programs
 typedef struct
 {
    SDL_Rect viewport;
-    SDL_bool viewport_dirty;
+    bool viewport_dirty;
    SDL_Texture *texture;
    SDL_Texture *target;
    SDL_FColor color;
@@ -112,19 +112,19 @@ typedef struct
    SceGxmVertexProgram *vertex_program;
    int last_command;

-    SDL_bool cliprect_enabled_dirty;
-    SDL_bool cliprect_enabled;
-    SDL_bool cliprect_dirty;
+    bool cliprect_enabled_dirty;
+    bool cliprect_enabled;
+    bool cliprect_dirty;
    SDL_Rect cliprect;
-    SDL_bool texturing;
+    bool texturing;
    int drawablew;
    int drawableh;
 } gxm_drawstate_cache;

 typedef struct
 {
-    SDL_bool initialized;
-    SDL_bool drawing;
+    bool initialized;
+    bool drawing;

    unsigned int psm;
    unsigned int bpp;
@@ -203,8 +203,8 @@ typedef struct
    unsigned int w;
    unsigned int h;
    float wscale;
-    SDL_bool yuv;
-    SDL_bool nv12;
+    bool yuv;
+    bool nv12;
 } VITA_GXM_TextureData;

 #endif // SDL_RENDER_VITA_GXM_TYPES_H
--- a/src/render/vulkan/SDL_render_vulkan.c
+++ b/src/render/vulkan/SDL_render_vulkan.c
@@ -228,7 +228,7 @@ typedef struct
 // Vulkan image
 typedef struct
 {
-    SDL_bool allocatedImage;
+    bool allocatedImage;
    VkImage image;
    VkImageView imageView;
    VkDeviceMemory deviceMemory;
@@ -283,9 +283,9 @@ typedef struct
 {
    PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
    VkInstance instance;
-    SDL_bool instance_external;
+    bool instance_external;
    VkSurfaceKHR surface;
-    SDL_bool surface_external;
+    bool surface_external;
    VkPhysicalDevice physicalDevice;
    VkPhysicalDeviceProperties physicalDeviceProperties;
    VkPhysicalDeviceMemoryProperties physicalDeviceMemoryProperties;
@@ -293,7 +293,7 @@ typedef struct
    VkQueue graphicsQueue;
    VkQueue presentQueue;
    VkDevice device;
-    SDL_bool device_external;
+    bool device_external;
    uint32_t graphicsQueueFamilyIndex;
    uint32_t presentQueueFamilyIndex;
    VkSwapchainKHR swapchain;
@@ -304,7 +304,7 @@ typedef struct
    VkFence *fences;
    VkSurfaceCapabilitiesKHR surfaceCapabilities;
    VkSurfaceFormatKHR *surfaceFormats;
-    SDL_bool recreateSwapchain;
+    bool recreateSwapchain;
    int vsync;

    VkFramebuffer *framebuffers;
@@ -340,9 +340,9 @@ typedef struct
    VULKAN_PipelineState *pipelineStates;
    VULKAN_PipelineState *currentPipelineState;

-    SDL_bool supportsEXTSwapchainColorspace;
-    SDL_bool supportsKHRGetPhysicalDeviceProperties2;
-    SDL_bool supportsKHRSamplerYCbCrConversion;
+    bool supportsEXTSwapchainColorspace;
+    bool supportsKHRGetPhysicalDeviceProperties2;
+    bool supportsKHRSamplerYCbCrConversion;
    uint32_t surfaceFormatsAllocatedCount;
    uint32_t surfaceFormatsCount;
    uint32_t swapchainDesiredImageCount;
@@ -367,16 +367,16 @@ typedef struct

    // Cached renderer properties
    VULKAN_TextureData *textureRenderTarget;
-    SDL_bool cliprectDirty;
-    SDL_bool currentCliprectEnabled;
+    bool cliprectDirty;
+    bool currentCliprectEnabled;
    SDL_Rect currentCliprect;
    SDL_Rect currentViewport;
    int currentViewportRotation;
-    SDL_bool viewportDirty;
+    bool viewportDirty;
    Float4X4 identity;
    VkComponentMapping identitySwizzle;
    int currentVertexBuffer;
-    SDL_bool issueBatch;
+    bool issueBatch;
 } VULKAN_RenderData;

 static SDL_PixelFormat VULKAN_VkFormatToSDLPixelFormat(VkFormat vkFormat)
@@ -460,7 +460,7 @@ static void VULKAN_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture);
 static void VULKAN_DestroyBuffer(VULKAN_RenderData *rendererData, VULKAN_Buffer *vulkanBuffer);
 static void VULKAN_DestroyImage(VULKAN_RenderData *rendererData, VULKAN_Image *vulkanImage);
 static void VULKAN_ResetCommandList(VULKAN_RenderData *rendererData);
-static SDL_bool VULKAN_FindMemoryTypeIndex(VULKAN_RenderData *rendererData, uint32_t typeBits, VkMemoryPropertyFlags requiredFlags, VkMemoryPropertyFlags desiredFlags, uint32_t *memoryTypeIndexOut);
+static bool VULKAN_FindMemoryTypeIndex(VULKAN_RenderData *rendererData, uint32_t typeBits, VkMemoryPropertyFlags requiredFlags, VkMemoryPropertyFlags desiredFlags, uint32_t *memoryTypeIndexOut);
 static VkResult VULKAN_CreateWindowSizeDependentResources(SDL_Renderer *renderer);
 static VkDescriptorPool VULKAN_AllocateDescriptorPool(VULKAN_RenderData *rendererData);
 static VkResult VULKAN_CreateDescriptorSetAndPipelineLayout(VULKAN_RenderData *rendererData, VkSampler samplerYcbcr, VkDescriptorSetLayout *descriptorSetLayoutOut, VkPipelineLayout *pipelineLayoutOut);
@@ -966,7 +966,7 @@ static void VULKAN_EnsureCommandBuffer(VULKAN_RenderData *rendererData)
    }
 }

-static SDL_bool VULKAN_ActivateCommandBuffer(SDL_Renderer *renderer, VkAttachmentLoadOp loadOp, VkClearColorValue *clearColor, VULKAN_DrawStateCache *stateCache)
+static bool VULKAN_ActivateCommandBuffer(SDL_Renderer *renderer, VkAttachmentLoadOp loadOp, VkClearColorValue *clearColor, VULKAN_DrawStateCache *stateCache)
 {
    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;

@@ -986,7 +986,7 @@ static SDL_bool VULKAN_ActivateCommandBuffer(SDL_Renderer *renderer, VkAttachmen
        vkCmdBindVertexBuffers(rendererData->currentCommandBuffer, 0, 1, &stateCache->vertexBuffer, &offset);
    }

-    return SDL_TRUE;
+    return true;
 }

 static void VULKAN_WaitForGPU(VULKAN_RenderData *rendererData)
@@ -1009,8 +1009,8 @@ static void VULKAN_ResetCommandList(VULKAN_RenderData *rendererData)

    rendererData->currentPipelineState = NULL;
    rendererData->currentVertexBuffer = 0;
-    rendererData->issueBatch = SDL_FALSE;
-    rendererData->cliprectDirty = SDL_TRUE;
+    rendererData->issueBatch = false;
+    rendererData->cliprectDirty = true;
    rendererData->currentDescriptorSetIndex = 0;
    rendererData->currentDescriptorPoolIndex = 0;
    rendererData->currentConstantBufferOffset = -1;
@@ -1036,7 +1036,7 @@ static VkResult VULKAN_IssueBatch(VULKAN_RenderData *rendererData)
    }

    rendererData->currentPipelineState = VK_NULL_HANDLE;
-    rendererData->viewportDirty = SDL_TRUE;
+    rendererData->viewportDirty = true;

    vkEndCommandBuffer(rendererData->currentCommandBuffer);

@@ -1278,10 +1278,10 @@ static VULKAN_PipelineState *VULKAN_CreatePipelineState(SDL_Renderer *renderer,
    return &pipelineStates[rendererData->pipelineStateCount - 1];
 }

-static SDL_bool VULKAN_FindMemoryTypeIndex(VULKAN_RenderData *rendererData, uint32_t typeBits, VkMemoryPropertyFlags requiredFlags, VkMemoryPropertyFlags desiredFlags, uint32_t *memoryTypeIndexOut)
+static bool VULKAN_FindMemoryTypeIndex(VULKAN_RenderData *rendererData, uint32_t typeBits, VkMemoryPropertyFlags requiredFlags, VkMemoryPropertyFlags desiredFlags, uint32_t *memoryTypeIndexOut)
 {
    uint32_t memoryTypeIndex = 0;
-    SDL_bool foundExactMatch = SDL_FALSE;
+    bool foundExactMatch = false;

    // Desired flags must be a superset of required flags.
    desiredFlags |= requiredFlags;
@@ -1289,7 +1289,7 @@ static SDL_bool VULKAN_FindMemoryTypeIndex(VULKAN_RenderData *rendererData, uint
    for (memoryTypeIndex = 0; memoryTypeIndex < rendererData->physicalDeviceMemoryProperties.memoryTypeCount; memoryTypeIndex++) {
        if (typeBits & (1 << memoryTypeIndex)) {
            if (rendererData->physicalDeviceMemoryProperties.memoryTypes[memoryTypeIndex].propertyFlags == desiredFlags) {
-                foundExactMatch = SDL_TRUE;
+                foundExactMatch = true;
                break;
            }
        }
@@ -1306,10 +1306,10 @@ static SDL_bool VULKAN_FindMemoryTypeIndex(VULKAN_RenderData *rendererData, uint

    if (memoryTypeIndex >= rendererData->physicalDeviceMemoryProperties.memoryTypeCount) {
        SDL_SetError("[Vulkan] Unable to find memory type for allocation");
-        return SDL_FALSE;
+        return false;
    }
    *memoryTypeIndexOut = memoryTypeIndex;
-    return SDL_TRUE;
+    return true;
 }

 static VkResult VULKAN_CreateVertexBuffer(VULKAN_RenderData *rendererData, size_t vbidx, size_t size)
@@ -1434,7 +1434,7 @@ static VkResult VULKAN_FindPhysicalDevice(VULKAN_RenderData *rendererData)
        uint32_t queueFamiliesCount = 0;
        uint32_t queueFamilyIndex;
        uint32_t deviceExtensionCount = 0;
-        SDL_bool hasSwapchainExtension = SDL_FALSE;
+        bool hasSwapchainExtension = false;
        uint32_t i;

        VkPhysicalDevice physicalDevice = physicalDevices[physicalDeviceIndex];
@@ -1525,7 +1525,7 @@ static VkResult VULKAN_FindPhysicalDevice(VULKAN_RenderData *rendererData)
        }
        for (i = 0; i < deviceExtensionCount; i++) {
            if (SDL_strcmp(deviceExtensions[i].extensionName, VK_KHR_SWAPCHAIN_EXTENSION_NAME) == 0) {
-                hasSwapchainExtension = SDL_TRUE;
+                hasSwapchainExtension = true;
                break;
            }
        }
@@ -1589,14 +1589,14 @@ static VkSemaphore VULKAN_CreateSemaphore(VULKAN_RenderData *rendererData)
    return semaphore;
 }

-static SDL_bool VULKAN_DeviceExtensionsFound(VULKAN_RenderData *rendererData, int extensionsToCheck, const char* const* extNames)
+static bool VULKAN_DeviceExtensionsFound(VULKAN_RenderData *rendererData, int extensionsToCheck, const char* const* extNames)
 {
    uint32_t extensionCount;
-    SDL_bool foundExtensions = SDL_TRUE;
+    bool foundExtensions = true;
    VkResult result = vkEnumerateDeviceExtensionProperties(rendererData->physicalDevice, NULL, &extensionCount, NULL);
    if (result != VK_SUCCESS ) {
        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "vkEnumerateDeviceExtensionProperties(): %s.\n", SDL_Vulkan_GetResultString(result));
-        return SDL_FALSE;
+        return false;
    }
    if (extensionCount > 0 ) {
        VkExtensionProperties *extensionProperties = (VkExtensionProperties *)SDL_calloc(sizeof(VkExtensionProperties), extensionCount);
@@ -1604,13 +1604,13 @@ static SDL_bool VULKAN_DeviceExtensionsFound(VULKAN_RenderData *rendererData, in
        if (result != VK_SUCCESS ) {
            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "vkEnumerateDeviceExtensionProperties): %s.\n", SDL_Vulkan_GetResultString(result));
            SDL_free(extensionProperties);
-            return SDL_FALSE;
+            return false;
        }
        for (int ext = 0; ext < extensionsToCheck && foundExtensions; ext++) {
-            SDL_bool foundExtension = SDL_FALSE;
+            bool foundExtension = false;
            for (uint32_t i = 0; i < extensionCount; i++) {
                if (SDL_strcmp(extensionProperties[i].extensionName, extNames[ext]) == 0) {
-                    foundExtension = SDL_TRUE;
+                    foundExtension = true;
                    break;
                }
            }
@@ -1623,13 +1623,13 @@ static SDL_bool VULKAN_DeviceExtensionsFound(VULKAN_RenderData *rendererData, in
    return foundExtensions;
 }

-static SDL_bool VULKAN_InstanceExtensionFound(VULKAN_RenderData *rendererData, const char *extName)
+static bool VULKAN_InstanceExtensionFound(VULKAN_RenderData *rendererData, const char *extName)
 {
    uint32_t extensionCount;
    VkResult result = vkEnumerateInstanceExtensionProperties(NULL, &extensionCount, NULL);
    if (result != VK_SUCCESS ) {
        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "vkEnumerateInstanceExtensionProperties( NULL, ... ): %s.\n", SDL_Vulkan_GetResultString(result));
-        return SDL_FALSE;
+        return false;
    }
    if (extensionCount > 0 ) {
        VkExtensionProperties *extensionProperties = (VkExtensionProperties *)SDL_calloc(extensionCount, sizeof(VkExtensionProperties));
@@ -1637,25 +1637,25 @@ static SDL_bool VULKAN_InstanceExtensionFound(VULKAN_RenderData *rendererData, c
        if (result != VK_SUCCESS ) {
            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "vkEnumerateInstanceExtensionProperties( NULL, ... ): %s.\n", SDL_Vulkan_GetResultString(result));
            SDL_free(extensionProperties);
-            return SDL_FALSE;
+            return false;
        }
        for (uint32_t i = 0; i< extensionCount; i++) {
            if (SDL_strcmp(extensionProperties[i].extensionName, extName) == 0) {
                SDL_free(extensionProperties);
-                return SDL_TRUE;
+                return true;
            }
        }
        SDL_free(extensionProperties);
    }

-    return SDL_FALSE;
+    return false;
 }

-static SDL_bool VULKAN_ValidationLayersFound(void)
+static bool VULKAN_ValidationLayersFound(void)
 {
    uint32_t instanceLayerCount = 0;
    uint32_t i;
-    SDL_bool foundValidation = SDL_FALSE;
+    bool foundValidation = false;

    vkEnumerateInstanceLayerProperties(&instanceLayerCount, NULL);
    if (instanceLayerCount > 0) {
@@ -1663,7 +1663,7 @@ static SDL_bool VULKAN_ValidationLayersFound(void)
        vkEnumerateInstanceLayerProperties(&instanceLayerCount, instanceLayers);
        for (i = 0; i < instanceLayerCount; i++) {
            if (!SDL_strcmp(SDL_VULKAN_VALIDATION_LAYER_NAME, instanceLayers[i].layerName)) {
-                foundValidation = SDL_TRUE;
+                foundValidation = true;
                break;
            }
        }
@@ -1691,7 +1691,7 @@ static VkResult VULKAN_CreateDeviceResources(SDL_Renderer *renderer, SDL_Propert
    SDL_VideoDevice *device = SDL_GetVideoDevice();
    VkResult result = VK_SUCCESS;
    PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = NULL;
-    SDL_bool createDebug = SDL_GetHintBoolean(SDL_HINT_RENDER_VULKAN_DEBUG, SDL_FALSE);
+    bool createDebug = SDL_GetHintBoolean(SDL_HINT_RENDER_VULKAN_DEBUG, false);
    const char *validationLayerName[] = { SDL_VULKAN_VALIDATION_LAYER_NAME };

    if (SDL_Vulkan_LoadLibrary(NULL) < 0) {
@@ -1727,7 +1727,7 @@ static VkResult VULKAN_CreateDeviceResources(SDL_Renderer *renderer, SDL_Propert
    // Create VkInstance
    rendererData->instance = (VkInstance)SDL_GetPointerProperty(create_props, SDL_PROP_RENDERER_CREATE_VULKAN_INSTANCE_POINTER, NULL);
    if (rendererData->instance) {
-        rendererData->instance_external = SDL_TRUE;
+        rendererData->instance_external = true;
    } else {
        VkInstanceCreateInfo instanceCreateInfo = { 0 };
        VkApplicationInfo appInfo = { 0 };
@@ -1771,7 +1771,7 @@ static VkResult VULKAN_CreateDeviceResources(SDL_Renderer *renderer, SDL_Propert
    // Create Vulkan surface
    rendererData->surface = (VkSurfaceKHR)SDL_GetNumberProperty(create_props, SDL_PROP_RENDERER_CREATE_VULKAN_SURFACE_NUMBER, 0);
    if (rendererData->surface) {
-        rendererData->surface_external = SDL_TRUE;
+        rendererData->surface_external = true;
    } else {
        if (!device->Vulkan_CreateSurface || (device->Vulkan_CreateSurface(device, renderer->window, rendererData->instance, NULL, &rendererData->surface) < 0)) {
            VULKAN_DestroyAll(renderer);
@@ -1801,13 +1801,13 @@ static VkResult VULKAN_CreateDeviceResources(SDL_Renderer *renderer, SDL_Propert

    if (rendererData->supportsKHRGetPhysicalDeviceProperties2 &&
        VULKAN_DeviceExtensionsFound(rendererData, 4, &deviceExtensionNames[1])) {
-        rendererData->supportsKHRSamplerYCbCrConversion = SDL_TRUE;
+        rendererData->supportsKHRSamplerYCbCrConversion = true;
    }

    // Create Vulkan device
    rendererData->device = (VkDevice)SDL_GetPointerProperty(create_props, SDL_PROP_RENDERER_CREATE_VULKAN_DEVICE_POINTER, NULL);
    if (rendererData->device) {
-        rendererData->device_external = SDL_TRUE;
+        rendererData->device_external = true;
    } else {
        VkPhysicalDeviceSamplerYcbcrConversionFeatures deviceSamplerYcbcrConversionFeatures = { 0 };
        VkDeviceQueueCreateInfo deviceQueueCreateInfo[2] = { { 0 }, { 0 } };
@@ -2452,7 +2452,7 @@ static VkResult VULKAN_CreateWindowSizeDependentResources(SDL_Renderer *renderer
        rendererData->recreateSwapchain = VK_TRUE;
    }

-    rendererData->viewportDirty = SDL_TRUE;
+    rendererData->viewportDirty = true;

    return result;
 }
@@ -2472,11 +2472,11 @@ static void VULKAN_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *ev
    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;

    if (event->type == SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED) {
-        rendererData->recreateSwapchain = SDL_TRUE;
+        rendererData->recreateSwapchain = true;
    }
 }

-static SDL_bool VULKAN_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
+static bool VULKAN_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
 {
    SDL_BlendFactor srcColorFactor = SDL_GetBlendModeSrcColorFactor(blendMode);
    SDL_BlendFactor srcAlphaFactor = SDL_GetBlendModeSrcAlphaFactor(blendMode);
@@ -2491,9 +2491,9 @@ static SDL_bool VULKAN_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode b
        GetBlendFactor(dstColorFactor) == VK_BLEND_FACTOR_MAX_ENUM ||
        GetBlendFactor(dstAlphaFactor) == VK_BLEND_FACTOR_MAX_ENUM ||
        GetBlendOp(alphaOperation) == VK_BLEND_OP_MAX_ENUM) {
-        return SDL_FALSE;
+        return false;
    }
-    return SDL_TRUE;
+    return true;
 }

 static int VULKAN_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_PropertiesID create_props)
@@ -3074,7 +3074,7 @@ static int VULKAN_QueueDrawPoints(SDL_Renderer *renderer, SDL_RenderCommand *cmd
 {
    VertexPositionColor *verts = (VertexPositionColor *)SDL_AllocateRenderVertices(renderer, count * sizeof(VertexPositionColor), 0, &cmd->data.draw.first);
    int i;
-    SDL_bool convert_color = SDL_RenderingLinearSpace(renderer);
+    bool convert_color = SDL_RenderingLinearSpace(renderer);

    if (!verts) {
        return -1;
@@ -3103,7 +3103,7 @@ static int VULKAN_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd,
    int i;
    int count = indices ? num_indices : num_vertices;
    VertexPositionColor *verts = (VertexPositionColor *)SDL_AllocateRenderVertices(renderer, count * sizeof(VertexPositionColor), 0, &cmd->data.draw.first);
-    SDL_bool convert_color = SDL_RenderingLinearSpace(renderer);
+    bool convert_color = SDL_RenderingLinearSpace(renderer);
    VULKAN_TextureData *textureData = texture ? (VULKAN_TextureData *)texture->internal : NULL;
    float u_scale = textureData ? (float)texture->w / textureData->width : 0.0f;
    float v_scale = textureData ? (float)texture->h / textureData->height : 0.0f;
@@ -3151,7 +3151,7 @@ static int VULKAN_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd,
    return 0;
 }

-static SDL_bool VULKAN_UpdateVertexBuffer(SDL_Renderer *renderer,
+static bool VULKAN_UpdateVertexBuffer(SDL_Renderer *renderer,
                                    const void *vertexData, size_t dataSizeInBytes, VULKAN_DrawStateCache *stateCache)
 {
    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
@@ -3165,7 +3165,7 @@ static SDL_bool VULKAN_UpdateVertexBuffer(SDL_Renderer *renderer,
    if (rendererData->issueBatch) {
        if (VULKAN_IssueBatch(rendererData) != VK_SUCCESS) {
            SDL_SetError("Failed to issue intermediate batch");
-            return SDL_FALSE;
+            return false;
        }
    }
    // If the existing vertex buffer isn't big enough, we need to recreate a big enough one
@@ -3183,10 +3183,10 @@ static SDL_bool VULKAN_UpdateVertexBuffer(SDL_Renderer *renderer,
    rendererData->currentVertexBuffer++;
    if (rendererData->currentVertexBuffer >= SDL_VULKAN_NUM_VERTEX_BUFFERS) {
        rendererData->currentVertexBuffer = 0;
-        rendererData->issueBatch = SDL_TRUE;
+        rendererData->issueBatch = true;
    }

-    return SDL_TRUE;
+    return true;
 }

 static int VULKAN_UpdateViewport(SDL_Renderer *renderer)
@@ -3229,7 +3229,7 @@ static int VULKAN_UpdateViewport(SDL_Renderer *renderer)
    vkViewport.maxDepth = 1.0f;
    vkCmdSetViewport(rendererData->currentCommandBuffer, 0, 1, &vkViewport);

-    rendererData->viewportDirty = SDL_FALSE;
+    rendererData->viewportDirty = false;
    return 0;
 }

@@ -3252,7 +3252,7 @@ static int VULKAN_UpdateClipRect(SDL_Renderer *renderer)
    }
    vkCmdSetScissor(rendererData->currentCommandBuffer, 0, 1, &scissor);

-    rendererData->cliprectDirty = SDL_FALSE;
+    rendererData->cliprectDirty = false;
    return 0;
 }

@@ -3479,7 +3479,7 @@ static VkDescriptorSet VULKAN_AllocateDescriptorSet(SDL_Renderer *renderer, VULK
    return descriptorSet;
 }

-static SDL_bool VULKAN_SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, VULKAN_Shader shader, VkPipelineLayout pipelineLayout, VkDescriptorSetLayout descriptorSetLayout,
+static bool VULKAN_SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, VULKAN_Shader shader, VkPipelineLayout pipelineLayout, VkDescriptorSetLayout descriptorSetLayout,
    const PixelShaderConstants *shader_constants, VkPrimitiveTopology topology, VkImageView imageView, VkSampler sampler, const Float4X4 *matrix, VULKAN_DrawStateCache *stateCache)

 {
@@ -3487,7 +3487,7 @@ static SDL_bool VULKAN_SetDrawState(SDL_Renderer *renderer, const SDL_RenderComm
    const SDL_BlendMode blendMode = cmd->data.draw.blend;
    VkFormat format = rendererData->surfaceFormat.format;
    const Float4X4 *newmatrix = matrix ? matrix : &rendererData->identity;
-    SDL_bool updateConstants = SDL_FALSE;
+    bool updateConstants = false;
    PixelShaderConstants solid_constants;
    VkDescriptorSet descriptorSet;
    VkBuffer constantBuffer;
@@ -3495,7 +3495,7 @@ static SDL_bool VULKAN_SetDrawState(SDL_Renderer *renderer, const SDL_RenderComm
    int i;

    if (!VULKAN_ActivateCommandBuffer(renderer, VK_ATTACHMENT_LOAD_OP_LOAD, NULL, stateCache)) {
-        return SDL_FALSE;
+        return false;
    }

    // See if we need to change the pipeline state
@@ -3531,13 +3531,13 @@ static SDL_bool VULKAN_SetDrawState(SDL_Renderer *renderer, const SDL_RenderComm
        }

        vkCmdBindPipeline(rendererData->currentCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, rendererData->currentPipelineState->pipeline);
-        updateConstants = SDL_TRUE;
+        updateConstants = true;
    }

    if (rendererData->viewportDirty) {
        if (VULKAN_UpdateViewport(renderer) == 0) {
            // vertexShaderConstantsData.projectionAndView has changed
-            updateConstants = SDL_TRUE;
+            updateConstants = true;
        }
    }

@@ -3545,7 +3545,7 @@ static SDL_bool VULKAN_SetDrawState(SDL_Renderer *renderer, const SDL_RenderComm
        VULKAN_UpdateClipRect(renderer);
    }

-    if (updateConstants == SDL_TRUE || SDL_memcmp(&rendererData->vertexShaderConstantsData.model, newmatrix, sizeof(*newmatrix)) != 0) {
+    if (updateConstants == true || SDL_memcmp(&rendererData->vertexShaderConstantsData.model, newmatrix, sizeof(*newmatrix)) != 0) {
        SDL_memcpy(&rendererData->vertexShaderConstantsData.model, newmatrix, sizeof(*newmatrix));
        vkCmdPushConstants(rendererData->currentCommandBuffer, rendererData->currentPipelineState->pipelineLayout, VK_SHADER_STAGE_VERTEX_BIT, 0,
            sizeof(rendererData->vertexShaderConstantsData),
@@ -3591,7 +3591,7 @@ static SDL_bool VULKAN_SetDrawState(SDL_Renderer *renderer, const SDL_RenderComm

                if (result != VK_SUCCESS) {
                    SDL_SetError("[Vulkan] Could not allocate new memory for constant buffer" );
-                    return SDL_FALSE;
+                    return false;
                }

                rendererData->numConstantBuffers[rendererData->currentCommandBufferIndex]++;
@@ -3617,18 +3617,18 @@ static SDL_bool VULKAN_SetDrawState(SDL_Renderer *renderer, const SDL_RenderComm
    // Allocate/update descriptor set with the bindings
    descriptorSet = VULKAN_AllocateDescriptorSet(renderer, shader, descriptorSetLayout, sampler, constantBuffer, constantBufferOffset, imageView);
    if (descriptorSet == VK_NULL_HANDLE) {
-        return SDL_FALSE;
+        return false;
    }

    // Bind the descriptor set with the sampler/UBO/image views
    vkCmdBindDescriptorSets(rendererData->currentCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, rendererData->currentPipelineState->pipelineLayout,
            0, 1, &descriptorSet, 0, NULL);

-    return SDL_TRUE;
+    return true;
 }


-static SDL_bool VULKAN_SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const Float4X4 *matrix, VULKAN_DrawStateCache *stateCache)
+static bool VULKAN_SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const Float4X4 *matrix, VULKAN_DrawStateCache *stateCache)
 {
    SDL_Texture *texture = cmd->data.draw.texture;
    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
@@ -3670,11 +3670,11 @@ static SDL_bool VULKAN_SetCopyState(SDL_Renderer *renderer, const SDL_RenderComm
    }

    if (textureData->mainImage.imageLayout != VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {
-        SDL_bool stoppedRenderPass = SDL_FALSE;
+        bool stoppedRenderPass = false;
        if (rendererData->currentRenderPass != VK_NULL_HANDLE) {
            vkCmdEndRenderPass(rendererData->currentCommandBuffer);
            rendererData->currentRenderPass = VK_NULL_HANDLE;
-            stoppedRenderPass = SDL_TRUE;
+            stoppedRenderPass = true;
        }

        VULKAN_RecordPipelineImageBarrier(rendererData,
@@ -3704,7 +3704,7 @@ static void VULKAN_InvalidateCachedState(SDL_Renderer *renderer)
 {
    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
    rendererData->currentPipelineState = NULL;
-    rendererData->cliprectDirty = SDL_TRUE;
+    rendererData->cliprectDirty = true;
 }

 static int VULKAN_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
@@ -3717,7 +3717,7 @@ static int VULKAN_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd
        if (VULKAN_UpdateForWindowSizeChange(renderer) != VK_SUCCESS) {
            return -1;
        }
-        rendererData->recreateSwapchain = SDL_FALSE;
+        rendererData->recreateSwapchain = false;
    }

    if (!VULKAN_UpdateVertexBuffer(renderer, vertices, vertsize, &stateCache)) {
@@ -3736,8 +3736,8 @@ static int VULKAN_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd
            SDL_Rect *viewport = &rendererData->currentViewport;
            if (SDL_memcmp(viewport, &cmd->data.viewport.rect, sizeof(cmd->data.viewport.rect)) != 0) {
                SDL_copyp(viewport, &cmd->data.viewport.rect);
-                rendererData->viewportDirty = SDL_TRUE;
-                rendererData->cliprectDirty = SDL_TRUE;
+                rendererData->viewportDirty = true;
+                rendererData->cliprectDirty = true;
            }
            break;
        }
@@ -3747,18 +3747,18 @@ static int VULKAN_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd
            const SDL_Rect *rect = &cmd->data.cliprect.rect;
            if (rendererData->currentCliprectEnabled != cmd->data.cliprect.enabled) {
                rendererData->currentCliprectEnabled = cmd->data.cliprect.enabled;
-                rendererData->cliprectDirty = SDL_TRUE;
+                rendererData->cliprectDirty = true;
            }
            if (SDL_memcmp(&rendererData->currentCliprect, rect, sizeof(*rect)) != 0) {
                SDL_copyp(&rendererData->currentCliprect, rect);
-                rendererData->cliprectDirty = SDL_TRUE;
+                rendererData->cliprectDirty = true;
            }
            break;
        }

        case SDL_RENDERCMD_CLEAR:
        {
-            SDL_bool convert_color = SDL_RenderingLinearSpace(renderer);
+            bool convert_color = SDL_RenderingLinearSpace(renderer);
            SDL_FColor color = cmd->data.color.color;
            if (convert_color) {
                SDL_ConvertToLinear(&color);
@@ -3981,7 +3981,7 @@ static int VULKAN_RenderPresent(SDL_Renderer *renderer)
    if (rendererData->currentCommandBuffer) {

        rendererData->currentPipelineState = VK_NULL_HANDLE;
-        rendererData->viewportDirty = SDL_TRUE;
+        rendererData->viewportDirty = true;

        VULKAN_RecordPipelineImageBarrier(rendererData,
            VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
@@ -4081,7 +4081,7 @@ static int VULKAN_SetVSync(SDL_Renderer *renderer, const int vsync)
    }
    if (vsync != rendererData->vsync) {
        rendererData->vsync = vsync;
-        rendererData->recreateSwapchain = SDL_TRUE;
+        rendererData->recreateSwapchain = true;
    }
    return 0;
 }