The rendering functions take a context so it's clear what window they're...

The rendering functions take a context so it's clear what window they're drawing to.  This also potentially opens to the door to multi-threaded rendering in the future.

src/SDL_compat.c

@@ -31,7 +31,7 @@
 #include "video/SDL_yuv_sw_c.h"
 
 static SDL_Window *SDL_VideoWindow = NULL;
-static SDL_RendererInfo SDL_VideoRendererInfo;
+static SDL_Renderer *SDL_VideoRenderer = NULL;
 static SDL_Texture *SDL_VideoTexture = NULL;
 static SDL_Surface *SDL_VideoSurface = NULL;
 static SDL_Surface *SDL_ShadowSurface = NULL;
@@ -467,7 +467,8 @@ SDL_ResizeVideoMode(int width, int height, int bpp, Uint32 flags)
     /* Destroy the screen texture and recreate it */
     SDL_QueryTexture(SDL_VideoTexture, &format, &access, &w, &h);
     SDL_DestroyTexture(SDL_VideoTexture);
-    SDL_VideoTexture = SDL_CreateTexture(format, access, width, height);
+    SDL_VideoTexture = SDL_CreateTexture(SDL_VideoRenderer, format,
+                                         access, width, height);
     if (!SDL_VideoTexture) {
         return -1;
     }
@@ -667,20 +668,20 @@ SDL_SetVideoMode(int width, int height, int bpp, Uint32 flags)
     }
 
     /* Create a renderer for the window */
-    if (SDL_CreateRenderer(SDL_VideoWindow, -1, 0) < 0) {
+    SDL_VideoRenderer = SDL_CreateRenderer(SDL_VideoWindow, -1, 0);
+    if (!SDL_VideoRenderer) {
         return NULL;
     }
-    SDL_GetRendererInfo(&SDL_VideoRendererInfo);
 
     /* Create a texture for the screen surface */
-    SDL_VideoTexture =
-        SDL_CreateTexture(desired_format, SDL_TEXTUREACCESS_STREAMING, width,
-                          height);
+    SDL_VideoTexture = SDL_CreateTexture(SDL_VideoRenderer, desired_format,
+                                         SDL_TEXTUREACCESS_STREAMING,
+                                         width, height);
 
     if (!SDL_VideoTexture) {
-        SDL_VideoTexture =
-            SDL_CreateTexture(desktop_format,
-                              SDL_TEXTUREACCESS_STREAMING, width, height);
+        SDL_VideoTexture = SDL_CreateTexture(SDL_VideoRenderer, desktop_format,
+                                             SDL_TEXTUREACCESS_STREAMING,
+                                             width, height);
     }
     if (!SDL_VideoTexture) {
         return NULL;
@@ -890,8 +891,8 @@ SDL_UpdateRects(SDL_Surface * screen, int numrects, SDL_Rect * rects)
         rect.y = 0;
         rect.w = screen->w;
         rect.h = screen->h;
-        SDL_RenderCopy(SDL_VideoTexture, &rect, &rect);
-        SDL_RenderPresent();
+        SDL_RenderCopy(SDL_VideoRenderer, SDL_VideoTexture, &rect, &rect);
+        SDL_RenderPresent(SDL_VideoRenderer);
     }
 }
 
@@ -1584,7 +1585,8 @@ SDL_CreateYUVOverlay(int w, int h, Uint32 format, SDL_Surface * display)
     }
 
     overlay->hwdata->texture =
-        SDL_CreateTexture(texture_format, SDL_TEXTUREACCESS_STREAMING, w, h);
+        SDL_CreateTexture(SDL_VideoRenderer, texture_format,
+                          SDL_TEXTUREACCESS_STREAMING, w, h);
     if (overlay->hwdata->texture) {
         overlay->hwdata->sw = NULL;
     } else {
@@ -1600,7 +1602,7 @@ SDL_CreateYUVOverlay(int w, int h, Uint32 format, SDL_Surface * display)
         SDL_GetCurrentDisplayMode(&current_mode);
         texture_format = current_mode.format;
         overlay->hwdata->texture =
-            SDL_CreateTexture(texture_format,
+            SDL_CreateTexture(SDL_VideoRenderer, texture_format,
                               SDL_TEXTUREACCESS_STREAMING, w, h);
     }
     if (!overlay->hwdata->texture) {
@@ -1688,10 +1690,10 @@ SDL_DisplayYUVOverlay(SDL_Overlay * overlay, SDL_Rect * dstrect)
         SDL_SetError("Passed a NULL overlay or dstrect");
         return -1;
     }
-    if (SDL_RenderCopy(overlay->hwdata->texture, NULL, dstrect) < 0) {
+    if (SDL_RenderCopy(SDL_VideoRenderer, overlay->hwdata->texture, NULL, dstrect) < 0) {
         return -1;
     }
-    SDL_RenderPresent();
+    SDL_RenderPresent(SDL_VideoRenderer);
     return 0;
 }
 

src/events/SDL_windowevents.c

@@ -106,7 +106,6 @@ SDL_SendWindowEvent(SDL_Window * window, Uint8 windowevent, int data1,
         }
         window->w = data1;
         window->h = data2;
-        SDL_OnWindowResized(window);
         break;
     case SDL_WINDOWEVENT_MINIMIZED:
         if (window->flags & SDL_WINDOW_MINIMIZED) {

src/video/SDL_renderer_gl.c

@@ -66,8 +66,8 @@ bytes_per_pixel(const Uint32 format)
 static const float inv255f = 1.0f / 255.0f;
 
 static SDL_Renderer *GL_CreateRenderer(SDL_Window * window, Uint32 flags);
-static int GL_ActivateRenderer(SDL_Renderer * renderer);
-static int GL_DisplayModeChanged(SDL_Renderer * renderer);
+static void GL_WindowEvent(SDL_Renderer * renderer,
+                           const SDL_WindowEvent *event);
 static int GL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture);
 static int GL_QueryTexturePixels(SDL_Renderer * renderer,
                                  SDL_Texture * texture, void **pixels,
@@ -277,8 +277,7 @@ GL_CreateRenderer(SDL_Window * window, Uint32 flags)
         return NULL;
     }
 
-    renderer->ActivateRenderer = GL_ActivateRenderer;
-    renderer->DisplayModeChanged = GL_DisplayModeChanged;
+    renderer->WindowEvent = GL_WindowEvent;
     renderer->CreateTexture = GL_CreateTexture;
     renderer->QueryTexturePixels = GL_QueryTexturePixels;
     renderer->SetTexturePalette = GL_SetTexturePalette;
@@ -408,15 +407,20 @@ GL_CreateRenderer(SDL_Window * window, Uint32 flags)
     return renderer;
 }
 
+static SDL_GLContext SDL_CurrentContext = NULL;
+
 static int
 GL_ActivateRenderer(SDL_Renderer * renderer)
 {
     GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
     SDL_Window *window = renderer->window;
 
+    if (SDL_CurrentContext != data->context) {
         if (SDL_GL_MakeCurrent(window, data->context) < 0) {
             return -1;
         }
+        SDL_CurrentContext = data->context;
+    }
     if (data->updateSize) {
         data->glMatrixMode(GL_PROJECTION);
         data->glLoadIdentity();
@@ -430,14 +434,16 @@ GL_ActivateRenderer(SDL_Renderer * renderer)
     return 0;
 }
 
-static int
-GL_DisplayModeChanged(SDL_Renderer * renderer)
+static void
+GL_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)
 {
     GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
 
+    if (event->event == SDL_WINDOWEVENT_RESIZED) {
         /* Rebind the context to the window area and update matrices */
+        SDL_CurrentContext = NULL;
         data->updateSize = SDL_TRUE;
-    return GL_ActivateRenderer(renderer);
+    }
 }
 
 static __inline__ int
@@ -717,6 +723,8 @@ GL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
     GLuint shader = 0;
     GLenum result;
 
+    GL_ActivateRenderer(renderer);
+
     if (!convert_format(renderdata, texture->format, &internalFormat,
                         &format, &type)) {
         SDL_SetError("Texture format %s not supported by OpenGL",
@@ -874,6 +882,8 @@ GL_SetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture,
     GL_TextureData *data = (GL_TextureData *) texture->driverdata;
     Uint8 *palette;
 
+    GL_ActivateRenderer(renderer);
+
     if (!data->palette) {
         SDL_SetError("Texture doesn't have a palette");
         return -1;
@@ -938,6 +948,8 @@ GL_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
     GL_TextureData *data = (GL_TextureData *) texture->driverdata;
     GLenum result;
 
+    GL_ActivateRenderer(renderer);
+
     renderdata->glGetError();
     SetupTextureUpdate(renderdata, texture, pitch);
     renderdata->glEnable(data->type);
@@ -1018,6 +1030,8 @@ GL_RenderClear(SDL_Renderer * renderer)
 {
     GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
 
+    GL_ActivateRenderer(renderer);
+
     data->glClearColor((GLfloat) renderer->r * inv255f,
                        (GLfloat) renderer->g * inv255f,
                        (GLfloat) renderer->b * inv255f,
@@ -1035,6 +1049,8 @@ GL_RenderDrawPoints(SDL_Renderer * renderer, const SDL_Point * points,
     GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
     int i;
 
+    GL_ActivateRenderer(renderer);
+
     GL_SetBlendMode(data, renderer->blendMode);
 
     data->glColor4f((GLfloat) renderer->r * inv255f,
@@ -1058,6 +1074,8 @@ GL_RenderDrawLines(SDL_Renderer * renderer, const SDL_Point * points,
     GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
     int i;
 
+    GL_ActivateRenderer(renderer);
+
     GL_SetBlendMode(data, renderer->blendMode);
 
     data->glColor4f((GLfloat) renderer->r * inv255f,
@@ -1126,6 +1144,8 @@ GL_RenderDrawRects(SDL_Renderer * renderer, const SDL_Rect ** rects, int count)
     GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
     int i, x, y;
 
+    GL_ActivateRenderer(renderer);
+
     GL_SetBlendMode(data, renderer->blendMode);
 
     data->glColor4f((GLfloat) renderer->r * inv255f,
@@ -1164,6 +1184,8 @@ GL_RenderFillRects(SDL_Renderer * renderer, const SDL_Rect ** rects, int count)
     GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
     int i;
 
+    GL_ActivateRenderer(renderer);
+
     GL_SetBlendMode(data, renderer->blendMode);
 
     data->glColor4f((GLfloat) renderer->r * inv255f,
@@ -1189,6 +1211,8 @@ GL_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
     int minx, miny, maxx, maxy;
     GLfloat minu, maxu, minv, maxv;
 
+    GL_ActivateRenderer(renderer);
+
     if (texturedata->dirty.list) {
         SDL_DirtyRect *dirty;
         void *pixels;
@@ -1276,6 +1300,8 @@ GL_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
     Uint8 *src, *dst, *tmp;
     int length, rows;
 
+    GL_ActivateRenderer(renderer);
+
     if (!convert_format(data, pixel_format, &internalFormat, &format, &type)) {
         /* FIXME: Do a temp copy to a format that is supported */
         SDL_SetError("Unsupported pixel format");
@@ -1323,6 +1349,8 @@ GL_RenderWritePixels(SDL_Renderer * renderer, const SDL_Rect * rect,
     Uint8 *src, *dst, *tmp;
     int length, rows;
 
+    GL_ActivateRenderer(renderer);
+
     if (!convert_format(data, pixel_format, &internalFormat, &format, &type)) {
         /* FIXME: Do a temp copy to a format that is supported */
         SDL_SetError("Unsupported pixel format");
@@ -1360,6 +1388,8 @@ GL_RenderWritePixels(SDL_Renderer * renderer, const SDL_Rect * rect,
 static void
 GL_RenderPresent(SDL_Renderer * renderer)
 {
+    GL_ActivateRenderer(renderer);
+
     SDL_GL_SwapWindow(renderer->window);
 }
 
@@ -1369,6 +1399,8 @@ GL_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
     GL_RenderData *renderdata = (GL_RenderData *) renderer->driverdata;
     GL_TextureData *data = (GL_TextureData *) texture->driverdata;
 
+    GL_ActivateRenderer(renderer);
+
     if (!data) {
         return;
     }

src/video/SDL_renderer_gles.c

@@ -54,8 +54,8 @@ glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height)
 static const float inv255f = 1.0f / 255.0f;
 
 static SDL_Renderer *GLES_CreateRenderer(SDL_Window * window, Uint32 flags);
-static int GLES_ActivateRenderer(SDL_Renderer * renderer);
-static int GLES_DisplayModeChanged(SDL_Renderer * renderer);
+static void GLES_WindowEvent(SDL_Renderer * renderer,
+                             const SDL_WindowEvent *event);
 static int GLES_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture);
 static int GLES_QueryTexturePixels(SDL_Renderer * renderer,
                                    SDL_Texture * texture, void **pixels,
@@ -218,8 +218,7 @@ GLES_CreateRenderer(SDL_Window * window, Uint32 flags)
         return NULL;
     }
 
-    renderer->ActivateRenderer = GLES_ActivateRenderer;
-    renderer->DisplayModeChanged = GLES_DisplayModeChanged;
+    renderer->WindowEvent = GLES_WindowEvent;
     renderer->CreateTexture = GLES_CreateTexture;
     renderer->QueryTexturePixels = GLES_QueryTexturePixels;
     renderer->SetTexturePalette = GLES_SetTexturePalette;
@@ -311,6 +310,8 @@ GLES_CreateRenderer(SDL_Window * window, Uint32 flags)
     return renderer;
 }
 
+static SDL_GLContext SDL_CurrentContext = NULL;
+
 static int
 GLES_ActivateRenderer(SDL_Renderer * renderer)
 {
@@ -318,9 +319,12 @@ GLES_ActivateRenderer(SDL_Renderer * renderer)
     GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
     SDL_Window *window = renderer->window;
 
+    if (SDL_CurrentContext != data->context) {
         if (SDL_GL_MakeCurrent(window, data->context) < 0) {
             return -1;
         }
+        SDL_CurrentContext = data->context;
+    }
     if (data->updateSize) {
         data->glMatrixMode(GL_PROJECTION);
         data->glLoadIdentity();
@@ -334,13 +338,16 @@ GLES_ActivateRenderer(SDL_Renderer * renderer)
     return 0;
 }
 
-static int
-GLES_DisplayModeChanged(SDL_Renderer * renderer)
+static void
+GLES_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)
 {
     GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
 
+    if (event->event == SDL_WINDOWEVENT_RESIZED) {
+        /* Rebind the context to the window area and update matrices */
+        SDL_CurrentContext = NULL;
         data->updateSize = SDL_TRUE;
-    return 0;
+    }
 }
 
 static __inline__ int
@@ -364,6 +371,8 @@ GLES_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
     int texture_w, texture_h;
     GLenum result;
 
+    GLES_ActivateRenderer(renderer);
+
     switch (texture->format) {
     case SDL_PIXELFORMAT_RGB24:
         internalFormat = GL_RGB;
@@ -498,6 +507,8 @@ GLES_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
     void * temp_ptr;
     int i;
 
+    GLES_ActivateRenderer(renderer);
+
     renderdata->glGetError();
     renderdata->glEnable(data->type);
     SetupTextureUpdate(renderdata, texture, pitch);
@@ -599,6 +610,8 @@ GLES_RenderDrawPoints(SDL_Renderer * renderer, const SDL_Point * points,
     int i;
     GLshort *vertices;
 
+    GLES_ActivateRenderer(renderer);
+
     GLES_SetBlendMode(data, renderer->blendMode);
 
     data->glColor4f((GLfloat) renderer->r * inv255f,
@@ -626,6 +639,8 @@ GLES_RenderDrawLines(SDL_Renderer * renderer, const SDL_Point * points,
     int i;
     GLshort *vertices;
 
+    GLES_ActivateRenderer(renderer);
+
     GLES_SetBlendMode(data, renderer->blendMode);
 
     data->glColor4f((GLfloat) renderer->r * inv255f,
@@ -659,6 +674,8 @@ GLES_RenderDrawRects(SDL_Renderer * renderer, const SDL_Rect ** rects,
     GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
     int i;
 
+    GLES_ActivateRenderer(renderer);
+
     GLES_SetBlendMode(data, renderer->blendMode);
 
     data->glColor4f((GLfloat) renderer->r * inv255f,
@@ -696,6 +713,8 @@ GLES_RenderFillRects(SDL_Renderer * renderer, const SDL_Rect ** rects,
     GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
     int i;
 
+    GLES_ActivateRenderer(renderer);
+
     GLES_SetBlendMode(data, renderer->blendMode);
 
     data->glColor4f((GLfloat) renderer->r * inv255f,
@@ -739,6 +758,8 @@ GLES_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
     void *temp_buffer;          /* used for reformatting dirty rect pixels */
     void *temp_ptr;
 
+    GLES_ActivateRenderer(renderer);
+
     data->glEnable(GL_TEXTURE_2D);
 
     if (texturedata->dirty.list) {
@@ -859,6 +880,8 @@ GLES_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
 static void
 GLES_RenderPresent(SDL_Renderer * renderer)
 {
+    GLES_ActivateRenderer(renderer);
+
     SDL_GL_SwapWindow(renderer->window);
 }
 
@@ -867,6 +890,8 @@ GLES_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
 {
     GLES_TextureData *data = (GLES_TextureData *) texture->driverdata;
 
+    GLES_ActivateRenderer(renderer);
+
     if (!data) {
         return;
     }

src/video/SDL_renderer_sw.c

@@ -32,8 +32,8 @@
 /* SDL surface based renderer implementation */
 
 static SDL_Renderer *SW_CreateRenderer(SDL_Window * window, Uint32 flags);
-static int SW_ActivateRenderer(SDL_Renderer * renderer);
-static int SW_DisplayModeChanged(SDL_Renderer * renderer);
+static void SW_WindowEvent(SDL_Renderer * renderer,
+                           const SDL_WindowEvent *event);
 static int SW_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture);
 static int SW_QueryTexturePixels(SDL_Renderer * renderer,
                                  SDL_Texture * texture, void **pixels,
@@ -212,8 +212,7 @@ SW_CreateRenderer(SDL_Window * window, Uint32 flags)
         SDL_OutOfMemory();
         return NULL;
     }
-    renderer->ActivateRenderer = SW_ActivateRenderer;
-    renderer->DisplayModeChanged = SW_DisplayModeChanged;
+    renderer->WindowEvent = SW_WindowEvent;
 
     renderer->RenderDrawPoints = SW_RenderDrawPoints;
     renderer->RenderDrawLines = SW_RenderDrawLines;
@@ -287,47 +286,34 @@ SW_CreateRenderer(SDL_Window * window, Uint32 flags)
     return renderer;
 }
 
-static int
+static SDL_Texture *
 SW_ActivateRenderer(SDL_Renderer * renderer)
 {
     SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
     SDL_Window *window = renderer->window;
-    int i, n;
 
-    if (data->renderer && data->renderer->ActivateRenderer) {
-        if (data->renderer->ActivateRenderer(data->renderer) < 0) {
-            return -1;
-        }
-    }
     if (data->updateSize) {
         /* Recreate the textures for the new window size */
         if (data->texture) {
             DestroyTexture(data->renderer, data->texture);
-            data->texture = 0;
         }
         data->texture = CreateTexture(data->renderer, data->format,
                                       window->w, window->h);
-        if (!data->texture) {
-            return -1;
-        }
+        if (data->texture) {
             data->updateSize = SDL_FALSE;
         }
-    return 0;
+    }
+    return data->texture;
 }
 
-static int
-SW_DisplayModeChanged(SDL_Renderer * renderer)
+static void
+SW_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)
 {
     SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
 
-    if (data->renderer && data->renderer->DisplayModeChanged) {
-        if (data->renderer->DisplayModeChanged(data->renderer) < 0) {
-            return -1;
-        }
-    }
-    /* Rebind the context to the window area */
+    if (event->event == SDL_WINDOWEVENT_RESIZED) {
         data->updateSize = SDL_TRUE;
-    return SW_ActivateRenderer(renderer);
+    }
 }
 
 static int
@@ -496,12 +482,16 @@ SW_RenderDrawPoints(SDL_Renderer * renderer, const SDL_Point * points,
                     int count)
 {
     SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
-    SDL_Texture *texture = data->texture;
+    SDL_Texture *texture = SW_ActivateRenderer(renderer);
     SDL_Rect rect;
     int i;
     int x, y;
     int status = 0;
 
+    if (!texture) {
+        return -1;
+    }
+
     /* Get the smallest rectangle that contains everything */
     rect.x = 0;
     rect.y = 0;
@@ -555,12 +545,16 @@ SW_RenderDrawLines(SDL_Renderer * renderer, const SDL_Point * points,
                    int count)
 {
     SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
-    SDL_Texture *texture = data->texture;
+    SDL_Texture *texture = SW_ActivateRenderer(renderer);
     SDL_Rect clip, rect;
     int i;
     int x1, y1, x2, y2;
     int status = 0;
 
+    if (!texture) {
+        return -1;
+    }
+
     /* Get the smallest rectangle that contains everything */
     clip.x = 0;
     clip.y = 0;
@@ -619,12 +613,16 @@ SW_RenderDrawRects(SDL_Renderer * renderer, const SDL_Rect ** rects,
                    int count)
 {
     SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
-    SDL_Texture *texture = data->texture;
+    SDL_Texture *texture = SW_ActivateRenderer(renderer);
     SDL_Rect clip, rect;
     Uint32 color = 0;
     int i;
     int status = 0;
 
+    if (!texture) {
+        return -1;
+    }
+
     clip.x = 0;
     clip.y = 0;
     clip.w = texture->w;
@@ -671,12 +669,16 @@ SW_RenderFillRects(SDL_Renderer * renderer, const SDL_Rect ** rects,
                    int count)
 {
     SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
-    SDL_Texture *texture = data->texture;
+    SDL_Texture *texture = SW_ActivateRenderer(renderer);
     SDL_Rect clip, rect;
     Uint32 color = 0;
     int i;
     int status = 0;
 
+    if (!texture) {
+        return -1;
+    }
+
     clip.x = 0;
     clip.y = 0;
     clip.w = texture->w;
@@ -724,6 +726,10 @@ SW_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
     SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
     int status;
 
+    if (!SW_ActivateRenderer(renderer)) {
+        return -1;
+    }
+
     if (data->renderer->LockTexture(data->renderer, data->texture,
                                     dstrect, 1, &data->surface.pixels,
                                     &data->surface.pitch) < 0) {
@@ -760,6 +766,10 @@ SW_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
 {
     SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
 
+    if (!SW_ActivateRenderer(renderer)) {
+        return -1;
+    }
+
     if (data->renderer->LockTexture(data->renderer, data->texture,
                                     rect, 0, &data->surface.pixels,
                                     &data->surface.pitch) < 0) {
@@ -780,6 +790,10 @@ SW_RenderWritePixels(SDL_Renderer * renderer, const SDL_Rect * rect,
 {
     SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
 
+    if (!SW_ActivateRenderer(renderer)) {
+        return -1;
+    }
+
     if (data->renderer->LockTexture(data->renderer, data->texture,
                                     rect, 1, &data->surface.pixels,
                                     &data->surface.pitch) < 0) {
@@ -797,9 +811,13 @@ static void
 SW_RenderPresent(SDL_Renderer * renderer)
 {
     SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
-    SDL_Texture *texture = data->texture;
+    SDL_Texture *texture = SW_ActivateRenderer(renderer);
     SDL_Rect rect;
 
+    if (!texture) {
+        return;
+    }
+
     /* Send the data to the display */
     rect.x = 0;
     rect.y = 0;

src/video/SDL_sysvideo.h

@@ -24,6 +24,7 @@
 #ifndef _SDL_sysvideo_h
 #define _SDL_sysvideo_h
 
+#include "SDL_events.h"
 #include "SDL_mouse.h"
 #include "SDL_keysym.h"
 #include "SDL_render.h"
@@ -31,7 +32,6 @@
 
 /* The SDL video driver */
 
-typedef struct SDL_Renderer SDL_Renderer;
 typedef struct SDL_RenderDriver SDL_RenderDriver;
 typedef struct SDL_WindowShaper SDL_WindowShaper;
 typedef struct SDL_ShapeDriver SDL_ShapeDriver;
@@ -61,8 +61,9 @@ struct SDL_Texture
 /* Define the SDL renderer structure */
 struct SDL_Renderer
 {
-    int (*ActivateRenderer) (SDL_Renderer * renderer);
-    int (*DisplayModeChanged) (SDL_Renderer * renderer);
+    const void *magic;
+
+    void (*WindowEvent) (SDL_Renderer * renderer, const SDL_WindowEvent *event);
     int (*CreateTexture) (SDL_Renderer * renderer, SDL_Texture * texture);
     int (*QueryTexturePixels) (SDL_Renderer * renderer, SDL_Texture * texture,
                                void **pixels, int *pitch);
@@ -168,7 +169,6 @@ struct SDL_Window
     Uint32 flags;
 
     SDL_VideoDisplay *display;
-    SDL_Renderer *renderer;
 
     SDL_DisplayMode fullscreen_mode;
     
@@ -208,8 +208,6 @@ struct SDL_VideoDisplay
     SDL_Window *windows;
     SDL_Window *fullscreen_window;
 
-    SDL_Renderer *current_renderer;
-
     SDL_VideoDevice *device;
 
     void *driverdata;
@@ -344,6 +342,7 @@ struct SDL_VideoDevice
     SDL_VideoDisplay *displays;
     int current_display;
     Uint8 window_magic;
+    Uint8 renderer_magic;
     Uint8 texture_magic;
     Uint32 next_object_id;
     char * clipboard_text;
@@ -439,7 +438,6 @@ extern VideoBootStrap Android_bootstrap;
 #endif
 
 #define SDL_CurrentDisplay	(&_this->displays[_this->current_display])
-#define SDL_CurrentRenderer	(SDL_CurrentDisplay->current_renderer)
 
 extern SDL_VideoDevice *SDL_GetVideoDevice(void);
 extern int SDL_AddBasicVideoDisplay(const SDL_DisplayMode * desktop_mode);
@@ -461,7 +459,6 @@ extern int SDL_RecreateWindow(SDL_Window * window, Uint32 flags);
 
 extern void SDL_OnWindowShown(SDL_Window * window);
 extern void SDL_OnWindowHidden(SDL_Window * window);
-extern void SDL_OnWindowResized(SDL_Window * window);
 extern void SDL_OnWindowMinimized(SDL_Window * window);
 extern void SDL_OnWindowRestored(SDL_Window * window);
 extern void SDL_OnWindowFocusGained(SDL_Window * window);

test/common.c

@@ -646,7 +646,10 @@ CommonInit(CommonState * state)
         state->windows =
             (SDL_Window **) SDL_malloc(state->num_windows *
                                         sizeof(*state->windows));
-        if (!state->windows) {
+        state->renderers =
+            (SDL_Renderer **) SDL_malloc(state->num_windows *
+                                        sizeof(*state->renderers));
+        if (!state->windows || !state->renderers) {
             fprintf(stderr, "Out of memory!\n");
             return SDL_FALSE;
         }
@@ -685,6 +688,8 @@ CommonInit(CommonState * state)
 
             SDL_ShowWindow(state->windows[i]);
 
+            state->renderers[i] = NULL;
+
             if (!state->skip_renderer
                 && (state->renderdriver
                     || !(state->window_flags & SDL_WINDOW_OPENGL))) {
@@ -707,8 +712,9 @@ CommonInit(CommonState * state)
                         return SDL_FALSE;
                     }
                 }
-                if (SDL_CreateRenderer
-                    (state->windows[i], m, state->render_flags) < 0) {
+                state->renderers[i] = SDL_CreateRenderer(state->windows[i],
+                                            m, state->render_flags);
+                if (!state->renderers[i]) {
                     fprintf(stderr, "Couldn't create renderer: %s\n",
                             SDL_GetError());
                     return SDL_FALSE;
@@ -717,12 +723,11 @@ CommonInit(CommonState * state)
                     SDL_RendererInfo info;
 
                     fprintf(stderr, "Current renderer:\n");
-                    SDL_GetRendererInfo(&info);
+                    SDL_GetRendererInfo(state->renderers[i], &info);
                     PrintRenderer(&info);
                 }
             }
         }
-        SDL_SelectRenderer(state->windows[0]);
     }
 
     if (state->flags & SDL_INIT_AUDIO) {
@@ -1012,15 +1017,25 @@ CommonEvent(CommonState * state, SDL_Event * event, int *done)
 void
 CommonQuit(CommonState * state)
 {
+    int i;
+
+    if (state->windows) {
+        SDL_free(state->windows);
+    }
+    if (state->renderers) {
+        for (i = 0; i < state->num_windows; ++i) {
+            if (state->renderers[i]) {
+                SDL_DestroyRenderer(state->renderers[i]);
+            }
+        }
+        SDL_free(state->renderers);
+    }
     if (state->flags & SDL_INIT_VIDEO) {
         SDL_VideoQuit();
     }
     if (state->flags & SDL_INIT_AUDIO) {
         SDL_AudioQuit();
     }
-    if (state->windows) {
-        SDL_free(state->windows);
-    }
     SDL_free(state);
 }
 

test/common.h

@@ -39,6 +39,7 @@ typedef struct
     const char *renderdriver;
     Uint32 render_flags;
     SDL_bool skip_renderer;
+    SDL_Renderer **renderers;
 
     /* Audio info */
     const char *audiodriver;

test/testdraw2.c

@@ -19,7 +19,7 @@ static int current_color = 255;
 static SDL_BlendMode blendMode = SDL_BLENDMODE_NONE;
 
 void
-DrawPoints(SDL_Window * window)
+DrawPoints(SDL_Window * window, SDL_Renderer * renderer)
 {
     int i;
     int x, y;
@@ -28,7 +28,6 @@ DrawPoints(SDL_Window * window)
     /* Query the sizes */
     SDL_GetWindowSize(window, &window_w, &window_h);
 
-    SDL_SetRenderDrawBlendMode(blendMode);
     for (i = 0; i < num_objects * 4; ++i) {
         /* Cycle the color and alpha, if desired */
         if (cycle_color) {
@@ -53,18 +52,17 @@ DrawPoints(SDL_Window * window)
                 cycle_direction = -cycle_direction;
             }
         }
-        SDL_SetRenderDrawColor(255, (Uint8) current_color,
+        SDL_SetRenderDrawColor(renderer, 255, (Uint8) current_color,
                                (Uint8) current_color, (Uint8) current_alpha);
 
         x = rand() % window_w;
         y = rand() % window_h;
-        SDL_RenderDrawPoint(x, y);
+        SDL_RenderDrawPoint(renderer, x, y);
     }
-    SDL_SetRenderDrawBlendMode(SDL_BLENDMODE_NONE);
 }
 
 void
-DrawLines(SDL_Window * window)
+DrawLines(SDL_Window * window, SDL_Renderer * renderer)
 {
     int i;
     int x1, y1, x2, y2;
@@ -73,7 +71,6 @@ DrawLines(SDL_Window * window)
     /* Query the sizes */
     SDL_GetWindowSize(window, &window_w, &window_h);
 
-    SDL_SetRenderDrawBlendMode(blendMode);
     for (i = 0; i < num_objects; ++i) {
         /* Cycle the color and alpha, if desired */
         if (cycle_color) {
@@ -98,27 +95,26 @@ DrawLines(SDL_Window * window)
                 cycle_direction = -cycle_direction;
             }
         }
-        SDL_SetRenderDrawColor(255, (Uint8) current_color,
+        SDL_SetRenderDrawColor(renderer, 255, (Uint8) current_color,
                                (Uint8) current_color, (Uint8) current_alpha);
 
         if (i == 0) {
-            SDL_RenderDrawLine(0, 0, window_w - 1, window_h - 1);
-            SDL_RenderDrawLine(0, window_h - 1, window_w - 1, 0);
-            SDL_RenderDrawLine(0, window_h / 2, window_w - 1, window_h / 2);
-            SDL_RenderDrawLine(window_w / 2, 0, window_w / 2, window_h - 1);
+            SDL_RenderDrawLine(renderer, 0, 0, window_w - 1, window_h - 1);
+            SDL_RenderDrawLine(renderer, 0, window_h - 1, window_w - 1, 0);
+            SDL_RenderDrawLine(renderer, 0, window_h / 2, window_w - 1, window_h / 2);
+            SDL_RenderDrawLine(renderer, window_w / 2, 0, window_w / 2, window_h - 1);
         } else {
             x1 = (rand() % (window_w*2)) - window_w;
             x2 = (rand() % (window_w*2)) - window_w;
             y1 = (rand() % (window_h*2)) - window_h;
             y2 = (rand() % (window_h*2)) - window_h;
-            SDL_RenderDrawLine(x1, y1, x2, y2);
+            SDL_RenderDrawLine(renderer, x1, y1, x2, y2);
         }
     }
-    SDL_SetRenderDrawBlendMode(SDL_BLENDMODE_NONE);
 }
 
 void
-DrawRects(SDL_Window * window)
+DrawRects(SDL_Window * window, SDL_Renderer * renderer)
 {
     int i;
     SDL_Rect rect;
@@ -127,7 +123,6 @@ DrawRects(SDL_Window * window)
     /* Query the sizes */
     SDL_GetWindowSize(window, &window_w, &window_h);
 
-    SDL_SetRenderDrawBlendMode(blendMode);
     for (i = 0; i < num_objects / 4; ++i) {
         /* Cycle the color and alpha, if desired */
         if (cycle_color) {
@@ -152,16 +147,15 @@ DrawRects(SDL_Window * window)
                 cycle_direction = -cycle_direction;
             }
         }
-        SDL_SetRenderDrawColor(255, (Uint8) current_color,
+        SDL_SetRenderDrawColor(renderer, 255, (Uint8) current_color,
                                (Uint8) current_color, (Uint8) current_alpha);
 
         rect.w = rand() % (window_h / 2);
         rect.h = rand() % (window_h / 2);
         rect.x = (rand() % (window_w*2) - window_w) - (rect.w / 2);
         rect.y = (rand() % (window_h*2) - window_h) - (rect.h / 2);
-        SDL_RenderFillRect(&rect);
+        SDL_RenderFillRect(renderer, &rect);
     }
-    SDL_SetRenderDrawBlendMode(SDL_BLENDMODE_NONE);
 }
 
 int
@@ -223,9 +217,10 @@ main(int argc, char *argv[])
 
     /* Create the windows and initialize the renderers */
     for (i = 0; i < state->num_windows; ++i) {
-        SDL_SelectRenderer(state->windows[i]);
-        SDL_SetRenderDrawColor(0xA0, 0xA0, 0xA0, 0xFF);
-        SDL_RenderClear();
+        SDL_Renderer *renderer = state->renderers[i];
+        SDL_SetRenderDrawBlendMode(renderer, blendMode);
+        SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);
+        SDL_RenderClear(renderer);
     }
 
     srand((unsigned int)time(NULL));
@@ -239,30 +234,17 @@ main(int argc, char *argv[])
         ++frames;
         while (SDL_PollEvent(&event)) {
             CommonEvent(state, &event, &done);
-            switch (event.type) {
-            case SDL_WINDOWEVENT:
-                switch (event.window.event) {
-                case SDL_WINDOWEVENT_EXPOSED:
-                    SDL_SelectRenderer(SDL_GetWindowFromID(event.window.windowID));
-                    SDL_SetRenderDrawColor(0xA0, 0xA0, 0xA0, 0xFF);
-                    SDL_RenderClear();
-                    break;
-                }
-                break;
-            default:
-                break;
-            }
         }
         for (i = 0; i < state->num_windows; ++i) {
-            SDL_SelectRenderer(state->windows[i]);
-            SDL_SetRenderDrawColor(0xA0, 0xA0, 0xA0, 0xFF);
-            SDL_RenderClear();
+            SDL_Renderer *renderer = state->renderers[i];
+            SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);
+            SDL_RenderClear(renderer);
 
-            DrawRects(state->windows[i]);
-            DrawLines(state->windows[i]);
-            DrawPoints(state->windows[i]);
+            DrawRects(state->windows[i], renderer);
+            DrawLines(state->windows[i], renderer);
+            DrawPoints(state->windows[i], renderer);
 
-            SDL_RenderPresent();
+            SDL_RenderPresent(renderer);
         }
     }
 

test/testintersections.c

@@ -20,7 +20,7 @@ static int current_color = 255;
 static SDL_BlendMode blendMode = SDL_BLENDMODE_NONE;
 
 void
-DrawPoints(SDL_Window * window)
+DrawPoints(SDL_Window * window, SDL_Renderer * renderer)
 {
     int i;
     int x, y;
@@ -29,7 +29,6 @@ DrawPoints(SDL_Window * window)
     /* Query the sizes */
     SDL_GetWindowSize(window, &window_w, &window_h);
 
-    SDL_SetRenderDrawBlendMode(blendMode);
     for (i = 0; i < num_objects * 4; ++i) {
         /* Cycle the color and alpha, if desired */
         if (cycle_color) {
@@ -54,14 +53,13 @@ DrawPoints(SDL_Window * window)
                 cycle_direction = -cycle_direction;
             }
         }
-        SDL_SetRenderDrawColor(255, (Uint8) current_color,
+        SDL_SetRenderDrawColor(renderer, 255, (Uint8) current_color,
                                (Uint8) current_color, (Uint8) current_alpha);
 
         x = rand() % window_w;
         y = rand() % window_h;
-        SDL_RenderDrawPoint(x, y);
+        SDL_RenderDrawPoint(renderer, x, y);
     }
-    SDL_SetRenderDrawBlendMode(SDL_BLENDMODE_NONE);
 }
 
 #define MAX_LINES 16
@@ -86,7 +84,7 @@ add_line(int x1, int y1, int x2, int y2)
 
 
 void
-DrawLines(SDL_Window * window)
+DrawLines(SDL_Window * window, SDL_Renderer * renderer)
 {
     int i;
     int x1, y1, x2, y2;
@@ -95,20 +93,18 @@ DrawLines(SDL_Window * window)
     /* Query the sizes */
     SDL_GetWindowSize(window, &window_w, &window_h);
 
-    SDL_SetRenderDrawBlendMode(blendMode);
     for (i = 0; i < num_lines; ++i) {
-        SDL_SetRenderDrawColor(255, 255, 255, 255);
+        SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
 
         if (i == -1) {
-            SDL_RenderDrawLine(0, 0, window_w - 1, window_h - 1);
-            SDL_RenderDrawLine(0, window_h - 1, window_w - 1, 0);
-            SDL_RenderDrawLine(0, window_h / 2, window_w - 1, window_h / 2);
-            SDL_RenderDrawLine(window_w / 2, 0, window_w / 2, window_h - 1);
+            SDL_RenderDrawLine(renderer, 0, 0, window_w - 1, window_h - 1);
+            SDL_RenderDrawLine(renderer, 0, window_h - 1, window_w - 1, 0);
+            SDL_RenderDrawLine(renderer, 0, window_h / 2, window_w - 1, window_h / 2);
+            SDL_RenderDrawLine(renderer, window_w / 2, 0, window_w / 2, window_h - 1);
         } else {
-            SDL_RenderDrawLine(lines[i].x, lines[i].y, lines[i].w, lines[i].h);
+            SDL_RenderDrawLine(renderer, lines[i].x, lines[i].y, lines[i].w, lines[i].h);
         }
     }
-    SDL_SetRenderDrawBlendMode(SDL_BLENDMODE_NONE);
 }
 
 #define MAX_RECTS 16
@@ -139,7 +135,7 @@ add_rect(int x1, int y1, int x2, int y2)
 }
 
 static void
-DrawRects(SDL_Window * window)
+DrawRects(SDL_Window * window, SDL_Renderer * renderer)
 {
     int i;
     int window_w, window_h;
@@ -147,24 +143,20 @@ DrawRects(SDL_Window * window)
     /* Query the sizes */
     SDL_GetWindowSize(window, &window_w, &window_h);
 
-    SDL_SetRenderDrawBlendMode(SDL_BLENDMODE_NONE);
     for (i = 0; i < num_rects; ++i) {
-        SDL_SetRenderDrawColor(255, 127, 0, 255);
-        SDL_RenderFillRect(&rects[i]);
+        SDL_SetRenderDrawColor(renderer, 255, 127, 0, 255);
+        SDL_RenderFillRect(renderer, &rects[i]);
     }
-    SDL_SetRenderDrawBlendMode(SDL_BLENDMODE_NONE);
 }
 
 static void
-DrawRectLineIntersections(SDL_Window * window)
+DrawRectLineIntersections(SDL_Window * window, SDL_Renderer * renderer)
 {
     int i, j, window_w, window_h;
 
     /* Query the sizes */
     SDL_GetWindowSize(window, &window_w, &window_h);
 
-    SDL_SetRenderDrawBlendMode(SDL_BLENDMODE_NONE);
-
     for (i = 0; i < num_rects; i++)
         for (j = 0; j < num_lines; j++) {
             int x1, y1, x2, y2;
@@ -177,31 +169,25 @@ DrawRectLineIntersections(SDL_Window * window)
             y2 = lines[j].h;
 
             if (SDL_IntersectRectAndLine(&r, &x1, &y1, &x2, &y2)) {
-                SDL_SetRenderDrawColor(0, 255, 55, 255);
-                SDL_RenderDrawLine(x1, y1, x2, y2);
+                SDL_SetRenderDrawColor(renderer, 0, 255, 55, 255);
+                SDL_RenderDrawLine(renderer, x1, y1, x2, y2);
             }
         }
-
-    SDL_SetRenderDrawBlendMode(SDL_BLENDMODE_NONE);
 }
 
 static void
-DrawRectRectIntersections(SDL_Window * window)
+DrawRectRectIntersections(SDL_Window * window, SDL_Renderer * renderer)
 {
     int i, j;
 
-    SDL_SetRenderDrawBlendMode(SDL_BLENDMODE_NONE);
-
     for (i = 0; i < num_rects; i++)
         for (j = i + 1; j < num_rects; j++) {
             SDL_Rect r;
             if (SDL_IntersectRect(&rects[i], &rects[j], &r)) {
-                SDL_SetRenderDrawColor(255, 200, 0, 255);
-                SDL_RenderFillRect(&r);
+                SDL_SetRenderDrawColor(renderer, 255, 200, 0, 255);
+                SDL_RenderFillRect(renderer, &r);
             }
         }
-
-    SDL_SetRenderDrawBlendMode(SDL_BLENDMODE_NONE);
 }
 
 int
@@ -264,9 +250,10 @@ main(int argc, char *argv[])
 
     /* Create the windows and initialize the renderers */
     for (i = 0; i < state->num_windows; ++i) {
-        SDL_SelectRenderer(state->windows[i]);
-        SDL_SetRenderDrawColor(0xA0, 0xA0, 0xA0, 0xFF);
-        SDL_RenderClear();
+        SDL_Renderer *renderer = state->renderers[i];
+        SDL_SetRenderDrawBlendMode(renderer, blendMode);
+        SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);
+        SDL_RenderClear(renderer);
     }
 
     srand(time(NULL));
@@ -311,31 +298,22 @@ main(int argc, char *argv[])
                     break;
                 }
                 break;
-            case SDL_WINDOWEVENT:
-                switch (event.window.event) {
-                case SDL_WINDOWEVENT_EXPOSED:
-                    SDL_SelectRenderer(SDL_GetWindowFromID(event.window.windowID));
-                    SDL_SetRenderDrawColor(0xA0, 0xA0, 0xA0, 0xFF);
-                    SDL_RenderClear();
-                    break;
-                }
-                break;
             default:
                 break;
             }
         }
         for (i = 0; i < state->num_windows; ++i) {
-            SDL_SelectRenderer(state->windows[i]);
-            SDL_SetRenderDrawColor(0xA0, 0xA0, 0xA0, 0xFF);
-            SDL_RenderClear();
+            SDL_Renderer *renderer = state->renderers[i];
+            SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);
+            SDL_RenderClear(renderer);
 
-            DrawRects(state->windows[i]);
-            DrawPoints(state->windows[i]);
-            DrawRectRectIntersections(state->windows[i]);
-            DrawLines(state->windows[i]);
-            DrawRectLineIntersections(state->windows[i]);
+            DrawRects(state->windows[i], renderer);
+            DrawPoints(state->windows[i], renderer);
+            DrawRectRectIntersections(state->windows[i], renderer);
+            DrawLines(state->windows[i], renderer);
+            DrawRectLineIntersections(state->windows[i], renderer);
 
-            SDL_RenderPresent();
+            SDL_RenderPresent(renderer);
         }
     }
 

test/testshape.c

@@ -16,22 +16,22 @@ typedef struct LoadedPicture {
     SDL_WindowShapeMode mode;
 } LoadedPicture;
 
-void render(SDL_Window* window,SDL_Texture *texture,SDL_Rect texture_dimensions) {
-	SDL_SelectRenderer(window);
-	
+void render(SDL_Renderer *renderer,SDL_Texture *texture,SDL_Rect texture_dimensions)
+{
     //Clear render-target to blue.
-	SDL_SetRenderDrawColor(0x00,0x00,0xff,0xff);
-	SDL_RenderClear();
+    SDL_SetRenderDrawColor(renderer,0x00,0x00,0xff,0xff);
+    SDL_RenderClear(renderer);
     
     //Render the texture.
-	SDL_RenderCopy(texture,&texture_dimensions,&texture_dimensions);
+    SDL_RenderCopy(renderer,texture,&texture_dimensions,&texture_dimensions);
     
-	SDL_RenderPresent();
+    SDL_RenderPresent(renderer);
 }
 
 static Uint32 next_time;
 
-Uint32 time_left() {
+Uint32 time_left()
+{
     Uint32 now = SDL_GetTicks();
     if(next_time <= now)
         return 0;
@@ -39,12 +39,14 @@ Uint32 time_left() {
         return next_time - now;
 }
 
-int main(int argc,char** argv) {
+int main(int argc,char** argv)
+{
     Uint8 num_pictures;
     LoadedPicture* pictures;
     int i, j;
     SDL_PixelFormat* format = NULL;
     SDL_Window *window;
+    SDL_Renderer *renderer;
     SDL_Color black = {0,0,0,0xff};
     SDL_Event event;
     int event_pending = 0;
@@ -102,7 +104,8 @@ int main(int argc,char** argv) {
         printf("Could not create shaped window for SDL_Shape.\n");
         exit(-4);
     }
-	if(SDL_CreateRenderer(window,-1,0) == -1) {
+    renderer = SDL_CreateRenderer(window,-1,0);
+    if (!renderer) {
         SDL_DestroyWindow(window);
         for(i=0;i<num_pictures;i++)
             SDL_FreeSurface(pictures[i].surface);
@@ -115,7 +118,7 @@ int main(int argc,char** argv) {
     for(i=0;i<num_pictures;i++)
         pictures[i].texture = NULL;
     for(i=0;i<num_pictures;i++) {
-		pictures[i].texture = SDL_CreateTextureFromSurface(0,pictures[i].surface);
+        pictures[i].texture = SDL_CreateTextureFromSurface(renderer,0,pictures[i].surface);
         if(pictures[i].texture == NULL) {
             j = 0;
             for(j=0;j<num_pictures;i++)
@@ -124,7 +127,7 @@ int main(int argc,char** argv) {
             for(i=0;i<num_pictures;i++)
                 SDL_FreeSurface(pictures[i].surface);
             free(pictures);
-			SDL_DestroyRenderer(window);
+            SDL_DestroyRenderer(renderer);
             SDL_DestroyWindow(window);
             SDL_VideoQuit();
             printf("Could not create texture for SDL_shape.\n");
@@ -166,7 +169,7 @@ int main(int argc,char** argv) {
                 should_exit = 1;
             event_pending = 0;
         }
-		render(window,pictures[current_picture].texture,texture_dimensions);
+        render(renderer,pictures[current_picture].texture,texture_dimensions);
         SDL_Delay(time_left());
         next_time += TICK_INTERVAL;
     }
@@ -174,6 +177,7 @@ int main(int argc,char** argv) {
     //Free the textures.
     for(i=0;i<num_pictures;i++)
         SDL_DestroyTexture(pictures[i].texture);
+    SDL_DestroyRenderer(renderer);
     //Destroy the window.
     SDL_DestroyWindow(window);
     //Free the original surfaces backing the textures.
@@ -185,3 +189,5 @@ int main(int argc,char** argv) {
 
     return 0;
 }
+
+/* vi: set ts=4 sw=4 expandtab: */

test/testsprite2.c

@@ -76,11 +76,11 @@ LoadSprite(char *file)
 
     /* Create textures from the image */
     for (i = 0; i < state->num_windows; ++i) {
-        SDL_SelectRenderer(state->windows[i]);
-        sprites[i] = SDL_CreateTextureFromSurface(0, temp);
+        SDL_Renderer *renderer = state->renderers[i];
+        sprites[i] = SDL_CreateTextureFromSurface(renderer, 0, temp);
         if (!sprites[i]) {
             SDL_SetColorKey(temp, 0, 0);
-		sprites[i] = SDL_CreateTextureFromSurface(0, temp);
+            sprites[i] = SDL_CreateTextureFromSurface(renderer, 0, temp);
         }
         if (!sprites[i]) {
             fprintf(stderr, "Couldn't create texture: %s\n", SDL_GetError());
@@ -96,15 +96,13 @@ LoadSprite(char *file)
 }
 
 void
-MoveSprites(SDL_Window * window, SDL_Texture * sprite)
+MoveSprites(SDL_Window * window, SDL_Renderer * renderer, SDL_Texture * sprite)
 {
     int i, n;
     int window_w, window_h;
     SDL_Rect temp;
     SDL_Rect *position, *velocity;
 
-    SDL_SelectRenderer(window);
-
     /* Query the sizes */
     SDL_GetWindowSize(window, &window_w, &window_h);
 
@@ -136,55 +134,55 @@ MoveSprites(SDL_Window * window, SDL_Texture * sprite)
     }
 
     /* Draw a gray background */
-    SDL_SetRenderDrawColor(0xA0, 0xA0, 0xA0, 0xFF);
-    SDL_RenderClear();
+    SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);
+    SDL_RenderClear(renderer);
 
     /* Test points */
-    SDL_SetRenderDrawColor(0xFF, 0x00, 0x00, 0xFF);
-    SDL_RenderDrawPoint(0, 0);
-    SDL_RenderDrawPoint(window_w-1, 0);
-    SDL_RenderDrawPoint(0, window_h-1);
-    SDL_RenderDrawPoint(window_w-1, window_h-1);
+    SDL_SetRenderDrawColor(renderer, 0xFF, 0x00, 0x00, 0xFF);
+    SDL_RenderDrawPoint(renderer, 0, 0);
+    SDL_RenderDrawPoint(renderer, window_w-1, 0);
+    SDL_RenderDrawPoint(renderer, 0, window_h-1);
+    SDL_RenderDrawPoint(renderer, window_w-1, window_h-1);
 
     /* Test horizontal and vertical lines */
-    SDL_SetRenderDrawColor(0x00, 0xFF, 0x00, 0xFF);
-    SDL_RenderDrawLine(1, 0, window_w-2, 0);
-    SDL_RenderDrawLine(1, window_h-1, window_w-2, window_h-1);
-    SDL_RenderDrawLine(0, 1, 0, window_h-2);
-    SDL_RenderDrawLine(window_w-1, 1, window_w-1, window_h-2);
+    SDL_SetRenderDrawColor(renderer, 0x00, 0xFF, 0x00, 0xFF);
+    SDL_RenderDrawLine(renderer, 1, 0, window_w-2, 0);
+    SDL_RenderDrawLine(renderer, 1, window_h-1, window_w-2, window_h-1);
+    SDL_RenderDrawLine(renderer, 0, 1, 0, window_h-2);
+    SDL_RenderDrawLine(renderer, window_w-1, 1, window_w-1, window_h-2);
 
     /* Test fill and copy */
-    SDL_SetRenderDrawColor(0xFF, 0xFF, 0xFF, 0xFF);
+    SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xFF, 0xFF);
     temp.x = 1;
     temp.y = 1;
     temp.w = sprite_w;
     temp.h = sprite_h;
-    SDL_RenderFillRect(&temp);
-    SDL_RenderCopy(sprite, NULL, &temp);
+    SDL_RenderFillRect(renderer, &temp);
+    SDL_RenderCopy(renderer, sprite, NULL, &temp);
     temp.x = window_w-sprite_w-1;
     temp.y = 1;
     temp.w = sprite_w;
     temp.h = sprite_h;
-    SDL_RenderFillRect(&temp);
-    SDL_RenderCopy(sprite, NULL, &temp);
+    SDL_RenderFillRect(renderer, &temp);
+    SDL_RenderCopy(renderer, sprite, NULL, &temp);
     temp.x = 1;
     temp.y = window_h-sprite_h-1;
     temp.w = sprite_w;
     temp.h = sprite_h;
-    SDL_RenderFillRect(&temp);
-    SDL_RenderCopy(sprite, NULL, &temp);
+    SDL_RenderFillRect(renderer, &temp);
+    SDL_RenderCopy(renderer, sprite, NULL, &temp);
     temp.x = window_w-sprite_w-1;
     temp.y = window_h-sprite_h-1;
     temp.w = sprite_w;
     temp.h = sprite_h;
-    SDL_RenderFillRect(&temp);
-    SDL_RenderCopy(sprite, NULL, &temp);
+    SDL_RenderFillRect(renderer, &temp);
+    SDL_RenderCopy(renderer, sprite, NULL, &temp);
 
     /* Test diagonal lines */
-    SDL_SetRenderDrawColor(0x00, 0xFF, 0x00, 0xFF);
-    SDL_RenderDrawLine(sprite_w, sprite_h,
+    SDL_SetRenderDrawColor(renderer, 0x00, 0xFF, 0x00, 0xFF);
+    SDL_RenderDrawLine(renderer, sprite_w, sprite_h,
                        window_w-sprite_w-2, window_h-sprite_h-2);
-    SDL_RenderDrawLine(window_w-sprite_w-2, sprite_h,
+    SDL_RenderDrawLine(renderer, window_w-sprite_w-2, sprite_h,
                        sprite_w, window_h-sprite_h-2);
 
     /* Move the sprite, bounce at the wall, and draw */
@@ -204,11 +202,11 @@ MoveSprites(SDL_Window * window, SDL_Texture * sprite)
         }
 
         /* Blit the sprite onto the screen */
-        SDL_RenderCopy(sprite, NULL, position);
+        SDL_RenderCopy(renderer, sprite, NULL, position);
     }
 
     /* Update the screen! */
-    SDL_RenderPresent();
+    SDL_RenderPresent(renderer);
 }
 
 int
@@ -276,9 +274,9 @@ main(int argc, char *argv[])
         quit(2);
     }
     for (i = 0; i < state->num_windows; ++i) {
-        SDL_SelectRenderer(state->windows[i]);
-        SDL_SetRenderDrawColor(0xA0, 0xA0, 0xA0, 0xFF);
-        SDL_RenderClear();
+        SDL_Renderer *renderer = state->renderers[i];
+        SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);
+        SDL_RenderClear(renderer);
     }
     if (LoadSprite("icon.bmp") < 0) {
         quit(2);
@@ -314,22 +312,9 @@ main(int argc, char *argv[])
         ++frames;
         while (SDL_PollEvent(&event)) {
             CommonEvent(state, &event, &done);
-            switch (event.type) {
-            case SDL_WINDOWEVENT:
-                switch (event.window.event) {
-                case SDL_WINDOWEVENT_EXPOSED:
-                    SDL_SelectRenderer(SDL_GetWindowFromID(event.window.windowID));
-                    SDL_SetRenderDrawColor(0xA0, 0xA0, 0xA0, 0xFF);
-                    SDL_RenderClear();
-                    break;
-                }
-                break;
-            default:
-                break;
-            }
         }
         for (i = 0; i < state->num_windows; ++i) {
-            MoveSprites(state->windows[i], sprites[i]);
+            MoveSprites(state->windows[i], state->renderers[i], sprites[i]);
         }
     }
 

test/testspriteminimal.c

@@ -24,7 +24,7 @@ quit(int rc)
 }
 
 int
-LoadSprite(char *file)
+LoadSprite(char *file, SDL_Renderer *renderer)
 {
     SDL_Surface *temp;
 
@@ -60,10 +60,10 @@ LoadSprite(char *file)
     }
 
     /* Create textures from the image */
-    sprite = SDL_CreateTextureFromSurface(0, temp);
+    sprite = SDL_CreateTextureFromSurface(renderer, 0, temp);
     if (!sprite) {
         SDL_SetColorKey(temp, 0, 0);
-        sprite = SDL_CreateTextureFromSurface(0, temp);
+        sprite = SDL_CreateTextureFromSurface(renderer, 0, temp);
     }
     if (!sprite) {
         fprintf(stderr, "Couldn't create texture: %s\n", SDL_GetError());
@@ -77,7 +77,7 @@ LoadSprite(char *file)
 }
 
 void
-MoveSprites(SDL_Window * window, SDL_Texture * sprite)
+MoveSprites(SDL_Window * window, SDL_Renderer * renderer, SDL_Texture * sprite)
 {
     int i;
     int window_w = WINDOW_WIDTH;
@@ -85,8 +85,8 @@ MoveSprites(SDL_Window * window, SDL_Texture * sprite)
     SDL_Rect *position, *velocity;
 
     /* Draw a gray background */
-    SDL_SetRenderDrawColor(0xA0, 0xA0, 0xA0, 0xFF);
-    SDL_RenderClear();
+    SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);
+    SDL_RenderClear(renderer);
 
     /* Move the sprite, bounce at the wall, and draw */
     for (i = 0; i < NUM_SPRITES; ++i) {
@@ -104,17 +104,18 @@ MoveSprites(SDL_Window * window, SDL_Texture * sprite)
         }
 
         /* Blit the sprite onto the screen */
-        SDL_RenderCopy(sprite, NULL, position);
+        SDL_RenderCopy(renderer, sprite, NULL, position);
     }
 
     /* Update the screen! */
-    SDL_RenderPresent();
+    SDL_RenderPresent(renderer);
 }
 
 int
 main(int argc, char *argv[])
 {
     SDL_Window *window;
+    SDL_Renderer *renderer;
     int i, done;
     SDL_Event event;
 
@@ -127,7 +128,12 @@ main(int argc, char *argv[])
         quit(2);
     }
 
-    if (LoadSprite("icon.bmp") < 0) {
+    renderer = SDL_CreateRenderer(window, -1, 0);
+    if (!renderer) {
+        quit(2);
+    }
+
+    if (LoadSprite("icon.bmp", renderer) < 0) {
         quit(2);
     }
 
@@ -155,7 +161,7 @@ main(int argc, char *argv[])
                 done = 1;
             }
         }
-        MoveSprites(window, sprite);
+        MoveSprites(window, renderer, sprite);
     }
 
     quit(0);