Mercurial > sdl-ios-xcode

changeset 1903:f132024010be

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
More of the Direct3D renderer is implemented, I'm not sure why it's not showing texture copies yet...
author Sam Lantinga <slouken@libsdl.org>
date Fri, 14 Jul 2006 06:40:53 +0000
parents eb2891493b66
children 1a713f9d1f71
files include/SDL_config_win32.h include/SDL_stdinc.h src/audio/SDL_audio.c src/stdlib/SDL_string.c src/video/win32/SDL_d3drender.c src/video/win32/SDL_gdirender.c test/testsprite2.c
diffstat 7 files changed, 242 insertions(+), 86 deletions(-) [+]
line wrap: on
line diff
--- a/include/SDL_config_win32.h	Thu Jul 13 08:15:35 2006 +0000
+++ b/include/SDL_config_win32.h	Fri Jul 14 06:40:53 2006 +0000
@@ -64,7 +64,7 @@
 #define SDL_HAS_64BIT_TYPE	1
 
 /* Enabled for SDL 1.2 (binary compatibility) */
-//#define HAVE_LIBC	1
+//#define HAVE_LIBC     1
 #ifdef HAVE_LIBC
 /* Useful headers */
 #define HAVE_STDIO_H 1
--- a/include/SDL_stdinc.h	Thu Jul 13 08:15:35 2006 +0000
+++ b/include/SDL_stdinc.h	Fri Jul 14 06:40:53 2006 +0000
@@ -416,7 +416,7 @@
 #ifdef HAVE_WCSLEN
 #define SDL_wcslen      wcslen
 #else
-extern DECLSPEC size_t SDLCALL SDL_wcslen(const wchar_t *string);
+extern DECLSPEC size_t SDLCALL SDL_wcslen(const wchar_t * string);
 #endif
 
 #ifdef HAVE_STRLCPY
--- a/src/audio/SDL_audio.c	Thu Jul 13 08:15:35 2006 +0000
+++ b/src/audio/SDL_audio.c	Fri Jul 14 06:40:53 2006 +0000
@@ -497,7 +497,7 @@
     if (desired->channels == 0) {
         env = SDL_getenv("SDL_AUDIO_CHANNELS");
         if (env) {
-            desired->channels = (Uint8)SDL_atoi(env);
+            desired->channels = (Uint8) SDL_atoi(env);
         }
     }
     if (desired->channels == 0) {
@@ -517,7 +517,7 @@
     if (desired->samples == 0) {
         env = SDL_getenv("SDL_AUDIO_SAMPLES");
         if (env) {
-            desired->samples = (Uint16)SDL_atoi(env);
+            desired->samples = (Uint16) SDL_atoi(env);
         }
     }
     if (desired->samples == 0) {
--- a/src/stdlib/SDL_string.c	Thu Jul 13 08:15:35 2006 +0000
+++ b/src/stdlib/SDL_string.c	Fri Jul 14 06:40:53 2006 +0000
@@ -338,7 +338,7 @@
 
 #ifndef HAVE_WCSLEN
 size_t
-SDL_wcslen(const wchar_t *string)
+SDL_wcslen(const wchar_t * string)
 {
     size_t len = 0;
     while (*string++) {
--- a/src/video/win32/SDL_d3drender.c	Thu Jul 13 08:15:35 2006 +0000
+++ b/src/video/win32/SDL_d3drender.c	Fri Jul 14 06:40:53 2006 +0000
@@ -24,7 +24,6 @@
 #if SDL_VIDEO_RENDER_D3D
 
 #include "SDL_win32video.h"
-#include "../SDL_yuv_sw_c.h"
 
 /* Direct3D renderer implementation */
 
@@ -32,9 +31,6 @@
                                             Uint32 flags);
 static int SDL_D3D_CreateTexture(SDL_Renderer * renderer,
                                  SDL_Texture * texture);
-static int SDL_D3D_QueryTexturePixels(SDL_Renderer * renderer,
-                                      SDL_Texture * texture, void **pixels,
-                                      int *pitch);
 static int SDL_D3D_SetTexturePalette(SDL_Renderer * renderer,
                                      SDL_Texture * texture,
                                      const SDL_Color * colors, int firstcolor,
@@ -85,19 +81,20 @@
      (SDL_TextureBlendMode_None |
       SDL_TextureBlendMode_Mask | SDL_TextureBlendMode_Blend),
      (SDL_TextureScaleMode_None | SDL_TextureScaleMode_Fast),
-     11,
+     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_BGR888,
       SDL_PixelFormat_ARGB8888,
-      SDL_PixelFormat_RGBA8888,
-      SDL_PixelFormat_ABGR8888,
-      SDL_PixelFormat_BGRA8888,
-      SDL_PixelFormat_YUY2,
-      SDL_PixelFormat_UYVY},
+      SDL_PixelFormat_ARGB2101010,
+      SDL_PixelFormat_UYVY,
+      SDL_PixelFormat_YUY2},
      0,
      0}
 };
@@ -110,9 +107,15 @@
 
 typedef struct
 {
-    SDL_SW_YUVTexture *yuv;
+    IDirect3DTexture9 *texture;
 } SDL_D3D_TextureData;
 
+typedef struct
+{
+    float x, y, z;
+    float tu, tv;
+} Vertex;
+
 static void
 D3D_SetError(const char *prefix, HRESULT result)
 {
@@ -192,18 +195,37 @@
     SDL_SetError("%s: %s", prefix, error);
 }
 
-static void
-UpdateYUVTextureData(SDL_Texture * texture)
+static D3DFORMAT
+PixelFormatToD3DFMT(Uint32 format)
 {
-    SDL_D3D_TextureData *data = (SDL_D3D_TextureData *) texture->driverdata;
-    SDL_Rect rect;
-
-    rect.x = 0;
-    rect.y = 0;
-    rect.w = texture->w;
-    rect.h = texture->h;
-    //SDL_SW_CopyYUVToRGB(data->yuv, &rect, data->format, texture->w,
-    //                    texture->h, data->pixels, data->pitch);
+    switch (format) {
+    case SDL_PixelFormat_Index8:
+        return D3DFMT_P8;
+    case SDL_PixelFormat_RGB332:
+        return D3DFMT_R3G3B2;
+    case SDL_PixelFormat_RGB444:
+        return D3DFMT_X4R4G4B4;
+    case SDL_PixelFormat_RGB555:
+        return D3DFMT_X1R5G5B5;
+    case SDL_PixelFormat_ARGB4444:
+        return D3DFMT_A4R4G4B4;
+    case SDL_PixelFormat_ARGB1555:
+        return D3DFMT_A1R5G5B5;
+    case SDL_PixelFormat_RGB565:
+        return D3DFMT_R5G6B5;
+    case SDL_PixelFormat_RGB888:
+        return D3DFMT_X8R8G8B8;
+    case SDL_PixelFormat_ARGB8888:
+        return D3DFMT_A8R8G8B8;
+    case SDL_PixelFormat_ARGB2101010:
+        return D3DFMT_A2R10G10B10;
+    case SDL_PixelFormat_UYVY:
+        return D3DFMT_UYVY;
+    case SDL_PixelFormat_YUY2:
+        return D3DFMT_YUY2;
+    default:
+        return D3DFMT_UNKNOWN;
+    }
 }
 
 void
@@ -243,7 +265,6 @@
     SDL_zerop(data);
 
     renderer->CreateTexture = SDL_D3D_CreateTexture;
-    renderer->QueryTexturePixels = SDL_D3D_QueryTexturePixels;
     renderer->SetTexturePalette = SDL_D3D_SetTexturePalette;
     renderer->GetTexturePalette = SDL_D3D_GetTexturePalette;
     renderer->UpdateTexture = SDL_D3D_UpdateTexture;
@@ -267,7 +288,12 @@
     SDL_zero(pparams);
     pparams.BackBufferWidth = window->w;
     pparams.BackBufferHeight = window->h;
-    pparams.BackBufferFormat = D3DFMT_UNKNOWN;  /* FIXME */
+    if (window->flags & SDL_WINDOW_FULLSCREEN) {
+        pparams.BackBufferFormat =
+            PixelFormatToD3DFMT(display->fullscreen_mode->format);
+    } else {
+        pparams.BackBufferFormat = D3DFMT_UNKNOWN;
+    }
     if (flags & SDL_Renderer_PresentFlip2) {
         pparams.BackBufferCount = 2;
         pparams.SwapEffect = D3DSWAPEFFECT_FLIP;
@@ -283,10 +309,12 @@
     }
     if (window->flags & SDL_WINDOW_FULLSCREEN) {
         pparams.Windowed = FALSE;
+        pparams.FullScreen_RefreshRateInHz =
+            display->fullscreen_mode->refresh_rate;
     } else {
         pparams.Windowed = TRUE;
+        pparams.FullScreen_RefreshRateInHz = 0;
     }
-    pparams.FullScreen_RefreshRateInHz = 0;     /* FIXME */
     pparams.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
 
     result = IDirect3D9_CreateDevice(videodata->d3d, D3DADAPTER_DEFAULT,        /* FIXME */
@@ -301,6 +329,11 @@
     }
     data->beginScene = SDL_TRUE;
 
+    /* Set up parameters for rendering */
+    IDirect3DDevice9_SetRenderState(data->device, D3DRS_CULLMODE,
+                                    D3DCULL_NONE);
+    IDirect3DDevice9_SetFVF(data->device, D3DFVF_XYZ | D3DFVF_TEX1);
+
     return renderer;
 }
 
@@ -312,6 +345,8 @@
     SDL_Window *window = SDL_GetWindowFromID(renderer->window);
     SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
     SDL_D3D_TextureData *data;
+    D3DPOOL pool;
+    HRESULT result;
 
     data = (SDL_D3D_TextureData *) SDL_malloc(sizeof(*data));
     if (!data) {
@@ -322,20 +357,23 @@
 
     texture->driverdata = data;
 
-    return 0;
-}
+    if (texture->access == SDL_TextureAccess_Local) {
+        pool = D3DPOOL_MANAGED;
+    } else {
+        pool = D3DPOOL_DEFAULT;
+    }
+    result =
+        IDirect3DDevice9_CreateTexture(renderdata->device, texture->w,
+                                       texture->h, 1, 0,
+                                       PixelFormatToD3DFMT(texture->format),
+                                       pool, &data->texture, NULL);
+    if (FAILED(result)) {
+        SDL_free(data);
+        D3D_SetError("CreateTexture()", result);
+        return -1;
+    }
 
-static int
-SDL_D3D_QueryTexturePixels(SDL_Renderer * renderer, SDL_Texture * texture,
-                           void **pixels, int *pitch)
-{
-    SDL_D3D_TextureData *data = (SDL_D3D_TextureData *) texture->driverdata;
-
-    if (data->yuv) {
-        return SDL_SW_QueryYUVTexturePixels(data->yuv, pixels, pitch);
-    } else {
-        return 0;
-    }
+    return 0;
 }
 
 static int
@@ -347,12 +385,7 @@
         (SDL_D3D_RenderData *) renderer->driverdata;
     SDL_D3D_TextureData *data = (SDL_D3D_TextureData *) texture->driverdata;
 
-    if (data->yuv) {
-        SDL_SetError("YUV textures don't have a palette");
-        return -1;
-    } else {
-        return 0;
-    }
+    return 0;
 }
 
 static int
@@ -361,12 +394,7 @@
 {
     SDL_D3D_TextureData *data = (SDL_D3D_TextureData *) texture->driverdata;
 
-    if (data->yuv) {
-        SDL_SetError("YUV textures don't have a palette");
-        return -1;
-    } else {
-        return 0;
-    }
+    return 0;
 }
 
 static int
@@ -374,19 +402,59 @@
                       const SDL_Rect * rect, const void *pixels, int pitch)
 {
     SDL_D3D_TextureData *data = (SDL_D3D_TextureData *) texture->driverdata;
+    SDL_D3D_RenderData *renderdata =
+        (SDL_D3D_RenderData *) renderer->driverdata;
+    IDirect3DTexture9 *temp;
+    RECT d3drect;
+    D3DLOCKED_RECT locked;
+    const Uint8 *src;
+    Uint8 *dst;
+    int row, length;
+    HRESULT result;
 
-    if (data->yuv) {
-        if (SDL_SW_UpdateYUVTexture(data->yuv, rect, pixels, pitch) < 0) {
-            return -1;
-        }
-        UpdateYUVTextureData(texture);
-        return 0;
-    } else {
-        SDL_D3D_RenderData *renderdata =
-            (SDL_D3D_RenderData *) renderer->driverdata;
+    result =
+        IDirect3DDevice9_CreateTexture(renderdata->device, texture->w,
+                                       texture->h, 1, 0,
+                                       PixelFormatToD3DFMT(texture->format),
+                                       D3DPOOL_SYSTEMMEM, &temp, NULL);
+    if (FAILED(result)) {
+        D3D_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);
+        D3D_SetError("LockRect()", result);
+        return -1;
+    }
 
-        return 0;
+    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)) {
+        D3D_SetError("UpdateTexture()", result);
+        return -1;
+    }
+    return 0;
 }
 
 static int
@@ -395,13 +463,30 @@
                     int *pitch)
 {
     SDL_D3D_TextureData *data = (SDL_D3D_TextureData *) texture->driverdata;
+    RECT d3drect;
+    D3DLOCKED_RECT locked;
+    HRESULT result;
 
-    if (data->yuv) {
-        return SDL_SW_LockYUVTexture(data->yuv, rect, markDirty, pixels,
-                                     pitch);
-    } else {
+    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 : D3DLOCK_NO_DIRTY_UPDATE);
+    if (FAILED(result)) {
+        D3D_SetError("LockRect()", result);
+        return -1;
+    }
+    *pixels = locked.pBits;
+    *pitch = locked.Pitch;
+    return 0;
 }
 
 static void
@@ -409,16 +494,27 @@
 {
     SDL_D3D_TextureData *data = (SDL_D3D_TextureData *) texture->driverdata;
 
-    if (data->yuv) {
-        SDL_SW_UnlockYUVTexture(data->yuv);
-        UpdateYUVTextureData(texture);
-    }
+    IDirect3DTexture9_UnlockRect(data->texture, 0);
 }
 
 static void
 SDL_D3D_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture,
                      int numrects, const SDL_Rect * rects)
 {
+    SDL_D3D_TextureData *data = (SDL_D3D_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 void
@@ -441,11 +537,13 @@
     }
 
     d3drect.x1 = rect->x;
-    d3drect.x2 = rect->x+rect->w;
+    d3drect.x2 = rect->x + rect->w;
     d3drect.y1 = rect->y;
-    d3drect.y2 = rect->y+rect->h;
+    d3drect.y2 = rect->y + rect->h;
 
-    result = IDirect3DDevice9_Clear(data->device, 1, &d3drect, D3DCLEAR_TARGET, (D3DCOLOR) color, 1.0f, 0);
+    result =
+        IDirect3DDevice9_Clear(data->device, 1, &d3drect, D3DCLEAR_TARGET,
+                               (D3DCOLOR) color, 1.0f, 0);
     if (FAILED(result)) {
         D3D_SetError("Clear()", result);
         return -1;
@@ -461,11 +559,62 @@
     SDL_D3D_RenderData *data = (SDL_D3D_RenderData *) renderer->driverdata;
     SDL_D3D_TextureData *texturedata =
         (SDL_D3D_TextureData *) texture->driverdata;
+    float minx, miny, maxx, maxy;
+    float mintu, maxtu, mintv, maxtv;
+    Vertex vertices[4];
+    HRESULT result;
 
     if (data->beginScene) {
         IDirect3DDevice9_BeginScene(data->device);
         data->beginScene = SDL_FALSE;
     }
+
+    minx = (float) dstrect->x;
+    miny = (float) dstrect->y;
+    maxx = (float) dstrect->x + dstrect->w;
+    maxy = (float) dstrect->y + dstrect->h;
+
+    mintu = (float) srcrect->x / texture->w;
+    maxtu = (float) (srcrect->x + srcrect->w) / texture->w;
+    mintv = (float) srcrect->y / texture->h;
+    maxtv = (float) (srcrect->y + srcrect->h) / texture->h;
+
+    vertices[0].x = minx;
+    vertices[0].y = miny;
+    vertices[0].z = 0.0f;
+    vertices[0].tu = mintu;
+    vertices[0].tv = mintv;
+    vertices[1].x = maxx;
+    vertices[1].y = miny;
+    vertices[1].z = 0.0f;
+    vertices[1].tu = maxtu;
+    vertices[1].tv = mintv;
+    vertices[2].x = maxx;
+    vertices[2].y = maxy;
+    vertices[2].z = 0.0f;
+    vertices[2].tu = maxtu;
+    vertices[2].tv = maxtv;
+    vertices[3].x = minx;
+    vertices[3].y = maxy;
+    vertices[3].z = 0.0f;
+    vertices[3].tu = mintu;
+    vertices[3].tv = maxtv;
+
+    result =
+        IDirect3DDevice9_SetTexture(data->device, 0,
+                                    (IDirect3DBaseTexture9 *) texturedata->
+                                    texture);
+    if (FAILED(result)) {
+        D3D_SetError("SetTexture()", result);
+        return -1;
+    }
+    result =
+        IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_TRIANGLEFAN, 2,
+                                         vertices, sizeof(*vertices));
+    if (FAILED(result)) {
+        D3D_SetError("DrawPrimitiveUP()", result);
+        return -1;
+    }
     return 0;
 }
 
@@ -512,6 +661,9 @@
     if (!data) {
         return;
     }
+    if (data->texture) {
+        IDirect3DTexture9_Release(data->texture);
+    }
     SDL_free(data);
     texture->driverdata = NULL;
 }
--- a/src/video/win32/SDL_gdirender.c	Thu Jul 13 08:15:35 2006 +0000
+++ b/src/video/win32/SDL_gdirender.c	Fri Jul 14 06:40:53 2006 +0000
@@ -80,9 +80,9 @@
     {
      "gdi",
      (SDL_Renderer_Minimal |
-         SDL_Renderer_SingleBuffer | SDL_Renderer_PresentCopy |
-         SDL_Renderer_PresentFlip2 | SDL_Renderer_PresentFlip3 |
-         SDL_Renderer_PresentDiscard | SDL_Renderer_RenderTarget),
+      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),
--- a/test/testsprite2.c	Thu Jul 13 08:15:35 2006 +0000
+++ b/test/testsprite2.c	Fri Jul 14 06:40:53 2006 +0000
@@ -5,7 +5,7 @@
 
 #include "SDL.h"
 
-#define NUM_WINDOWS 4
+#define NUM_WINDOWS 1
 #define WINDOW_W    640
 #define WINDOW_H    480
 #define NUM_SPRITES	100
@@ -91,10 +91,13 @@
 
     /* Move the sprite, bounce at the wall, and draw */
     n = 0;
-    for (i = 0; i < num_sprites; ++i) {
-        position = &positions[i];
-        SDL_RenderFill(position, BACKGROUND);
-    }
+    SDL_RenderFill(NULL, BACKGROUND);
+    /*
+       for (i = 0; i < num_sprites; ++i) {
+       position = &positions[i];
+       SDL_RenderFill(position, BACKGROUND);
+       }
+     */
     for (i = 0; i < num_sprites; ++i) {
         position = &positions[i];
         velocity = &velocities[i];
@@ -237,7 +240,8 @@
                 }
                 break;
             case SDL_KEYDOWN:
-                /* Any keypress quits the app... */
+                ///* Any keypress quits the app... */
+                break;
             case SDL_QUIT:
                 done = 1;
                 break;