diff --git a/examples/renderer/02-primitives/renderer-primitives.c b/examples/renderer/02-primitives/renderer-primitives.c
index cb5f57c14..bae450b6f 100644
--- a/examples/renderer/02-primitives/renderer-primitives.c
+++ b/examples/renderer/02-primitives/renderer-primitives.c
@@ -24,11 +24,13 @@ SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[])
         return SDL_APP_FAILURE;
     }
 
-    if (!SDL_CreateWindowAndRenderer("examples/renderer/primitives", 640, 480, 0, &window, &renderer)) {
+    if (!SDL_CreateWindowAndRenderer("examples/renderer/primitives", 640, 480, SDL_WINDOW_RESIZABLE, &window, &renderer)) {
         SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Couldn't create window/renderer!", SDL_GetError(), NULL);
         return SDL_APP_FAILURE;
     }
 
+    SDL_SetRenderLogicalPresentation(renderer, 640, 480, SDL_LOGICAL_PRESENTATION_LETTERBOX, SDL_SCALEMODE_NEAREST);
+
     /* set up some random points */
     for (i = 0; i < SDL_arraysize(points); i++) {
         points[i].x = (SDL_randf() * 440.0f) + 100.0f;
@@ -53,7 +55,7 @@ SDL_AppResult SDL_AppIterate(void *appstate)
     SDL_FRect rect;
 
     /* as you can see from this, rendering draws over whatever was drawn before it. */
-    SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);  /* black, full alpha */
+    SDL_SetRenderDrawColor(renderer, 33, 33, 33, 255);  /* black, full alpha */
     SDL_RenderClear(renderer);  /* start with a blank canvas. */
 
     /* draw a filled rectangle in the middle of the canvas. */
diff --git a/src/render/SDL_render.c b/src/render/SDL_render.c
index a17365aa2..11b2a59c6 100644
--- a/src/render/SDL_render.c
+++ b/src/render/SDL_render.c
@@ -431,10 +431,9 @@ static void UpdatePixelViewport(SDL_Renderer *renderer, SDL_RenderViewState *vie
 
 static bool QueueCmdSetViewport(SDL_Renderer *renderer)
 {
-    SDL_Rect viewport;
     bool result = true;
 
-    viewport = renderer->view->pixel_viewport;
+    SDL_Rect viewport = renderer->view->pixel_viewport;
 
     if (!renderer->viewport_queued ||
         SDL_memcmp(&viewport, &renderer->last_queued_viewport, sizeof(viewport)) != 0) {
@@ -467,11 +466,9 @@ static void UpdatePixelClipRect(SDL_Renderer *renderer, SDL_RenderViewState *vie
 
 static bool QueueCmdSetClipRect(SDL_Renderer *renderer)
 {
-    SDL_Rect clip_rect;
     bool result = true;
 
-    clip_rect = renderer->view->pixel_clip_rect;
-
+    SDL_Rect clip_rect = renderer->view->pixel_clip_rect;
     if (!renderer->cliprect_queued ||
         renderer->view->clipping_enabled != renderer->last_queued_cliprect_enabled ||
         SDL_memcmp(&clip_rect, &renderer->last_queued_cliprect, sizeof(clip_rect)) != 0) {
@@ -718,7 +715,6 @@ static bool QueueCmdGeometry(SDL_Renderer *renderer, SDL_Texture *texture,
     cmd = PrepQueueCmdDraw(renderer, SDL_RENDERCMD_GEOMETRY, texture);
     if (cmd) {
         cmd->data.draw.texture_address_mode = texture_address_mode;
-
         result = renderer->QueueGeometry(renderer, cmd, texture,
                                          xy, xy_stride,
                                          color, color_stride, uv, uv_stride,
@@ -794,7 +790,7 @@ static void UpdateHDRProperties(SDL_Renderer *renderer)
     UpdateColorScale(renderer);
 }
 
-static bool UpdateLogicalPresentation(SDL_Renderer *renderer);
+static void UpdateLogicalPresentation(SDL_Renderer *renderer);
 
 
 int SDL_GetNumRenderDrivers(void)
@@ -835,6 +831,8 @@ static bool SDLCALL SDL_RendererEventWatch(void *userdata, SDL_Event *event)
             if (event->type == SDL_EVENT_WINDOW_RESIZED ||
                 event->type == SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED ||
                 event->type == SDL_EVENT_WINDOW_METAL_VIEW_RESIZED) {
+
+SDL_Log("Window is now %dx%d", event->window.data1, event->window.data2);
                 UpdateMainViewDimensions(renderer);
                 UpdateLogicalPresentation(renderer);
             } else if (event->type == SDL_EVENT_WINDOW_HIDDEN) {
@@ -2485,7 +2483,7 @@ void SDL_UnlockTexture(SDL_Texture *texture)
     texture->locked_surface = NULL;
 }
 
-static bool SDL_SetRenderTargetInternal(SDL_Renderer *renderer, SDL_Texture *texture)
+bool SDL_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
 {
     // texture == NULL is valid and means reset the target to the window
     if (texture) {
@@ -2514,6 +2512,8 @@ static bool SDL_SetRenderTargetInternal(SDL_Renderer *renderer, SDL_Texture *tex
     renderer->target = texture;
     if (texture) {
         renderer->view = &texture->view;
+    } else if (renderer->logical_presentation_mode != SDL_LOGICAL_PRESENTATION_DISABLED) {
+        renderer->view = &renderer->logical_view;
     } else {
         renderer->view = &renderer->main_view;
     }
@@ -2537,46 +2537,28 @@ static bool SDL_SetRenderTargetInternal(SDL_Renderer *renderer, SDL_Texture *tex
     return true;
 }
 
-bool SDL_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
-{
-    if (!texture && renderer->logical_target) {
-        return SDL_SetRenderTargetInternal(renderer, renderer->logical_target);
-    } else {
-        return SDL_SetRenderTargetInternal(renderer, texture);
-    }
-}
-
 SDL_Texture *SDL_GetRenderTarget(SDL_Renderer *renderer)
 {
     CHECK_RENDERER_MAGIC(renderer, NULL);
-
-    if (renderer->target == renderer->logical_target) {
+    if (!renderer->target) {
         return NULL;
-    } else {
-        return (SDL_Texture *)SDL_GetPointerProperty(SDL_GetTextureProperties(renderer->target), SDL_PROP_TEXTURE_PARENT_POINTER, renderer->target);
     }
+    return (SDL_Texture *) SDL_GetPointerProperty(SDL_GetTextureProperties(renderer->target), SDL_PROP_TEXTURE_PARENT_POINTER, renderer->target);
 }
 
-static bool UpdateLogicalPresentation(SDL_Renderer *renderer)
+static void UpdateLogicalPresentation(SDL_Renderer *renderer)
 {
-    float logical_w = 1.0f, logical_h = 1.0f;
-    float output_w = (float)renderer->main_view.pixel_w;
-    float output_h = (float)renderer->main_view.pixel_h;
-    float want_aspect = 1.0f;
-    float real_aspect = 1.0f;
-    float scale;
-
     if (renderer->logical_presentation_mode == SDL_LOGICAL_PRESENTATION_DISABLED) {
-        // All done!
-        return true;
+        renderer->view = &renderer->main_view;
+        return;  // All done!
     }
 
-    if (!SDL_GetTextureSize(renderer->logical_target, &logical_w, &logical_h)) {
-        goto error;
-    }
-
-    want_aspect = logical_w / logical_h;
-    real_aspect = output_w / output_h;
+    const float output_w = (float)renderer->main_view.pixel_w;
+    const float output_h = (float)renderer->main_view.pixel_h;
+    const float logical_w = renderer->logical_w;
+    const float logical_h = renderer->logical_h;
+    const float want_aspect = logical_w / logical_h;
+    const float real_aspect = output_w / output_h;
 
     renderer->logical_src_rect.x = 0.0f;
     renderer->logical_src_rect.y = 0.0f;
@@ -2584,6 +2566,7 @@ static bool UpdateLogicalPresentation(SDL_Renderer *renderer)
     renderer->logical_src_rect.h = logical_h;
 
     if (renderer->logical_presentation_mode == SDL_LOGICAL_PRESENTATION_INTEGER_SCALE) {
+        float scale;
         if (want_aspect > real_aspect) {
             scale = (float)((int)output_w / (int)logical_w); // This an integer division!
         } else {
@@ -2609,7 +2592,7 @@ static bool UpdateLogicalPresentation(SDL_Renderer *renderer)
     } else if (want_aspect > real_aspect) {
         if (renderer->logical_presentation_mode == SDL_LOGICAL_PRESENTATION_LETTERBOX) {
             // We want a wider aspect ratio than is available - letterbox it
-            scale = output_w / logical_w;
+            const float scale = output_w / logical_w;
             renderer->logical_dst_rect.x = 0.0f;
             renderer->logical_dst_rect.w = output_w;
             renderer->logical_dst_rect.h = SDL_floorf(logical_h * scale);
@@ -2619,7 +2602,7 @@ static bool UpdateLogicalPresentation(SDL_Renderer *renderer)
                zoom so logical height matches the real height
                and the width will grow off the screen
              */
-            scale = output_h / logical_h;
+            const float scale = output_h / logical_h;
             renderer->logical_dst_rect.y = 0.0f;
             renderer->logical_dst_rect.h = output_h;
             renderer->logical_dst_rect.w = SDL_floorf(logical_w * scale);
@@ -2628,7 +2611,7 @@ static bool UpdateLogicalPresentation(SDL_Renderer *renderer)
     } else {
         if (renderer->logical_presentation_mode == SDL_LOGICAL_PRESENTATION_LETTERBOX) {
             // We want a narrower aspect ratio than is available - use side-bars
-            scale = output_h / logical_h;
+            const float scale = output_h / logical_h;
             renderer->logical_dst_rect.y = 0.0f;
             renderer->logical_dst_rect.h = output_h;
             renderer->logical_dst_rect.w = SDL_floorf(logical_w * scale);
@@ -2638,7 +2621,7 @@ static bool UpdateLogicalPresentation(SDL_Renderer *renderer)
                zoom so logical width matches the real width
                and the height will grow off the screen
              */
-            scale = output_w / logical_w;
+            const float scale = output_w / logical_w;
             renderer->logical_dst_rect.x = 0.0f;
             renderer->logical_dst_rect.w = output_w;
             renderer->logical_dst_rect.h = SDL_floorf(logical_h * scale);
@@ -2646,97 +2629,58 @@ static bool UpdateLogicalPresentation(SDL_Renderer *renderer)
         }
     }
 
-    SDL_SetTextureScaleMode(renderer->logical_target, renderer->logical_scale_mode);
+    renderer->logical_scale_x = (logical_w != 0.0f) ? renderer->logical_dst_rect.w / logical_w : 0.0f;
+    renderer->logical_scale_y = (logical_h != 0.0f) ? renderer->logical_dst_rect.h / logical_h : 0.0f;
 
-    if (!renderer->target) {
-        SDL_SetRenderTarget(renderer, renderer->logical_target);
-    }
+    renderer->logical_view.viewport.x = (int) SDL_roundf(renderer->logical_dst_rect.x);
+    renderer->logical_view.viewport.y = (int) SDL_roundf(renderer->logical_dst_rect.y);
+    renderer->logical_view.viewport.w = (int) SDL_roundf(renderer->logical_dst_rect.w);
+    renderer->logical_view.viewport.h = (int) SDL_roundf(renderer->logical_dst_rect.h);
+    renderer->logical_view.pixel_w = renderer->logical_view.viewport.w;
+    renderer->logical_view.pixel_h = renderer->logical_view.viewport.h;
+    renderer->logical_view.scale.x = renderer->logical_scale_x;
+    renderer->logical_view.scale.y = renderer->logical_scale_y;
 
-    return true;
+    SDL_copyp(&renderer->logical_view.pixel_viewport, &renderer->logical_view.viewport);
+    SDL_copyp(&renderer->logical_view.clip_rect, &renderer->logical_view.viewport);
+    UpdatePixelClipRect(renderer, &renderer->logical_view);
 
-error:
-    SDL_SetRenderLogicalPresentation(renderer, 0, 0, SDL_LOGICAL_PRESENTATION_DISABLED, SDL_SCALEMODE_NEAREST);
-    return false;
+    renderer->view = &renderer->logical_view;
 }
 
 bool SDL_SetRenderLogicalPresentation(SDL_Renderer *renderer, int w, int h, SDL_RendererLogicalPresentation mode, SDL_ScaleMode scale_mode)
 {
     CHECK_RENDERER_MAGIC(renderer, false);
 
-    if (mode == SDL_LOGICAL_PRESENTATION_DISABLED) {
-        if (renderer->logical_target) {
-            SDL_DestroyTexture(renderer->logical_target);
-        }
-    } else {
-        if (renderer->logical_target) {
-            SDL_PropertiesID props = SDL_GetTextureProperties(renderer->logical_target);
-            if (!props) {
-                goto error;
-            }
-
-            int existing_w = (int)SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_WIDTH_NUMBER, 0);
-            int existing_h = (int)SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_HEIGHT_NUMBER, 0);
-
-            if (w != existing_w || h != existing_h) {
-                SDL_DestroyTexture(renderer->logical_target);
-            }
-        }
-        if (!renderer->logical_target) {
-            renderer->logical_target = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_UNKNOWN, SDL_TEXTUREACCESS_TARGET, w, h);
-            if (!renderer->logical_target) {
-                goto error;
-            }
-            SDL_SetTextureBlendMode(renderer->logical_target, SDL_BLENDMODE_NONE);
-        }
-    }
-
     renderer->logical_presentation_mode = mode;
     renderer->logical_scale_mode = scale_mode;
+    renderer->logical_w = w;
+    renderer->logical_h = h;
 
-    return UpdateLogicalPresentation(renderer);
+    UpdateLogicalPresentation(renderer);
+    SDL_copyp(&renderer->logical_view.clip_rect, &renderer->logical_view.viewport);
+    UpdatePixelClipRect(renderer, &renderer->logical_view);
 
-error:
-    SDL_SetRenderLogicalPresentation(renderer, 0, 0, SDL_LOGICAL_PRESENTATION_DISABLED, SDL_SCALEMODE_NEAREST);
-    return false;
+    return true;
 }
 
 bool SDL_GetRenderLogicalPresentation(SDL_Renderer *renderer, int *w, int *h, SDL_RendererLogicalPresentation *mode, SDL_ScaleMode *scale_mode)
 {
-    if (w) {
-        *w = 0;
-    }
-    if (h) {
-        *h = 0;
-    }
-    if (mode) {
-        *mode = SDL_LOGICAL_PRESENTATION_DISABLED;
-    }
-    if (scale_mode) {
-        *scale_mode = SDL_SCALEMODE_NEAREST;
-    }
+    #define SETVAL(ptr, val) if (ptr) { *ptr = val; }
+
+    SETVAL(w, 0);
+    SETVAL(h, 0);
+    SETVAL(mode, SDL_LOGICAL_PRESENTATION_DISABLED);
+    SETVAL(scale_mode, SDL_SCALEMODE_NEAREST);
 
     CHECK_RENDERER_MAGIC(renderer, false);
 
-    if (renderer->logical_target) {
-        SDL_PropertiesID props = SDL_GetTextureProperties(renderer->logical_target);
-        if (!props) {
-            return false;
-        }
+    SETVAL(mode, renderer->logical_presentation_mode);
+    SETVAL(scale_mode, renderer->logical_scale_mode);
+    SETVAL(w, renderer->logical_w);
+    SETVAL(h, renderer->logical_h);
 
-        if (w) {
-            *w = (int)SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_WIDTH_NUMBER, 0);
-        }
-        if (h) {
-            *h = (int)SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_HEIGHT_NUMBER, 0);
-        }
-    }
-
-    if (mode) {
-        *mode = renderer->logical_presentation_mode;
-    }
-    if (scale_mode) {
-        *scale_mode = renderer->logical_scale_mode;
-    }
+    #undef SETVAL
 
     return true;
 }
@@ -2814,12 +2758,14 @@ static void SDL_RenderLogicalBorders(SDL_Renderer *renderer)
 
 static void SDL_RenderLogicalPresentation(SDL_Renderer *renderer)
 {
-    SDL_assert(renderer->target == NULL);
-    SDL_SetRenderViewport(renderer, NULL);
-    SDL_SetRenderClipRect(renderer, NULL);
-    SDL_SetRenderScale(renderer, 1.0f, 1.0f);
-    SDL_RenderLogicalBorders(renderer);
-    SDL_RenderTexture(renderer, renderer->logical_target, &renderer->logical_src_rect, &renderer->logical_dst_rect);
+    if (renderer->logical_presentation_mode != SDL_LOGICAL_PRESENTATION_DISABLED) {
+        renderer->view = &renderer->main_view;
+        SDL_SetRenderViewport(renderer, NULL);  // !!! FIXME: do we need to set this back afterwards?
+        SDL_SetRenderClipRect(renderer, NULL);
+        SDL_SetRenderScale(renderer, 1.0f, 1.0f);
+        SDL_RenderLogicalBorders(renderer);
+        renderer->view = &renderer->logical_view;
+    }
 }
 
 bool SDL_RenderCoordinatesFromWindow(SDL_Renderer *renderer, float window_x, float window_y, float *x, float *y)
@@ -2834,7 +2780,7 @@ bool SDL_RenderCoordinatesFromWindow(SDL_Renderer *renderer, float window_x, flo
     render_y = window_y * renderer->dpi_scale.y;
 
     // Convert from pixels within the window to pixels within the view
-    if (renderer->logical_target) {
+    if (renderer->logical_presentation_mode != SDL_LOGICAL_PRESENTATION_DISABLED) {
         const SDL_FRect *src = &renderer->logical_src_rect;
         const SDL_FRect *dst = &renderer->logical_dst_rect;
         render_x = ((render_x - dst->x) * src->w) / dst->w;
@@ -2842,8 +2788,8 @@ bool SDL_RenderCoordinatesFromWindow(SDL_Renderer *renderer, float window_x, flo
     }
 
     // Convert from pixels within the view to render coordinates
-    if (renderer->logical_target) {
-        view = &renderer->logical_target->view;
+    if (renderer->logical_presentation_mode != SDL_LOGICAL_PRESENTATION_DISABLED) {
+        view = &renderer->logical_view;
     } else {
         view = &renderer->main_view;
     }
@@ -2866,8 +2812,8 @@ bool SDL_RenderCoordinatesToWindow(SDL_Renderer *renderer, float x, float y, flo
     CHECK_RENDERER_MAGIC(renderer, false);
 
     // Convert from render coordinates to pixels within the view
-    if (renderer->logical_target) {
-        view = &renderer->logical_target->view;
+    if (renderer->logical_presentation_mode != SDL_LOGICAL_PRESENTATION_DISABLED) {
+        view = &renderer->logical_view;
     } else {
         view = &renderer->main_view;
     }
@@ -2875,7 +2821,7 @@ bool SDL_RenderCoordinatesToWindow(SDL_Renderer *renderer, float x, float y, flo
     y = (view->viewport.y + y) * view->scale.y;
 
     // Convert from pixels within the view to pixels within the window
-    if (renderer->logical_target) {
+    if (renderer->logical_presentation_mode != SDL_LOGICAL_PRESENTATION_DISABLED) {
         const SDL_FRect *src = &renderer->logical_src_rect;
         const SDL_FRect *dst = &renderer->logical_dst_rect;
         x = dst->x + ((x * dst->w) / src->w);
@@ -2911,15 +2857,15 @@ bool SDL_ConvertEventToRenderCoordinates(SDL_Renderer *renderer, SDL_Event *even
                 float scale = renderer->dpi_scale.x;
 
                 // Convert from pixels within the window to pixels within the view
-                if (renderer->logical_target) {
+                if (renderer->logical_presentation_mode != SDL_LOGICAL_PRESENTATION_DISABLED) {
                     const SDL_FRect *src = &renderer->logical_src_rect;
                     const SDL_FRect *dst = &renderer->logical_dst_rect;
                     scale = (scale * src->w) / dst->w;
                 }
 
                 // Convert from pixels within the view to render coordinates
-                if (renderer->logical_target) {
-                    view = &renderer->logical_target->view;
+                if (renderer->logical_presentation_mode != SDL_LOGICAL_PRESENTATION_DISABLED) {
+                    view = &renderer->logical_view;
                 } else {
                     view = &renderer->main_view;
                 }
@@ -2934,15 +2880,15 @@ bool SDL_ConvertEventToRenderCoordinates(SDL_Renderer *renderer, SDL_Event *even
                 float scale = renderer->dpi_scale.y;
 
                 // Convert from pixels within the window to pixels within the view
-                if (renderer->logical_target) {
+                if (renderer->logical_presentation_mode != SDL_LOGICAL_PRESENTATION_DISABLED) {
                     const SDL_FRect *src = &renderer->logical_src_rect;
                     const SDL_FRect *dst = &renderer->logical_dst_rect;
                     scale = (scale * src->h) / dst->h;
                 }
 
                 // Convert from pixels within the view to render coordinates
-                if (renderer->logical_target) {
-                    view = &renderer->logical_target->view;
+                if (renderer->logical_presentation_mode != SDL_LOGICAL_PRESENTATION_DISABLED) {
+                    view = &renderer->logical_view;
                 } else {
                     view = &renderer->main_view;
                 }
@@ -3043,15 +2989,19 @@ bool SDL_RenderViewportSet(SDL_Renderer *renderer)
 
 static void GetRenderViewportSize(SDL_Renderer *renderer, SDL_FRect *rect)
 {
+    const bool islogical = (renderer->view == &renderer->logical_view);
+    const float logical_xscale = islogical ? renderer->logical_view.scale.x : 1.0f;
+    const float logical_yscale = islogical ? renderer->logical_view.scale.y : 1.0f;
+
     rect->x = 0.0f;
     rect->y = 0.0f;
     if (renderer->view->viewport.w >= 0) {
-        rect->w = (float)renderer->view->viewport.w;
+        rect->w = (float)renderer->view->viewport.w / logical_xscale;
     } else {
         rect->w = renderer->view->pixel_w / renderer->view->scale.x;
     }
     if (renderer->view->viewport.h >= 0) {
-        rect->h = (float)renderer->view->viewport.h;
+        rect->h = (float)renderer->view->viewport.h / logical_yscale;
     } else {
         rect->h = renderer->view->pixel_h / renderer->view->scale.y;
     }
@@ -3600,9 +3550,8 @@ bool SDL_RenderLines(SDL_Renderer *renderer, const SDL_FPoint *points, int count
     }
 #endif
 
-    if (renderer->line_method == SDL_RENDERLINEMETHOD_POINTS) {
-        result = RenderLinesWithRectsF(renderer, points, count);
-    } else if (renderer->line_method == SDL_RENDERLINEMETHOD_GEOMETRY) {
+    const bool islogical = (renderer->view == &renderer->logical_view);
+    if (islogical || (renderer->line_method == SDL_RENDERLINEMETHOD_GEOMETRY)) {
         bool isstack1;
         bool isstack2;
         const float scale_x = renderer->view->scale.x;
@@ -3722,6 +3671,8 @@ bool SDL_RenderLines(SDL_Renderer *renderer, const SDL_FPoint *points, int count
         SDL_small_free(xy, isstack1);
         SDL_small_free(indices, isstack2);
 
+    } else if (renderer->line_method == SDL_RENDERLINEMETHOD_POINTS) {
+        result = RenderLinesWithRectsF(renderer, points, count);
     } else if (renderer->view->scale.x != 1.0f || renderer->view->scale.y != 1.0f) {
         result = RenderLinesWithRectsF(renderer, points, count);
     } else {
@@ -5008,10 +4959,9 @@ bool SDL_RenderPresent(SDL_Renderer *renderer)
 
     CHECK_RENDERER_MAGIC(renderer, false);
 
-    if (renderer->logical_target) {
-        SDL_SetRenderTargetInternal(renderer, NULL);
-        SDL_RenderLogicalPresentation(renderer);
-    }
+    // !!! FIXME: fail if using a render target? Or just implicitly set the render target to NULL now?
+
+    SDL_RenderLogicalPresentation(renderer);
 
     if (renderer->transparent_window) {
         SDL_RenderApplyWindowShape(renderer);
@@ -5029,10 +4979,6 @@ bool SDL_RenderPresent(SDL_Renderer *renderer)
         presented = false;
     }
 
-    if (renderer->logical_target) {
-        SDL_SetRenderTargetInternal(renderer, renderer->logical_target);
-    }
-
     if (renderer->simulate_vsync ||
         (!presented && renderer->wanted_vsync)) {
         SDL_SimulateRenderVSync(renderer);
@@ -5053,22 +4999,12 @@ static bool SDL_DestroyTextureInternal(SDL_Texture *texture, bool is_destroying)
         // Renderer get destroyed, avoid to queue more commands
     } else {
         if (texture == renderer->target) {
-            SDL_SetRenderTargetInternal(renderer, NULL); // implies command queue flush
-
-            if (texture == renderer->logical_target) {
-                // Complete any logical presentation
-                SDL_RenderLogicalPresentation(renderer);
-                FlushRenderCommands(renderer);
-            }
+            SDL_SetRenderTarget(renderer, NULL); // implies command queue flush
         } else {
             FlushRenderCommandsIfTextureNeeded(texture);
         }
     }
 
-    if (texture == renderer->logical_target) {
-        renderer->logical_target = NULL;
-    }
-
     SDL_SetObjectValid(texture, SDL_OBJECT_TYPE_TEXTURE, false);
 
     if (texture->next) {
diff --git a/src/render/SDL_sysrender.h b/src/render/SDL_sysrender.h
index dcd0604bd..62db7d92f 100644
--- a/src/render/SDL_sysrender.h
+++ b/src/render/SDL_sysrender.h
@@ -63,7 +63,6 @@ typedef struct SDL_RenderViewState
     SDL_Rect pixel_clip_rect;
     bool clipping_enabled;
     SDL_FPoint scale;
-
 } SDL_RenderViewState;
 
 // Define the SDL texture structure
@@ -240,11 +239,13 @@ struct SDL_Renderer
     Uint64 last_present;
 
     // Support for logical output coordinates
-    SDL_Texture *logical_target;
     SDL_RendererLogicalPresentation logical_presentation_mode;
     SDL_ScaleMode logical_scale_mode;
+    int logical_w, logical_h;
     SDL_FRect logical_src_rect;
     SDL_FRect logical_dst_rect;
+    float logical_scale_x, logical_scale_y;
+    SDL_RenderViewState logical_view;
 
     SDL_RenderViewState *view;
     SDL_RenderViewState main_view;
diff --git a/test/testsprite.c b/test/testsprite.c
index 9568efa97..eeaa94538 100644
--- a/test/testsprite.c
+++ b/test/testsprite.c
@@ -81,10 +81,14 @@ static void MoveSprites(SDL_Renderer *renderer, SDL_Texture *sprite)
     SDL_FRect *position, *velocity;
 
     /* Query the sizes */
+viewport.x = viewport.y = 0;
+viewport.w = 640;
+viewport.h = 480;
+/*
     SDL_SetRenderViewport(renderer, NULL);
     SDL_GetRenderSafeArea(renderer, &viewport);
     SDL_SetRenderViewport(renderer, &viewport);
-
+*/
     /* Cycle the color and alpha, if desired */
     if (cycle_color) {
         current_color += cycle_direction;
@@ -495,6 +499,10 @@ SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[])
         return SDL_APP_FAILURE;
     }
 
+    for (i = 0; i < state->num_windows; i++) {
+        SDL_SetRenderLogicalPresentation(state->renderers[i], 640, 480, SDL_LOGICAL_PRESENTATION_LETTERBOX, SDL_SCALEMODE_NEAREST);
+    }
+
     /* Create the windows, initialize the renderers, and load the textures */
     sprites =
         (SDL_Texture **)SDL_malloc(state->num_windows * sizeof(*sprites));
diff --git a/test/testspriteminimal.c b/test/testspriteminimal.c
index a89d3a396..26ec38d3d 100644
--- a/test/testspriteminimal.c
+++ b/test/testspriteminimal.c
@@ -117,11 +117,13 @@ int main(int argc, char *argv[])
         goto quit;
     }
 
-    if (!SDL_CreateWindowAndRenderer("testspriteminimal", WINDOW_WIDTH, WINDOW_HEIGHT, 0, &window, &renderer)) {
+    if (!SDL_CreateWindowAndRenderer("testspriteminimal", WINDOW_WIDTH, WINDOW_HEIGHT, SDL_WINDOW_RESIZABLE, &window, &renderer)) {
         return_code = 2;
         goto quit;
     }
 
+    SDL_SetRenderLogicalPresentation(renderer, WINDOW_WIDTH, WINDOW_HEIGHT, SDL_LOGICAL_PRESENTATION_LETTERBOX, SDL_SCALEMODE_NEAREST);
+
     sprite = CreateTexture(renderer, icon_bmp, icon_bmp_len, &sprite_w, &sprite_h);
 
     if (!sprite) {