Mercurial > sdl-ios-xcode
annotate src/video/win32/SDL_ceddrawrender.c @ 5004:0c72ae7b7cb2
Added native atomic operations for Windows, Mac OS X, and gcc compiler intrinsics.
Changed the CAS return value to bool, so it's efficient with OSAtomicCompareAndSwap32Barrier()
Added an atomic test adapted from code by Michael Davidsaver
| author | Sam Lantinga <slouken@libsdl.org> |
|---|---|
| date | Sun, 16 Jan 2011 15:16:39 -0800 |
| parents | aa8888658021 |
| children |
| rev | line source |
|---|---|
| 3168 | 1 /* |
| 2 SDL - Simple DirectMedia Layer | |
| 3697 | 3 Copyright (C) 1997-2010 Sam Lantinga |
| 3168 | 4 |
| 5 This library is free software; you can redistribute it and/or | |
| 6 modify it under the terms of the GNU Lesser General Public | |
| 7 License as published by the Free Software Foundation; either | |
| 8 version 2.1 of the License, or (at your option) any later version. | |
| 9 | |
| 10 This library is distributed in the hope that it will be useful, | |
| 11 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 13 Lesser General Public License for more details. | |
| 14 | |
| 15 You should have received a copy of the GNU Lesser General Public | |
| 16 License along with this library; if not, write to the Free Software | |
| 17 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | |
| 18 | |
| 19 Sam Lantinga | |
| 20 slouken@libsdl.org | |
| 21 | |
| 22 Stefan Klug | |
| 23 klug.stefan@gmx.de | |
| 24 */ | |
| 25 #include "SDL_config.h" | |
| 26 | |
| 27 #if SDL_VIDEO_RENDER_DDRAW | |
| 28 | |
| 29 #include "SDL_win32video.h" | |
| 30 #include "../SDL_yuv_sw_c.h" | |
| 31 | |
| 32 #if 0 | |
| 33 #define DDRAW_LOG(...) printf(__VA_ARGS__) | |
| 34 #else | |
| 35 #define DDRAW_LOG(...) | |
| 36 #endif | |
| 37 | |
| 38 | |
| 39 /* DirectDraw renderer implementation */ | |
| 40 | |
| 41 static SDL_Renderer *DDRAW_CreateRenderer(SDL_Window * window, Uint32 flags); | |
| 42 static int DDRAW_DisplayModeChanged(SDL_Renderer * renderer); | |
| 43 static int DDRAW_CreateTexture(SDL_Renderer * renderer, | |
| 44 SDL_Texture * texture); | |
| 45 static int DDRAW_QueryTexturePixels(SDL_Renderer * renderer, | |
| 46 SDL_Texture * texture, void **pixels, | |
| 47 int *pitch); | |
| 48 static int DDRAW_SetTextureColorMod(SDL_Renderer * renderer, | |
| 49 SDL_Texture * texture); | |
| 50 static int DDRAW_SetTextureAlphaMod(SDL_Renderer * renderer, | |
| 51 SDL_Texture * texture); | |
| 52 static int DDRAW_SetTextureBlendMode(SDL_Renderer * renderer, | |
| 53 SDL_Texture * texture); | |
| 54 static int DDRAW_SetTextureScaleMode(SDL_Renderer * renderer, | |
| 55 SDL_Texture * texture); | |
| 56 static int DDRAW_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture, | |
| 57 const SDL_Rect * rect, const void *pixels, | |
| 58 int pitch); | |
| 59 static int DDRAW_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture, | |
| 60 const SDL_Rect * rect, int markDirty, | |
| 61 void **pixels, int *pitch); | |
| 62 static void DDRAW_UnlockTexture(SDL_Renderer * renderer, | |
| 63 SDL_Texture * texture); | |
| 64 static void DDRAW_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture, | |
| 65 int numrects, const SDL_Rect * rects); | |
| 66 static int DDRAW_RenderPoint(SDL_Renderer * renderer, int x, int y); | |
| 67 static int DDRAW_RenderLine(SDL_Renderer * renderer, int x1, int y1, int x2, | |
| 68 int y2); | |
| 69 static int DDRAW_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect); | |
| 70 static int DDRAW_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture, | |
| 71 const SDL_Rect * srcrect, | |
| 72 const SDL_Rect * dstrect); | |
| 73 static void DDRAW_RenderPresent(SDL_Renderer * renderer); | |
| 74 static void DDRAW_DestroyTexture(SDL_Renderer * renderer, | |
| 75 SDL_Texture * texture); | |
| 76 static void DDRAW_DestroyRenderer(SDL_Renderer * renderer); | |
| 77 | |
| 78 | |
| 79 SDL_RenderDriver DDRAW_RenderDriver = { | |
| 80 DDRAW_CreateRenderer, | |
| 81 { | |
| 82 "ddraw", | |
| 83 (SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY | | |
| 84 SDL_RENDERER_PRESENTFLIP2 | SDL_RENDERER_PRESENTFLIP3 | | |
| 85 SDL_RENDERER_PRESENTDISCARD | SDL_RENDERER_ACCELERATED), | |
| 86 (SDL_TEXTUREMODULATE_NONE), | |
| 87 (SDL_BLENDMODE_NONE), | |
|
4929
aa8888658021
Use the enumerated type for blend and scale mode instead of int
Sam Lantinga <slouken@libsdl.org>
parents:
4569
diff
changeset
|
88 (SDL_SCALEMODE_NONE), |
| 3168 | 89 0, |
| 90 {0}, | |
| 91 0, | |
| 92 0} | |
| 93 }; | |
| 94 | |
| 95 typedef struct | |
| 96 { | |
| 97 IDirectDraw *ddraw; | |
| 98 IDirectDrawSurface *primary; | |
| 99 } DDRAW_RenderData; | |
| 100 | |
| 101 typedef struct | |
| 102 { | |
| 103 RECT lock; | |
| 104 IDirectDrawSurface *surface; | |
| 105 } DDRAW_TextureData; | |
| 106 | |
| 107 | |
| 108 static void | |
| 109 DDRAW_SetError(const char *prefix, HRESULT result) | |
| 110 { | |
| 111 const char *error; | |
| 112 | |
| 113 switch (result) { | |
| 114 case DDERR_CANTCREATEDC: | |
| 115 error = "CANTCREATEDC"; | |
| 116 break; | |
| 117 case DDERR_CANTLOCKSURFACE: | |
| 118 error = "CANTLOCKSURFACE"; | |
| 119 break; | |
| 120 case DDERR_CLIPPERISUSINGHWND: | |
| 121 error = "CLIPPERISUSINGHWND"; | |
| 122 break; | |
| 123 case DDERR_COLORKEYNOTSET: | |
| 124 error = "COLORKEYNOTSET"; | |
| 125 break; | |
| 126 case DDERR_CURRENTLYNOTAVAIL: | |
| 127 error = "CURRENTLYNOTAVAIL"; | |
| 128 break; | |
| 129 case DDERR_DCALREADYCREATED: | |
| 130 error = "DCALREADYCREATED"; | |
| 131 break; | |
| 132 case DDERR_DEVICEDOESNTOWNSURFACE: | |
| 133 error = "DEVICEDOESNTOWNSURFACE"; | |
| 134 break; | |
| 135 case DDERR_DIRECTDRAWALREADYCREATED: | |
| 136 error = "DIRECTDRAWALREADYCREATED"; | |
| 137 break; | |
| 138 case DDERR_EXCLUSIVEMODEALREADYSET: | |
| 139 error = "EXCLUSIVEMODEALREADYSET"; | |
| 140 break; | |
| 141 case DDERR_GENERIC: | |
| 142 error = "GENERIC"; | |
| 143 break; | |
| 144 case DDERR_HEIGHTALIGN: | |
| 145 error = "HEIGHTALIGN"; | |
| 146 break; | |
| 147 case DDERR_IMPLICITLYCREATED: | |
| 148 error = "IMPLICITLYCREATED"; | |
| 149 break; | |
| 150 case DDERR_INCOMPATIBLEPRIMARY: | |
| 151 error = "INCOMPATIBLEPRIMARY"; | |
| 152 break; | |
| 153 case DDERR_INVALIDCAPS: | |
| 154 error = "INVALIDCAPS"; | |
| 155 break; | |
| 156 case DDERR_INVALIDCLIPLIST: | |
| 157 error = "INVALIDCLIPLIST"; | |
| 158 break; | |
| 159 case DDERR_INVALIDMODE: | |
| 160 error = "INVALIDMODE"; | |
| 161 break; | |
| 162 case DDERR_INVALIDOBJECT: | |
| 163 error = "INVALIDOBJECT"; | |
| 164 break; | |
| 165 case DDERR_INVALIDPARAMS: | |
| 166 error = "INVALIDPARAMS"; | |
| 167 break; | |
| 168 case DDERR_INVALIDPIXELFORMAT: | |
| 169 error = "INVALIDPIXELFORMAT"; | |
| 170 break; | |
| 171 case DDERR_INVALIDPOSITION: | |
| 172 error = "INVALIDPOSITION"; | |
| 173 break; | |
| 174 case DDERR_INVALIDRECT: | |
| 175 error = "INVALIDRECT"; | |
| 176 break; | |
| 177 case DDERR_LOCKEDSURFACES: | |
| 178 error = "LOCKEDSURFACES"; | |
| 179 break; | |
| 180 case DDERR_MOREDATA: | |
| 181 error = "MOREDATA"; | |
| 182 break; | |
| 183 case DDERR_NOALPHAHW: | |
| 184 error = "NOALPHAHW"; | |
| 185 break; | |
| 186 case DDERR_NOBLTHW: | |
| 187 error = "NOBLTHW"; | |
| 188 break; | |
| 189 case DDERR_NOCLIPLIST: | |
| 190 error = "NOCLIPLIST"; | |
| 191 break; | |
| 192 case DDERR_NOCLIPPERATTACHED: | |
| 193 error = "NOCLIPPERATTACHED"; | |
| 194 break; | |
| 195 case DDERR_NOCOLORCONVHW: | |
| 196 error = "NOCOLORCONVHW"; | |
| 197 break; | |
| 198 case DDERR_NOCOLORKEYHW: | |
| 199 error = "NOCOLORKEYHW"; | |
| 200 break; | |
| 201 case DDERR_NOCOOPERATIVELEVELSET: | |
| 202 error = "NOCOOPERATIVELEVELSET"; | |
| 203 break; | |
| 204 case DDERR_NODC: | |
| 205 error = "NODC"; | |
| 206 break; | |
| 207 case DDERR_NOFLIPHW: | |
| 208 error = "NOFLIPHW"; | |
| 209 break; | |
| 210 case DDERR_NOOVERLAYDEST: | |
| 211 error = "NOOVERLAYDEST"; | |
| 212 break; | |
| 213 case DDERR_NOOVERLAYHW: | |
| 214 error = "NOOVERLAYHW"; | |
| 215 break; | |
| 216 case DDERR_NOPALETTEATTACHED: | |
| 217 error = "NOPALETTEATTACHED"; | |
| 218 break; | |
| 219 case DDERR_NOPALETTEHW: | |
| 220 error = "NOPALETTEHW"; | |
| 221 break; | |
| 222 case DDERR_NORASTEROPHW: | |
| 223 error = "NORASTEROPHW"; | |
| 224 break; | |
| 225 case DDERR_NOSTRETCHHW: | |
| 226 error = "NOSTRETCHHW"; | |
| 227 break; | |
| 228 case DDERR_NOTAOVERLAYSURFACE: | |
| 229 error = "NOTAOVERLAYSURFACE"; | |
| 230 break; | |
| 231 case DDERR_NOTFLIPPABLE: | |
| 232 error = "NOTFLIPPABLE"; | |
| 233 break; | |
| 234 case DDERR_NOTFOUND: | |
| 235 error = "NOTFOUND"; | |
| 236 break; | |
| 237 case DDERR_NOTLOCKED: | |
| 238 error = "NOTLOCKED"; | |
| 239 break; | |
| 240 case DDERR_NOTPALETTIZED: | |
| 241 error = "NOTPALETTIZED"; | |
| 242 break; | |
| 243 case DDERR_NOVSYNCHW: | |
| 244 error = "NOVSYNCHW"; | |
| 245 break; | |
| 246 case DDERR_NOZOVERLAYHW: | |
| 247 error = "NOZOVERLAYHW"; | |
| 248 break; | |
| 249 case DDERR_OUTOFCAPS: | |
| 250 error = "OUTOFCAPS"; | |
| 251 break; | |
| 252 case DDERR_OUTOFMEMORY: | |
| 253 error = "OUTOFMEMORY"; | |
| 254 break; | |
| 255 case DDERR_OUTOFVIDEOMEMORY: | |
| 256 error = "OUTOFVIDEOMEMORY"; | |
| 257 break; | |
| 258 case DDERR_OVERLAPPINGRECTS: | |
| 259 error = "OVERLAPPINGRECTS"; | |
| 260 break; | |
| 261 case DDERR_OVERLAYNOTVISIBLE: | |
| 262 error = "OVERLAYNOTVISIBLE"; | |
| 263 break; | |
| 264 case DDERR_PALETTEBUSY: | |
| 265 error = "PALETTEBUSY"; | |
| 266 break; | |
| 267 case DDERR_PRIMARYSURFACEALREADYEXISTS: | |
| 268 error = "PRIMARYSURFACEALREADYEXISTS"; | |
| 269 break; | |
| 270 case DDERR_REGIONTOOSMALL: | |
| 271 error = "REGIONTOOSMALL"; | |
| 272 break; | |
| 273 case DDERR_SURFACEBUSY: | |
| 274 error = "SURFACEBUSY"; | |
| 275 break; | |
| 276 case DDERR_SURFACELOST: | |
| 277 error = "SURFACELOST"; | |
| 278 break; | |
| 279 case DDERR_TOOBIGHEIGHT: | |
| 280 error = "TOOBIGHEIGHT"; | |
| 281 break; | |
| 282 case DDERR_TOOBIGSIZE: | |
| 283 error = "TOOBIGSIZE"; | |
| 284 break; | |
| 285 case DDERR_TOOBIGWIDTH: | |
| 286 error = "TOOBIGWIDTH"; | |
| 287 break; | |
| 288 case DDERR_UNSUPPORTED: | |
| 289 error = "UNSUPPORTED"; | |
| 290 break; | |
| 291 case DDERR_UNSUPPORTEDFORMAT: | |
| 292 error = "UNSUPPORTEDFORMAT"; | |
| 293 break; | |
| 294 case DDERR_VERTICALBLANKINPROGRESS: | |
| 295 error = "VERTICALBLANKINPROGRESS"; | |
| 296 break; | |
| 297 case DDERR_VIDEONOTACTIVE: | |
| 298 error = "VIDEONOTACTIVE"; | |
| 299 break; | |
| 300 case DDERR_WASSTILLDRAWING: | |
| 301 error = "WASSTILLDRAWING"; | |
| 302 break; | |
| 303 case DDERR_WRONGMODE: | |
| 304 error = "WRONGMODE"; | |
| 305 break; | |
| 306 default: | |
| 307 error = "UNKNOWN"; | |
| 308 break; | |
| 309 } | |
| 310 SDL_SetError("%s: %s", prefix, error); | |
| 311 } | |
| 312 | |
| 313 static SDL_bool | |
| 314 PixelFormatToDDPIXELFORMAT(Uint32 format, LPDDPIXELFORMAT dst) | |
| 315 { | |
| 316 SDL_zerop(dst); | |
| 317 dst->dwSize = sizeof(*dst); | |
| 318 | |
| 319 if (SDL_ISPIXELFORMAT_FOURCC(format)) { | |
| 320 dst->dwFlags = DDPF_FOURCC; | |
| 321 dst->dwFourCC = format; | |
| 322 } else if (SDL_ISPIXELFORMAT_INDEXED(format)) { | |
| 323 SDL_SetError("Indexed pixelformats are not supported."); | |
| 324 return SDL_FALSE; | |
| 325 } else { | |
| 326 int bpp; | |
| 327 Uint32 Rmask, Gmask, Bmask, Amask; | |
| 328 if (!SDL_PixelFormatEnumToMasks | |
| 329 (format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) { | |
| 330 SDL_SetError("pixelformat not supported"); | |
| 331 return SDL_FALSE; | |
| 332 } | |
| 333 | |
| 334 if (!Rmask && !Gmask && !Bmask) { | |
| 335 dst->dwFlags = DDPF_ALPHA; | |
| 336 dst->dwAlphaBitDepth = bpp; | |
| 337 } else { | |
| 338 dst->dwFlags = DDPF_RGB; | |
| 339 dst->dwRGBBitCount = bpp; | |
| 340 dst->dwRBitMask = Rmask; | |
| 341 dst->dwGBitMask = Gmask; | |
| 342 dst->dwBBitMask = Bmask; | |
| 343 | |
| 344 if (Amask) { | |
| 345 dst->dwFlags |= DDPF_ALPHAPIXELS; | |
| 346 dst->dwRGBAlphaBitMask = Amask; | |
| 347 } | |
| 348 } | |
| 349 } | |
| 350 | |
| 351 return SDL_TRUE; | |
| 352 } | |
| 353 | |
| 354 static SDL_bool | |
| 355 DDRAW_IsTextureFormatAvailable(IDirectDraw * ddraw, Uint32 display_format, | |
| 356 Uint32 texture_format) | |
| 357 { | |
| 358 int bpp; | |
| 359 Uint32 Rmask, Gmask, Bmask, Amask; | |
| 360 | |
| 361 if (SDL_ISPIXELFORMAT_FOURCC(texture_format)) { | |
| 362 //TODO I don't expect DDRAW to support all 4CC formats, but I don't know which ones | |
| 363 return SDL_TRUE; | |
| 364 } | |
| 365 //These are only basic checks | |
| 366 if (SDL_ISPIXELFORMAT_INDEXED(texture_format)) { | |
| 367 return SDL_FALSE; | |
| 368 } | |
| 369 | |
| 370 if (!SDL_PixelFormatEnumToMasks | |
| 371 (texture_format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) { | |
| 372 return SDL_FALSE; | |
| 373 } | |
| 374 | |
| 375 switch (bpp) { | |
| 376 case 4: | |
| 377 case 8: | |
| 378 case 16: | |
| 379 case 24: | |
| 380 case 32: | |
| 381 break; | |
| 382 default: | |
| 383 return SDL_FALSE; | |
| 384 } | |
| 385 | |
| 386 return SDL_TRUE; | |
| 387 } | |
| 388 | |
| 389 void | |
| 390 DDRAW_AddRenderDriver(_THIS) | |
| 391 { | |
| 392 SDL_VideoData *data = (SDL_VideoData *) _this->driverdata; | |
| 393 SDL_RendererInfo *info = &DDRAW_RenderDriver.info; | |
|
3685
64ce267332c6
Switched from SDL_WindowID and SDL_TextureID to SDL_Window* and SDL_Texture* for code simplicity and improved performance.
Sam Lantinga <slouken@libsdl.org>
parents:
3520
diff
changeset
|
394 SDL_DisplayMode *mode = &SDL_CurrentDisplay->desktop_mode; |
| 3168 | 395 |
| 396 if (data->ddraw) { | |
| 397 int i; | |
| 398 int formats[] = { | |
| 399 SDL_PIXELFORMAT_INDEX8, | |
| 400 SDL_PIXELFORMAT_RGB332, | |
| 401 SDL_PIXELFORMAT_RGB444, | |
| 402 SDL_PIXELFORMAT_RGB555, | |
| 403 SDL_PIXELFORMAT_ARGB4444, | |
| 404 SDL_PIXELFORMAT_ARGB1555, | |
| 405 SDL_PIXELFORMAT_RGB565, | |
| 406 SDL_PIXELFORMAT_RGB888, | |
| 407 SDL_PIXELFORMAT_ARGB8888, | |
| 408 SDL_PIXELFORMAT_ARGB2101010, | |
| 409 }; | |
| 410 | |
| 411 for (i = 0; i < SDL_arraysize(formats); ++i) { | |
| 412 if (DDRAW_IsTextureFormatAvailable | |
| 413 (data->ddraw, mode->format, formats[i])) { | |
| 414 info->texture_formats[info->num_texture_formats++] = | |
| 415 formats[i]; | |
| 416 } | |
| 417 } | |
| 418 | |
| 419 //TODO the fourcc formats should get fetched from IDirectDraw::GetFourCCCodes | |
| 420 info->texture_formats[info->num_texture_formats++] = | |
| 421 SDL_PIXELFORMAT_YV12; | |
| 422 info->texture_formats[info->num_texture_formats++] = | |
| 423 SDL_PIXELFORMAT_IYUV; | |
| 424 info->texture_formats[info->num_texture_formats++] = | |
| 425 SDL_PIXELFORMAT_YUY2; | |
| 426 info->texture_formats[info->num_texture_formats++] = | |
| 427 SDL_PIXELFORMAT_UYVY; | |
| 428 info->texture_formats[info->num_texture_formats++] = | |
| 429 SDL_PIXELFORMAT_YVYU; | |
| 430 | |
|
3520
83518f8fcd61
Fixed calls to SDL_AddRenderDriver()
Sam Lantinga <slouken@libsdl.org>
parents:
3168
diff
changeset
|
431 for (i = 0; i < _this->num_displays; ++i) |
|
83518f8fcd61
Fixed calls to SDL_AddRenderDriver()
Sam Lantinga <slouken@libsdl.org>
parents:
3168
diff
changeset
|
432 SDL_AddRenderDriver(&_this->displays[i], &DDRAW_RenderDriver); |
|
83518f8fcd61
Fixed calls to SDL_AddRenderDriver()
Sam Lantinga <slouken@libsdl.org>
parents:
3168
diff
changeset
|
433 } |
| 3168 | 434 } |
| 435 } | |
| 436 | |
| 437 SDL_Renderer * | |
| 438 DDRAW_CreateRenderer(SDL_Window * window, Uint32 flags) | |
| 439 { | |
|
3685
64ce267332c6
Switched from SDL_WindowID and SDL_TextureID to SDL_Window* and SDL_Texture* for code simplicity and improved performance.
Sam Lantinga <slouken@libsdl.org>
parents:
3520
diff
changeset
|
440 SDL_VideoDisplay *display = window->display; |
| 3168 | 441 SDL_VideoData *videodata = (SDL_VideoData *) display->device->driverdata; |
| 442 SDL_WindowData *windowdata = (SDL_WindowData *) window->driverdata; | |
| 443 SDL_Renderer *renderer; | |
| 444 DDRAW_RenderData *data; | |
| 445 HRESULT result; | |
| 446 DDSURFACEDESC ddsd; | |
| 447 | |
| 448 renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer)); | |
| 449 if (!renderer) { | |
| 450 SDL_OutOfMemory(); | |
| 451 return NULL; | |
| 452 } | |
| 453 | |
| 454 data = (DDRAW_RenderData *) SDL_calloc(1, sizeof(*data)); | |
| 455 if (!data) { | |
| 456 DDRAW_DestroyRenderer(renderer); | |
| 457 SDL_OutOfMemory(); | |
| 458 return NULL; | |
| 459 } | |
| 460 data->ddraw = videodata->ddraw; | |
| 461 | |
| 4569 | 462 videodata->render = RENDER_DDRAW; |
| 463 | |
| 3168 | 464 renderer->DisplayModeChanged = DDRAW_DisplayModeChanged; |
| 465 renderer->CreateTexture = DDRAW_CreateTexture; | |
| 466 renderer->QueryTexturePixels = DDRAW_QueryTexturePixels; | |
| 467 | |
| 468 renderer->SetTextureColorMod = DDRAW_SetTextureColorMod; | |
| 469 renderer->SetTextureAlphaMod = DDRAW_SetTextureAlphaMod; | |
| 470 renderer->SetTextureBlendMode = DDRAW_SetTextureBlendMode; | |
| 471 renderer->SetTextureScaleMode = DDRAW_SetTextureScaleMode; | |
| 472 renderer->UpdateTexture = DDRAW_UpdateTexture; | |
| 473 renderer->LockTexture = DDRAW_LockTexture; | |
| 474 renderer->UnlockTexture = DDRAW_UnlockTexture; | |
| 475 renderer->DirtyTexture = DDRAW_DirtyTexture; | |
| 476 renderer->RenderPoint = DDRAW_RenderPoint; | |
| 477 renderer->RenderLine = DDRAW_RenderLine; | |
| 478 renderer->RenderFill = DDRAW_RenderFill; | |
| 479 renderer->RenderCopy = DDRAW_RenderCopy; | |
| 480 renderer->RenderPresent = DDRAW_RenderPresent; | |
| 481 renderer->DestroyTexture = DDRAW_DestroyTexture; | |
| 482 renderer->DestroyRenderer = DDRAW_DestroyRenderer; | |
| 483 renderer->info = DDRAW_RenderDriver.info; | |
|
3685
64ce267332c6
Switched from SDL_WindowID and SDL_TextureID to SDL_Window* and SDL_Texture* for code simplicity and improved performance.
Sam Lantinga <slouken@libsdl.org>
parents:
3520
diff
changeset
|
484 renderer->window = window; |
| 3168 | 485 renderer->driverdata = data; |
| 486 | |
| 487 renderer->info.flags = SDL_RENDERER_ACCELERATED; | |
| 488 | |
| 489 SDL_zero(ddsd); | |
| 490 ddsd.dwSize = sizeof(ddsd); | |
| 491 ddsd.dwFlags = DDSD_CAPS; | |
| 492 | |
| 493 if (window->flags & SDL_WINDOW_FULLSCREEN) { | |
| 494 ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; | |
| 495 } else { | |
| 496 //TODO handle non fullscreen | |
| 497 SDL_SetError("DirectDraw renderer has only fullscreen implemented"); | |
| 498 DDRAW_DestroyRenderer(renderer); | |
| 499 return NULL; | |
| 500 } | |
| 501 | |
| 502 if (flags & SDL_RENDERER_PRESENTFLIP2) { | |
| 503 ddsd.dwFlags |= DDSD_BACKBUFFERCOUNT; | |
| 504 ddsd.dwBackBufferCount = 2; | |
| 505 } else if (flags & SDL_RENDERER_PRESENTFLIP3) { | |
| 506 ddsd.dwFlags |= DDSD_BACKBUFFERCOUNT; | |
| 507 ddsd.dwBackBufferCount = 3; | |
| 508 } else if (flags & SDL_RENDERER_PRESENTCOPY) { | |
| 509 //TODO what is the best approximation to this mode | |
| 510 } else { | |
| 511 | |
| 512 } | |
| 513 | |
| 514 if (flags & SDL_RENDERER_PRESENTVSYNC) { | |
| 515 SDL_SetError("DirectDraw renderer with v-sync is not implemented"); | |
| 516 DDRAW_DestroyRenderer(renderer); | |
| 517 return NULL; | |
| 518 } | |
| 519 | |
| 520 result = | |
| 521 data->ddraw->lpVtbl->SetCooperativeLevel(data->ddraw, | |
| 522 windowdata->hwnd, | |
| 523 DDSCL_NORMAL); | |
| 524 if (result != DD_OK) { | |
| 525 DDRAW_SetError("CreateDevice()", result); | |
| 526 DDRAW_DestroyRenderer(renderer); | |
| 527 return NULL; | |
| 528 } | |
| 529 | |
| 530 result = | |
| 531 data->ddraw->lpVtbl->CreateSurface(data->ddraw, &ddsd, &data->primary, | |
| 532 NULL); | |
| 533 if (result != DD_OK) { | |
| 534 DDRAW_SetError("CreateDevice()", result); | |
| 535 DDRAW_DestroyRenderer(renderer); | |
| 536 return NULL; | |
| 537 } | |
| 538 | |
| 539 return renderer; | |
| 540 } | |
| 541 | |
| 542 static int | |
| 543 DDRAW_Reset(SDL_Renderer * renderer) | |
| 544 { | |
| 545 //TODO implement | |
| 546 /*D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata; | |
| 547 HRESULT result; | |
| 548 | |
| 549 result = IDirect3DDevice9_Reset(data->device, &data->pparams); | |
| 550 if (FAILED(result)) { | |
| 551 if (result == D3DERR_DEVICELOST) { | |
| 552 /* Don't worry about it, we'll reset later... * | |
| 553 return 0; | |
| 554 } else { | |
| 555 D3D_SetError("Reset()", result); | |
| 556 return -1; | |
| 557 } | |
| 558 } | |
| 559 IDirect3DDevice9_SetVertexShader(data->device, NULL); | |
| 560 IDirect3DDevice9_SetFVF(data->device, | |
| 561 D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1); | |
| 562 IDirect3DDevice9_SetRenderState(data->device, D3DRS_CULLMODE, | |
| 563 D3DCULL_NONE); | |
| 564 IDirect3DDevice9_SetRenderState(data->device, D3DRS_LIGHTING, FALSE); */ | |
| 565 return 0; | |
| 566 } | |
| 567 | |
| 568 static int | |
| 569 DDRAW_DisplayModeChanged(SDL_Renderer * renderer) | |
| 570 { | |
| 571 //TODO implement | |
| 572 /*D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata; | |
|
3685
64ce267332c6
Switched from SDL_WindowID and SDL_TextureID to SDL_Window* and SDL_Texture* for code simplicity and improved performance.
Sam Lantinga <slouken@libsdl.org>
parents:
3520
diff
changeset
|
573 SDL_Window *window = renderer->window; |
|
64ce267332c6
Switched from SDL_WindowID and SDL_TextureID to SDL_Window* and SDL_Texture* for code simplicity and improved performance.
Sam Lantinga <slouken@libsdl.org>
parents:
3520
diff
changeset
|
574 SDL_VideoDisplay *display = window->display; |
| 3168 | 575 |
| 576 data->pparams.BackBufferWidth = window->w; | |
| 577 data->pparams.BackBufferHeight = window->h; | |
| 578 if (window->flags & SDL_WINDOW_FULLSCREEN) { | |
| 579 data->pparams.BackBufferFormat = | |
| 580 PixelFormatToD3DFMT(display->fullscreen_mode.format); | |
| 581 } else { | |
| 582 data->pparams.BackBufferFormat = D3DFMT_UNKNOWN; | |
| 583 } | |
| 584 return D3D_Reset(renderer); */ | |
| 585 return 0; | |
| 586 } | |
| 587 | |
| 588 static int | |
| 589 DDRAW_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture) | |
| 590 { | |
| 591 DDRAW_RenderData *renderdata = (DDRAW_RenderData *) renderer->driverdata; | |
|
3685
64ce267332c6
Switched from SDL_WindowID and SDL_TextureID to SDL_Window* and SDL_Texture* for code simplicity and improved performance.
Sam Lantinga <slouken@libsdl.org>
parents:
3520
diff
changeset
|
592 SDL_Window *window = renderer->window; |
|
64ce267332c6
Switched from SDL_WindowID and SDL_TextureID to SDL_Window* and SDL_Texture* for code simplicity and improved performance.
Sam Lantinga <slouken@libsdl.org>
parents:
3520
diff
changeset
|
593 SDL_VideoDisplay *display = window->display; |
| 3168 | 594 Uint32 display_format = display->current_mode.format; |
| 595 DDRAW_TextureData *data; | |
| 596 DDSURFACEDESC ddsd; | |
| 597 HRESULT result; | |
| 598 | |
| 599 data = (DDRAW_TextureData *) SDL_calloc(1, sizeof(*data)); | |
| 600 if (!data) { | |
| 601 SDL_OutOfMemory(); | |
| 602 return -1; | |
| 603 } | |
| 604 | |
| 605 SDL_zero(ddsd); | |
| 606 ddsd.dwSize = sizeof(ddsd); | |
| 607 ddsd.dwFlags = DDSD_PIXELFORMAT | DDSD_HEIGHT | DDSD_WIDTH; | |
| 608 ddsd.dwWidth = texture->w; | |
| 609 ddsd.dwHeight = texture->h; | |
| 610 | |
| 611 | |
| 612 if (!PixelFormatToDDPIXELFORMAT(texture->format, &ddsd.ddpfPixelFormat)) { | |
| 613 SDL_free(data); | |
| 614 return -1; | |
| 615 } | |
| 616 | |
| 617 texture->driverdata = data; | |
| 618 | |
| 619 result = | |
| 620 renderdata->ddraw->lpVtbl->CreateSurface(renderdata->ddraw, &ddsd, | |
| 621 &data->surface, NULL); | |
| 622 if (result != DD_OK) { | |
| 623 SDL_free(data); | |
| 624 DDRAW_SetError("CreateTexture", result); | |
| 625 return -1; | |
| 626 } | |
| 627 | |
| 628 return 0; | |
| 629 } | |
| 630 | |
| 631 static int | |
| 632 DDRAW_QueryTexturePixels(SDL_Renderer * renderer, SDL_Texture * texture, | |
| 633 void **pixels, int *pitch) | |
| 634 { | |
| 635 //TODO implement | |
| 636 SDL_SetError("QueryTexturePixels is not implemented"); | |
| 637 return -1; | |
| 638 } | |
| 639 | |
| 640 static int | |
| 641 DDRAW_SetTextureColorMod(SDL_Renderer * renderer, SDL_Texture * texture) | |
| 642 { | |
| 643 return 0; | |
| 644 } | |
| 645 | |
| 646 static int | |
| 647 DDRAW_SetTextureAlphaMod(SDL_Renderer * renderer, SDL_Texture * texture) | |
| 648 { | |
| 649 return 0; | |
| 650 } | |
| 651 | |
| 652 static int | |
| 653 DDRAW_SetTextureBlendMode(SDL_Renderer * renderer, SDL_Texture * texture) | |
| 654 { | |
| 655 switch (texture->blendMode) { | |
| 656 case SDL_BLENDMODE_NONE: | |
| 657 return 0; | |
| 658 default: | |
| 659 SDL_Unsupported(); | |
| 660 texture->blendMode = SDL_BLENDMODE_NONE; | |
| 661 return -1; | |
| 662 } | |
| 663 } | |
| 664 | |
| 665 static int | |
| 666 DDRAW_SetTextureScaleMode(SDL_Renderer * renderer, SDL_Texture * texture) | |
| 667 { | |
| 668 switch (texture->scaleMode) { | |
|
4929
aa8888658021
Use the enumerated type for blend and scale mode instead of int
Sam Lantinga <slouken@libsdl.org>
parents:
4569
diff
changeset
|
669 case SDL_SCALEMODE_NONE: |
| 3168 | 670 default: |
| 671 SDL_Unsupported(); | |
|
4929
aa8888658021
Use the enumerated type for blend and scale mode instead of int
Sam Lantinga <slouken@libsdl.org>
parents:
4569
diff
changeset
|
672 texture->scaleMode = SDL_SCALEMODE_NONE; |
| 3168 | 673 return -1; |
| 674 } | |
| 675 return 0; | |
| 676 } | |
| 677 | |
| 678 static int | |
| 679 DDRAW_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture, | |
| 680 const SDL_Rect * rect, const void *pixels, int pitch) | |
| 681 { | |
| 682 DDRAW_TextureData *data = (DDRAW_TextureData *) texture->driverdata; | |
| 683 | |
| 684 //TODO implement | |
| 685 SDL_SetError("UpdateTexture is not implemented"); | |
| 686 return 0; | |
| 687 } | |
| 688 | |
| 689 static int | |
| 690 DDRAW_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture, | |
| 691 const SDL_Rect * rect, int markDirty, void **pixels, | |
| 692 int *pitch) | |
| 693 { | |
| 694 DDRAW_TextureData *data = (DDRAW_TextureData *) texture->driverdata; | |
| 695 HRESULT result; | |
| 696 DDSURFACEDESC ddsd; | |
| 697 | |
| 698 SDL_zero(ddsd); | |
| 699 ddsd.dwSize = sizeof(ddsd); | |
| 700 | |
| 701 /** | |
| 702 * On a Axim x51v locking a subrect returns the startaddress of the whole surface, | |
| 703 * wheras on my ASUS MyPal 696 the startaddress of the locked area is returned, | |
| 704 * thats why I always lock the whole surface and calculate the pixels pointer by hand. | |
| 705 * This shouldn't be a speed problem, as multiple locks aren't available on DDraw Mobile | |
| 706 * see http://msdn.microsoft.com/en-us/library/ms858221.aspx | |
| 707 */ | |
| 708 | |
| 709 result = data->surface->lpVtbl->Lock(data->surface, NULL, &ddsd, 0, NULL); | |
| 710 if (result != DD_OK) { | |
| 711 DDRAW_SetError("LockRect()", result); | |
| 712 return -1; | |
| 713 } | |
| 714 | |
| 715 *pixels = ddsd.lpSurface + rect->y * ddsd.lPitch + rect->x * ddsd.lXPitch; | |
| 716 *pitch = ddsd.lPitch; | |
| 717 return 0; | |
| 718 } | |
| 719 | |
| 720 static void | |
| 721 DDRAW_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture) | |
| 722 { | |
| 723 DDRAW_TextureData *data = (DDRAW_TextureData *) texture->driverdata; | |
| 724 | |
| 725 data->surface->lpVtbl->Unlock(data->surface, NULL); | |
| 726 } | |
| 727 | |
| 728 static void | |
| 729 DDRAW_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture, | |
| 730 int numrects, const SDL_Rect * rects) | |
| 731 { | |
| 732 } | |
| 733 | |
| 734 static void | |
| 735 DDRAW_SetBlendMode(DDRAW_RenderData * data, int blendMode) | |
| 736 { | |
| 737 switch (blendMode) { | |
| 738 | |
| 739 } | |
| 740 } | |
| 741 | |
| 742 static int | |
| 743 DDRAW_RenderPoint(SDL_Renderer * renderer, int x, int y) | |
| 744 { | |
| 745 return -1; | |
| 746 } | |
| 747 | |
| 748 static int | |
| 749 DDRAW_RenderLine(SDL_Renderer * renderer, int x1, int y1, int x2, int y2) | |
| 750 { | |
| 751 return -1; | |
| 752 } | |
| 753 | |
| 754 static int | |
| 755 DDRAW_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect) | |
| 756 { | |
| 757 return -1; | |
| 758 } | |
| 759 | |
| 760 static int | |
| 761 DDRAW_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture, | |
| 762 const SDL_Rect * srcrect, const SDL_Rect * dstrect) | |
| 763 { | |
| 764 DDRAW_RenderData *data = (DDRAW_RenderData *) renderer->driverdata; | |
| 765 DDRAW_TextureData *texturedata = | |
| 766 (DDRAW_TextureData *) texture->driverdata; | |
| 767 HRESULT result; | |
| 768 RECT srcr; | |
| 769 RECT dstr; | |
| 770 DDBLTFX bltfx; | |
| 771 | |
| 772 srcr.left = srcrect->x; | |
| 773 srcr.top = srcrect->y; | |
| 774 srcr.right = srcrect->x + srcrect->w; | |
| 775 srcr.bottom = srcrect->y + srcrect->h; | |
| 776 | |
| 777 dstr.left = dstrect->x; | |
| 778 dstr.top = dstrect->y; | |
| 779 dstr.right = dstrect->x + dstrect->w; | |
| 780 dstr.bottom = dstrect->y + dstrect->h; | |
| 781 | |
| 782 SDL_zero(bltfx); | |
| 783 bltfx.dwSize = sizeof(bltfx); | |
| 784 bltfx.dwROP = SRCCOPY; | |
| 785 | |
| 786 data->primary->lpVtbl->Blt(data->primary, &dstr, texturedata->surface, | |
| 787 &srcr, DDBLT_ROP, &bltfx); | |
| 788 | |
| 789 return 0; | |
| 790 } | |
| 791 | |
| 792 static void | |
| 793 DDRAW_RenderPresent(SDL_Renderer * renderer) | |
| 794 { | |
| 795 DDRAW_RenderData *data = (DDRAW_RenderData *) renderer->driverdata; | |
| 796 HRESULT result; | |
| 797 | |
| 798 return; | |
| 799 | |
| 800 result = | |
| 801 data->primary->lpVtbl->Flip(data->primary, NULL, DDFLIP_INTERVAL1); | |
| 802 if (result != DD_OK) { | |
| 803 DDRAW_SetError("Present()", result); | |
| 804 } | |
| 805 } | |
| 806 | |
| 807 static void | |
| 808 DDRAW_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture) | |
| 809 { | |
| 810 DDRAW_TextureData *data = (DDRAW_TextureData *) texture->driverdata; | |
| 811 | |
| 812 if (!data) { | |
| 813 return; | |
| 814 } | |
| 815 | |
| 816 data->surface->lpVtbl->Release(data->surface); | |
| 817 SDL_free(data); | |
| 818 texture->driverdata = NULL; | |
| 819 } | |
| 820 | |
| 821 static void | |
| 822 DDRAW_DestroyRenderer(SDL_Renderer * renderer) | |
| 823 { | |
| 824 DDRAW_RenderData *data = (DDRAW_RenderData *) renderer->driverdata; | |
| 825 | |
| 826 if (data) { | |
| 827 data->primary->lpVtbl->Release(data->primary); | |
| 828 SDL_free(data); | |
| 829 } | |
| 830 SDL_free(renderer); | |
| 831 } | |
| 832 | |
| 833 #endif /* SDL_VIDEO_RENDER_DDRAW */ | |
| 834 | |
| 835 /* vi: set ts=4 sw=4 expandtab: */ |