From fa78c259a882e6ca597c234cd721675769558227 Mon Sep 17 00:00:00 2001 From: Sam Lantinga Date: Sat, 15 Jul 2006 09:46:36 +0000 Subject: [PATCH] Streamlined the API a bit and optimized the software renderer. --- include/SDL_video.h | 16 +- src/SDL_compat.c | 22 ++- src/video/SDL_renderer_sw.c | 320 ++++++++++++++++++------------- src/video/SDL_sysvideo.h | 6 - src/video/SDL_video.c | 95 ++------- src/video/dummy/SDL_nullrender.c | 59 +----- src/video/win32/SDL_d3drender.c | 167 +++++----------- src/video/win32/SDL_gdirender.c | 145 +------------- test/testsprite.c | 1 + test/testsprite2.c | 8 +- 10 files changed, 282 insertions(+), 557 deletions(-) diff --git a/include/SDL_video.h b/include/SDL_video.h index 78244ec92..daa37b3df 100644 --- a/include/SDL_video.h +++ b/include/SDL_video.h @@ -176,9 +176,7 @@ typedef enum SDL_Renderer_PresentFlip3 = 0x00000008, /**< Present uses a flip, rotating between two back buffers and a front buffer */ SDL_Renderer_PresentDiscard = 0x00000010, /**< Present leaves the contents of the backbuffer undefined */ SDL_Renderer_PresentVSync = 0x00000020, /**< Present is synchronized with the refresh rate */ - SDL_Renderer_RenderTarget = 0x00000040, /**< The renderer can create texture render targets */ - SDL_Renderer_Accelerated = 0x00000080, /**< The renderer uses hardware acceleration */ - SDL_Renderer_Minimal = 0x00000100, /**< The renderer only supports the read/write pixel and present functions */ + SDL_Renderer_Accelerated = 0x00000040, /**< The renderer uses hardware acceleration */ } SDL_RendererFlags; /** @@ -193,7 +191,7 @@ typedef struct SDL_RendererInfo Uint32 blend_modes; /**< A mask of supported blend modes */ Uint32 scale_modes; /**< A mask of supported scale modes */ Uint32 num_texture_formats; /**< The number of available texture formats */ - Uint32 texture_formats[32]; /**< The available texture formats */ + Uint32 texture_formats[16]; /**< The available texture formats */ int max_texture_width; /**< The maximimum texture width */ int max_texture_height; /**< The maximimum texture height */ } SDL_RendererInfo; @@ -205,9 +203,8 @@ typedef struct SDL_RendererInfo */ typedef enum { - SDL_TextureAccess_Render, /**< Unlockable video memory, rendering allowed */ - SDL_TextureAccess_Remote, /**< Unlockable video memory */ SDL_TextureAccess_Local, /**< Lockable system memory */ + SDL_TextureAccess_Remote, /**< Unlockable video memory */ } SDL_TextureAccess; /** @@ -836,11 +833,16 @@ extern DECLSPEC void SDLCALL SDL_DestroyWindow(SDL_WindowID windowID); extern DECLSPEC int SDLCALL SDL_GetNumRenderers(void); /** - * \fn SDL_RendererInfo *SDL_GetRendererInfo(int index) + * \fn int SDL_GetRendererInfo(int index, SDL_RendererInfo *info) * * \brief Get information about a specific render manager on the current * display. * + * \param index The index to query information about, or -1 to query the currently renderer + * \param info A pointer to an SDL_RendererInfo struct to be filled with information on the renderer + * + * \return 0 on success, -1 if the index was out of range + * * \sa SDL_CreateRenderer() */ extern DECLSPEC int SDLCALL SDL_GetRendererInfo(int index, diff --git a/src/SDL_compat.c b/src/SDL_compat.c index a01f0ff3e..afc9241bd 100644 --- a/src/SDL_compat.c +++ b/src/SDL_compat.c @@ -31,6 +31,7 @@ static SDL_WindowID SDL_VideoWindow; +static SDL_RendererInfo SDL_VideoRendererInfo; static SDL_TextureID SDL_VideoTexture; static SDL_Surface *SDL_VideoSurface; static SDL_Surface *SDL_ShadowSurface; @@ -442,10 +443,12 @@ SDL_SetVideoMode(int width, int height, int bpp, Uint32 flags) } /* Create a renderer for the window */ - if (SDL_CreateRenderer(SDL_VideoWindow, -1, SDL_Renderer_SingleBuffer) < - 0) { + if (SDL_CreateRenderer + (SDL_VideoWindow, -1, + SDL_Renderer_SingleBuffer | SDL_Renderer_PresentDiscard) < 0) { return NULL; } + SDL_GetRendererInfo(-1, &SDL_VideoRendererInfo); /* Create a texture for the screen surface */ SDL_VideoTexture = @@ -642,8 +645,19 @@ SDL_UpdateRects(SDL_Surface * screen, int numrects, SDL_Rect * rects) screen = SDL_VideoSurface; } if (screen == SDL_VideoSurface) { - for (i = 0; i < numrects; ++i) { - SDL_RenderCopy(SDL_VideoTexture, &rects[i], &rects[i], + if (SDL_VideoRendererInfo.flags & SDL_Renderer_PresentCopy) { + for (i = 0; i < numrects; ++i) { + SDL_RenderCopy(SDL_VideoTexture, &rects[i], &rects[i], + SDL_TextureBlendMode_None, + SDL_TextureScaleMode_None); + } + } else { + SDL_Rect rect; + rect.x = 0; + rect.y = 0; + rect.w = screen->w; + rect.h = screen->h; + SDL_RenderCopy(SDL_VideoTexture, &rect, &rect, SDL_TextureBlendMode_None, SDL_TextureScaleMode_None); } diff --git a/src/video/SDL_renderer_sw.c b/src/video/SDL_renderer_sw.c index 666adca2b..427a9665c 100644 --- a/src/video/SDL_renderer_sw.c +++ b/src/video/SDL_renderer_sw.c @@ -23,6 +23,7 @@ #include "SDL_video.h" #include "SDL_sysvideo.h" +#include "SDL_pixels_c.h" #include "SDL_rect_c.h" #include "SDL_yuv_sw_c.h" @@ -53,20 +54,12 @@ static void SDL_SW_UnlockTexture(SDL_Renderer * renderer, static void SDL_SW_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture, int numrects, const SDL_Rect * rects); -static void SDL_SW_SelectRenderTexture(SDL_Renderer * renderer, - SDL_Texture * texture); static int SDL_SW_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect, Uint32 color); static int SDL_SW_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture, const SDL_Rect * srcrect, const SDL_Rect * dstrect, int blendMode, int scaleMode); -static int SDL_SW_RenderReadPixels(SDL_Renderer * renderer, - const SDL_Rect * rect, void *pixels, - int pitch); -static int SDL_SW_RenderWritePixels(SDL_Renderer * renderer, - const 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); @@ -79,7 +72,7 @@ SDL_RenderDriver SDL_SW_RenderDriver = { "software", (SDL_Renderer_SingleBuffer | SDL_Renderer_PresentCopy | SDL_Renderer_PresentFlip2 | SDL_Renderer_PresentFlip3 | - SDL_Renderer_PresentDiscard | SDL_Renderer_RenderTarget), + SDL_Renderer_PresentDiscard | SDL_Renderer_PresentVSync), (SDL_TextureBlendMode_None | SDL_TextureBlendMode_Mask | SDL_TextureBlendMode_Blend), (SDL_TextureScaleMode_None | SDL_TextureScaleMode_Fast), @@ -102,14 +95,63 @@ SDL_RenderDriver SDL_SW_RenderDriver = { typedef struct { - int current_screen; - SDL_Surface *screens[3]; - SDL_Surface *target; + Uint32 format; + int current_texture; + SDL_Texture *texture[3]; + SDL_Surface surface; SDL_Renderer *renderer; SDL_DirtyRectList dirty; - SDL_bool makedirty; } SDL_SW_RenderData; +static SDL_Texture * +CreateTexture(SDL_Renderer * renderer, Uint32 format, int w, int h) +{ + SDL_Texture *texture; + + texture = (SDL_Texture *) SDL_malloc(sizeof(*texture)); + if (!texture) { + SDL_OutOfMemory(); + return NULL; + } + + SDL_zerop(texture); + texture->format = format; + texture->access = SDL_TextureAccess_Local; + texture->w = w; + texture->h = h; + texture->renderer = renderer; + + if (renderer->CreateTexture(renderer, texture) < 0) { + SDL_free(texture); + return NULL; + } + return texture; +} + +static void +DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture) +{ + renderer->DestroyTexture(renderer, texture); + SDL_free(texture); +} + +static int +DisplayPaletteChanged(void *userdata, SDL_Palette * palette) +{ + SDL_SW_RenderData *data = (SDL_SW_RenderData *) userdata; + int i; + + for (i = 0; i < SDL_arraysize(data->texture); ++i) { + if (data->texture[i] && data->renderer->SetTexturePalette) { + data->renderer->SetTexturePalette(data->renderer, + data->texture[i], + palette->colors, 0, + palette->ncolors); + } + } + return 0; +} + SDL_Renderer * SDL_SW_CreateRenderer(SDL_Window * window, Uint32 flags) { @@ -120,6 +162,7 @@ SDL_SW_CreateRenderer(SDL_Window * window, Uint32 flags) int i, n; int bpp; Uint32 Rmask, Gmask, Bmask, Amask; + Uint32 renderer_flags; if (!SDL_PixelFormatEnumToMasks (displayMode->format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) { @@ -149,11 +192,8 @@ SDL_SW_CreateRenderer(SDL_Window * window, Uint32 flags) 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; @@ -161,7 +201,7 @@ SDL_SW_CreateRenderer(SDL_Window * window, Uint32 flags) renderer->window = window->id; renderer->driverdata = data; - renderer->info.flags = SDL_Renderer_RenderTarget; + renderer->info.flags = 0; if (flags & SDL_Renderer_PresentFlip2) { renderer->info.flags |= SDL_Renderer_PresentFlip2; @@ -173,28 +213,18 @@ SDL_SW_CreateRenderer(SDL_Window * window, Uint32 flags) 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; - } - SDL_SetSurfacePalette(data->screens[i], display->palette); - } - data->current_screen = 0; - data->target = data->screens[0]; - data->makedirty = SDL_TRUE; + data->format = displayMode->format; /* Find a render driver that we can use to display data */ + renderer_flags = (SDL_Renderer_SingleBuffer | + SDL_Renderer_PresentDiscard); + if (flags & SDL_Renderer_PresentVSync) { + renderer_flags |= SDL_Renderer_PresentVSync; + } for (i = 0; i < display->num_render_drivers; ++i) { SDL_RenderDriver *driver = &display->render_drivers[i]; if (driver->info.name != SDL_SW_RenderDriver.info.name) { - data->renderer = - driver->CreateRenderer(window, - (SDL_Renderer_SingleBuffer | - SDL_Renderer_PresentDiscard)); + data->renderer = driver->CreateRenderer(window, renderer_flags); if (data->renderer) { break; } @@ -205,6 +235,35 @@ SDL_SW_CreateRenderer(SDL_Window * window, Uint32 flags) SDL_SetError("Couldn't find display render driver"); return NULL; } + if (data->renderer->info.flags & SDL_Renderer_PresentVSync) { + renderer->info.flags |= SDL_Renderer_PresentVSync; + } + + /* Create the textures we'll use for display */ + for (i = 0; i < n; ++i) { + data->texture[i] = + CreateTexture(data->renderer, data->format, window->w, window->h); + if (!data->texture[i]) { + SDL_SW_DestroyRenderer(renderer); + return NULL; + } + } + data->current_texture = 0; + + /* Create a surface we'll use for rendering */ + data->surface.flags = SDL_PREALLOC; + data->surface.format = SDL_AllocFormat(bpp, Rmask, Gmask, Bmask, Amask); + if (!data->surface.format) { + SDL_SW_DestroyRenderer(renderer); + return NULL; + } + SDL_SetSurfacePalette(&data->surface, display->palette); + + /* Set up a palette watch on the display palette */ + if (display->palette) { + SDL_AddPaletteWatch(display->palette, DisplayPaletteChanged, data); + } + return renderer; } @@ -212,10 +271,6 @@ static int SDL_SW_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture) { if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) { - if (texture->access == SDL_TextureAccess_Render) { - SDL_SetError("Rendering to YUV format textures is not supported"); - return -1; - } texture->driverdata = SDL_SW_CreateYUVTexture(texture); } else { int bpp; @@ -347,29 +402,18 @@ SDL_SW_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture, { } -static void -SDL_SW_SelectRenderTexture(SDL_Renderer * renderer, SDL_Texture * texture) -{ - SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata; - - if (texture) { - data->target = (SDL_Surface *) texture->driverdata; - data->makedirty = SDL_FALSE; - } else { - data->target = data->screens[data->current_screen]; - data->makedirty = SDL_TRUE; - } -} - static int SDL_SW_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect, Uint32 color) { SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata; - SDL_Rect real_rect = *rect; Uint8 r, g, b, a; + void *pixels; + int pitch; + SDL_Rect real_rect; + int status; - if (data->makedirty) { + if (data->renderer->info.flags & SDL_Renderer_PresentCopy) { SDL_AddDirtyRect(&data->dirty, rect); } @@ -377,9 +421,25 @@ SDL_SW_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect, r = (Uint8) ((color >> 16) & 0xFF); g = (Uint8) ((color >> 8) & 0xFF); b = (Uint8) (color & 0xFF); - color = SDL_MapRGBA(data->target->format, r, g, b, a); + color = SDL_MapRGBA(data->surface.format, r, g, b, a); + + if (data->renderer-> + LockTexture(data->renderer, data->texture[data->current_texture], + rect, 1, &data->surface.pixels, + &data->surface.pitch) < 0) { + return -1; + } + data->surface.w = rect->w; + data->surface.h = rect->h; + data->surface.clip_rect.w = rect->w; + data->surface.clip_rect.h = rect->h; + real_rect = data->surface.clip_rect; + + status = SDL_FillRect(&data->surface, &real_rect, color); - return SDL_FillRect(data->target, &real_rect, color); + data->renderer->UnlockTexture(data->renderer, + data->texture[data->current_texture]); + return status; } static int @@ -389,25 +449,34 @@ SDL_SW_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture, { SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata; SDL_Window *window = SDL_GetWindowFromID(renderer->window); - SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); + int status; - if (data->makedirty) { + if (data->renderer->info.flags & SDL_Renderer_PresentCopy) { SDL_AddDirtyRect(&data->dirty, dstrect); } + if (data->renderer-> + LockTexture(data->renderer, data->texture[data->current_texture], + dstrect, 1, &data->surface.pixels, + &data->surface.pitch) < 0) { + return -1; + } + if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) { - SDL_Surface *target = data->target; - void *pixels = - (Uint8 *) target->pixels + dstrect->y * target->pitch + - dstrect->x * target->format->BytesPerPixel; - return SDL_SW_CopyYUVToRGB((SDL_SW_YUVTexture *) texture->driverdata, - srcrect, display->current_mode.format, - dstrect->w, dstrect->h, pixels, - target->pitch); + status = + SDL_SW_CopyYUVToRGB((SDL_SW_YUVTexture *) texture->driverdata, + srcrect, data->format, dstrect->w, dstrect->h, + data->surface.pixels, data->surface.pitch); } else { SDL_Surface *surface = (SDL_Surface *) texture->driverdata; SDL_Rect real_srcrect = *srcrect; - SDL_Rect real_dstrect = *dstrect; + SDL_Rect real_dstrect; + + data->surface.w = dstrect->w; + data->surface.h = dstrect->h; + data->surface.clip_rect.w = dstrect->w; + data->surface.clip_rect.h = dstrect->h; + real_dstrect = data->surface.clip_rect; if (blendMode & (SDL_TextureBlendMode_Mask | SDL_TextureBlendMode_Blend)) { @@ -417,91 +486,53 @@ SDL_SW_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture, } if (scaleMode != SDL_TextureScaleMode_None && (srcrect->w != dstrect->w || srcrect->h != dstrect->h)) { - return SDL_SoftStretch(surface, &real_srcrect, data->target, - &real_dstrect); + status = + SDL_SoftStretch(surface, &real_srcrect, &data->surface, + &real_dstrect); } else { - return SDL_LowerBlit(surface, &real_srcrect, data->target, - &real_dstrect); + status = + SDL_LowerBlit(surface, &real_srcrect, &data->surface, + &real_dstrect); } } -} - -static int -SDL_SW_RenderReadPixels(SDL_Renderer * renderer, const 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; -} - -static int -SDL_SW_RenderWritePixels(SDL_Renderer * renderer, const 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; - - if (data->makedirty) { - SDL_AddDirtyRect(&data->dirty, rect); - } - - 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; + data->renderer->UnlockTexture(data->renderer, + data->texture[data->current_texture]); + return status; } static 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_DirtyRect *dirty; + SDL_Texture *texture = data->texture[data->current_texture]; /* Send the data to the display */ - for (dirty = data->dirty.list; dirty; dirty = dirty->next) { - void *pixels = - (void *) ((Uint8 *) surface->pixels + - dirty->rect.y * surface->pitch + - dirty->rect.x * surface->format->BytesPerPixel); - data->renderer->RenderWritePixels(data->renderer, &dirty->rect, - pixels, surface->pitch); + if (data->renderer->info.flags & SDL_Renderer_PresentCopy) { + SDL_DirtyRect *dirty; + for (dirty = data->dirty.list; dirty; dirty = dirty->next) { + data->renderer->RenderCopy(data->renderer, texture, &dirty->rect, + &dirty->rect, + SDL_TextureBlendMode_None, + SDL_TextureScaleMode_None); + } + SDL_ClearDirtyRects(&data->dirty); + } else { + SDL_Rect rect; + rect.x = 0; + rect.y = 0; + rect.w = texture->w; + rect.h = texture->h; + data->renderer->RenderCopy(data->renderer, texture, &rect, &rect, + SDL_TextureBlendMode_None, + SDL_TextureScaleMode_None); } - SDL_ClearDirtyRects(&data->dirty); data->renderer->RenderPresent(data->renderer); /* Update the flipping chain, if any */ if (renderer->info.flags & SDL_Renderer_PresentFlip2) { - data->current_screen = (data->current_screen + 1) % 2; - data->target = data->screens[data->current_screen]; + data->current_texture = (data->current_texture + 1) % 2; } else if (renderer->info.flags & SDL_Renderer_PresentFlip3) { - data->current_screen = (data->current_screen + 1) % 3; - data->target = data->screens[data->current_screen]; + data->current_texture = (data->current_texture + 1) % 3; } } @@ -521,14 +552,27 @@ static void SDL_SW_DestroyRenderer(SDL_Renderer * renderer) { SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata; + SDL_Window *window = SDL_GetWindowFromID(renderer->window); + SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); int i; if (data) { - for (i = 0; i < SDL_arraysize(data->screens); ++i) { - if (data->screens[i]) { - SDL_FreeSurface(data->screens[i]); + for (i = 0; i < SDL_arraysize(data->texture); ++i) { + if (data->texture[i]) { + DestroyTexture(data->renderer, data->texture[i]); } } + if (data->surface.format) { + SDL_SetSurfacePalette(&data->surface, NULL); + SDL_FreeFormat(data->surface.format); + } + if (display->palette) { + SDL_DelPaletteWatch(display->palette, DisplayPaletteChanged, + data); + } + if (data->renderer) { + data->renderer->DestroyRenderer(data->renderer); + } SDL_FreeDirtyRects(&data->dirty); SDL_free(data); } diff --git a/src/video/SDL_sysvideo.h b/src/video/SDL_sysvideo.h index 5a31d56ae..5342e2ac7 100644 --- a/src/video/SDL_sysvideo.h +++ b/src/video/SDL_sysvideo.h @@ -73,17 +73,11 @@ struct SDL_Renderer void (*UnlockTexture) (SDL_Renderer * renderer, SDL_Texture * texture); void (*DirtyTexture) (SDL_Renderer * renderer, SDL_Texture * texture, int numrects, const SDL_Rect * rects); - void (*SelectRenderTexture) (SDL_Renderer * renderer, - SDL_Texture * texture); int (*RenderFill) (SDL_Renderer * renderer, const SDL_Rect * rect, Uint32 color); int (*RenderCopy) (SDL_Renderer * renderer, SDL_Texture * texture, const SDL_Rect * srcrect, const SDL_Rect * dstrect, int blendMode, int scaleMode); - int (*RenderReadPixels) (SDL_Renderer * renderer, const SDL_Rect * rect, - void *pixels, int pitch); - int (*RenderWritePixels) (SDL_Renderer * renderer, const SDL_Rect * rect, - const void *pixels, int pitch); void (*RenderPresent) (SDL_Renderer * renderer); void (*DestroyTexture) (SDL_Renderer * renderer, SDL_Texture * texture); diff --git a/src/video/SDL_video.c b/src/video/SDL_video.c index 88015ac4e..7162a83b3 100644 --- a/src/video/SDL_video.c +++ b/src/video/SDL_video.c @@ -1277,12 +1277,24 @@ SDL_GetNumRenderers(void) int SDL_GetRendererInfo(int index, SDL_RendererInfo * info) { - if (index < 0 || index >= SDL_GetNumRenderers()) { + if (!_this) { + return -1; + } + + if (index >= SDL_GetNumRenderers()) { SDL_SetError("index must be in the range of 0 - %d", SDL_GetNumRenderers() - 1); return -1; } - *info = SDL_CurrentDisplay.render_drivers[index].info; + if (index < 0) { + if (!SDL_CurrentDisplay.current_renderer) { + SDL_SetError("There is no current renderer"); + return -1; + } + *info = SDL_CurrentDisplay.current_renderer->info; + } else { + *info = SDL_CurrentDisplay.render_drivers[index].info; + } return 0; } @@ -1307,11 +1319,6 @@ SDL_CreateRenderer(SDL_WindowID windowID, int index, Uint32 flags) break; } } else { - /* Skip minimal drivers in automatic scans */ - if (!(flags & SDL_Renderer_Minimal) - && (driver->info.flags & SDL_Renderer_Minimal)) { - continue; - } if ((driver->info.flags & flags) == flags) { break; } @@ -1734,22 +1741,6 @@ SDL_DirtyTexture(SDL_TextureID textureID, int numrects, renderer->DirtyTexture(renderer, texture, numrects, rects); } -void -SDL_SelectRenderTexture(SDL_TextureID textureID) -{ - SDL_Texture *texture = SDL_GetTextureFromID(textureID); - SDL_Renderer *renderer; - - if (!texture || texture->access != SDL_TextureAccess_Render) { - return; - } - renderer = texture->renderer; - if (!renderer->SelectRenderTexture) { - return; - } - renderer->SelectRenderTexture(renderer, texture); -} - int SDL_RenderFill(const SDL_Rect * rect, Uint32 color) { @@ -1821,60 +1812,6 @@ SDL_RenderCopy(SDL_TextureID textureID, const SDL_Rect * srcrect, &real_dstrect, blendMode, scaleMode); } -int -SDL_RenderReadPixels(const SDL_Rect * rect, void *pixels, int pitch) -{ - SDL_Renderer *renderer; - SDL_Rect full_rect; - - if (!_this) { - return -1; - } - - renderer = SDL_CurrentDisplay.current_renderer; - if (!renderer || !renderer->RenderReadPixels) { - return -1; - } - - if (!rect) { - SDL_Window *window = SDL_GetWindowFromID(renderer->window); - full_rect.x = 0; - full_rect.y = 0; - full_rect.w = window->w; - full_rect.h = window->h; - rect = &full_rect; - } - - return renderer->RenderReadPixels(renderer, rect, pixels, pitch); -} - -int -SDL_RenderWritePixels(const SDL_Rect * rect, const void *pixels, int pitch) -{ - SDL_Renderer *renderer; - SDL_Rect full_rect; - - if (!_this) { - return -1; - } - - renderer = SDL_CurrentDisplay.current_renderer; - if (!renderer || !renderer->RenderWritePixels) { - return -1; - } - - if (!rect) { - SDL_Window *window = SDL_GetWindowFromID(renderer->window); - full_rect.x = 0; - full_rect.y = 0; - full_rect.w = window->w; - full_rect.h = window->h; - rect = &full_rect; - } - - return renderer->RenderWritePixels(renderer, rect, pixels, pitch); -} - void SDL_RenderPresent(void) { @@ -1888,10 +1825,6 @@ SDL_RenderPresent(void) if (!renderer || !renderer->RenderPresent) { return; } - - if (renderer->SelectRenderTexture) { - renderer->SelectRenderTexture(renderer, NULL); - } renderer->RenderPresent(renderer); } diff --git a/src/video/dummy/SDL_nullrender.c b/src/video/dummy/SDL_nullrender.c index 73c8e2381..655a3fb03 100644 --- a/src/video/dummy/SDL_nullrender.c +++ b/src/video/dummy/SDL_nullrender.c @@ -31,12 +31,6 @@ static SDL_Renderer *SDL_DUMMY_CreateRenderer(SDL_Window * window, Uint32 flags); static int SDL_DUMMY_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture); -static int SDL_DUMMY_RenderReadPixels(SDL_Renderer * renderer, - const SDL_Rect * rect, void *pixels, - int pitch); -static int SDL_DUMMY_RenderWritePixels(SDL_Renderer * renderer, - const SDL_Rect * rect, - const void *pixels, int pitch); static void SDL_DUMMY_RenderPresent(SDL_Renderer * renderer); static void SDL_DUMMY_DestroyRenderer(SDL_Renderer * renderer); @@ -45,8 +39,7 @@ SDL_RenderDriver SDL_DUMMY_RenderDriver = { SDL_DUMMY_CreateRenderer, { "dummy", - (SDL_Renderer_Minimal | SDL_Renderer_PresentDiscard | - SDL_Renderer_PresentCopy), + (SDL_Renderer_PresentDiscard | SDL_Renderer_PresentCopy), SDL_TextureBlendMode_None, SDL_TextureScaleMode_None, 0, @@ -91,8 +84,6 @@ SDL_DUMMY_CreateRenderer(SDL_Window * window, Uint32 flags) } SDL_zerop(data); - renderer->RenderReadPixels = SDL_DUMMY_RenderReadPixels; - renderer->RenderWritePixels = SDL_DUMMY_RenderWritePixels; renderer->RenderPresent = SDL_DUMMY_RenderPresent; renderer->DestroyRenderer = SDL_DUMMY_DestroyRenderer; renderer->info = SDL_DUMMY_RenderDriver.info; @@ -111,54 +102,6 @@ SDL_DUMMY_CreateRenderer(SDL_Window * window, Uint32 flags) return renderer; } -int -SDL_DUMMY_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect, - void *pixels, int pitch) -{ - SDL_DUMMY_RenderData *data = - (SDL_DUMMY_RenderData *) renderer->driverdata; - SDL_Surface *surface = data->surface; - 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_DUMMY_RenderWritePixels(SDL_Renderer * renderer, const SDL_Rect * rect, - const void *pixels, int pitch) -{ - SDL_DUMMY_RenderData *data = - (SDL_DUMMY_RenderData *) renderer->driverdata; - SDL_Surface *surface = data->surface; - 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_DUMMY_RenderPresent(SDL_Renderer * renderer) { diff --git a/src/video/win32/SDL_d3drender.c b/src/video/win32/SDL_d3drender.c index 5f54ba367..ded7b39a6 100644 --- a/src/video/win32/SDL_d3drender.c +++ b/src/video/win32/SDL_d3drender.c @@ -50,20 +50,12 @@ static void SDL_D3D_UnlockTexture(SDL_Renderer * renderer, static void SDL_D3D_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture, int numrects, const SDL_Rect * rects); -static void SDL_D3D_SelectRenderTexture(SDL_Renderer * renderer, - SDL_Texture * texture); static int SDL_D3D_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect, Uint32 color); static int SDL_D3D_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture, const SDL_Rect * srcrect, const SDL_Rect * dstrect, int blendMode, int scaleMode); -static int SDL_D3D_RenderReadPixels(SDL_Renderer * renderer, - const SDL_Rect * rect, void *pixels, - int pitch); -static int SDL_D3D_RenderWritePixels(SDL_Renderer * renderer, - const SDL_Rect * rect, - const void *pixels, int pitch); static void SDL_D3D_RenderPresent(SDL_Renderer * renderer); static void SDL_D3D_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture); @@ -76,10 +68,9 @@ SDL_RenderDriver SDL_D3D_RenderDriver = { "d3d", (SDL_Renderer_SingleBuffer | SDL_Renderer_PresentCopy | SDL_Renderer_PresentFlip2 | SDL_Renderer_PresentFlip3 | - SDL_Renderer_PresentDiscard | SDL_Renderer_RenderTarget), - (SDL_TextureBlendMode_None | - SDL_TextureBlendMode_Mask | SDL_TextureBlendMode_Blend), - (SDL_TextureScaleMode_None | SDL_TextureScaleMode_Fast), + SDL_Renderer_PresentDiscard | SDL_Renderer_PresentVSync), + (SDL_TextureBlendMode_None | SDL_TextureBlendMode_Mask | SDL_TextureBlendMode_Blend), /* FIXME */ + (SDL_TextureScaleMode_None | SDL_TextureScaleMode_Fast), /* FIXME */ 12, { SDL_PixelFormat_Index8, @@ -101,8 +92,6 @@ SDL_RenderDriver SDL_D3D_RenderDriver = { typedef struct { IDirect3DDevice9 *device; - IDirect3DSurface9 *surface; - IDirect3DSurface9 *offscreen; SDL_bool beginScene; } SDL_D3D_RenderData; @@ -250,6 +239,7 @@ SDL_D3D_CreateRenderer(SDL_Window * window, Uint32 flags) SDL_D3D_RenderData *data; HRESULT result; D3DPRESENT_PARAMETERS pparams; + IDirect3DSwapChain9 *chain; renderer = (SDL_Renderer *) SDL_malloc(sizeof(*renderer)); if (!renderer) { @@ -273,11 +263,8 @@ SDL_D3D_CreateRenderer(SDL_Window * window, Uint32 flags) renderer->LockTexture = SDL_D3D_LockTexture; renderer->UnlockTexture = SDL_D3D_UnlockTexture; renderer->DirtyTexture = SDL_D3D_DirtyTexture; - renderer->SelectRenderTexture = SDL_D3D_SelectRenderTexture; renderer->RenderFill = SDL_D3D_RenderFill; renderer->RenderCopy = SDL_D3D_RenderCopy; - renderer->RenderReadPixels = SDL_D3D_RenderReadPixels; - renderer->RenderWritePixels = SDL_D3D_RenderWritePixels; renderer->RenderPresent = SDL_D3D_RenderPresent; renderer->DestroyTexture = SDL_D3D_DestroyTexture; renderer->DestroyRenderer = SDL_D3D_DestroyRenderer; @@ -285,7 +272,7 @@ SDL_D3D_CreateRenderer(SDL_Window * window, Uint32 flags) renderer->window = window->id; renderer->driverdata = data; - renderer->info.flags = SDL_Renderer_RenderTarget; + renderer->info.flags = SDL_Renderer_Accelerated; SDL_zero(pparams); pparams.BackBufferWidth = window->w; @@ -317,7 +304,11 @@ SDL_D3D_CreateRenderer(SDL_Window * window, Uint32 flags) pparams.Windowed = TRUE; pparams.FullScreen_RefreshRateInHz = 0; } - pparams.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE; + if (flags & SDL_Renderer_PresentVSync) { + pparams.PresentationInterval = D3DPRESENT_INTERVAL_ONE; + } else { + pparams.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE; + } result = IDirect3D9_CreateDevice(videodata->d3d, D3DADAPTER_DEFAULT, /* FIXME */ D3DDEVTYPE_HAL, @@ -331,6 +322,43 @@ SDL_D3D_CreateRenderer(SDL_Window * window, Uint32 flags) } data->beginScene = SDL_TRUE; + /* Get presentation parameters to fill info */ + result = IDirect3DDevice9_GetSwapChain(data->device, 0, &chain); + if (FAILED(result)) { + SDL_D3D_DestroyRenderer(renderer); + D3D_SetError("GetSwapChain()", result); + return NULL; + } + result = IDirect3DSwapChain9_GetPresentParameters(chain, &pparams); + if (FAILED(result)) { + IDirect3DSwapChain9_Release(chain); + SDL_D3D_DestroyRenderer(renderer); + D3D_SetError("GetPresentParameters()", result); + return NULL; + } + IDirect3DSwapChain9_Release(chain); + switch (pparams.SwapEffect) { + case D3DSWAPEFFECT_COPY: + renderer->info.flags |= SDL_Renderer_PresentCopy; + break; + case D3DSWAPEFFECT_FLIP: + switch (pparams.BackBufferCount) { + case 2: + renderer->info.flags |= SDL_Renderer_PresentFlip2; + break; + case 3: + renderer->info.flags |= SDL_Renderer_PresentFlip3; + break; + } + break; + case D3DSWAPEFFECT_DISCARD: + renderer->info.flags |= SDL_Renderer_PresentDiscard; + break; + } + if (pparams.PresentationInterval == D3DPRESENT_INTERVAL_ONE) { + renderer->info.flags |= SDL_Renderer_PresentVSync; + } + /* Set up parameters for rendering */ IDirect3DDevice9_SetVertexShader(data->device, NULL); IDirect3DDevice9_SetFVF(data->device, D3DFVF_XYZRHW | D3DFVF_TEX1); @@ -527,14 +555,6 @@ SDL_D3D_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture, } } -static void -SDL_D3D_SelectRenderTexture(SDL_Renderer * renderer, SDL_Texture * texture) -{ - SDL_D3D_RenderData *data = (SDL_D3D_RenderData *) renderer->driverdata; - - /* FIXME */ -} - static int SDL_D3D_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect, Uint32 color) @@ -637,93 +657,6 @@ SDL_D3D_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture, return 0; } -static int -SDL_D3D_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect, - void *pixels, int pitch) -{ - SDL_D3D_RenderData *data = (SDL_D3D_RenderData *) renderer->driverdata; - - /* FIXME */ - return 0; -} - -static int -SDL_D3D_RenderWritePixels(SDL_Renderer * renderer, const SDL_Rect * rect, - const void *pixels, int pitch) -{ - SDL_Window *window = SDL_GetWindowFromID(renderer->window); - SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); - SDL_D3D_RenderData *data = (SDL_D3D_RenderData *) renderer->driverdata; - RECT d3drect; - POINT point; - D3DLOCKED_RECT locked; - const Uint8 *src; - Uint8 *dst; - int row, length; - HRESULT result; - - if (!data->surface) { - result = - IDirect3DDevice9_GetBackBuffer(data->device, 0, 0, - D3DBACKBUFFER_TYPE_MONO, - &data->surface); - if (FAILED(result)) { - D3D_SetError("GetBackBuffer()", result); - return -1; - } - } - if (!data->offscreen) { - result = - IDirect3DDevice9_CreateOffscreenPlainSurface(data->device, - window->w, window->h, - PixelFormatToD3DFMT - (display-> - current_mode. - format), - D3DPOOL_SYSTEMMEM, - &data->offscreen, - NULL); - if (FAILED(result)) { - D3D_SetError("CreateOffscreenPlainSurface()", result); - return -1; - } - } - - d3drect.left = rect->x; - d3drect.right = rect->x + rect->w; - d3drect.top = rect->y; - d3drect.bottom = rect->y + rect->h; - - result = - IDirect3DSurface9_LockRect(data->offscreen, &locked, &d3drect, 0); - if (FAILED(result)) { - D3D_SetError("LockRect()", result); - return -1; - } - - src = pixels; - dst = locked.pBits; - length = rect->w * SDL_BYTESPERPIXEL(display->current_mode.format); - for (row = 0; row < rect->h; ++row) { - SDL_memcpy(dst, src, length); - src += pitch; - dst += locked.Pitch; - } - IDirect3DSurface9_UnlockRect(data->offscreen); - - point.x = rect->x; - point.y = rect->y; - result = - IDirect3DDevice9_UpdateSurface(data->device, data->offscreen, - &d3drect, data->surface, &point); - if (FAILED(result)) { - D3D_SetError("UpdateSurface()", result); - return -1; - } - - return 0; -} - static void SDL_D3D_RenderPresent(SDL_Renderer * renderer) { @@ -765,12 +698,6 @@ SDL_D3D_DestroyRenderer(SDL_Renderer * renderer) if (data->device) { IDirect3DDevice9_Release(data->device); } - if (data->surface) { - IDirect3DSurface9_Release(data->surface); - } - if (data->offscreen) { - IDirect3DSurface9_Release(data->offscreen); - } SDL_free(data); } SDL_free(renderer); diff --git a/src/video/win32/SDL_gdirender.c b/src/video/win32/SDL_gdirender.c index 194c733b6..6e8e85c9f 100644 --- a/src/video/win32/SDL_gdirender.c +++ b/src/video/win32/SDL_gdirender.c @@ -55,20 +55,12 @@ static void SDL_GDI_UnlockTexture(SDL_Renderer * renderer, static void SDL_GDI_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture, int numrects, const SDL_Rect * rects); -static void SDL_GDI_SelectRenderTexture(SDL_Renderer * renderer, - SDL_Texture * texture); static int SDL_GDI_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect, Uint32 color); static int SDL_GDI_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture, const SDL_Rect * srcrect, const SDL_Rect * dstrect, int blendMode, int scaleMode); -static int SDL_GDI_RenderReadPixels(SDL_Renderer * renderer, - const SDL_Rect * rect, void *pixels, - int pitch); -static int SDL_GDI_RenderWritePixels(SDL_Renderer * renderer, - const SDL_Rect * rect, - const void *pixels, int pitch); static void SDL_GDI_RenderPresent(SDL_Renderer * renderer); static void SDL_GDI_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture); @@ -81,7 +73,7 @@ SDL_RenderDriver SDL_GDI_RenderDriver = { "gdi", (SDL_Renderer_SingleBuffer | SDL_Renderer_PresentCopy | SDL_Renderer_PresentFlip2 | SDL_Renderer_PresentFlip3 | - SDL_Renderer_PresentDiscard | SDL_Renderer_RenderTarget), + SDL_Renderer_PresentDiscard), (SDL_TextureBlendMode_None | SDL_TextureBlendMode_Mask | SDL_TextureBlendMode_Blend), (SDL_TextureScaleMode_None | SDL_TextureScaleMode_Fast), @@ -114,9 +106,6 @@ typedef struct int current_hbm; SDL_DirtyRectList dirty; SDL_bool makedirty; - HBITMAP window_dib; - void *window_pixels; - int window_pitch; } SDL_GDI_RenderData; typedef struct @@ -182,11 +171,8 @@ SDL_GDI_CreateRenderer(SDL_Window * window, Uint32 flags) renderer->LockTexture = SDL_GDI_LockTexture; renderer->UnlockTexture = SDL_GDI_UnlockTexture; renderer->DirtyTexture = SDL_GDI_DirtyTexture; - renderer->SelectRenderTexture = SDL_GDI_SelectRenderTexture; renderer->RenderFill = SDL_GDI_RenderFill; renderer->RenderCopy = SDL_GDI_RenderCopy; - renderer->RenderReadPixels = SDL_GDI_RenderReadPixels; - renderer->RenderWritePixels = SDL_GDI_RenderWritePixels; renderer->RenderPresent = SDL_GDI_RenderPresent; renderer->DestroyTexture = SDL_GDI_DestroyTexture; renderer->DestroyRenderer = SDL_GDI_DestroyRenderer; @@ -194,7 +180,7 @@ SDL_GDI_CreateRenderer(SDL_Window * window, Uint32 flags) renderer->window = window->id; renderer->driverdata = data; - renderer->info.flags = SDL_Renderer_RenderTarget; + renderer->info.flags = SDL_Renderer_Accelerated; data->hwnd = windowdata->hwnd; data->window_hdc = GetDC(data->hwnd); @@ -218,7 +204,8 @@ SDL_GDI_CreateRenderer(SDL_Window * window, Uint32 flags) DeleteObject(hbm); if (flags & SDL_Renderer_SingleBuffer) { - renderer->info.flags |= SDL_Renderer_SingleBuffer; + renderer->info.flags |= + (SDL_Renderer_SingleBuffer | SDL_Renderer_PresentCopy); n = 0; } else if (flags & SDL_Renderer_PresentFlip2) { renderer->info.flags |= SDL_Renderer_PresentFlip2; @@ -271,10 +258,6 @@ SDL_GDI_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture) texture->driverdata = data; if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) { - if (texture->access == SDL_TextureAccess_Render) { - SDL_SetError("Rendering to YUV format textures is not supported"); - return -1; - } data->yuv = SDL_SW_CreateYUVTexture(texture); if (!data->yuv) { SDL_GDI_DestroyTexture(renderer, texture); @@ -521,31 +504,6 @@ SDL_GDI_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture, { } -static void -SDL_GDI_SelectRenderTexture(SDL_Renderer * renderer, SDL_Texture * texture) -{ - SDL_GDI_RenderData *data = (SDL_GDI_RenderData *) renderer->driverdata; - - if (texture) { - SDL_GDI_TextureData *texturedata = - (SDL_GDI_TextureData *) texture->driverdata; - SelectObject(data->render_hdc, texturedata->hbm); - if (texturedata->hpal) { - SelectPalette(data->render_hdc, texturedata->hpal, TRUE); - RealizePalette(data->render_hdc); - } - data->current_hdc = data->render_hdc; - data->makedirty = SDL_FALSE; - } else if (renderer->info.flags & SDL_Renderer_SingleBuffer) { - data->current_hdc = data->window_hdc; - data->makedirty = SDL_FALSE; - } else { - SelectObject(data->render_hdc, data->hbm[data->current_hbm]); - data->current_hdc = data->render_hdc; - data->makedirty = SDL_TRUE; - } -} - static int SDL_GDI_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect, Uint32 color) @@ -637,98 +595,6 @@ SDL_GDI_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture, return 0; } -static int -CreateWindowDIB(SDL_GDI_RenderData * data, SDL_Window * window) -{ - data->window_pitch = window->w * (data->bmi->bmiHeader.biBitCount / 8); - data->bmi->bmiHeader.biWidth = window->w; - data->bmi->bmiHeader.biHeight = -window->h; - data->bmi->bmiHeader.biSizeImage = - window->h * (data->bmi->bmiHeader.biBitCount / 8); - data->window_dib = - CreateDIBSection(data->window_hdc, data->bmi, DIB_RGB_COLORS, - &data->window_pixels, NULL, 0); - if (!data->window_dib) { - WIN_SetError("CreateDIBSection()"); - return -1; - } - return 0; -} - -static int -SDL_GDI_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect, - void *pixels, int pitch) -{ - SDL_Window *window = SDL_GetWindowFromID(renderer->window); - SDL_GDI_RenderData *data = (SDL_GDI_RenderData *) renderer->driverdata; - - if (!data->window_dib) { - if (CreateWindowDIB(data, window) < 0) { - return -1; - } - } - - SelectObject(data->memory_hdc, data->window_dib); - BitBlt(data->memory_hdc, rect->x, rect->y, rect->w, rect->h, - data->current_hdc, rect->x, rect->y, SRCCOPY); - - { - int bpp = data->bmi->bmiHeader.biBitCount / 8; - Uint8 *src = - (Uint8 *) data->window_pixels + rect->y * data->window_pitch + - rect->x * bpp; - Uint8 *dst = (Uint8 *) pixels; - int row; - - for (row = 0; row < rect->h; ++row) { - SDL_memcpy(dst, src, rect->w * bpp); - src += data->window_pitch; - dst += pitch; - } - } - - return 0; -} - -static int -SDL_GDI_RenderWritePixels(SDL_Renderer * renderer, const SDL_Rect * rect, - const void *pixels, int pitch) -{ - SDL_Window *window = SDL_GetWindowFromID(renderer->window); - SDL_GDI_RenderData *data = (SDL_GDI_RenderData *) renderer->driverdata; - - if (data->makedirty) { - SDL_AddDirtyRect(&data->dirty, rect); - } - - if (!data->window_dib) { - if (CreateWindowDIB(data, window) < 0) { - return -1; - } - } - - { - int bpp = data->bmi->bmiHeader.biBitCount / 8; - Uint8 *src = (Uint8 *) pixels; - Uint8 *dst = - (Uint8 *) data->window_pixels + rect->y * data->window_pitch + - rect->x * bpp; - int row; - - for (row = 0; row < rect->h; ++row) { - SDL_memcpy(dst, src, rect->w * bpp); - src += pitch; - dst += data->window_pitch; - } - } - - SelectObject(data->memory_hdc, data->window_dib); - BitBlt(data->current_hdc, rect->x, rect->y, rect->w, rect->h, - data->memory_hdc, rect->x, rect->y, SRCCOPY); - - return 0; -} - static void SDL_GDI_RenderPresent(SDL_Renderer * renderer) { @@ -795,9 +661,6 @@ SDL_GDI_DestroyRenderer(SDL_Renderer * renderer) } } SDL_FreeDirtyRects(&data->dirty); - if (data->window_dib) { - DeleteObject(data->window_dib); - } SDL_free(data); } SDL_free(renderer); diff --git a/test/testsprite.c b/test/testsprite.c index 76ee5de26..5a8429c83 100644 --- a/test/testsprite.c +++ b/test/testsprite.c @@ -1,6 +1,7 @@ /* Simple program: Move N sprites around on the screen as fast as possible */ #include +#include #include #include "SDL.h" diff --git a/test/testsprite2.c b/test/testsprite2.c index b648edde4..538c9d35f 100644 --- a/test/testsprite2.c +++ b/test/testsprite2.c @@ -1,6 +1,7 @@ /* Simple program: Move N sprites around on the screen as fast as possible */ #include +#include #include #include "SDL.h" @@ -126,6 +127,7 @@ main(int argc, char *argv[]) { int window_w, window_h; Uint32 window_flags = SDL_WINDOW_SHOWN; + Uint32 render_flags = 0; SDL_DisplayMode *mode, fullscreen_mode; int i, done; SDL_Event event; @@ -152,11 +154,13 @@ main(int argc, char *argv[]) } else if (strcmp(argv[i], "-fullscreen") == 0) { num_windows = 1; window_flags |= SDL_WINDOW_FULLSCREEN; + } else if (strcmp(argv[i], "-sync") == 0) { + render_flags |= SDL_Renderer_PresentVSync; } else if (isdigit(argv[i][0])) { num_sprites = atoi(argv[i]); } else { fprintf(stderr, - "Usage: %s [-width N] [-height N] [-windows N] [-fullscreen] [numsprites]\n", + "Usage: %s [-width N] [-height N] [-windows N] [-fullscreen] [-sync] [numsprites]\n", argv[0]); quit(1); } @@ -189,7 +193,7 @@ main(int argc, char *argv[]) quit(2); } - if (SDL_CreateRenderer(windows[i], -1, 0) < 0) { + if (SDL_CreateRenderer(windows[i], -1, render_flags) < 0) { fprintf(stderr, "Couldn't create renderer: %s\n", SDL_GetError()); quit(2); }