From 8e280e26b107c844b1a9aabc3aa3022a506ef67a Mon Sep 17 00:00:00 2001 From: Sam Lantinga Date: Wed, 19 Jul 2006 07:18:45 +0000 Subject: [PATCH] Starting on the OpenGL renderer... --- src/video/SDL_renderer_gl.c | 544 ++++++++++++++++++++++++++++++++ src/video/SDL_renderer_gl.h | 28 ++ src/video/SDL_renderer_sw.c | 175 +++++----- src/video/SDL_renderer_sw.h | 2 +- src/video/SDL_video.c | 6 +- src/video/win32/SDL_d3drender.c | 12 +- src/video/win32/SDL_gdirender.c | 2 +- 7 files changed, 673 insertions(+), 96 deletions(-) create mode 100644 src/video/SDL_renderer_gl.c create mode 100644 src/video/SDL_renderer_gl.h diff --git a/src/video/SDL_renderer_gl.c b/src/video/SDL_renderer_gl.c new file mode 100644 index 000000000..2c9193973 --- /dev/null +++ b/src/video/SDL_renderer_gl.c @@ -0,0 +1,544 @@ +/* + 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" + +#if SDL_VIDEO_OPENGL + +#include "SDL_win32video.h" + +/* OpenGL renderer implementation */ + +static SDL_Renderer *GL_CreateRenderer(SDL_Window * window, Uint32 flags); +static int GL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture); +static int GL_SetTexturePalette(SDL_Renderer * renderer, + SDL_Texture * texture, + const SDL_Color * colors, int firstcolor, + int ncolors); +static int GL_GetTexturePalette(SDL_Renderer * renderer, + SDL_Texture * texture, SDL_Color * colors, + int firstcolor, int ncolors); +static int GL_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture, + const SDL_Rect * rect, const void *pixels, + int pitch); +static int GL_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture, + const SDL_Rect * rect, int markDirty, + void **pixels, int *pitch); +static void GL_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture); +static void GL_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture, + int numrects, const SDL_Rect * rects); +static int GL_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect, + Uint32 color); +static int GL_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture, + const SDL_Rect * srcrect, const SDL_Rect * dstrect, + int blendMode, int scaleMode); +static void GL_RenderPresent(SDL_Renderer * renderer); +static void GL_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture); +static void GL_DestroyRenderer(SDL_Renderer * renderer); + + +SDL_RenderDriver GL_RenderDriver = { + GL_CreateRenderer, + { + "opengl", + (SDL_Renderer_PresentDiscard | SDL_Renderer_PresentVSync | + SDL_Renderer_Accelerated), + (SDL_TextureBlendMode_None | SDL_TextureBlendMode_Mask | + SDL_TextureBlendMode_Blend | SDL_TextureBlendMode_Add | + SDL_TextureBlendMode_Mod), + (SDL_TextureScaleMode_None | SDL_TextureScaleMode_Fast | + SDL_TextureScaleMode_Best), + 12, + { + SDL_PixelFormat_Index8, + SDL_PixelFormat_RGB332, + SDL_PixelFormat_RGB444, + SDL_PixelFormat_RGB555, + SDL_PixelFormat_ARGB4444, + SDL_PixelFormat_ARGB1555, + SDL_PixelFormat_RGB565, + SDL_PixelFormat_RGB888, + SDL_PixelFormat_ARGB8888, + SDL_PixelFormat_ARGB2101010, + SDL_PixelFormat_UYVY, + SDL_PixelFormat_YUY2}, + 0, + 0} +}; + +typedef struct +{ + SDL_GLContext context; + SDL_bool beginScene; +} GL_RenderData; + +typedef struct +{ + GLuint texture; + GLfloat texw; + GLfloat texh; + void *pixels; + int pitch; +} GL_TextureData; + +static GLFORMAT +PixelFormatToOpenGL(Uint32 format,) +{ + switch (format) { + case SDL_PixelFormat_Index8: + return GLFMT_P8; + case SDL_PixelFormat_RGB332: + return GLFMT_R3G3B2; + case SDL_PixelFormat_RGB444: + return GLFMT_X4R4G4B4; + case SDL_PixelFormat_RGB555: + return GLFMT_X1R5G5B5; + case SDL_PixelFormat_ARGB4444: + return GLFMT_A4R4G4B4; + case SDL_PixelFormat_ARGB1555: + return GLFMT_A1R5G5B5; + case SDL_PixelFormat_RGB565: + return GLFMT_R5G6B5; + case SDL_PixelFormat_RGB888: + return GLFMT_X8R8G8B8; + case SDL_PixelFormat_ARGB8888: + return GLFMT_A8R8G8B8; + case SDL_PixelFormat_ARGB2101010: + return GLFMT_A2R10G10B10; + case SDL_PixelFormat_UYVY: + return GLFMT_UYVY; + case SDL_PixelFormat_YUY2: + return GLFMT_YUY2; + default: + return GLFMT_UNKNOWN; + } +} + +void +GL_AddRenderDriver(_THIS) +{ + SDL_VideoData *data = (SDL_VideoData *) _this->driverdata; + + if (data->d3d) { + SDL_AddRenderDriver(0, &GL_RenderDriver); + } +} + +SDL_Renderer * +GL_CreateRenderer(SDL_Window * window, Uint32 flags) +{ + SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); + SDL_VideoData *videodata = (SDL_VideoData *) display->device->driverdata; + SDL_WindowData *windowdata = (SDL_WindowData *) window->driverdata; + SDL_Renderer *renderer; + GL_RenderData *data; + HRESULT result; + GLPRESENT_PARAMETERS pparams; + IDirect3DSwapChain9 *chain; + + if (!(window->flags & SDL_WINDOW_OPENGL)) { + SDL_SetError + ("The OpenGL renderer can only be used on OpenGL windows"); + return NULL; + } + + renderer = (SDL_Renderer *) SDL_malloc(sizeof(*renderer)); + if (!renderer) { + SDL_OutOfMemory(); + return NULL; + } + SDL_zerop(renderer); + + data = (GL_RenderData *) SDL_malloc(sizeof(*data)); + if (!data) { + GL_DestroyRenderer(renderer); + SDL_OutOfMemory(); + return NULL; + } + SDL_zerop(data); + + renderer->CreateTexture = GL_CreateTexture; + renderer->SetTexturePalette = GL_SetTexturePalette; + renderer->GetTexturePalette = GL_GetTexturePalette; + renderer->UpdateTexture = GL_UpdateTexture; + renderer->LockTexture = GL_LockTexture; + renderer->UnlockTexture = GL_UnlockTexture; + renderer->DirtyTexture = GL_DirtyTexture; + renderer->RenderFill = GL_RenderFill; + renderer->RenderCopy = GL_RenderCopy; + renderer->RenderPresent = GL_RenderPresent; + renderer->DestroyTexture = GL_DestroyTexture; + renderer->DestroyRenderer = GL_DestroyRenderer; + renderer->info = GL_RenderDriver.info; + renderer->window = window->id; + renderer->driverdata = data; + + renderer->info.flags = + (SDL_Renderer_PresentDiscard | SDL_Renderer_Accelerated); + + data->context = SDL_GL_CreateContext(window->id); + if (!data->context) { + GL_DestroyRenderer(renderer); + return NULL; + } + if (SDL_GL_MakeCurrent(window->id, data->context) < 0) { + GL_DestroyRenderer(renderer); + return NULL; + } + data->beginScene = SDL_TRUE; + + if (flags & SDL_Renderer_PresentVSync) { + SDL_GL_SetSwapInterval(1); + } else { + SDL_GL_SetSwapInterval(0); + } + if (SDL_GL_GetSwapInterval() > 0) { + renderer->info.flags |= SDL_Renderer_PresentVSync; + } + + /* Set up parameters for rendering */ + glDisable(GL_DEPTH_TEST); + glDisable(GL_CULL_FACE); + glEnable(GL_TEXTURE_2D); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + glViewport(0, 0, window->w, window->h); + glOrtho(0.0, (GLdouble) window->w, (GLdouble) window->h, 0.0, 0.0, 1.0); + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); + + return renderer; +} + +/* Quick utility function for texture creation */ +static int +power_of_two(int input) +{ + int value = 1; + + while (value < input) { + value <<= 1; + } + return value; +} + +static int +GL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture) +{ + GL_RenderData *renderdata = (GL_RenderData *) renderer->driverdata; + SDL_Window *window = SDL_GetWindowFromID(renderer->window); + SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); + GL_TextureData *data; + GLPOOL pool; + HRESULT result; + + data = (GL_TextureData *) SDL_malloc(sizeof(*data)); + if (!data) { + SDL_OutOfMemory(); + return -1; + } + SDL_zerop(data); + + texture->driverdata = data; + + if (texture->access == SDL_TextureAccess_Local) { + pool = GLPOOL_MANAGED; + } else { + pool = GLPOOL_DEFAULT; + } + result = + IDirect3DDevice9_CreateTexture(renderdata->device, texture->w, + texture->h, 1, 0, + PixelFormatToGLFMT(texture->format), + pool, &data->texture, NULL); + if (FAILED(result)) { + SDL_free(data); + GL_SetError("CreateTexture()", result); + return -1; + } + + return 0; +} + +static int +GL_SetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture, + const SDL_Color * colors, int firstcolor, int ncolors) +{ + GL_RenderData *renderdata = (GL_RenderData *) renderer->driverdata; + GL_TextureData *data = (GL_TextureData *) texture->driverdata; + + return 0; +} + +static int +GL_GetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture, + SDL_Color * colors, int firstcolor, int ncolors) +{ + GL_TextureData *data = (GL_TextureData *) texture->driverdata; + + return 0; +} + +static int +GL_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture, + const SDL_Rect * rect, const void *pixels, int pitch) +{ + GL_TextureData *data = (GL_TextureData *) texture->driverdata; + GL_RenderData *renderdata = (GL_RenderData *) renderer->driverdata; + IDirect3DTexture9 *temp; + RECT d3drect; + GLLOCKED_RECT locked; + const Uint8 *src; + Uint8 *dst; + int row, length; + HRESULT result; + + result = + IDirect3DDevice9_CreateTexture(renderdata->device, texture->w, + texture->h, 1, 0, + PixelFormatToGLFMT(texture->format), + GLPOOL_SYSTEMMEM, &temp, NULL); + if (FAILED(result)) { + GL_SetError("CreateTexture()", result); + return -1; + } + + d3drect.left = rect->x; + d3drect.right = rect->x + rect->w; + d3drect.top = rect->y; + d3drect.bottom = rect->y + rect->h; + + result = IDirect3DTexture9_LockRect(temp, 0, &locked, &d3drect, 0); + if (FAILED(result)) { + IDirect3DTexture9_Release(temp); + GL_SetError("LockRect()", result); + return -1; + } + + src = pixels; + dst = locked.pBits; + length = rect->w * SDL_BYTESPERPIXEL(texture->format); + for (row = 0; row < rect->h; ++row) { + SDL_memcpy(dst, src, length); + src += pitch; + dst += locked.Pitch; + } + IDirect3DTexture9_UnlockRect(temp, 0); + + result = + IDirect3DDevice9_UpdateTexture(renderdata->device, + (IDirect3DBaseTexture9 *) temp, + (IDirect3DBaseTexture9 *) data-> + texture); + IDirect3DTexture9_Release(temp); + if (FAILED(result)) { + GL_SetError("UpdateTexture()", result); + return -1; + } + return 0; +} + +static int +GL_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture, + const SDL_Rect * rect, int markDirty, void **pixels, + int *pitch) +{ + GL_TextureData *data = (GL_TextureData *) texture->driverdata; + RECT d3drect; + GLLOCKED_RECT locked; + HRESULT result; + + if (texture->access != SDL_TextureAccess_Local) { + SDL_SetError("Can't lock remote video memory"); + return -1; + } + + d3drect.left = rect->x; + d3drect.right = rect->x + rect->w; + d3drect.top = rect->y; + d3drect.bottom = rect->y + rect->h; + + result = + IDirect3DTexture9_LockRect(data->texture, 0, &locked, &d3drect, + markDirty ? 0 : GLLOCK_NO_DIRTY_UPDATE); + if (FAILED(result)) { + GL_SetError("LockRect()", result); + return -1; + } + *pixels = locked.pBits; + *pitch = locked.Pitch; + return 0; +} + +static void +GL_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture) +{ + GL_TextureData *data = (GL_TextureData *) texture->driverdata; + + IDirect3DTexture9_UnlockRect(data->texture, 0); +} + +static void +GL_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture, int numrects, + const SDL_Rect * rects) +{ + GL_TextureData *data = (GL_TextureData *) texture->driverdata; + RECT d3drect; + int i; + + for (i = 0; i < numrects; ++i) { + const SDL_Rect *rect = &rects[i]; + + d3drect.left = rect->x; + d3drect.right = rect->x + rect->w; + d3drect.top = rect->y; + d3drect.bottom = rect->y + rect->h; + + IDirect3DTexture9_AddDirtyRect(data->texture, &d3drect); + } +} + +static int +GL_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect, Uint32 color) +{ + GL_RenderData *data = (GL_RenderData *) renderer->driverdata; + SDL_Window *window = SDL_GetWindowFromID(renderer->window); + GLclampf r, g, b, a; + + a = ((GLclampf) ((color >> 24) & 0xFF)) / 255.0f; + r = ((GLclampf) ((color >> 16) & 0xFF)) / 255.0f; + g = ((GLclampf) ((color >> 8) & 0xFF)) / 255.0f; + b = ((GLclampf) (color & 0xFF)) / 255.0f; + + glClearColor(r, g, b, a); + glViewport(rect->x, window->h - rect->y, rect->w, rect->h); + glClear(GL_COLOR_BUFFER_BIT); + glViewport(0, 0, window->w, window->h); + return 0; +} + +static int +GL_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture, + const SDL_Rect * srcrect, const SDL_Rect * dstrect, + int blendMode, int scaleMode) +{ + GL_RenderData *data = (GL_RenderData *) renderer->driverdata; + GL_TextureData *texturedata = (GL_TextureData *) texture->driverdata; + int minx, miny, maxx, maxy; + GLfloat minu, maxu, minv, maxv; + + minx = dstrect->x; + miny = dstrect->y; + maxx = dstrect->x + dstrect->w; + maxy = dstrect->y + dstrect->h; + + minu = (GLfloat) srcrect->x / texture->w; + maxu = (GLfloat) (srcrect->x + srcrect->w) / texture->w; + minv = (GLfloat) srcrect->y / texture->h; + maxv = (GLfloat) (srcrect->y + srcrect->h) / texture->h; + + glBindTexture(GL_TEXTURE_2D, texturedata->texture); + + switch (blendMode) { + case SDL_TextureBlendMode_None: + glDisable(GL_BLEND); + break; + case SDL_TextureBlendMode_Mask: + case SDL_TextureBlendMode_Blend: + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + break; + case SDL_TextureBlendMode_Add: + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE); + break; + case SDL_TextureBlendMode_Mod: + glEnable(GL_BLEND); + glBlendFunc(GL_ZERO, GL_SRC_COLOR); + break; + } + + switch (scaleMode) { + case SDL_TextureScaleMode_None: + case SDL_TextureScaleMode_Fast: + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + break; + case SDL_TextureScaleMode_Slow: + case SDL_TextureScaleMode_Best: + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + break; + } + + glBegin(GL_TRIANGLE_STRIP); + glTexCoord2f(minu, minv); + glVertex2i(minx, miny); + glTexCoord2f(maxu, minv); + glVertex2i(maxx, miny); + glTexCoord2f(minu, maxv); + glVertex2i(miny, maxy); + glTexCoord2f(maxu, maxv); + glVertex2i(maxx, maxy); + glEnd(); + + return 0; +} + +static void +GL_RenderPresent(SDL_Renderer * renderer) +{ + SDL_GL_SwapWindow(renderer->window); +} + +static void +GL_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture) +{ + GL_TextureData *data = (GL_TextureData *) texture->driverdata; + + if (!data) { + return; + } + if (data->texture) { + IDirect3DTexture9_Release(data->texture); + } + SDL_free(data); + texture->driverdata = NULL; +} + +void +GL_DestroyRenderer(SDL_Renderer * renderer) +{ + GL_RenderData *data = (GL_RenderData *) renderer->driverdata; + + if (data) { + if (data->device) { + IDirect3DDevice9_Release(data->device); + } + SDL_free(data); + } + SDL_free(renderer); +} + +#endif /* SDL_VIDEO_OPENGL */ + +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/src/video/SDL_renderer_gl.h b/src/video/SDL_renderer_gl.h new file mode 100644 index 000000000..a3a671758 --- /dev/null +++ b/src/video/SDL_renderer_gl.h @@ -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" + +/* OpenGL renderer implementation */ + +extern SDL_RenderDriver GL_RenderDriver; + +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/src/video/SDL_renderer_sw.c b/src/video/SDL_renderer_sw.c index 427a9665c..ac9e460a5 100644 --- a/src/video/SDL_renderer_sw.c +++ b/src/video/SDL_renderer_sw.c @@ -30,44 +30,41 @@ /* 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_QueryTexturePixels(SDL_Renderer * renderer, - SDL_Texture * texture, void **pixels, - int *pitch); -static int SDL_SW_SetTexturePalette(SDL_Renderer * renderer, - SDL_Texture * texture, - const SDL_Color * colors, int firstcolor, - int ncolors); -static int SDL_SW_GetTexturePalette(SDL_Renderer * renderer, - SDL_Texture * texture, SDL_Color * colors, - int firstcolor, int ncolors); -static int SDL_SW_UpdateTexture(SDL_Renderer * renderer, - SDL_Texture * texture, const SDL_Rect * rect, - const void *pixels, int pitch); -static int SDL_SW_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture, - const 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, - const SDL_Rect * rects); -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 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, +static SDL_Renderer *SW_CreateRenderer(SDL_Window * window, Uint32 flags); +static int SW_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture); +static int SW_QueryTexturePixels(SDL_Renderer * renderer, + SDL_Texture * texture, void **pixels, + int *pitch); +static int SW_SetTexturePalette(SDL_Renderer * renderer, + SDL_Texture * texture, + const SDL_Color * colors, int firstcolor, + int ncolors); +static int SW_GetTexturePalette(SDL_Renderer * renderer, + SDL_Texture * texture, SDL_Color * colors, + int firstcolor, int ncolors); +static int SW_UpdateTexture(SDL_Renderer * renderer, + SDL_Texture * texture, const SDL_Rect * rect, + const void *pixels, int pitch); +static int SW_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture, + const SDL_Rect * rect, int markDirty, + void **pixels, int *pitch); +static void SW_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture); +static void SW_DirtyTexture(SDL_Renderer * renderer, + SDL_Texture * texture, int numrects, + const SDL_Rect * rects); +static int SW_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect, + Uint32 color); +static int SW_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture, + const SDL_Rect * srcrect, + const SDL_Rect * dstrect, int blendMode, + int scaleMode); +static void SW_RenderPresent(SDL_Renderer * renderer); +static void SW_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture); +static void SW_DestroyRenderer(SDL_Renderer * renderer); + + +SDL_RenderDriver SW_RenderDriver = { + SW_CreateRenderer, { "software", (SDL_Renderer_SingleBuffer | SDL_Renderer_PresentCopy | @@ -101,7 +98,7 @@ typedef struct SDL_Surface surface; SDL_Renderer *renderer; SDL_DirtyRectList dirty; -} SDL_SW_RenderData; +} SW_RenderData; static SDL_Texture * CreateTexture(SDL_Renderer * renderer, Uint32 format, int w, int h) @@ -138,7 +135,7 @@ DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture) static int DisplayPaletteChanged(void *userdata, SDL_Palette * palette) { - SDL_SW_RenderData *data = (SDL_SW_RenderData *) userdata; + SW_RenderData *data = (SW_RenderData *) userdata; int i; for (i = 0; i < SDL_arraysize(data->texture); ++i) { @@ -153,12 +150,12 @@ DisplayPaletteChanged(void *userdata, SDL_Palette * palette) } SDL_Renderer * -SDL_SW_CreateRenderer(SDL_Window * window, Uint32 flags) +SW_CreateRenderer(SDL_Window * window, Uint32 flags) { SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); SDL_DisplayMode *displayMode = &display->current_mode; SDL_Renderer *renderer; - SDL_SW_RenderData *data; + SW_RenderData *data; int i, n; int bpp; Uint32 Rmask, Gmask, Bmask, Amask; @@ -176,28 +173,28 @@ SDL_SW_CreateRenderer(SDL_Window * window, Uint32 flags) return NULL; } - data = (SDL_SW_RenderData *) SDL_malloc(sizeof(*data)); + data = (SW_RenderData *) SDL_malloc(sizeof(*data)); if (!data) { - SDL_SW_DestroyRenderer(renderer); + SW_DestroyRenderer(renderer); SDL_OutOfMemory(); return NULL; } SDL_zerop(data); - renderer->CreateTexture = SDL_SW_CreateTexture; - renderer->QueryTexturePixels = SDL_SW_QueryTexturePixels; - renderer->SetTexturePalette = SDL_SW_SetTexturePalette; - renderer->GetTexturePalette = SDL_SW_GetTexturePalette; - renderer->UpdateTexture = SDL_SW_UpdateTexture; - renderer->LockTexture = SDL_SW_LockTexture; - renderer->UnlockTexture = SDL_SW_UnlockTexture; - renderer->DirtyTexture = SDL_SW_DirtyTexture; - renderer->RenderFill = SDL_SW_RenderFill; - renderer->RenderCopy = SDL_SW_RenderCopy; - renderer->RenderPresent = SDL_SW_RenderPresent; - renderer->DestroyTexture = SDL_SW_DestroyTexture; - renderer->DestroyRenderer = SDL_SW_DestroyRenderer; - renderer->info = SDL_SW_RenderDriver.info; + renderer->CreateTexture = SW_CreateTexture; + renderer->QueryTexturePixels = SW_QueryTexturePixels; + renderer->SetTexturePalette = SW_SetTexturePalette; + renderer->GetTexturePalette = SW_GetTexturePalette; + renderer->UpdateTexture = SW_UpdateTexture; + renderer->LockTexture = SW_LockTexture; + renderer->UnlockTexture = SW_UnlockTexture; + renderer->DirtyTexture = SW_DirtyTexture; + renderer->RenderFill = SW_RenderFill; + renderer->RenderCopy = SW_RenderCopy; + renderer->RenderPresent = SW_RenderPresent; + renderer->DestroyTexture = SW_DestroyTexture; + renderer->DestroyRenderer = SW_DestroyRenderer; + renderer->info = SW_RenderDriver.info; renderer->window = window->id; renderer->driverdata = data; @@ -223,7 +220,7 @@ SDL_SW_CreateRenderer(SDL_Window * window, Uint32 flags) } 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) { + if (driver->info.name != SW_RenderDriver.info.name) { data->renderer = driver->CreateRenderer(window, renderer_flags); if (data->renderer) { break; @@ -231,7 +228,7 @@ SDL_SW_CreateRenderer(SDL_Window * window, Uint32 flags) } } if (i == display->num_render_drivers) { - SDL_SW_DestroyRenderer(renderer); + SW_DestroyRenderer(renderer); SDL_SetError("Couldn't find display render driver"); return NULL; } @@ -244,7 +241,7 @@ SDL_SW_CreateRenderer(SDL_Window * window, Uint32 flags) data->texture[i] = CreateTexture(data->renderer, data->format, window->w, window->h); if (!data->texture[i]) { - SDL_SW_DestroyRenderer(renderer); + SW_DestroyRenderer(renderer); return NULL; } } @@ -254,7 +251,7 @@ SDL_SW_CreateRenderer(SDL_Window * window, Uint32 flags) data->surface.flags = SDL_PREALLOC; data->surface.format = SDL_AllocFormat(bpp, Rmask, Gmask, Bmask, Amask); if (!data->surface.format) { - SDL_SW_DestroyRenderer(renderer); + SW_DestroyRenderer(renderer); return NULL; } SDL_SetSurfacePalette(&data->surface, display->palette); @@ -268,7 +265,7 @@ SDL_SW_CreateRenderer(SDL_Window * window, Uint32 flags) } static int -SDL_SW_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture) +SW_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture) { if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) { texture->driverdata = SDL_SW_CreateYUVTexture(texture); @@ -294,8 +291,8 @@ SDL_SW_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture) } static int -SDL_SW_QueryTexturePixels(SDL_Renderer * renderer, SDL_Texture * texture, - void **pixels, int *pitch) +SW_QueryTexturePixels(SDL_Renderer * renderer, SDL_Texture * texture, + void **pixels, int *pitch) { if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) { return SDL_SW_QueryYUVTexturePixels((SDL_SW_YUVTexture *) texture-> @@ -310,9 +307,8 @@ SDL_SW_QueryTexturePixels(SDL_Renderer * renderer, SDL_Texture * texture, } static int -SDL_SW_SetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture, - const SDL_Color * colors, int firstcolor, - int ncolors) +SW_SetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture, + const SDL_Color * colors, int firstcolor, int ncolors) { if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) { SDL_SetError("YUV textures don't have a palette"); @@ -326,8 +322,8 @@ SDL_SW_SetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture, } static int -SDL_SW_GetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture, - SDL_Color * colors, int firstcolor, int ncolors) +SW_GetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture, + SDL_Color * colors, int firstcolor, int ncolors) { if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) { SDL_SetError("YUV textures don't have a palette"); @@ -342,8 +338,8 @@ SDL_SW_GetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture, } static int -SDL_SW_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture, - const SDL_Rect * rect, const void *pixels, int pitch) +SW_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture, + const SDL_Rect * rect, const void *pixels, int pitch) { if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) { return SDL_SW_UpdateYUVTexture((SDL_SW_YUVTexture *) texture-> @@ -369,9 +365,9 @@ SDL_SW_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture, } static int -SDL_SW_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture, - const SDL_Rect * rect, int markDirty, void **pixels, - int *pitch) +SW_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture, + const SDL_Rect * rect, int markDirty, void **pixels, + int *pitch) { if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) { return SDL_SW_LockYUVTexture((SDL_SW_YUVTexture *) texture-> @@ -389,7 +385,7 @@ SDL_SW_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture, } static void -SDL_SW_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture) +SW_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture) { if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) { SDL_SW_UnlockYUVTexture((SDL_SW_YUVTexture *) texture->driverdata); @@ -397,16 +393,15 @@ SDL_SW_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture) } static void -SDL_SW_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture, - int numrects, const SDL_Rect * rects) +SW_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture, + int numrects, const SDL_Rect * rects) { } static int -SDL_SW_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect, - Uint32 color) +SW_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect, Uint32 color) { - SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata; + SW_RenderData *data = (SW_RenderData *) renderer->driverdata; Uint8 r, g, b, a; void *pixels; int pitch; @@ -443,11 +438,11 @@ SDL_SW_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect, } static int -SDL_SW_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture, - const SDL_Rect * srcrect, const SDL_Rect * dstrect, - int blendMode, int scaleMode) +SW_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture, + const SDL_Rect * srcrect, const SDL_Rect * dstrect, + int blendMode, int scaleMode) { - SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata; + SW_RenderData *data = (SW_RenderData *) renderer->driverdata; SDL_Window *window = SDL_GetWindowFromID(renderer->window); int status; @@ -501,9 +496,9 @@ SDL_SW_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture, } static void -SDL_SW_RenderPresent(SDL_Renderer * renderer) +SW_RenderPresent(SDL_Renderer * renderer) { - SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata; + SW_RenderData *data = (SW_RenderData *) renderer->driverdata; SDL_Texture *texture = data->texture[data->current_texture]; /* Send the data to the display */ @@ -537,7 +532,7 @@ SDL_SW_RenderPresent(SDL_Renderer * renderer) } static void -SDL_SW_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture) +SW_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture) { if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) { SDL_SW_DestroyYUVTexture((SDL_SW_YUVTexture *) texture->driverdata); @@ -549,9 +544,9 @@ SDL_SW_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture) } static void -SDL_SW_DestroyRenderer(SDL_Renderer * renderer) +SW_DestroyRenderer(SDL_Renderer * renderer) { - SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata; + SW_RenderData *data = (SW_RenderData *) renderer->driverdata; SDL_Window *window = SDL_GetWindowFromID(renderer->window); SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); int i; diff --git a/src/video/SDL_renderer_sw.h b/src/video/SDL_renderer_sw.h index 6dcdb44de..1ddc45f5b 100644 --- a/src/video/SDL_renderer_sw.h +++ b/src/video/SDL_renderer_sw.h @@ -23,6 +23,6 @@ /* SDL surface based renderer implementation */ -extern SDL_RenderDriver SDL_SW_RenderDriver; +extern SDL_RenderDriver SW_RenderDriver; /* vi: set ts=4 sw=4 expandtab: */ diff --git a/src/video/SDL_video.c b/src/video/SDL_video.c index 7ce375435..ac6276c50 100644 --- a/src/video/SDL_video.c +++ b/src/video/SDL_video.c @@ -27,6 +27,7 @@ #include "SDL_sysvideo.h" #include "SDL_blit.h" #include "SDL_pixels_c.h" +#include "SDL_renderer_gl.h" #include "SDL_renderer_sw.h" #include "../events/SDL_sysevents.h" #include "../events/SDL_events_c.h" @@ -279,7 +280,10 @@ SDL_VideoInit(const char *driver_name, Uint32 flags) /* 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); +#if SDL_VIDEO_OPENGL + SDL_AddRenderDriver(i, &GL_RenderDriver); +#endif + SDL_AddRenderDriver(i, &SW_RenderDriver); } } diff --git a/src/video/win32/SDL_d3drender.c b/src/video/win32/SDL_d3drender.c index 6c04c62cd..9d992c7d2 100644 --- a/src/video/win32/SDL_d3drender.c +++ b/src/video/win32/SDL_d3drender.c @@ -62,9 +62,13 @@ SDL_RenderDriver D3D_RenderDriver = { "d3d", (SDL_Renderer_SingleBuffer | SDL_Renderer_PresentCopy | SDL_Renderer_PresentFlip2 | SDL_Renderer_PresentFlip3 | - SDL_Renderer_PresentDiscard | SDL_Renderer_PresentVSync), - (SDL_TextureBlendMode_None | SDL_TextureBlendMode_Mask | SDL_TextureBlendMode_Blend), /* FIXME */ - (SDL_TextureScaleMode_None | SDL_TextureScaleMode_Fast), /* FIXME */ + SDL_Renderer_PresentDiscard | SDL_Renderer_PresentVSync | + SDL_Renderer_Accelerated), + (SDL_TextureBlendMode_None | SDL_TextureBlendMode_Mask | + SDL_TextureBlendMode_Blend | SDL_TextureBlendMode_Add | + SDL_TextureBlendMode_Mod), + (SDL_TextureScaleMode_None | SDL_TextureScaleMode_Fast | + SDL_TextureScaleMode_Best), 12, { SDL_PixelFormat_Index8, @@ -353,6 +357,8 @@ D3D_CreateRenderer(SDL_Window * window, Uint32 flags) renderer->info.flags |= SDL_Renderer_PresentVSync; } + /* FIXME: Query maximum texture size */ + /* Set up parameters for rendering */ IDirect3DDevice9_SetVertexShader(data->device, NULL); IDirect3DDevice9_SetFVF(data->device, D3DFVF_XYZRHW | D3DFVF_TEX1); diff --git a/src/video/win32/SDL_gdirender.c b/src/video/win32/SDL_gdirender.c index 81ad72ca5..aa91527f8 100644 --- a/src/video/win32/SDL_gdirender.c +++ b/src/video/win32/SDL_gdirender.c @@ -67,7 +67,7 @@ SDL_RenderDriver GDI_RenderDriver = { "gdi", (SDL_Renderer_SingleBuffer | SDL_Renderer_PresentCopy | SDL_Renderer_PresentFlip2 | SDL_Renderer_PresentFlip3 | - SDL_Renderer_PresentDiscard), + SDL_Renderer_PresentDiscard | SDL_Renderer_Accelerated), (SDL_TextureBlendMode_None | SDL_TextureBlendMode_Mask | SDL_TextureBlendMode_Blend), (SDL_TextureScaleMode_None | SDL_TextureScaleMode_Fast),