# HG changeset patch # User Sam Lantinga # Date 1150103406 0 # Node ID e136f3ffdc1bf14bc0d8b25b1b3b9066d6d96814 # Parent d33dcfc3fde7a8282f9bcd4f885d4c7841ea6153 Adding software renderer implementation diff -r d33dcfc3fde7 -r e136f3ffdc1b include/SDL_pixels.h --- a/include/SDL_pixels.h Sun Jun 11 07:30:16 2006 +0000 +++ b/include/SDL_pixels.h Mon Jun 12 09:10:06 2006 +0000 @@ -108,6 +108,8 @@ #define SDL_BITSPERPIXEL(X) (((X) >> 8) & 0xFF) #define SDL_BYTESPERPIXEL(X) (((X) >> 0) & 0xFF) +#define SDL_ISPIXELFORMAT_FOURCC(format) (((format) & 0x8000000) != 0) + enum { SDL_PixelFormat_Unknown, diff -r d33dcfc3fde7 -r e136f3ffdc1b include/SDL_video.h --- a/include/SDL_video.h Sun Jun 11 07:30:16 2006 +0000 +++ b/include/SDL_video.h Mon Jun 12 09:10:06 2006 +0000 @@ -201,11 +201,11 @@ */ typedef enum { - SDL_TextureBlendMode_None, /**< No blending */ - SDL_TextureBlendMode_Mask, /**< dst = A ? src : dst (alpha is mask) */ - SDL_TextureBlendMode_Blend, /**< dst = (src * A) + (dst * (1-A)) */ - SDL_TextureBlendMode_Add, /**< dst = (src * A) + dst */ - SDL_TextureBlendMode_Mod, /**< dst = src * dst */ + SDL_TextureBlendMode_None = 0x00000000, /**< No blending */ + SDL_TextureBlendMode_Mask = 0x00000001, /**< dst = A ? src : dst (alpha is mask) */ + SDL_TextureBlendMode_Blend = 0x00000002, /**< dst = (src * A) + (dst * (1-A)) */ + SDL_TextureBlendMode_Add = 0x00000004, /**< dst = (src * A) + dst */ + SDL_TextureBlendMode_Mod = 0x00000008, /**< dst = src * dst */ } SDL_TextureBlendMode; /** @@ -215,10 +215,10 @@ */ typedef enum { - SDL_TextureScaleMode_None, /**< No scaling, rectangles must match dimensions */ - SDL_TextureScaleMode_Fast, /**< Point sampling or equivalent algorithm */ - SDL_TextureScaleMode_Slow, /**< Linear filtering or equivalent algorithm */ - SDL_TextureScaleMode_Best, /**< Bicubic filtering or equivalent algorithm */ + SDL_TextureScaleMode_None = 0x00000000, /**< No scaling, rectangles must match dimensions */ + SDL_TextureScaleMode_Fast = 0x00000001, /**< Point sampling or equivalent algorithm */ + SDL_TextureScaleMode_Slow = 0x00000002, /**< Linear filtering or equivalent algorithm */ + SDL_TextureScaleMode_Best = 0x00000004, /**< Bicubic filtering or equivalent algorithm */ } SDL_TextureScaleMode; /** diff -r d33dcfc3fde7 -r e136f3ffdc1b src/video/SDL_renderer_sw.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/video/SDL_renderer_sw.c Mon Jun 12 09:10:06 2006 +0000 @@ -0,0 +1,409 @@ +/* + SDL - Simple DirectMedia Layer + Copyright (C) 1997-2006 Sam Lantinga + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Sam Lantinga + slouken@libsdl.org +*/ +#include "SDL_config.h" + +#include "SDL_video.h" +#include "SDL_sysvideo.h" + + +/* SDL surface based renderer implementation */ + +static SDL_Renderer *SDL_SW_CreateRenderer(SDL_Window * window, Uint32 flags); +static int SDL_SW_CreateTexture(SDL_Renderer * renderer, + SDL_Texture * texture); +static int SDL_SW_UpdateTexture(SDL_Renderer * renderer, + SDL_Texture * texture, SDL_Rect * rect, + const void *pixels, int pitch); +static int SDL_SW_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture, + SDL_Rect * rect, int markDirty, void **pixels, + int *pitch); +static void SDL_SW_UnlockTexture(SDL_Renderer * renderer, + SDL_Texture * texture); +static void SDL_SW_DirtyTexture(SDL_Renderer * renderer, + SDL_Texture * texture, int numrects, + SDL_Rect * rects); +static void SDL_SW_SelectRenderTexture(SDL_Renderer * renderer, + SDL_Texture * texture); +static void SDL_SW_RenderFill(SDL_Renderer * renderer, SDL_Rect * rect, + Uint32 color); +static int SDL_SW_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture, + SDL_Rect * srcrect, SDL_Rect * dstrect, + int blendMode, int scaleMode); +static int SDL_SW_RenderReadPixels(SDL_Renderer * renderer, SDL_Rect * rect, + void *pixels, int pitch); +static int SDL_SW_RenderWritePixels(SDL_Renderer * renderer, SDL_Rect * rect, + const void *pixels, int pitch); +static void SDL_SW_RenderPresent(SDL_Renderer * renderer); +static void SDL_SW_DestroyTexture(SDL_Renderer * renderer, + SDL_Texture * texture); +static void SDL_SW_DestroyRenderer(SDL_Renderer * renderer); + + +SDL_RenderDriver SDL_SW_RenderDriver = { + SDL_SW_CreateRenderer, + { + "software", + (SDL_Renderer_PresentDiscard | + SDL_Renderer_PresentCopy | + SDL_Renderer_PresentFlip2 | + SDL_Renderer_PresentFlip3 | SDL_Renderer_RenderTarget), + (SDL_TextureBlendMode_None | + SDL_TextureBlendMode_Mask | SDL_TextureBlendMode_Blend), + (SDL_TextureScaleMode_None | SDL_TextureScaleMode_Fast), + 11, + { + SDL_PixelFormat_Index8, + SDL_PixelFormat_RGB555, + SDL_PixelFormat_RGB565, + SDL_PixelFormat_RGB888, + SDL_PixelFormat_BGR888, + SDL_PixelFormat_ARGB8888, + SDL_PixelFormat_RGBA8888, + SDL_PixelFormat_ABGR8888, + SDL_PixelFormat_BGRA8888, + SDL_PixelFormat_YUY2, + SDL_PixelFormat_UYVY}, + 32768, + 32768} +}; + +typedef struct +{ + int current_screen; + SDL_Surface *screens[3]; + SDL_Surface *target; + SDL_Renderer *renderer; +} SDL_SW_RenderData; + +SDL_Renderer * +SDL_SW_CreateRenderer(SDL_Window * window, Uint32 flags) +{ + SDL_DisplayMode *displayMode = &window->display->current_mode; + SDL_Renderer *renderer; + SDL_SW_RenderData *data; + int i, n; + int bpp; + Uint32 Rmask, Gmask, Bmask, Amask; + + if (!SDL_PixelFormatEnumToMasks + (displayMode->format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) { + SDL_SetError("Unknown display format"); + return NULL; + } + + renderer = (SDL_Renderer *) SDL_malloc(sizeof(*renderer)); + if (!renderer) { + SDL_OutOfMemory(); + return NULL; + } + SDL_zerop(renderer); + + data = (SDL_SW_RenderData *) SDL_malloc(sizeof(*data)); + if (!data) { + SDL_SW_DestroyRenderer(renderer); + SDL_OutOfMemory(); + return NULL; + } + SDL_zerop(data); + + renderer->CreateTexture = SDL_SW_CreateTexture; + renderer->UpdateTexture = SDL_SW_UpdateTexture; + renderer->LockTexture = SDL_SW_LockTexture; + renderer->UnlockTexture = SDL_SW_UnlockTexture; + renderer->DirtyTexture = SDL_SW_DirtyTexture; + renderer->SelectRenderTexture = SDL_SW_SelectRenderTexture; + renderer->RenderFill = SDL_SW_RenderFill; + renderer->RenderCopy = SDL_SW_RenderCopy; + renderer->RenderReadPixels = SDL_SW_RenderReadPixels; + renderer->RenderWritePixels = SDL_SW_RenderWritePixels; + renderer->RenderPresent = SDL_SW_RenderPresent; + renderer->DestroyTexture = SDL_SW_DestroyTexture; + renderer->DestroyRenderer = SDL_SW_DestroyRenderer; + renderer->info = SDL_SW_RenderDriver.info; + renderer->window = window; + renderer->driverdata = data; + + renderer->info.flags = SDL_Renderer_RenderTarget; + + if (flags & SDL_Renderer_PresentFlip2) { + renderer->info.flags |= SDL_Renderer_PresentFlip2; + n = 2; + } else if (flags & SDL_Renderer_PresentFlip3) { + renderer->info.flags |= SDL_Renderer_PresentFlip3; + n = 3; + } else { + renderer->info.flags |= SDL_Renderer_PresentCopy; + n = 1; + } + for (i = 0; i < n; ++i) { + data->screens[i] = + SDL_CreateRGBSurface(0, window->w, window->h, bpp, Rmask, Gmask, + Bmask, Amask); + if (!data->screens[i]) { + SDL_SW_DestroyRenderer(renderer); + return NULL; + } + } + data->current_screen = 0; + data->target = data->screens[0]; + + /* Find a render driver that we can use to display data */ + for (i = 0; i < window->display->num_render_drivers; ++i) { + SDL_RenderDriver *driver = &window->display->render_drivers[i]; + if (driver->info.name != SDL_SW_RenderDriver.info.name) { + data->renderer = + driver->CreateRenderer(window, SDL_Renderer_PresentDiscard); + if (data->renderer) { + break; + } + } + } + if (i == window->display->num_render_drivers) { + SDL_SW_DestroyRenderer(renderer); + SDL_SetError("Couldn't find display render driver"); + return NULL; + } + return renderer; +} + +int +SDL_SW_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture) +{ + SDL_Surface *surface; + int bpp; + Uint32 Rmask, Gmask, Bmask, Amask; + + if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) { + /* FIXME: implement this */ + return -1; + } + + if (!SDL_PixelFormatEnumToMasks + (texture->format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) { + SDL_SetError("Unknown texture format"); + return -1; + } + + surface = + SDL_CreateRGBSurface(0, texture->w, texture->h, bpp, Rmask, Gmask, + Bmask, Amask); + if (!surface) { + return -1; + } + + texture->driverdata = surface; + return 0; +} + +int +SDL_SW_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture, + SDL_Rect * rect, const void *pixels, int pitch) +{ + SDL_Surface *surface = (SDL_Surface *) texture->driverdata; + Uint8 *src, *dst; + int row; + size_t length; + + src = (Uint8 *) pixels; + dst = + (Uint8 *) surface->pixels + rect->y * surface->pitch + + rect->x * surface->format->BytesPerPixel; + length = rect->w * surface->format->BytesPerPixel; + for (row = 0; row < rect->h; ++row) { + SDL_memcpy(dst, src, length); + src += pitch; + dst += surface->pitch; + } + return 0; +} + +int +SDL_SW_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture, + SDL_Rect * rect, int markDirty, void **pixels, int *pitch) +{ + SDL_Surface *surface = (SDL_Surface *) texture->driverdata; + + *pixels = + (void *) ((Uint8 *) surface->pixels + rect->y * surface->pitch + + rect->x * surface->format->BytesPerPixel); + *pitch = surface->pitch; + return 0; +} + +void +SDL_SW_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture) +{ +} + +void +SDL_SW_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture, + int numrects, SDL_Rect * rects) +{ +} + +void +SDL_SW_SelectRenderTexture(SDL_Renderer * renderer, SDL_Texture * texture) +{ + SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata; + data->target = (SDL_Surface *) texture->driverdata; +} + +void +SDL_SW_RenderFill(SDL_Renderer * renderer, SDL_Rect * rect, Uint32 color) +{ + SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata; + Uint8 r, g, b, a; + + a = (Uint8) ((color >> 24) & 0xFF); + r = (Uint8) ((color >> 16) & 0xFF); + g = (Uint8) ((color >> 8) & 0xFF); + b = (Uint8) (color & 0xFF); + color = SDL_MapRGBA(data->target->format, r, g, b, a); + + SDL_FillRect(data->target, rect, color); +} + +int +SDL_SW_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture, + SDL_Rect * srcrect, SDL_Rect * dstrect, int blendMode, + int scaleMode) +{ + SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata; + SDL_Surface *surface = (SDL_Surface *) texture->driverdata; + + if (blendMode & (SDL_TextureBlendMode_Mask | SDL_TextureBlendMode_Blend)) { + SDL_SetAlpha(surface, SDL_SRCALPHA, 0); + } else { + SDL_SetAlpha(surface, 0, 0); + } + if (scaleMode != SDL_TextureScaleMode_None && + (srcrect->w != dstrect->w || srcrect->h != dstrect->h)) { + return SDL_SoftStretch(surface, srcrect, data->target, dstrect); + } else { + return SDL_LowerBlit(surface, srcrect, data->target, dstrect); + } +} + +int +SDL_SW_RenderReadPixels(SDL_Renderer * renderer, SDL_Rect * rect, + void *pixels, int pitch) +{ + SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata; + SDL_Surface *surface = data->target; + Uint8 *src, *dst; + int row; + size_t length; + + src = + (Uint8 *) surface->pixels + rect->y * surface->pitch + + rect->x * surface->format->BytesPerPixel; + dst = (Uint8 *) pixels; + length = rect->w * surface->format->BytesPerPixel; + for (row = 0; row < rect->h; ++row) { + SDL_memcpy(dst, src, length); + src += surface->pitch; + dst += pitch; + } + return 0; +} + +int +SDL_SW_RenderWritePixels(SDL_Renderer * renderer, SDL_Rect * rect, + const void *pixels, int pitch) +{ + SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata; + SDL_Surface *surface = data->target; + Uint8 *src, *dst; + int row; + size_t length; + + src = (Uint8 *) pixels; + dst = + (Uint8 *) surface->pixels + rect->y * surface->pitch + + rect->x * surface->format->BytesPerPixel; + length = rect->w * surface->format->BytesPerPixel; + for (row = 0; row < rect->h; ++row) { + SDL_memcpy(dst, src, length); + src += pitch; + dst += surface->pitch; + } + return 0; +} + +void +SDL_SW_RenderPresent(SDL_Renderer * renderer) +{ + SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata; + SDL_Surface *surface = data->screens[data->current_screen]; + SDL_Rect rect; + int new_screen; + + /* Send the data to the display */ + /* FIXME: implement dirty rect updates */ + rect.x = 0; + rect.y = 0; + rect.w = surface->w; + rect.h = surface->h; + data->renderer->RenderWritePixels(data->renderer, &rect, surface->pixels, + surface->pitch); + data->renderer->RenderPresent(data->renderer); + + /* Update the flipping chain, if any */ + if (renderer->info.flags & SDL_Renderer_PresentFlip2) { + new_screen = (data->current_screen + 1) % 2; + } else if (renderer->info.flags & SDL_Renderer_PresentFlip3) { + new_screen = (data->current_screen + 1) % 3; + } else { + new_screen = 0; + } + if (data->target == data->screens[data->current_screen]) { + data->target = data->screens[new_screen]; + } + data->current_screen = new_screen; +} + +void +SDL_SW_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture) +{ + SDL_Surface *surface = (SDL_Surface *) texture->driverdata; + + SDL_FreeSurface(surface); +} + +void +SDL_SW_DestroyRenderer(SDL_Renderer * renderer) +{ + SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata; + int i; + + if (data) { + for (i = 0; i < SDL_arraysize(data->screens); ++i) { + if (data->screens[i]) { + SDL_FreeSurface(data->screens[i]); + } + } + SDL_free(data); + } + SDL_free(renderer); +} + +/* vi: set ts=4 sw=4 expandtab: */ diff -r d33dcfc3fde7 -r e136f3ffdc1b src/video/SDL_renderer_sw.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/video/SDL_renderer_sw.h Mon Jun 12 09:10:06 2006 +0000 @@ -0,0 +1,28 @@ +/* + SDL - Simple DirectMedia Layer + Copyright (C) 1997-2006 Sam Lantinga + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Sam Lantinga + slouken@libsdl.org +*/ +#include "SDL_config.h" + +/* SDL surface based renderer implementation */ + +extern SDL_RenderDriver SDL_SW_RenderDriver; + +/* vi: set ts=4 sw=4 expandtab: */ diff -r d33dcfc3fde7 -r e136f3ffdc1b src/video/SDL_sysvideo.h --- a/src/video/SDL_sysvideo.h Sun Jun 11 07:30:16 2006 +0000 +++ b/src/video/SDL_sysvideo.h Mon Jun 12 09:10:06 2006 +0000 @@ -66,22 +66,28 @@ /* Define the SDL renderer structure */ struct SDL_Renderer { - int (*CreateTexture) (SDL_Texture * texture); - int (*UpdateTexture) (SDL_Texture * texture, SDL_Rect * rect, - const void *pixels, int pitch); - int (*LockTexture) (SDL_Texture * texture, SDL_Rect * rect, int markDirty, - void **pixels, int *pitch); - void (*UnlockTexture) (SDL_Texture * texture); - void (*DirtyTexture) (SDL_Texture * texture, int numrects, - SDL_Rect * rects); - void (*SelectRenderTexture) (SDL_Texture * texture); - void (*RenderFill) (SDL_Rect * rect, Uint32 color); - int (*RenderCopy) (SDL_Texture * texture, SDL_Rect * srcrect, - SDL_Rect * dstrect, int blendMode, int scaleMode); - int (*RenderReadPixels) (SDL_Rect * rect, void *pixels, int pitch); - int (*RenderWritePixels) (SDL_Rect * rect, const void *pixels, int pitch); - void (*RenderPresent) (void); - void (*DestroyTexture) (SDL_Texture * texture); + int (*CreateTexture) (SDL_Renderer * renderer, SDL_Texture * texture); + int (*UpdateTexture) (SDL_Renderer * renderer, SDL_Texture * texture, + SDL_Rect * rect, const void *pixels, int pitch); + int (*LockTexture) (SDL_Renderer * renderer, SDL_Texture * texture, + SDL_Rect * rect, int markDirty, void **pixels, + int *pitch); + void (*UnlockTexture) (SDL_Renderer * renderer, SDL_Texture * texture); + void (*DirtyTexture) (SDL_Renderer * renderer, SDL_Texture * texture, + int numrects, SDL_Rect * rects); + void (*SelectRenderTexture) (SDL_Renderer * renderer, + SDL_Texture * texture); + void (*RenderFill) (SDL_Renderer * renderer, SDL_Rect * rect, + Uint32 color); + int (*RenderCopy) (SDL_Renderer * renderer, SDL_Texture * texture, + SDL_Rect * srcrect, SDL_Rect * dstrect, int blendMode, + int scaleMode); + int (*RenderReadPixels) (SDL_Renderer * renderer, SDL_Rect * rect, + void *pixels, int pitch); + int (*RenderWritePixels) (SDL_Renderer * renderer, SDL_Rect * rect, + const void *pixels, int pitch); + void (*RenderPresent) (SDL_Renderer * renderer); + void (*DestroyTexture) (SDL_Renderer * renderer, SDL_Texture * texture); void (*DestroyRenderer) (SDL_Renderer * renderer); @@ -115,6 +121,7 @@ Uint16 *gamma; + SDL_VideoDisplay *display; SDL_Renderer *renderer; void *userdata; diff -r d33dcfc3fde7 -r e136f3ffdc1b src/video/SDL_video.c --- a/src/video/SDL_video.c Sun Jun 11 07:30:16 2006 +0000 +++ b/src/video/SDL_video.c Mon Jun 12 09:10:06 2006 +0000 @@ -27,6 +27,7 @@ #include "SDL_sysvideo.h" #include "SDL_blit.h" #include "SDL_pixels_c.h" +#include "SDL_renderer_sw.h" #include "../events/SDL_sysevents.h" #include "../events/SDL_events_c.h" @@ -274,6 +275,13 @@ sizeof(SDL_DisplayMode), cmpmodes); } + /* The software renderer is always available */ + for (i = 0; i < _this->num_displays; ++i) { + if (_this->displays[i].num_render_drivers > 0) { + SDL_AddRenderDriver(i, &SDL_SW_RenderDriver); + } + } + /* Start the event loop */ if (SDL_StartEventLoop(flags) < 0) { SDL_VideoQuit(); @@ -578,6 +586,7 @@ window.w = w; window.h = h; window.flags = (flags & allowed_flags); + window.display = &SDL_CurrentDisplay; if (_this->CreateWindow && _this->CreateWindow(_this, &window) < 0) { if (window.title) { @@ -620,6 +629,7 @@ SDL_zero(window); window.id = _this->next_object_id++; + window.display = &SDL_CurrentDisplay; if (!_this->CreateWindowFrom || _this->CreateWindowFrom(_this, &window, data) < 0) { @@ -1088,7 +1098,7 @@ texture->h = h; texture->renderer = renderer; - if (renderer->CreateTexture(texture) < 0) { + if (renderer->CreateTexture(renderer, texture) < 0) { SDL_free(texture); return 0; } @@ -1286,7 +1296,7 @@ if (!renderer->UpdateTexture) { return -1; } - return renderer->UpdateTexture(texture, rect, pixels, pitch); + return renderer->UpdateTexture(renderer, texture, rect, pixels, pitch); } int @@ -1304,7 +1314,8 @@ if (!renderer->LockTexture) { return -1; } - return renderer->LockTexture(texture, rect, markDirty, pixels, pitch); + return renderer->LockTexture(renderer, texture, rect, markDirty, pixels, + pitch); } void @@ -1321,7 +1332,7 @@ if (!renderer->UnlockTexture) { return; } - return renderer->UnlockTexture(texture); + return renderer->UnlockTexture(renderer, texture); } void @@ -1338,7 +1349,7 @@ if (!renderer->DirtyTexture) { return; } - renderer->DirtyTexture(texture, numrects, rects); + renderer->DirtyTexture(renderer, texture, numrects, rects); } void @@ -1354,7 +1365,7 @@ if (!renderer->SelectRenderTexture) { return; } - renderer->SelectRenderTexture(texture); + renderer->SelectRenderTexture(renderer, texture); } int @@ -1371,7 +1382,7 @@ return -1; } - renderer->RenderFill(rect, color); + renderer->RenderFill(renderer, rect, color); } int @@ -1390,8 +1401,8 @@ return -1; } - return renderer->RenderCopy(texture, srcrect, dstrect, blendMode, - scaleMode); + return renderer->RenderCopy(renderer, texture, srcrect, dstrect, + blendMode, scaleMode); } int @@ -1408,7 +1419,7 @@ return -1; } - return renderer->RenderReadPixels(rect, pixels, pitch); + return renderer->RenderReadPixels(renderer, rect, pixels, pitch); } int @@ -1425,7 +1436,7 @@ return -1; } - return renderer->RenderWritePixels(rect, pixels, pitch); + return renderer->RenderWritePixels(renderer, rect, pixels, pitch); } void @@ -1442,7 +1453,7 @@ return; } - renderer->RenderPresent(); + renderer->RenderPresent(renderer); } void @@ -1478,7 +1489,7 @@ /* Free the texture */ renderer = texture->renderer; - renderer->DestroyTexture(texture); + renderer->DestroyTexture(renderer, texture); SDL_free(texture); } @@ -1512,7 +1523,7 @@ } else { SDL_CurrentDisplay.textures[i] = next; } - renderer->DestroyTexture(texture); + renderer->DestroyTexture(renderer, texture); SDL_free(texture); } else { prev = texture; diff -r d33dcfc3fde7 -r e136f3ffdc1b src/video/dummy/SDL_nullevents.c --- a/src/video/dummy/SDL_nullevents.c Sun Jun 11 07:30:16 2006 +0000 +++ b/src/video/dummy/SDL_nullevents.c Mon Jun 12 09:10:06 2006 +0000 @@ -37,11 +37,4 @@ /* do nothing. */ } -void -DUMMY_InitOSKeymap(_THIS) -{ - /* do nothing. */ -} - -/* end of SDL_nullevents.c ... */ /* vi: set ts=4 sw=4 expandtab: */ diff -r d33dcfc3fde7 -r e136f3ffdc1b src/video/dummy/SDL_nullevents_c.h --- a/src/video/dummy/SDL_nullevents_c.h Sun Jun 11 07:30:16 2006 +0000 +++ b/src/video/dummy/SDL_nullevents_c.h Mon Jun 12 09:10:06 2006 +0000 @@ -23,11 +23,6 @@ #include "SDL_nullvideo.h" -/* Variables and functions exported by SDL_sysevents.c to other parts - of the native video subsystem (SDL_sysvideo.c) -*/ -extern void DUMMY_InitOSKeymap(_THIS); extern void DUMMY_PumpEvents(_THIS); -/* end of SDL_nullevents_c.h ... */ /* vi: set ts=4 sw=4 expandtab: */ diff -r d33dcfc3fde7 -r e136f3ffdc1b src/video/dummy/SDL_nullvideo.c --- a/src/video/dummy/SDL_nullvideo.c Sun Jun 11 07:30:16 2006 +0000 +++ b/src/video/dummy/SDL_nullvideo.c Mon Jun 12 09:10:06 2006 +0000 @@ -101,10 +101,7 @@ /* Set the function pointers */ device->VideoInit = DUMMY_VideoInit; device->SetDisplayMode = DUMMY_SetDisplayMode; - device->CreateWindowSurface = DUMMY_CreateWindowSurface; - device->UpdateWindowSurface = DUMMY_UpdateWindowSurface; device->VideoQuit = DUMMY_VideoQuit; - device->InitOSKeymap = DUMMY_InitOSKeymap; device->PumpEvents = DUMMY_PumpEvents; device->free = DUMMY_DeleteDevice; @@ -139,35 +136,6 @@ return 0; } -static void -DUMMY_CreateWindowSurface(_THIS, SDL_Window * window, Uint32 flags) -{ - int bpp; - Uint32 Rmask, Gmask, Bmask, Amask; - - SDL_PixelFormatEnumToMasks(SDL_GetCurrentDisplayMode()->format, &bpp, - &Rmask, &Gmask, &Bmask, &Amask); - window->surface = - SDL_CreateRGBSurface(flags, window->w, window->h, bpp, Rmask, Gmask, - Bmask, Amask); -} - -static void -DUMMY_UpdateWindowSurface(_THIS, SDL_Window * window, int numrects, - SDL_Rect * rects) -{ - static int frame_number; - if (SDL_getenv("SDL_VIDEO_DUMMY_SAVE_FRAMES")) { - char file[128]; - SDL_snprintf(file, sizeof(file), "SDL_screen-%8.8d.bmp", - ++frame_number); - SDL_SaveBMP(window->surface, file); - } -} - -/* Note: If we are terminated, this could be called in the middle of - another SDL video routine -- notably UpdateRects. -*/ void DUMMY_VideoQuit(_THIS) {