pandory500/SDL-mirror
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Making the API simpler, the renderer present semantics are always having a backbuffer and then discarding it. This is best for hardware accelerated rendering.

Browse source 
--HG--
extra : rebase_source : bbe6641fce097c79ccd47f4e1ea6b27683fd0acb
This commit is contained in:
Sam Lantinga 2011-02-01 12:19:46 -08:00
parent 4c06e58153
commit d627939049
11 changed files with 80 additions and 294 deletions
Download patch file Download diff file Expand all files Collapse all files

21
include/SDL_video.h
View file

@ -151,32 +151,11 @@ typedef enum
*/ */
typedef enum typedef enum
{ {
SDL_RENDERER_SINGLEBUFFER = 0x00000001, /**< Render directly to the
window, if possible */
SDL_RENDERER_PRESENTCOPY = 0x00000002, /**< Present uses a copy from
back buffer to the front
buffer */
SDL_RENDERER_PRESENTFLIP2 = 0x00000004, /**< Present uses a flip,
swapping back buffer and
front buffer */
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 SDL_RENDERER_PRESENTVSYNC = 0x00000020, /**< Present is synchronized
with the refresh rate */ with the refresh rate */
SDL_RENDERER_ACCELERATED = 0x00000040 /**< The renderer uses hardware SDL_RENDERER_ACCELERATED = 0x00000040 /**< The renderer uses hardware
acceleration */ acceleration */
} SDL_RendererFlags; } SDL_RendererFlags;
/** /**

12
src/SDL_compat.c
View file

@ -667,9 +667,7 @@ SDL_SetVideoMode(int width, int height, int bpp, Uint32 flags)
} }
/* Create a renderer for the window */ /* Create a renderer for the window */
if (SDL_CreateRenderer if (SDL_CreateRenderer(SDL_VideoWindow, -1, 0) < 0) {
(SDL_VideoWindow, -1,
SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTDISCARD) < 0) {
return NULL; return NULL;
} }
SDL_GetRendererInfo(&SDL_VideoRendererInfo); SDL_GetRendererInfo(&SDL_VideoRendererInfo);
@ -861,6 +859,7 @@ void
SDL_UpdateRects(SDL_Surface * screen, int numrects, SDL_Rect * rects) SDL_UpdateRects(SDL_Surface * screen, int numrects, SDL_Rect * rects)
{ {
int i; int i;
SDL_Rect rect;
if (screen == SDL_ShadowSurface) { if (screen == SDL_ShadowSurface) {
for (i = 0; i < numrects; ++i) { for (i = 0; i < numrects; ++i) {
@ -887,18 +886,11 @@ SDL_UpdateRects(SDL_Surface * screen, int numrects, SDL_Rect * rects)
SDL_UpdateTexture(SDL_VideoTexture, rect, pixels, pitch); SDL_UpdateTexture(SDL_VideoTexture, rect, pixels, pitch);
} }
} }
if (SDL_VideoRendererInfo.flags & SDL_RENDERER_PRESENTCOPY) {
for (i = 0; i < numrects; ++i) {
SDL_RenderCopy(SDL_VideoTexture, &rects[i], &rects[i]);
}
} else {
SDL_Rect rect;
rect.x = 0; rect.x = 0;
rect.y = 0; rect.y = 0;
rect.w = screen->w; rect.w = screen->w;
rect.h = screen->h; rect.h = screen->h;
SDL_RenderCopy(SDL_VideoTexture, &rect, &rect); SDL_RenderCopy(SDL_VideoTexture, &rect, &rect);
}
SDL_RenderPresent(); SDL_RenderPresent();
} }
} }

13
src/video/SDL_renderer_gl.c
View file

@ -112,8 +112,7 @@ SDL_RenderDriver GL_RenderDriver = {
GL_CreateRenderer, GL_CreateRenderer,
{ {
"opengl", "opengl",
(SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTDISCARD | (SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_ACCELERATED),
SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_ACCELERATED),
15, 15,
{ {
SDL_PIXELFORMAT_INDEX1LSB, SDL_PIXELFORMAT_INDEX1LSB,
@ -252,7 +251,6 @@ GL_CreateRenderer(SDL_Window * window, Uint32 flags)
SDL_Renderer *renderer; SDL_Renderer *renderer;
GL_RenderData *data; GL_RenderData *data;
GLint value; GLint value;
int doublebuffer;
/* Render directly to the window, unless we're compositing */ /* Render directly to the window, unless we're compositing */
#ifndef __MACOSX__ #ifndef __MACOSX__
@ -304,8 +302,7 @@ GL_CreateRenderer(SDL_Window * window, Uint32 flags)
renderer->window = window; renderer->window = window;
renderer->driverdata = data; renderer->driverdata = data;
renderer->info.flags = renderer->info.flags = SDL_RENDERER_ACCELERATED;
(SDL_RENDERER_PRESENTDISCARD | SDL_RENDERER_ACCELERATED);
if (GL_LoadFunctions(data) < 0) { if (GL_LoadFunctions(data) < 0) {
GL_DestroyRenderer(renderer); GL_DestroyRenderer(renderer);
@ -337,12 +334,6 @@ GL_CreateRenderer(SDL_Window * window, Uint32 flags)
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC; renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
} }
if (SDL_GL_GetAttribute(SDL_GL_DOUBLEBUFFER, &doublebuffer) == 0) {
if (!doublebuffer) {
renderer->info.flags |= SDL_RENDERER_SINGLEBUFFER;
}
}
data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value); data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_width = value; renderer->info.max_texture_width = value;
data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value); data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);

6
src/video/SDL_renderer_gles.c
View file

@ -98,8 +98,7 @@ SDL_RenderDriver GL_ES_RenderDriver = {
GLES_CreateRenderer, GLES_CreateRenderer,
{ {
"opengl_es", "opengl_es",
(SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTDISCARD | (SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_ACCELERATED),
SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_ACCELERATED),
{ {
/* OpenGL ES 1.x supported formats list */ /* OpenGL ES 1.x supported formats list */
SDL_PIXELFORMAT_RGBA4444, SDL_PIXELFORMAT_RGBA4444,
@ -241,8 +240,7 @@ GLES_CreateRenderer(SDL_Window * window, Uint32 flags)
renderer->window = window; renderer->window = window;
renderer->driverdata = data; renderer->driverdata = data;
renderer->info.flags = renderer->info.flags = SDL_RENDERER_ACCELERATED;
(SDL_RENDERER_PRESENTDISCARD | SDL_RENDERER_ACCELERATED);
#if defined(__QNXNTO__) #if defined(__QNXNTO__)
#if _NTO_VERSION<=641 #if _NTO_VERSION<=641

134
src/video/SDL_renderer_sw.c
View file

@ -81,9 +81,7 @@ SDL_RenderDriver SW_RenderDriver = {
SW_CreateRenderer, SW_CreateRenderer,
{ {
"software", "software",
(SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY | (SDL_RENDERER_PRESENTVSYNC),
SDL_RENDERER_PRESENTFLIP2 | SDL_RENDERER_PRESENTFLIP3 |
SDL_RENDERER_PRESENTDISCARD | SDL_RENDERER_PRESENTVSYNC),
14, 14,
{ {
SDL_PIXELFORMAT_INDEX8, SDL_PIXELFORMAT_INDEX8,
@ -108,8 +106,7 @@ typedef struct
{ {
Uint32 format; Uint32 format;
SDL_bool updateSize; SDL_bool updateSize;
int current_texture; SDL_Texture *texture;
SDL_Texture *texture[3];
SDL_Surface surface; SDL_Surface surface;
SDL_Renderer *renderer; SDL_Renderer *renderer;
SDL_DirtyRectList dirty; SDL_DirtyRectList dirty;
@ -150,16 +147,12 @@ static int
DisplayPaletteChanged(void *userdata, SDL_Palette * palette) DisplayPaletteChanged(void *userdata, SDL_Palette * palette)
{ {
SW_RenderData *data = (SW_RenderData *) userdata; SW_RenderData *data = (SW_RenderData *) userdata;
int i;
for (i = 0; i < SDL_arraysize(data->texture); ++i) { if (data->renderer->SetTexturePalette) {
if (data->texture[i] && data->renderer->SetTexturePalette) { data->renderer->SetTexturePalette(data->renderer, data->texture,
data->renderer->SetTexturePalette(data->renderer,
data->texture[i],
palette->colors, 0, palette->colors, 0,
palette->ncolors); palette->ncolors);
} }
}
return 0; return 0;
} }
@ -237,21 +230,11 @@ SW_CreateRenderer(SDL_Window * window, Uint32 flags)
renderer->driverdata = data; renderer->driverdata = data;
Setup_SoftwareRenderer(renderer); Setup_SoftwareRenderer(renderer);
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; n = 1;
}
data->format = displayMode->format; data->format = displayMode->format;
/* Find a render driver that we can use to display data */ /* Find a render driver that we can use to display data */
renderer_flags = (SDL_RENDERER_SINGLEBUFFER | renderer_flags = 0;
SDL_RENDERER_PRESENTDISCARD);
if (flags & SDL_RENDERER_PRESENTVSYNC) { if (flags & SDL_RENDERER_PRESENTVSYNC) {
renderer_flags |= SDL_RENDERER_PRESENTVSYNC; renderer_flags |= SDL_RENDERER_PRESENTVSYNC;
} }
@ -280,15 +263,12 @@ SW_CreateRenderer(SDL_Window * window, Uint32 flags)
} }
/* Create the textures we'll use for display */ /* Create the textures we'll use for display */
for (i = 0; i < n; ++i) { data->texture =
data->texture[i] =
CreateTexture(data->renderer, data->format, window->w, window->h); CreateTexture(data->renderer, data->format, window->w, window->h);
if (!data->texture[i]) { if (!data->texture) {
SW_DestroyRenderer(renderer); SW_DestroyRenderer(renderer);
return NULL; return NULL;
} }
}
data->current_texture = 0;
/* Create a surface we'll use for rendering */ /* Create a surface we'll use for rendering */
data->surface.flags = SDL_PREALLOC; data->surface.flags = SDL_PREALLOC;
@ -321,27 +301,15 @@ SW_ActivateRenderer(SDL_Renderer * renderer)
} }
if (data->updateSize) { if (data->updateSize) {
/* Recreate the textures for the new window size */ /* Recreate the textures for the new window size */
if (renderer->info.flags & SDL_RENDERER_PRESENTFLIP2) { if (data->texture) {
n = 2; DestroyTexture(data->renderer, data->texture);
} else if (renderer->info.flags & SDL_RENDERER_PRESENTFLIP3) { data->texture = 0;
n = 3;
} else {
n = 1;
} }
for (i = 0; i < n; ++i) { data->texture = CreateTexture(data->renderer, data->format,
if (data->texture[i]) { window->w, window->h);
DestroyTexture(data->renderer, data->texture[i]); if (!data->texture) {
data->texture[i] = 0;
}
}
for (i = 0; i < n; ++i) {
data->texture[i] =
CreateTexture(data->renderer, data->format, window->w,
window->h);
if (!data->texture[i]) {
return -1; return -1;
} }
}
data->updateSize = SDL_FALSE; data->updateSize = SDL_FALSE;
} }
return 0; return 0;
@ -528,7 +496,7 @@ SW_RenderDrawPoints(SDL_Renderer * renderer, const SDL_Point * points,
int count) int count)
{ {
SW_RenderData *data = (SW_RenderData *) renderer->driverdata; SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
SDL_Texture *texture = data->texture[data->current_texture]; SDL_Texture *texture = data->texture;
SDL_Rect rect; SDL_Rect rect;
int i; int i;
int x, y; int x, y;
@ -544,10 +512,6 @@ SW_RenderDrawPoints(SDL_Renderer * renderer, const SDL_Point * points,
return 0; return 0;
} }
if (data->renderer->info.flags & SDL_RENDERER_PRESENTCOPY) {
SDL_AddDirtyRect(&data->dirty, &rect);
}
if (data->renderer->LockTexture(data->renderer, texture, &rect, 1, if (data->renderer->LockTexture(data->renderer, texture, &rect, 1,
&data->surface.pixels, &data->surface.pixels,
&data->surface.pitch) < 0) { &data->surface.pitch) < 0) {
@ -591,7 +555,7 @@ SW_RenderDrawLines(SDL_Renderer * renderer, const SDL_Point * points,
int count) int count)
{ {
SW_RenderData *data = (SW_RenderData *) renderer->driverdata; SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
SDL_Texture *texture = data->texture[data->current_texture]; SDL_Texture *texture = data->texture;
SDL_Rect clip, rect; SDL_Rect clip, rect;
int i; int i;
int x1, y1, x2, y2; int x1, y1, x2, y2;
@ -608,10 +572,6 @@ SW_RenderDrawLines(SDL_Renderer * renderer, const SDL_Point * points,
return 0; return 0;
} }
if (data->renderer->info.flags & SDL_RENDERER_PRESENTCOPY) {
SDL_AddDirtyRect(&data->dirty, &rect);
}
if (data->renderer->LockTexture(data->renderer, texture, &rect, 1, if (data->renderer->LockTexture(data->renderer, texture, &rect, 1,
&data->surface.pixels, &data->surface.pixels,
&data->surface.pitch) < 0) { &data->surface.pitch) < 0) {
@ -659,7 +619,7 @@ SW_RenderDrawRects(SDL_Renderer * renderer, const SDL_Rect ** rects,
int count) int count)
{ {
SW_RenderData *data = (SW_RenderData *) renderer->driverdata; SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
SDL_Texture *texture = data->texture[data->current_texture]; SDL_Texture *texture = data->texture;
SDL_Rect clip, rect; SDL_Rect clip, rect;
Uint32 color = 0; Uint32 color = 0;
int i; int i;
@ -683,10 +643,6 @@ SW_RenderDrawRects(SDL_Renderer * renderer, const SDL_Rect ** rects,
continue; continue;
} }
if (data->renderer->info.flags & SDL_RENDERER_PRESENTCOPY) {
SDL_AddDirtyRect(&data->dirty, &rect);
}
if (data->renderer->LockTexture(data->renderer, texture, &rect, 1, if (data->renderer->LockTexture(data->renderer, texture, &rect, 1,
&data->surface.pixels, &data->surface.pixels,
&data->surface.pitch) < 0) { &data->surface.pitch) < 0) {
@ -715,7 +671,7 @@ SW_RenderFillRects(SDL_Renderer * renderer, const SDL_Rect ** rects,
int count) int count)
{ {
SW_RenderData *data = (SW_RenderData *) renderer->driverdata; SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
SDL_Texture *texture = data->texture[data->current_texture]; SDL_Texture *texture = data->texture;
SDL_Rect clip, rect; SDL_Rect clip, rect;
Uint32 color = 0; Uint32 color = 0;
int i; int i;
@ -738,10 +694,6 @@ SW_RenderFillRects(SDL_Renderer * renderer, const SDL_Rect ** rects,
continue; continue;
} }
if (data->renderer->info.flags & SDL_RENDERER_PRESENTCOPY) {
SDL_AddDirtyRect(&data->dirty, &rect);
}
if (data->renderer->LockTexture(data->renderer, texture, &rect, 1, if (data->renderer->LockTexture(data->renderer, texture, &rect, 1,
&data->surface.pixels, &data->surface.pixels,
&data->surface.pitch) < 0) { &data->surface.pitch) < 0) {
@ -772,12 +724,7 @@ SW_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
SW_RenderData *data = (SW_RenderData *) renderer->driverdata; SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
int status; int status;
if (data->renderer->info.flags & SDL_RENDERER_PRESENTCOPY) { if (data->renderer->LockTexture(data->renderer, data->texture,
SDL_AddDirtyRect(&data->dirty, dstrect);
}
if (data->renderer->LockTexture(data->renderer,
data->texture[data->current_texture],
dstrect, 1, &data->surface.pixels, dstrect, 1, &data->surface.pixels,
&data->surface.pitch) < 0) { &data->surface.pitch) < 0) {
return -1; return -1;
@ -803,8 +750,7 @@ SW_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
SDL_LowerBlit(surface, &real_srcrect, &data->surface, SDL_LowerBlit(surface, &real_srcrect, &data->surface,
&real_dstrect); &real_dstrect);
} }
data->renderer->UnlockTexture(data->renderer, data->renderer->UnlockTexture(data->renderer, data->texture);
data->texture[data->current_texture]);
return status; return status;
} }
@ -814,8 +760,7 @@ SW_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
{ {
SW_RenderData *data = (SW_RenderData *) renderer->driverdata; SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
if (data->renderer->LockTexture(data->renderer, if (data->renderer->LockTexture(data->renderer, data->texture,
data->texture[data->current_texture],
rect, 0, &data->surface.pixels, rect, 0, &data->surface.pixels,
&data->surface.pitch) < 0) { &data->surface.pitch) < 0) {
return -1; return -1;
@ -825,8 +770,7 @@ SW_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
data->format, data->surface.pixels, data->surface.pitch, data->format, data->surface.pixels, data->surface.pitch,
format, pixels, pitch); format, pixels, pitch);
data->renderer->UnlockTexture(data->renderer, data->renderer->UnlockTexture(data->renderer, data->texture);
data->texture[data->current_texture]);
return 0; return 0;
} }
@ -836,12 +780,7 @@ SW_RenderWritePixels(SDL_Renderer * renderer, const SDL_Rect * rect,
{ {
SW_RenderData *data = (SW_RenderData *) renderer->driverdata; SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
if (data->renderer->info.flags & SDL_RENDERER_PRESENTCOPY) { if (data->renderer->LockTexture(data->renderer, data->texture,
SDL_AddDirtyRect(&data->dirty, rect);
}
if (data->renderer->LockTexture(data->renderer,
data->texture[data->current_texture],
rect, 1, &data->surface.pixels, rect, 1, &data->surface.pixels,
&data->surface.pitch) < 0) { &data->surface.pitch) < 0) {
return -1; return -1;
@ -850,8 +789,7 @@ SW_RenderWritePixels(SDL_Renderer * renderer, const SDL_Rect * rect,
SDL_ConvertPixels(rect->w, rect->h, format, pixels, pitch, SDL_ConvertPixels(rect->w, rect->h, format, pixels, pitch,
data->format, data->surface.pixels, data->surface.pitch); data->format, data->surface.pixels, data->surface.pitch);
data->renderer->UnlockTexture(data->renderer, data->renderer->UnlockTexture(data->renderer, data->texture);
data->texture[data->current_texture]);
return 0; return 0;
} }
@ -859,32 +797,16 @@ static void
SW_RenderPresent(SDL_Renderer * renderer) SW_RenderPresent(SDL_Renderer * renderer)
{ {
SW_RenderData *data = (SW_RenderData *) renderer->driverdata; SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
SDL_Texture *texture = data->texture[data->current_texture]; SDL_Texture *texture = data->texture;
SDL_Rect rect;
/* Send the data to the display */ /* Send the data to the display */
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_ClearDirtyRects(&data->dirty);
} else {
SDL_Rect rect;
rect.x = 0; rect.x = 0;
rect.y = 0; rect.y = 0;
rect.w = texture->w; rect.w = texture->w;
rect.h = texture->h; rect.h = texture->h;
data->renderer->RenderCopy(data->renderer, texture, &rect, &rect); data->renderer->RenderCopy(data->renderer, texture, &rect, &rect);
}
data->renderer->RenderPresent(data->renderer); data->renderer->RenderPresent(data->renderer);
/* Update the flipping chain, if any */
if (renderer->info.flags & SDL_RENDERER_PRESENTFLIP2) {
data->current_texture = (data->current_texture + 1) % 2;
} else if (renderer->info.flags & SDL_RENDERER_PRESENTFLIP3) {
data->current_texture = (data->current_texture + 1) % 3;
}
} }
static void static void
@ -908,10 +830,8 @@ SW_DestroyRenderer(SDL_Renderer * renderer)
int i; int i;
if (data) { if (data) {
for (i = 0; i < SDL_arraysize(data->texture); ++i) { if (data->texture) {
if (data->texture[i]) { DestroyTexture(data->renderer, data->texture);
DestroyTexture(data->renderer, data->texture[i]);
}
} }
if (data->surface.format) { if (data->surface.format) {
SDL_SetSurfacePalette(&data->surface, NULL); SDL_SetSurfacePalette(&data->surface, NULL);

18
src/video/directfb/SDL_DirectFB_render.c
View file

@ -87,10 +87,7 @@ SDL_RenderDriver DirectFB_RenderDriver = {
DirectFB_CreateRenderer, DirectFB_CreateRenderer,
{ {
"directfb", "directfb",
(SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY | (SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_ACCELERATED),
SDL_RENDERER_PRESENTFLIP2 | SDL_RENDERER_PRESENTFLIP3 |
SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_PRESENTDISCARD |
SDL_RENDERER_ACCELERATED),
14, 14,
{ {
SDL_PIXELFORMAT_INDEX4LSB, SDL_PIXELFORMAT_INDEX4LSB,
@ -256,7 +253,6 @@ DirectFB_CreateRenderer(SDL_Window * window, Uint32 flags)
SDL_VideoDisplay *display = window->display; SDL_VideoDisplay *display = window->display;
SDL_Renderer *renderer = NULL; SDL_Renderer *renderer = NULL;
DirectFB_RenderData *data = NULL; DirectFB_RenderData *data = NULL;
DFBSurfaceCapabilities scaps;
char *p; char *p;
SDL_DFB_CALLOC(renderer, 1, sizeof(*renderer)); SDL_DFB_CALLOC(renderer, 1, sizeof(*renderer));
@ -288,8 +284,7 @@ DirectFB_CreateRenderer(SDL_Window * window, Uint32 flags)
renderer->window = window; /* SDL window */ renderer->window = window; /* SDL window */
renderer->driverdata = data; renderer->driverdata = data;
renderer->info.flags = renderer->info.flags = SDL_RENDERER_ACCELERATED;
SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTDISCARD;
data->window = window; data->window = window;
@ -301,15 +296,6 @@ DirectFB_CreateRenderer(SDL_Window * window, Uint32 flags)
} else } else
data->flipflags |= DSFLIP_ONSYNC; data->flipflags |= DSFLIP_ONSYNC;
SDL_DFB_CHECKERR(windata->surface->
GetCapabilities(windata->surface, &scaps));
if (scaps & DSCAPS_DOUBLE)
renderer->info.flags |= SDL_RENDERER_PRESENTFLIP2;
else if (scaps & DSCAPS_TRIPLE)
renderer->info.flags |= SDL_RENDERER_PRESENTFLIP3;
else
renderer->info.flags |= SDL_RENDERER_SINGLEBUFFER;
data->isyuvdirect = 0; /* default is off! */ data->isyuvdirect = 0; /* default is off! */
p = SDL_getenv(DFBENV_USE_YUV_DIRECT); p = SDL_getenv(DFBENV_USE_YUV_DIRECT);
if (p) if (p)

58
src/video/dummy/SDL_nullrender.c
View file

@ -59,16 +59,13 @@ SDL_RenderDriver SDL_DUMMY_RenderDriver = {
SDL_DUMMY_CreateRenderer, SDL_DUMMY_CreateRenderer,
{ {
"dummy", "dummy",
(SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY | (0),
SDL_RENDERER_PRESENTFLIP2 | SDL_RENDERER_PRESENTFLIP3 |
SDL_RENDERER_PRESENTDISCARD),
} }
}; };
typedef struct typedef struct
{ {
int current_screen; SDL_Surface *screen;
SDL_Surface *screens[3];
} SDL_DUMMY_RenderData; } SDL_DUMMY_RenderData;
SDL_Renderer * SDL_Renderer *
@ -78,7 +75,6 @@ SDL_DUMMY_CreateRenderer(SDL_Window * window, Uint32 flags)
SDL_DisplayMode *displayMode = &display->current_mode; SDL_DisplayMode *displayMode = &display->current_mode;
SDL_Renderer *renderer; SDL_Renderer *renderer;
SDL_DUMMY_RenderData *data; SDL_DUMMY_RenderData *data;
int i, n;
int bpp; int bpp;
Uint32 Rmask, Gmask, Bmask, Amask; Uint32 Rmask, Gmask, Bmask, Amask;
@ -117,27 +113,14 @@ SDL_DUMMY_CreateRenderer(SDL_Window * window, Uint32 flags)
renderer->driverdata = data; renderer->driverdata = data;
Setup_SoftwareRenderer(renderer); Setup_SoftwareRenderer(renderer);
if (flags & SDL_RENDERER_PRESENTFLIP2) { data->screen =
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, SDL_CreateRGBSurface(0, window->w, window->h, bpp, Rmask, Gmask,
Bmask, Amask); Bmask, Amask);
if (!data->screens[i]) { if (!data->screen) {
SDL_DUMMY_DestroyRenderer(renderer); SDL_DUMMY_DestroyRenderer(renderer);
return NULL; return NULL;
} }
SDL_SetSurfacePalette(data->screens[i], display->palette); SDL_SetSurfacePalette(data->screen, display->palette);
}
data->current_screen = 0;
return renderer; return renderer;
} }
@ -148,7 +131,7 @@ SDL_DUMMY_RenderDrawPoints(SDL_Renderer * renderer,
{ {
SDL_DUMMY_RenderData *data = SDL_DUMMY_RenderData *data =
(SDL_DUMMY_RenderData *) renderer->driverdata; (SDL_DUMMY_RenderData *) renderer->driverdata;
SDL_Surface *target = data->screens[data->current_screen]; SDL_Surface *target = data->screen;
if (renderer->blendMode == SDL_BLENDMODE_NONE) { if (renderer->blendMode == SDL_BLENDMODE_NONE) {
Uint32 color = SDL_MapRGBA(target->format, Uint32 color = SDL_MapRGBA(target->format,
@ -169,7 +152,7 @@ SDL_DUMMY_RenderDrawLines(SDL_Renderer * renderer,
{ {
SDL_DUMMY_RenderData *data = SDL_DUMMY_RenderData *data =
(SDL_DUMMY_RenderData *) renderer->driverdata; (SDL_DUMMY_RenderData *) renderer->driverdata;
SDL_Surface *target = data->screens[data->current_screen]; SDL_Surface *target = data->screen;
if (renderer->blendMode == SDL_BLENDMODE_NONE) { if (renderer->blendMode == SDL_BLENDMODE_NONE) {
Uint32 color = SDL_MapRGBA(target->format, Uint32 color = SDL_MapRGBA(target->format,
@ -190,7 +173,7 @@ SDL_DUMMY_RenderDrawRects(SDL_Renderer * renderer, const SDL_Rect ** rects,
{ {
SDL_DUMMY_RenderData *data = SDL_DUMMY_RenderData *data =
(SDL_DUMMY_RenderData *) renderer->driverdata; (SDL_DUMMY_RenderData *) renderer->driverdata;
SDL_Surface *target = data->screens[data->current_screen]; SDL_Surface *target = data->screen;
if (renderer->blendMode == SDL_BLENDMODE_NONE) { if (renderer->blendMode == SDL_BLENDMODE_NONE) {
Uint32 color = SDL_MapRGBA(target->format, Uint32 color = SDL_MapRGBA(target->format,
@ -212,7 +195,7 @@ SDL_DUMMY_RenderFillRects(SDL_Renderer * renderer, const SDL_Rect ** rects,
{ {
SDL_DUMMY_RenderData *data = SDL_DUMMY_RenderData *data =
(SDL_DUMMY_RenderData *) renderer->driverdata; (SDL_DUMMY_RenderData *) renderer->driverdata;
SDL_Surface *target = data->screens[data->current_screen]; SDL_Surface *target = data->screen;
if (renderer->blendMode == SDL_BLENDMODE_NONE) { if (renderer->blendMode == SDL_BLENDMODE_NONE) {
Uint32 color = SDL_MapRGBA(target->format, Uint32 color = SDL_MapRGBA(target->format,
@ -238,7 +221,7 @@ SDL_DUMMY_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
SDL_VideoDisplay *display = window->display; SDL_VideoDisplay *display = window->display;
if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) { if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
SDL_Surface *target = data->screens[data->current_screen]; SDL_Surface *target = data->screen;
void *pixels = void *pixels =
(Uint8 *) target->pixels + dstrect->y * target->pitch + (Uint8 *) target->pixels + dstrect->y * target->pitch +
dstrect->x * target->format->BytesPerPixel; dstrect->x * target->format->BytesPerPixel;
@ -248,7 +231,7 @@ SDL_DUMMY_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
target->pitch); target->pitch);
} else { } else {
SDL_Surface *surface = (SDL_Surface *) texture->driverdata; SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
SDL_Surface *target = data->screens[data->current_screen]; SDL_Surface *target = data->screen;
SDL_Rect real_srcrect = *srcrect; SDL_Rect real_srcrect = *srcrect;
SDL_Rect real_dstrect = *dstrect; SDL_Rect real_dstrect = *dstrect;
@ -264,7 +247,7 @@ SDL_DUMMY_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
(SDL_DUMMY_RenderData *) renderer->driverdata; (SDL_DUMMY_RenderData *) renderer->driverdata;
SDL_Window *window = renderer->window; SDL_Window *window = renderer->window;
SDL_VideoDisplay *display = window->display; SDL_VideoDisplay *display = window->display;
SDL_Surface *screen = data->screens[data->current_screen]; SDL_Surface *screen = data->screen;
Uint32 screen_format = display->current_mode.format; Uint32 screen_format = display->current_mode.format;
Uint8 *screen_pixels = (Uint8 *) screen->pixels + Uint8 *screen_pixels = (Uint8 *) screen->pixels +
rect->y * screen->pitch + rect->y * screen->pitch +
@ -284,7 +267,7 @@ SDL_DUMMY_RenderWritePixels(SDL_Renderer * renderer, const SDL_Rect * rect,
(SDL_DUMMY_RenderData *) renderer->driverdata; (SDL_DUMMY_RenderData *) renderer->driverdata;
SDL_Window *window = renderer->window; SDL_Window *window = renderer->window;
SDL_VideoDisplay *display = window->display; SDL_VideoDisplay *display = window->display;
SDL_Surface *screen = data->screens[data->current_screen]; SDL_Surface *screen = data->screen;
Uint32 screen_format = display->current_mode.format; Uint32 screen_format = display->current_mode.format;
Uint8 *screen_pixels = (Uint8 *) screen->pixels + Uint8 *screen_pixels = (Uint8 *) screen->pixels +
rect->y * screen->pitch + rect->y * screen->pitch +
@ -308,14 +291,7 @@ SDL_DUMMY_RenderPresent(SDL_Renderer * renderer)
char file[128]; char file[128];
SDL_snprintf(file, sizeof(file), "SDL_window%d-%8.8d.bmp", SDL_snprintf(file, sizeof(file), "SDL_window%d-%8.8d.bmp",
renderer->window->id, ++frame_number); renderer->window->id, ++frame_number);
SDL_SaveBMP(data->screens[data->current_screen], file); SDL_SaveBMP(data->screen, file);
}
/* Update the flipping chain, if any */
if (renderer->info.flags & SDL_RENDERER_PRESENTFLIP2) {
data->current_screen = (data->current_screen + 1) % 2;
} else if (renderer->info.flags & SDL_RENDERER_PRESENTFLIP3) {
data->current_screen = (data->current_screen + 1) % 3;
} }
} }
@ -327,10 +303,8 @@ SDL_DUMMY_DestroyRenderer(SDL_Renderer * renderer)
int i; int i;
if (data) { if (data) {
for (i = 0; i < SDL_arraysize(data->screens); ++i) { if (data->screen) {
if (data->screens[i]) { SDL_FreeSurface(data->screen);
SDL_FreeSurface(data->screens[i]);
}
} }
SDL_free(data); SDL_free(data);
} }

2
src/video/nds/SDL_ndsrender.c
View file

@ -71,7 +71,7 @@ static void NDS_DestroyRenderer(SDL_Renderer * renderer);
SDL_RenderDriver NDS_RenderDriver = { SDL_RenderDriver NDS_RenderDriver = {
NDS_CreateRenderer, NDS_CreateRenderer,
{"nds", /* char* name */ {"nds", /* char* name */
(SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTDISCARD | SDL_RENDERER_PRESENTVSYNC), /* u32 flags */ (SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC), /* u32 flags */
3, /* u32 num_texture_formats */ 3, /* u32 num_texture_formats */
{ {
SDL_PIXELFORMAT_INDEX8, SDL_PIXELFORMAT_INDEX8,

35
src/video/windows/SDL_d3drender.c
View file

@ -134,10 +134,7 @@ SDL_RenderDriver D3D_RenderDriver = {
D3D_CreateRenderer, D3D_CreateRenderer,
{ {
"d3d", "d3d",
(SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY | (SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_ACCELERATED),
SDL_RENDERER_PRESENTFLIP2 | SDL_RENDERER_PRESENTFLIP3 |
SDL_RENDERER_PRESENTDISCARD | SDL_RENDERER_PRESENTVSYNC |
SDL_RENDERER_ACCELERATED),
0, 0,
{0}, {0},
0, 0,
@ -472,19 +469,9 @@ D3D_CreateRenderer(SDL_Window * window, Uint32 flags)
} else { } else {
pparams.BackBufferFormat = D3DFMT_UNKNOWN; pparams.BackBufferFormat = D3DFMT_UNKNOWN;
} }
if (flags & SDL_RENDERER_PRESENTFLIP2) {
pparams.BackBufferCount = 2;
pparams.SwapEffect = D3DSWAPEFFECT_FLIP;
} else if (flags & SDL_RENDERER_PRESENTFLIP3) {
pparams.BackBufferCount = 3;
pparams.SwapEffect = D3DSWAPEFFECT_FLIP;
} else if (flags & SDL_RENDERER_PRESENTCOPY) {
pparams.BackBufferCount = 1;
pparams.SwapEffect = D3DSWAPEFFECT_COPY;
} else {
pparams.BackBufferCount = 1; pparams.BackBufferCount = 1;
pparams.SwapEffect = D3DSWAPEFFECT_DISCARD; pparams.SwapEffect = D3DSWAPEFFECT_DISCARD;
}
if (window->flags & SDL_WINDOW_FULLSCREEN) { if (window->flags & SDL_WINDOW_FULLSCREEN) {
pparams.Windowed = FALSE; pparams.Windowed = FALSE;
pparams.FullScreen_RefreshRateInHz = pparams.FullScreen_RefreshRateInHz =
@ -534,24 +521,6 @@ D3D_CreateRenderer(SDL_Window * window, Uint32 flags)
return NULL; return NULL;
} }
IDirect3DSwapChain9_Release(chain); 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) { if (pparams.PresentationInterval == D3DPRESENT_INTERVAL_ONE) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC; renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
} }

25
test/common.c
View file

@ -6,7 +6,7 @@
#include "common.h" #include "common.h"
#define VIDEO_USAGE \ #define VIDEO_USAGE \
"[--video driver] [--renderer driver] [--info all|video|modes|render|event] [--display N] [--fullscreen | --windows N] [--title title] [--icon icon.bmp] [--center | --position X,Y] [--geometry WxH] [--depth N] [--refresh R] [--vsync] [--noframe] [--resize] [--minimize] [--maximize] [--grab] [--double] [--triple]" "[--video driver] [--renderer driver] [--info all|video|modes|render|event] [--display N] [--fullscreen | --windows N] [--title title] [--icon icon.bmp] [--center | --position X,Y] [--geometry WxH] [--depth N] [--refresh R] [--vsync] [--noframe] [--resize] [--minimize] [--maximize] [--grab]"
#define AUDIO_USAGE \ #define AUDIO_USAGE \
"[--rate N] [--format U8|S8|U16|U16LE|U16BE|S16|S16LE|S16BE] [--channels N] [--samples N]" "[--rate N] [--format U8|S8|U16|U16LE|U16BE|S16|S16LE|S16BE] [--channels N] [--samples N]"
@ -211,14 +211,6 @@ CommonArg(CommonState * state, int index)
state->render_flags |= SDL_RENDERER_PRESENTVSYNC; state->render_flags |= SDL_RENDERER_PRESENTVSYNC;
return 1; return 1;
} }
if (SDL_strcasecmp(argv[index], "--double") == 0) {
state->render_flags |= SDL_RENDERER_PRESENTFLIP2;
return 1;
}
if (SDL_strcasecmp(argv[index], "--triple") == 0) {
state->render_flags |= SDL_RENDERER_PRESENTFLIP3;
return 1;
}
if (SDL_strcasecmp(argv[index], "--noframe") == 0) { if (SDL_strcasecmp(argv[index], "--noframe") == 0) {
state->window_flags |= SDL_WINDOW_BORDERLESS; state->window_flags |= SDL_WINDOW_BORDERLESS;
return 1; return 1;
@ -329,21 +321,6 @@ static void
PrintRendererFlag(Uint32 flag) PrintRendererFlag(Uint32 flag)
{ {
switch (flag) { switch (flag) {
case SDL_RENDERER_SINGLEBUFFER:
fprintf(stderr, "SingleBuffer");
break;
case SDL_RENDERER_PRESENTCOPY:
fprintf(stderr, "PresentCopy");
break;
case SDL_RENDERER_PRESENTFLIP2:
fprintf(stderr, "PresentFlip2");
break;
case SDL_RENDERER_PRESENTFLIP3:
fprintf(stderr, "PresentFlip3");
break;
case SDL_RENDERER_PRESENTDISCARD:
fprintf(stderr, "PresentDiscard");
break;
case SDL_RENDERER_PRESENTVSYNC: case SDL_RENDERER_PRESENTVSYNC:
fprintf(stderr, "PresentVSync"); fprintf(stderr, "PresentVSync");
break; break;

2
test/testshape.c
View file

@ -102,7 +102,7 @@ int main(int argc,char** argv) {
printf("Could not create shaped window for SDL_Shape.\n"); printf("Could not create shaped window for SDL_Shape.\n");
exit(-4); exit(-4);
} }
if(SDL_CreateRenderer(window,-1,SDL_RENDERER_PRESENTFLIP2) == -1) { if(SDL_CreateRenderer(window,-1,0) == -1) {
SDL_DestroyWindow(window); SDL_DestroyWindow(window);
for(i=0;i<num_pictures;i++) for(i=0;i<num_pictures;i++)
SDL_FreeSurface(pictures[i].surface); SDL_FreeSurface(pictures[i].surface);