1 /* 2 * DirectDraw helper functions 3 * 4 * Copyright (c) 1997-2000 Marcus Meissner 5 * Copyright (c) 1998 Lionel Ulmer 6 * Copyright (c) 2000 TransGaming Technologies Inc. 7 * Copyright (c) 2006 Stefan Dösinger 8 * 9 * This library is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU Lesser General Public 11 * License as published by the Free Software Foundation; either 12 * version 2.1 of the License, or (at your option) any later version. 13 * 14 * This library is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * Lesser General Public License for more details. 18 * 19 * You should have received a copy of the GNU Lesser General Public 20 * License along with this library; if not, write to the Free Software 21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 22 */ 23 24 #include "config.h" 25 #include "wine/port.h" 26 27 #include "ddraw_private.h" 28 29 WINE_DEFAULT_DEBUG_CHANNEL(ddraw); 30 31 static void DDRAW_dump_pixelformat(const DDPIXELFORMAT *pf); 32 33 void ddrawformat_from_wined3dformat(DDPIXELFORMAT *DDPixelFormat, enum wined3d_format_id wined3d_format) 34 { 35 DWORD Size = DDPixelFormat->dwSize; 36 37 if(Size==0) return; 38 39 memset(DDPixelFormat, 0x00, Size); 40 DDPixelFormat->dwSize = Size; 41 switch (wined3d_format) 42 { 43 case WINED3DFMT_B8G8R8_UNORM: 44 DDPixelFormat->dwFlags = DDPF_RGB; 45 DDPixelFormat->dwFourCC = 0; 46 DDPixelFormat->u1.dwRGBBitCount = 24; 47 DDPixelFormat->u2.dwRBitMask = 0x00ff0000; 48 DDPixelFormat->u3.dwGBitMask = 0x0000ff00; 49 DDPixelFormat->u4.dwBBitMask = 0x000000ff; 50 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0; 51 break; 52 53 case WINED3DFMT_B8G8R8A8_UNORM: 54 DDPixelFormat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS; 55 DDPixelFormat->dwFourCC = 0; 56 DDPixelFormat->u1.dwRGBBitCount = 32; 57 DDPixelFormat->u2.dwRBitMask = 0x00ff0000; 58 DDPixelFormat->u3.dwGBitMask = 0x0000ff00; 59 DDPixelFormat->u4.dwBBitMask = 0x000000ff; 60 DDPixelFormat->u5.dwRGBAlphaBitMask = 0xff000000; 61 break; 62 63 case WINED3DFMT_B8G8R8X8_UNORM: 64 DDPixelFormat->dwFlags = DDPF_RGB; 65 DDPixelFormat->dwFourCC = 0; 66 DDPixelFormat->u1.dwRGBBitCount = 32; 67 DDPixelFormat->u2.dwRBitMask = 0x00ff0000; 68 DDPixelFormat->u3.dwGBitMask = 0x0000ff00; 69 DDPixelFormat->u4.dwBBitMask = 0x000000ff; 70 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0; 71 break; 72 73 case WINED3DFMT_R8G8B8X8_UNORM: 74 DDPixelFormat->dwFlags = DDPF_RGB; 75 DDPixelFormat->dwFourCC = 0; 76 DDPixelFormat->u1.dwRGBBitCount = 32; 77 DDPixelFormat->u2.dwRBitMask = 0x000000ff; 78 DDPixelFormat->u3.dwGBitMask = 0x0000ff00; 79 DDPixelFormat->u4.dwBBitMask = 0x00ff0000; 80 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0; 81 break; 82 83 case WINED3DFMT_B5G6R5_UNORM: 84 DDPixelFormat->dwFlags = DDPF_RGB; 85 DDPixelFormat->dwFourCC = 0; 86 DDPixelFormat->u1.dwRGBBitCount = 16; 87 DDPixelFormat->u2.dwRBitMask = 0xF800; 88 DDPixelFormat->u3.dwGBitMask = 0x07E0; 89 DDPixelFormat->u4.dwBBitMask = 0x001F; 90 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0; 91 break; 92 93 case WINED3DFMT_B5G5R5X1_UNORM: 94 DDPixelFormat->dwFlags = DDPF_RGB; 95 DDPixelFormat->dwFourCC = 0; 96 DDPixelFormat->u1.dwRGBBitCount = 16; 97 DDPixelFormat->u2.dwRBitMask = 0x7C00; 98 DDPixelFormat->u3.dwGBitMask = 0x03E0; 99 DDPixelFormat->u4.dwBBitMask = 0x001F; 100 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0; 101 break; 102 103 case WINED3DFMT_B5G5R5A1_UNORM: 104 DDPixelFormat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS; 105 DDPixelFormat->dwFourCC = 0; 106 DDPixelFormat->u1.dwRGBBitCount = 16; 107 DDPixelFormat->u2.dwRBitMask = 0x7C00; 108 DDPixelFormat->u3.dwGBitMask = 0x03E0; 109 DDPixelFormat->u4.dwBBitMask = 0x001F; 110 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x8000; 111 break; 112 113 case WINED3DFMT_B4G4R4A4_UNORM: 114 DDPixelFormat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS; 115 DDPixelFormat->dwFourCC = 0; 116 DDPixelFormat->u1.dwRGBBitCount = 16; 117 DDPixelFormat->u2.dwRBitMask = 0x0F00; 118 DDPixelFormat->u3.dwGBitMask = 0x00F0; 119 DDPixelFormat->u4.dwBBitMask = 0x000F; 120 DDPixelFormat->u5.dwRGBAlphaBitMask = 0xF000; 121 break; 122 123 case WINED3DFMT_B2G3R3_UNORM: 124 DDPixelFormat->dwFlags = DDPF_RGB; 125 DDPixelFormat->dwFourCC = 0; 126 DDPixelFormat->u1.dwRGBBitCount = 8; 127 DDPixelFormat->u2.dwRBitMask = 0xE0; 128 DDPixelFormat->u3.dwGBitMask = 0x1C; 129 DDPixelFormat->u4.dwBBitMask = 0x03; 130 DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0x0; 131 break; 132 133 case WINED3DFMT_P8_UINT: 134 DDPixelFormat->dwFlags = DDPF_PALETTEINDEXED8 | DDPF_RGB; 135 DDPixelFormat->dwFourCC = 0; 136 DDPixelFormat->u1.dwRGBBitCount = 8; 137 DDPixelFormat->u2.dwRBitMask = 0x00; 138 DDPixelFormat->u3.dwGBitMask = 0x00; 139 DDPixelFormat->u4.dwBBitMask = 0x00; 140 break; 141 142 case WINED3DFMT_A8_UNORM: 143 DDPixelFormat->dwFlags = DDPF_ALPHA; 144 DDPixelFormat->dwFourCC = 0; 145 DDPixelFormat->u1.dwAlphaBitDepth = 8; 146 DDPixelFormat->u2.dwRBitMask = 0x0; 147 DDPixelFormat->u3.dwZBitMask = 0x0; 148 DDPixelFormat->u4.dwStencilBitMask = 0x0; 149 DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0x0; 150 break; 151 152 case WINED3DFMT_B2G3R3A8_UNORM: 153 DDPixelFormat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS; 154 DDPixelFormat->dwFourCC = 0; 155 DDPixelFormat->u1.dwRGBBitCount = 16; 156 DDPixelFormat->u2.dwRBitMask = 0x00E0; 157 DDPixelFormat->u3.dwGBitMask = 0x001C; 158 DDPixelFormat->u4.dwBBitMask = 0x0003; 159 DDPixelFormat->u5.dwRGBAlphaBitMask = 0xFF00; 160 break; 161 162 case WINED3DFMT_B4G4R4X4_UNORM: 163 DDPixelFormat->dwFlags = DDPF_RGB; 164 DDPixelFormat->dwFourCC = 0; 165 DDPixelFormat->u1.dwRGBBitCount = 16; 166 DDPixelFormat->u2.dwRBitMask = 0x0F00; 167 DDPixelFormat->u3.dwGBitMask = 0x00F0; 168 DDPixelFormat->u4.dwBBitMask = 0x000F; 169 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0; 170 break; 171 172 /* How are Z buffer bit depth and Stencil buffer bit depth related? 173 */ 174 case WINED3DFMT_D16_UNORM: 175 DDPixelFormat->dwFlags = DDPF_ZBUFFER; 176 DDPixelFormat->dwFourCC = 0; 177 DDPixelFormat->u1.dwZBufferBitDepth = 16; 178 DDPixelFormat->u2.dwStencilBitDepth = 0; 179 DDPixelFormat->u3.dwZBitMask = 0x0000FFFF; 180 DDPixelFormat->u4.dwStencilBitMask = 0x0; 181 DDPixelFormat->u5.dwRGBZBitMask = 0x00000000; 182 break; 183 184 case WINED3DFMT_D32_UNORM: 185 DDPixelFormat->dwFlags = DDPF_ZBUFFER; 186 DDPixelFormat->dwFourCC = 0; 187 DDPixelFormat->u1.dwZBufferBitDepth = 32; 188 DDPixelFormat->u2.dwStencilBitDepth = 0; 189 DDPixelFormat->u3.dwZBitMask = 0xFFFFFFFF; 190 DDPixelFormat->u4.dwStencilBitMask = 0x0; 191 DDPixelFormat->u5.dwRGBZBitMask = 0x00000000; 192 break; 193 194 case WINED3DFMT_S4X4_UINT_D24_UNORM: 195 DDPixelFormat->dwFlags = DDPF_ZBUFFER | DDPF_STENCILBUFFER; 196 DDPixelFormat->dwFourCC = 0; 197 /* Should I set dwZBufferBitDepth to 32 here? */ 198 DDPixelFormat->u1.dwZBufferBitDepth = 32; 199 DDPixelFormat->u2.dwStencilBitDepth = 4; 200 DDPixelFormat->u3.dwZBitMask = 0x00FFFFFF; 201 DDPixelFormat->u4.dwStencilBitMask = 0x0F000000; 202 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0; 203 break; 204 205 case WINED3DFMT_D24_UNORM_S8_UINT: 206 DDPixelFormat->dwFlags = DDPF_ZBUFFER | DDPF_STENCILBUFFER; 207 DDPixelFormat->dwFourCC = 0; 208 DDPixelFormat->u1.dwZBufferBitDepth = 32; 209 DDPixelFormat->u2.dwStencilBitDepth = 8; 210 DDPixelFormat->u3.dwZBitMask = 0x00FFFFFF; 211 DDPixelFormat->u4.dwStencilBitMask = 0xFF000000; 212 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0; 213 break; 214 215 case WINED3DFMT_X8D24_UNORM: 216 DDPixelFormat->dwFlags = DDPF_ZBUFFER; 217 DDPixelFormat->dwFourCC = 0; 218 DDPixelFormat->u1.dwZBufferBitDepth = 32; 219 DDPixelFormat->u2.dwStencilBitDepth = 0; 220 DDPixelFormat->u3.dwZBitMask = 0x00FFFFFF; 221 DDPixelFormat->u4.dwStencilBitMask = 0x00000000; 222 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0; 223 break; 224 225 case WINED3DFMT_S1_UINT_D15_UNORM: 226 DDPixelFormat->dwFlags = DDPF_ZBUFFER | DDPF_STENCILBUFFER; 227 DDPixelFormat->dwFourCC = 0; 228 DDPixelFormat->u1.dwZBufferBitDepth = 16; 229 DDPixelFormat->u2.dwStencilBitDepth = 1; 230 DDPixelFormat->u3.dwZBitMask = 0x7fff; 231 DDPixelFormat->u4.dwStencilBitMask = 0x8000; 232 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0; 233 break; 234 235 case WINED3DFMT_UYVY: 236 case WINED3DFMT_YUY2: 237 DDPixelFormat->u1.dwYUVBitCount = 16; 238 DDPixelFormat->dwFlags = DDPF_FOURCC; 239 DDPixelFormat->dwFourCC = wined3d_format; 240 break; 241 242 case WINED3DFMT_YV12: 243 DDPixelFormat->u1.dwYUVBitCount = 12; 244 DDPixelFormat->dwFlags = DDPF_FOURCC; 245 DDPixelFormat->dwFourCC = wined3d_format; 246 break; 247 248 case WINED3DFMT_DXT1: 249 case WINED3DFMT_DXT2: 250 case WINED3DFMT_DXT3: 251 case WINED3DFMT_DXT4: 252 case WINED3DFMT_DXT5: 253 case WINED3DFMT_MULTI2_ARGB8: 254 case WINED3DFMT_G8R8_G8B8: 255 case WINED3DFMT_R8G8_B8G8: 256 DDPixelFormat->dwFlags = DDPF_FOURCC; 257 DDPixelFormat->dwFourCC = wined3d_format; 258 break; 259 260 /* Luminance */ 261 case WINED3DFMT_L8_UNORM: 262 DDPixelFormat->dwFlags = DDPF_LUMINANCE; 263 DDPixelFormat->dwFourCC = 0; 264 DDPixelFormat->u1.dwLuminanceBitCount = 8; 265 DDPixelFormat->u2.dwLuminanceBitMask = 0xff; 266 DDPixelFormat->u3.dwBumpDvBitMask = 0x0; 267 DDPixelFormat->u4.dwBumpLuminanceBitMask = 0x0; 268 DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0x0; 269 break; 270 271 case WINED3DFMT_L4A4_UNORM: 272 DDPixelFormat->dwFlags = DDPF_ALPHAPIXELS | DDPF_LUMINANCE; 273 DDPixelFormat->dwFourCC = 0; 274 DDPixelFormat->u1.dwLuminanceBitCount = 4; 275 DDPixelFormat->u2.dwLuminanceBitMask = 0x0f; 276 DDPixelFormat->u3.dwBumpDvBitMask = 0x0; 277 DDPixelFormat->u4.dwBumpLuminanceBitMask = 0x0; 278 DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0xf0; 279 break; 280 281 case WINED3DFMT_L8A8_UNORM: 282 DDPixelFormat->dwFlags = DDPF_ALPHAPIXELS | DDPF_LUMINANCE; 283 DDPixelFormat->dwFourCC = 0; 284 DDPixelFormat->u1.dwLuminanceBitCount = 16; 285 DDPixelFormat->u2.dwLuminanceBitMask = 0x00ff; 286 DDPixelFormat->u3.dwBumpDvBitMask = 0x0; 287 DDPixelFormat->u4.dwBumpLuminanceBitMask = 0x0; 288 DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0xff00; 289 break; 290 291 /* Bump mapping */ 292 case WINED3DFMT_R8G8_SNORM: 293 DDPixelFormat->dwFlags = DDPF_BUMPDUDV; 294 DDPixelFormat->dwFourCC = 0; 295 DDPixelFormat->u1.dwBumpBitCount = 16; 296 DDPixelFormat->u2.dwBumpDuBitMask = 0x000000ff; 297 DDPixelFormat->u3.dwBumpDvBitMask = 0x0000ff00; 298 DDPixelFormat->u4.dwBumpLuminanceBitMask = 0x00000000; 299 DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0x00000000; 300 break; 301 302 case WINED3DFMT_R5G5_SNORM_L6_UNORM: 303 DDPixelFormat->dwFlags = DDPF_BUMPDUDV | DDPF_BUMPLUMINANCE; 304 DDPixelFormat->dwFourCC = 0; 305 DDPixelFormat->u1.dwBumpBitCount = 16; 306 DDPixelFormat->u2.dwBumpDuBitMask = 0x0000001f; 307 DDPixelFormat->u3.dwBumpDvBitMask = 0x000003e0; 308 DDPixelFormat->u4.dwBumpLuminanceBitMask = 0x0000fc00; 309 DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0x00000000; 310 break; 311 312 case WINED3DFMT_R8G8_SNORM_L8X8_UNORM: 313 DDPixelFormat->dwFlags = DDPF_BUMPDUDV | DDPF_BUMPLUMINANCE; 314 DDPixelFormat->dwFourCC = 0; 315 DDPixelFormat->u1.dwBumpBitCount = 32; 316 DDPixelFormat->u2.dwBumpDuBitMask = 0x000000ff; 317 DDPixelFormat->u3.dwBumpDvBitMask = 0x0000ff00; 318 DDPixelFormat->u4.dwBumpLuminanceBitMask = 0x00ff0000; 319 DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0x00000000; 320 break; 321 322 default: 323 FIXME("Unhandled wined3d format %#x.\n", wined3d_format); 324 break; 325 } 326 327 if(TRACE_ON(ddraw)) { 328 TRACE("Returning: "); 329 DDRAW_dump_pixelformat(DDPixelFormat); 330 } 331 } 332 333 enum wined3d_format_id wined3dformat_from_ddrawformat(const DDPIXELFORMAT *DDPixelFormat) 334 { 335 TRACE("Convert a DirectDraw Pixelformat to a WineD3D Pixelformat\n"); 336 if(TRACE_ON(ddraw)) 337 { 338 DDRAW_dump_pixelformat(DDPixelFormat); 339 } 340 341 if(DDPixelFormat->dwFlags & DDPF_PALETTEINDEXED8) 342 { 343 return WINED3DFMT_P8_UINT; 344 } 345 else if(DDPixelFormat->dwFlags & (DDPF_PALETTEINDEXED1 | DDPF_PALETTEINDEXED2 | DDPF_PALETTEINDEXED4) ) 346 { 347 FIXME("DDPF_PALETTEINDEXED1 to DDPF_PALETTEINDEXED4 are not supported by WineD3D (yet). Returning WINED3DFMT_P8\n"); 348 return WINED3DFMT_P8_UINT; 349 } 350 else if(DDPixelFormat->dwFlags & DDPF_RGB) 351 { 352 switch(DDPixelFormat->u1.dwRGBBitCount) 353 { 354 case 8: 355 /* This is the only format that can match here */ 356 return WINED3DFMT_B2G3R3_UNORM; 357 358 case 16: 359 /* Read the Color masks */ 360 if( (DDPixelFormat->u2.dwRBitMask == 0xF800) && 361 (DDPixelFormat->u3.dwGBitMask == 0x07E0) && 362 (DDPixelFormat->u4.dwBBitMask == 0x001F) ) 363 { 364 return WINED3DFMT_B5G6R5_UNORM; 365 } 366 367 if( (DDPixelFormat->u2.dwRBitMask == 0x7C00) && 368 (DDPixelFormat->u3.dwGBitMask == 0x03E0) && 369 (DDPixelFormat->u4.dwBBitMask == 0x001F) ) 370 { 371 if( (DDPixelFormat->dwFlags & DDPF_ALPHAPIXELS) && 372 (DDPixelFormat->u5.dwRGBAlphaBitMask == 0x8000)) 373 return WINED3DFMT_B5G5R5A1_UNORM; 374 else 375 return WINED3DFMT_B5G5R5X1_UNORM; 376 } 377 378 if( (DDPixelFormat->u2.dwRBitMask == 0x0F00) && 379 (DDPixelFormat->u3.dwGBitMask == 0x00F0) && 380 (DDPixelFormat->u4.dwBBitMask == 0x000F) ) 381 { 382 if( (DDPixelFormat->dwFlags & DDPF_ALPHAPIXELS) && 383 (DDPixelFormat->u5.dwRGBAlphaBitMask == 0xF000)) 384 return WINED3DFMT_B4G4R4A4_UNORM; 385 else 386 return WINED3DFMT_B4G4R4X4_UNORM; 387 } 388 389 if( (DDPixelFormat->dwFlags & DDPF_ALPHAPIXELS) && 390 (DDPixelFormat->u5.dwRGBAlphaBitMask == 0xFF00) && 391 (DDPixelFormat->u2.dwRBitMask == 0x00E0) && 392 (DDPixelFormat->u3.dwGBitMask == 0x001C) && 393 (DDPixelFormat->u4.dwBBitMask == 0x0003) ) 394 { 395 return WINED3DFMT_B2G3R3A8_UNORM; 396 } 397 WARN("16 bit RGB Pixel format does not match.\n"); 398 return WINED3DFMT_UNKNOWN; 399 400 case 24: 401 return WINED3DFMT_B8G8R8_UNORM; 402 403 case 32: 404 /* Read the Color masks */ 405 if( (DDPixelFormat->u2.dwRBitMask == 0x00FF0000) && 406 (DDPixelFormat->u3.dwGBitMask == 0x0000FF00) && 407 (DDPixelFormat->u4.dwBBitMask == 0x000000FF) ) 408 { 409 if( (DDPixelFormat->dwFlags & DDPF_ALPHAPIXELS) && 410 (DDPixelFormat->u5.dwRGBAlphaBitMask == 0xFF000000)) 411 return WINED3DFMT_B8G8R8A8_UNORM; 412 else 413 return WINED3DFMT_B8G8R8X8_UNORM; 414 415 } 416 WARN("32 bit RGB pixel format does not match.\n"); 417 return WINED3DFMT_UNKNOWN; 418 419 default: 420 WARN("Invalid dwRGBBitCount in Pixelformat structure.\n"); 421 return WINED3DFMT_UNKNOWN; 422 } 423 } 424 else if( (DDPixelFormat->dwFlags & DDPF_ALPHA) ) 425 { 426 /* Alpha only Pixelformat */ 427 switch(DDPixelFormat->u1.dwAlphaBitDepth) 428 { 429 case 8: 430 return WINED3DFMT_A8_UNORM; 431 432 default: 433 WARN("Invalid AlphaBitDepth in Alpha-Only Pixelformat.\n"); 434 return WINED3DFMT_UNKNOWN; 435 } 436 } 437 else if(DDPixelFormat->dwFlags & DDPF_LUMINANCE) 438 { 439 /* Luminance-only or luminance-alpha */ 440 if(DDPixelFormat->dwFlags & DDPF_ALPHAPIXELS) 441 { 442 /* Luminance with Alpha */ 443 switch(DDPixelFormat->u1.dwLuminanceBitCount) 444 { 445 case 4: 446 if(DDPixelFormat->u1.dwAlphaBitDepth == 4) 447 return WINED3DFMT_L4A4_UNORM; 448 WARN("Unknown Alpha / Luminance bit depth combination.\n"); 449 return WINED3DFMT_UNKNOWN; 450 451 case 6: 452 FIXME("A luminance Pixelformat shouldn't have 6 luminance bits. Returning D3DFMT_L6V5U5 for now.\n"); 453 return WINED3DFMT_R5G5_SNORM_L6_UNORM; 454 455 case 8: 456 if(DDPixelFormat->u1.dwAlphaBitDepth == 8) 457 return WINED3DFMT_L8A8_UNORM; 458 WARN("Unknown Alpha / Lumincase bit depth combination.\n"); 459 return WINED3DFMT_UNKNOWN; 460 } 461 } 462 else 463 { 464 /* Luminance-only */ 465 switch(DDPixelFormat->u1.dwLuminanceBitCount) 466 { 467 case 6: 468 FIXME("A luminance Pixelformat shouldn't have 6 luminance bits. Returning D3DFMT_L6V5U5 for now.\n"); 469 return WINED3DFMT_R5G5_SNORM_L6_UNORM; 470 471 case 8: 472 return WINED3DFMT_L8_UNORM; 473 474 default: 475 WARN("Unknown luminance-only bit depth 0x%x.\n", DDPixelFormat->u1.dwLuminanceBitCount); 476 return WINED3DFMT_UNKNOWN; 477 } 478 } 479 } 480 else if(DDPixelFormat->dwFlags & DDPF_ZBUFFER) 481 { 482 /* Z buffer */ 483 if(DDPixelFormat->dwFlags & DDPF_STENCILBUFFER) 484 { 485 switch(DDPixelFormat->u1.dwZBufferBitDepth) 486 { 487 case 16: 488 if (DDPixelFormat->u2.dwStencilBitDepth == 1) return WINED3DFMT_S1_UINT_D15_UNORM; 489 WARN("Unknown depth stencil format: 16 z bits, %u stencil bits.\n", 490 DDPixelFormat->u2.dwStencilBitDepth); 491 return WINED3DFMT_UNKNOWN; 492 493 case 32: 494 if (DDPixelFormat->u2.dwStencilBitDepth == 8) return WINED3DFMT_D24_UNORM_S8_UINT; 495 else if (DDPixelFormat->u2.dwStencilBitDepth == 4) return WINED3DFMT_S4X4_UINT_D24_UNORM; 496 WARN("Unknown depth stencil format: 32 z bits, %u stencil bits.\n", 497 DDPixelFormat->u2.dwStencilBitDepth); 498 return WINED3DFMT_UNKNOWN; 499 500 default: 501 WARN("Unknown depth stencil format: %u z bits, %u stencil bits.\n", 502 DDPixelFormat->u1.dwZBufferBitDepth, DDPixelFormat->u2.dwStencilBitDepth); 503 return WINED3DFMT_UNKNOWN; 504 } 505 } 506 else 507 { 508 switch(DDPixelFormat->u1.dwZBufferBitDepth) 509 { 510 case 16: 511 return WINED3DFMT_D16_UNORM; 512 513 case 24: 514 return WINED3DFMT_X8D24_UNORM; 515 516 case 32: 517 if (DDPixelFormat->u3.dwZBitMask == 0x00FFFFFF) return WINED3DFMT_X8D24_UNORM; 518 else if (DDPixelFormat->u3.dwZBitMask == 0xFFFFFF00) return WINED3DFMT_X8D24_UNORM; 519 else if (DDPixelFormat->u3.dwZBitMask == 0xFFFFFFFF) return WINED3DFMT_D32_UNORM; 520 WARN("Unknown depth-only format: 32 z bits, mask 0x%08x\n", 521 DDPixelFormat->u3.dwZBitMask); 522 return WINED3DFMT_UNKNOWN; 523 524 default: 525 WARN("Unknown depth-only format: %u z bits, mask 0x%08x\n", 526 DDPixelFormat->u1.dwZBufferBitDepth, DDPixelFormat->u3.dwZBitMask); 527 return WINED3DFMT_UNKNOWN; 528 } 529 } 530 } 531 else if(DDPixelFormat->dwFlags & DDPF_FOURCC) 532 { 533 return DDPixelFormat->dwFourCC; 534 } 535 else if(DDPixelFormat->dwFlags & DDPF_BUMPDUDV) 536 { 537 if( (DDPixelFormat->u1.dwBumpBitCount == 16 ) && 538 (DDPixelFormat->u2.dwBumpDuBitMask == 0x000000ff) && 539 (DDPixelFormat->u3.dwBumpDvBitMask == 0x0000ff00) && 540 (DDPixelFormat->u4.dwBumpLuminanceBitMask == 0x00000000) ) 541 { 542 return WINED3DFMT_R8G8_SNORM; 543 } 544 else if ( (DDPixelFormat->u1.dwBumpBitCount == 16 ) && 545 (DDPixelFormat->u2.dwBumpDuBitMask == 0x0000001f) && 546 (DDPixelFormat->u3.dwBumpDvBitMask == 0x000003e0) && 547 (DDPixelFormat->u4.dwBumpLuminanceBitMask == 0x0000fc00) ) 548 { 549 return WINED3DFMT_R5G5_SNORM_L6_UNORM; 550 } 551 else if ( (DDPixelFormat->u1.dwBumpBitCount == 32 ) && 552 (DDPixelFormat->u2.dwBumpDuBitMask == 0x000000ff) && 553 (DDPixelFormat->u3.dwBumpDvBitMask == 0x0000ff00) && 554 (DDPixelFormat->u4.dwBumpLuminanceBitMask == 0x00ff0000) ) 555 { 556 return WINED3DFMT_R8G8_SNORM_L8X8_UNORM; 557 } 558 } 559 560 WARN("Unknown Pixelformat.\n"); 561 return WINED3DFMT_UNKNOWN; 562 } 563 564 unsigned int wined3dmapflags_from_ddrawmapflags(unsigned int flags) 565 { 566 static const unsigned int handled = DDLOCK_NOSYSLOCK 567 | DDLOCK_NOOVERWRITE 568 | DDLOCK_DISCARDCONTENTS 569 | DDLOCK_DONOTWAIT; 570 unsigned int wined3d_flags; 571 572 wined3d_flags = flags & handled; 573 if (!(flags & (DDLOCK_NOOVERWRITE | DDLOCK_DISCARDCONTENTS | DDLOCK_WRITEONLY))) 574 wined3d_flags |= WINED3D_MAP_READ; 575 if (!(flags & DDLOCK_READONLY)) 576 wined3d_flags |= WINED3D_MAP_WRITE; 577 if (!(wined3d_flags & (WINED3D_MAP_READ | WINED3D_MAP_WRITE))) 578 wined3d_flags |= WINED3D_MAP_READ | WINED3D_MAP_WRITE; 579 if (flags & DDLOCK_NODIRTYUPDATE) 580 wined3d_flags |= WINED3D_MAP_NO_DIRTY_UPDATE; 581 flags &= ~(handled | DDLOCK_WAIT | DDLOCK_READONLY | DDLOCK_WRITEONLY | DDLOCK_NODIRTYUPDATE); 582 583 if (flags) 584 FIXME("Unhandled flags %#x.\n", flags); 585 586 return wined3d_flags; 587 } 588 589 static float colour_to_float(DWORD colour, DWORD mask) 590 { 591 if (!mask) 592 return 0.0f; 593 return (float)(colour & mask) / (float)mask; 594 } 595 596 BOOL wined3d_colour_from_ddraw_colour(const DDPIXELFORMAT *pf, const struct ddraw_palette *palette, 597 DWORD colour, struct wined3d_color *wined3d_colour) 598 { 599 if (pf->dwFlags & DDPF_ALPHA) 600 { 601 DWORD size, mask; 602 603 size = pf->u1.dwAlphaBitDepth; 604 mask = size < 32 ? (1u << size) - 1 : ~0u; 605 wined3d_colour->r = 0.0f; 606 wined3d_colour->g = 0.0f; 607 wined3d_colour->b = 0.0f; 608 wined3d_colour->a = colour_to_float(colour, mask); 609 return TRUE; 610 } 611 612 if (pf->dwFlags & DDPF_FOURCC) 613 { 614 WARN("FourCC formats not supported.\n"); 615 goto fail; 616 } 617 618 if (pf->dwFlags & DDPF_PALETTEINDEXED8) 619 { 620 PALETTEENTRY entry; 621 622 colour &= 0xff; 623 if (!palette || FAILED(wined3d_palette_get_entries(palette->wined3d_palette, 0, colour, 1, &entry))) 624 { 625 wined3d_colour->r = 0.0f; 626 wined3d_colour->g = 0.0f; 627 wined3d_colour->b = 0.0f; 628 } 629 else 630 { 631 wined3d_colour->r = entry.peRed / 255.0f; 632 wined3d_colour->g = entry.peGreen / 255.0f; 633 wined3d_colour->b = entry.peBlue / 255.0f; 634 } 635 wined3d_colour->a = colour / 255.0f; 636 return TRUE; 637 } 638 639 if (pf->dwFlags & DDPF_RGB) 640 { 641 wined3d_colour->r = colour_to_float(colour, pf->u2.dwRBitMask); 642 wined3d_colour->g = colour_to_float(colour, pf->u3.dwGBitMask); 643 wined3d_colour->b = colour_to_float(colour, pf->u4.dwBBitMask); 644 if (pf->dwFlags & DDPF_ALPHAPIXELS) 645 wined3d_colour->a = colour_to_float(colour, pf->u5.dwRGBAlphaBitMask); 646 else 647 wined3d_colour->a = 0.0f; 648 return TRUE; 649 } 650 651 if (pf->dwFlags & DDPF_ZBUFFER) 652 { 653 wined3d_colour->r = colour_to_float(colour, pf->u3.dwZBitMask); 654 if (pf->dwFlags & DDPF_STENCILBUFFER) 655 wined3d_colour->g = colour_to_float(colour, pf->u4.dwStencilBitMask); 656 else 657 wined3d_colour->g = 0.0f; 658 wined3d_colour->b = 0.0f; 659 wined3d_colour->a = 0.0f; 660 return TRUE; 661 } 662 663 FIXME("Unhandled pixel format.\n"); 664 DDRAW_dump_pixelformat(pf); 665 666 fail: 667 wined3d_colour->r = 0.0f; 668 wined3d_colour->g = 0.0f; 669 wined3d_colour->b = 0.0f; 670 wined3d_colour->a = 0.0f; 671 672 return FALSE; 673 } 674 675 /***************************************************************************** 676 * Various dumping functions. 677 * 678 * They write the contents of a specific function to a TRACE. 679 * 680 *****************************************************************************/ 681 static void 682 DDRAW_dump_DWORD(const void *in) 683 { 684 TRACE("%d\n", *((const DWORD *) in)); 685 } 686 static void 687 DDRAW_dump_PTR(const void *in) 688 { 689 TRACE("%p\n", *((const void * const*) in)); 690 } 691 static void 692 DDRAW_dump_DDCOLORKEY(const DDCOLORKEY *ddck) 693 { 694 TRACE("Low : 0x%08x - High : 0x%08x\n", ddck->dwColorSpaceLowValue, ddck->dwColorSpaceHighValue); 695 } 696 697 static void DDRAW_dump_flags_nolf(DWORD flags, const struct flag_info *names, size_t num_names) 698 { 699 unsigned int i; 700 701 for (i=0; i < num_names; i++) 702 if ((flags & names[i].val) || /* standard flag value */ 703 ((!flags) && (!names[i].val))) /* zero value only */ 704 TRACE("%s ", names[i].name); 705 } 706 707 static void DDRAW_dump_flags(DWORD flags, const struct flag_info *names, size_t num_names) 708 { 709 DDRAW_dump_flags_nolf(flags, names, num_names); 710 TRACE("\n"); 711 } 712 713 void DDRAW_dump_DDSCAPS2(const DDSCAPS2 *in) 714 { 715 static const struct flag_info flags[] = 716 { 717 FE(DDSCAPS_RESERVED1), 718 FE(DDSCAPS_ALPHA), 719 FE(DDSCAPS_BACKBUFFER), 720 FE(DDSCAPS_COMPLEX), 721 FE(DDSCAPS_FLIP), 722 FE(DDSCAPS_FRONTBUFFER), 723 FE(DDSCAPS_OFFSCREENPLAIN), 724 FE(DDSCAPS_OVERLAY), 725 FE(DDSCAPS_PALETTE), 726 FE(DDSCAPS_PRIMARYSURFACE), 727 FE(DDSCAPS_PRIMARYSURFACELEFT), 728 FE(DDSCAPS_SYSTEMMEMORY), 729 FE(DDSCAPS_TEXTURE), 730 FE(DDSCAPS_3DDEVICE), 731 FE(DDSCAPS_VIDEOMEMORY), 732 FE(DDSCAPS_VISIBLE), 733 FE(DDSCAPS_WRITEONLY), 734 FE(DDSCAPS_ZBUFFER), 735 FE(DDSCAPS_OWNDC), 736 FE(DDSCAPS_LIVEVIDEO), 737 FE(DDSCAPS_HWCODEC), 738 FE(DDSCAPS_MODEX), 739 FE(DDSCAPS_MIPMAP), 740 FE(DDSCAPS_RESERVED2), 741 FE(DDSCAPS_ALLOCONLOAD), 742 FE(DDSCAPS_VIDEOPORT), 743 FE(DDSCAPS_LOCALVIDMEM), 744 FE(DDSCAPS_NONLOCALVIDMEM), 745 FE(DDSCAPS_STANDARDVGAMODE), 746 FE(DDSCAPS_OPTIMIZED) 747 }; 748 static const struct flag_info flags2[] = 749 { 750 FE(DDSCAPS2_HARDWAREDEINTERLACE), 751 FE(DDSCAPS2_HINTDYNAMIC), 752 FE(DDSCAPS2_HINTSTATIC), 753 FE(DDSCAPS2_TEXTUREMANAGE), 754 FE(DDSCAPS2_RESERVED1), 755 FE(DDSCAPS2_RESERVED2), 756 FE(DDSCAPS2_OPAQUE), 757 FE(DDSCAPS2_HINTANTIALIASING), 758 FE(DDSCAPS2_CUBEMAP), 759 FE(DDSCAPS2_CUBEMAP_POSITIVEX), 760 FE(DDSCAPS2_CUBEMAP_NEGATIVEX), 761 FE(DDSCAPS2_CUBEMAP_POSITIVEY), 762 FE(DDSCAPS2_CUBEMAP_NEGATIVEY), 763 FE(DDSCAPS2_CUBEMAP_POSITIVEZ), 764 FE(DDSCAPS2_CUBEMAP_NEGATIVEZ), 765 FE(DDSCAPS2_MIPMAPSUBLEVEL), 766 FE(DDSCAPS2_D3DTEXTUREMANAGE), 767 FE(DDSCAPS2_DONOTPERSIST), 768 FE(DDSCAPS2_STEREOSURFACELEFT) 769 }; 770 771 DDRAW_dump_flags_nolf(in->dwCaps, flags, ARRAY_SIZE(flags)); 772 DDRAW_dump_flags(in->dwCaps2, flags2, ARRAY_SIZE(flags2)); 773 } 774 775 static void 776 DDRAW_dump_DDSCAPS(const DDSCAPS *in) 777 { 778 DDSCAPS2 in_bis; 779 780 in_bis.dwCaps = in->dwCaps; 781 in_bis.dwCaps2 = 0; 782 in_bis.dwCaps3 = 0; 783 in_bis.u1.dwCaps4 = 0; 784 785 DDRAW_dump_DDSCAPS2(&in_bis); 786 } 787 788 static void 789 DDRAW_dump_pixelformat_flag(DWORD flagmask) 790 { 791 static const struct flag_info flags[] = 792 { 793 FE(DDPF_ALPHAPIXELS), 794 FE(DDPF_ALPHA), 795 FE(DDPF_FOURCC), 796 FE(DDPF_PALETTEINDEXED4), 797 FE(DDPF_PALETTEINDEXEDTO8), 798 FE(DDPF_PALETTEINDEXED8), 799 FE(DDPF_RGB), 800 FE(DDPF_COMPRESSED), 801 FE(DDPF_RGBTOYUV), 802 FE(DDPF_YUV), 803 FE(DDPF_ZBUFFER), 804 FE(DDPF_PALETTEINDEXED1), 805 FE(DDPF_PALETTEINDEXED2), 806 FE(DDPF_ZPIXELS) 807 }; 808 809 DDRAW_dump_flags_nolf(flagmask, flags, ARRAY_SIZE(flags)); 810 } 811 812 static void DDRAW_dump_members(DWORD flags, const void *data, const struct member_info *mems, size_t num_mems) 813 { 814 unsigned int i; 815 816 for (i=0; i < num_mems; i++) 817 { 818 if (mems[i].val & flags) 819 { 820 TRACE(" - %s : ", mems[i].name); 821 mems[i].func((const char *)data + mems[i].offset); 822 } 823 } 824 } 825 826 static void 827 DDRAW_dump_pixelformat(const DDPIXELFORMAT *pf) 828 { 829 TRACE("( "); 830 DDRAW_dump_pixelformat_flag(pf->dwFlags); 831 if (pf->dwFlags & DDPF_FOURCC) 832 TRACE(", dwFourCC code '%c%c%c%c' (0x%08x) - %u bits per pixel", 833 (unsigned char)( pf->dwFourCC &0xff), 834 (unsigned char)((pf->dwFourCC>> 8)&0xff), 835 (unsigned char)((pf->dwFourCC>>16)&0xff), 836 (unsigned char)((pf->dwFourCC>>24)&0xff), 837 pf->dwFourCC, 838 pf->u1.dwYUVBitCount); 839 if (pf->dwFlags & DDPF_RGB) 840 { 841 TRACE(", RGB bits: %u, R 0x%08x G 0x%08x B 0x%08x", 842 pf->u1.dwRGBBitCount, 843 pf->u2.dwRBitMask, 844 pf->u3.dwGBitMask, 845 pf->u4.dwBBitMask); 846 if (pf->dwFlags & DDPF_ALPHAPIXELS) 847 TRACE(" A 0x%08x", pf->u5.dwRGBAlphaBitMask); 848 if (pf->dwFlags & DDPF_ZPIXELS) 849 TRACE(" Z 0x%08x", pf->u5.dwRGBZBitMask); 850 } 851 if (pf->dwFlags & DDPF_ZBUFFER) 852 TRACE(", Z bits: %u", pf->u1.dwZBufferBitDepth); 853 if (pf->dwFlags & DDPF_ALPHA) 854 TRACE(", Alpha bits: %u", pf->u1.dwAlphaBitDepth); 855 if (pf->dwFlags & DDPF_BUMPDUDV) 856 TRACE(", Bump bits: %u, U 0x%08x V 0x%08x L 0x%08x", 857 pf->u1.dwBumpBitCount, 858 pf->u2.dwBumpDuBitMask, 859 pf->u3.dwBumpDvBitMask, 860 pf->u4.dwBumpLuminanceBitMask); 861 TRACE(")\n"); 862 } 863 864 void DDRAW_dump_surface_desc(const DDSURFACEDESC2 *lpddsd) 865 { 866 #define STRUCT DDSURFACEDESC2 867 static const struct member_info members[] = 868 { 869 ME(DDSD_HEIGHT, DDRAW_dump_DWORD, dwHeight), 870 ME(DDSD_WIDTH, DDRAW_dump_DWORD, dwWidth), 871 ME(DDSD_PITCH, DDRAW_dump_DWORD, u1 /* lPitch */), 872 ME(DDSD_LINEARSIZE, DDRAW_dump_DWORD, u1 /* dwLinearSize */), 873 ME(DDSD_BACKBUFFERCOUNT, DDRAW_dump_DWORD, u5.dwBackBufferCount), 874 ME(DDSD_MIPMAPCOUNT, DDRAW_dump_DWORD, u2 /* dwMipMapCount */), 875 ME(DDSD_ZBUFFERBITDEPTH, DDRAW_dump_DWORD, u2 /* dwZBufferBitDepth */), /* This is for 'old-style' D3D */ 876 ME(DDSD_REFRESHRATE, DDRAW_dump_DWORD, u2 /* dwRefreshRate */), 877 ME(DDSD_ALPHABITDEPTH, DDRAW_dump_DWORD, dwAlphaBitDepth), 878 ME(DDSD_LPSURFACE, DDRAW_dump_PTR, lpSurface), 879 ME(DDSD_CKDESTOVERLAY, DDRAW_dump_DDCOLORKEY, u3 /* ddckCKDestOverlay */), 880 ME(DDSD_CKDESTBLT, DDRAW_dump_DDCOLORKEY, ddckCKDestBlt), 881 ME(DDSD_CKSRCOVERLAY, DDRAW_dump_DDCOLORKEY, ddckCKSrcOverlay), 882 ME(DDSD_CKSRCBLT, DDRAW_dump_DDCOLORKEY, ddckCKSrcBlt), 883 ME(DDSD_PIXELFORMAT, DDRAW_dump_pixelformat, u4 /* ddpfPixelFormat */) 884 }; 885 static const struct member_info members_caps[] = 886 { 887 ME(DDSD_CAPS, DDRAW_dump_DDSCAPS, ddsCaps) 888 }; 889 static const struct member_info members_caps2[] = 890 { 891 ME(DDSD_CAPS, DDRAW_dump_DDSCAPS2, ddsCaps) 892 }; 893 #undef STRUCT 894 895 if (NULL == lpddsd) 896 { 897 TRACE("(null)\n"); 898 } 899 else 900 { 901 if (lpddsd->dwSize >= sizeof(DDSURFACEDESC2)) 902 { 903 DDRAW_dump_members(lpddsd->dwFlags, lpddsd, members_caps2, 1); 904 } 905 else 906 { 907 DDRAW_dump_members(lpddsd->dwFlags, lpddsd, members_caps, 1); 908 } 909 DDRAW_dump_members(lpddsd->dwFlags, lpddsd, members, ARRAY_SIZE(members)); 910 } 911 } 912 913 void 914 dump_D3DMATRIX(const D3DMATRIX *mat) 915 { 916 TRACE(" %f %f %f %f\n", mat->_11, mat->_12, mat->_13, mat->_14); 917 TRACE(" %f %f %f %f\n", mat->_21, mat->_22, mat->_23, mat->_24); 918 TRACE(" %f %f %f %f\n", mat->_31, mat->_32, mat->_33, mat->_34); 919 TRACE(" %f %f %f %f\n", mat->_41, mat->_42, mat->_43, mat->_44); 920 } 921 922 DWORD 923 get_flexible_vertex_size(DWORD d3dvtVertexType) 924 { 925 DWORD size = 0; 926 DWORD i; 927 928 if (d3dvtVertexType & D3DFVF_NORMAL) size += 3 * sizeof(D3DVALUE); 929 if (d3dvtVertexType & D3DFVF_DIFFUSE) size += sizeof(DWORD); 930 if (d3dvtVertexType & D3DFVF_SPECULAR) size += sizeof(DWORD); 931 if (d3dvtVertexType & D3DFVF_RESERVED1) size += sizeof(DWORD); 932 switch (d3dvtVertexType & D3DFVF_POSITION_MASK) 933 { 934 case D3DFVF_XYZ: size += 3 * sizeof(D3DVALUE); break; 935 case D3DFVF_XYZRHW: size += 4 * sizeof(D3DVALUE); break; 936 case D3DFVF_XYZB1: size += 4 * sizeof(D3DVALUE); break; 937 case D3DFVF_XYZB2: size += 5 * sizeof(D3DVALUE); break; 938 case D3DFVF_XYZB3: size += 6 * sizeof(D3DVALUE); break; 939 case D3DFVF_XYZB4: size += 7 * sizeof(D3DVALUE); break; 940 case D3DFVF_XYZB5: size += 8 * sizeof(D3DVALUE); break; 941 default: ERR("Unexpected position mask\n"); 942 } 943 for (i = 0; i < GET_TEXCOUNT_FROM_FVF(d3dvtVertexType); i++) 944 { 945 size += GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, i) * sizeof(D3DVALUE); 946 } 947 948 return size; 949 } 950 951 void DDRAW_Convert_DDSCAPS_1_To_2(const DDSCAPS* pIn, DDSCAPS2* pOut) 952 { 953 /* 2 adds three additional caps fields to the end. Both versions 954 * are unversioned. */ 955 pOut->dwCaps = pIn->dwCaps; 956 pOut->dwCaps2 = 0; 957 pOut->dwCaps3 = 0; 958 pOut->u1.dwCaps4 = 0; 959 } 960 961 void DDRAW_Convert_DDDEVICEIDENTIFIER_2_To_1(const DDDEVICEIDENTIFIER2* pIn, DDDEVICEIDENTIFIER* pOut) 962 { 963 /* 2 adds a dwWHQLLevel field to the end. Both structures are 964 * unversioned. */ 965 memcpy(pOut, pIn, sizeof(*pOut)); 966 } 967 968 void DDRAW_dump_cooperativelevel(DWORD cooplevel) 969 { 970 static const struct flag_info flags[] = 971 { 972 FE(DDSCL_FULLSCREEN), 973 FE(DDSCL_ALLOWREBOOT), 974 FE(DDSCL_NOWINDOWCHANGES), 975 FE(DDSCL_NORMAL), 976 FE(DDSCL_ALLOWMODEX), 977 FE(DDSCL_EXCLUSIVE), 978 FE(DDSCL_SETFOCUSWINDOW), 979 FE(DDSCL_SETDEVICEWINDOW), 980 FE(DDSCL_CREATEDEVICEWINDOW) 981 }; 982 983 if (TRACE_ON(ddraw)) 984 { 985 TRACE(" - "); 986 DDRAW_dump_flags(cooplevel, flags, ARRAY_SIZE(flags)); 987 } 988 } 989 990 void DDRAW_dump_DDCAPS(const DDCAPS *lpcaps) 991 { 992 static const struct flag_info flags1[] = 993 { 994 FE(DDCAPS_3D), 995 FE(DDCAPS_ALIGNBOUNDARYDEST), 996 FE(DDCAPS_ALIGNSIZEDEST), 997 FE(DDCAPS_ALIGNBOUNDARYSRC), 998 FE(DDCAPS_ALIGNSIZESRC), 999 FE(DDCAPS_ALIGNSTRIDE), 1000 FE(DDCAPS_BLT), 1001 FE(DDCAPS_BLTQUEUE), 1002 FE(DDCAPS_BLTFOURCC), 1003 FE(DDCAPS_BLTSTRETCH), 1004 FE(DDCAPS_GDI), 1005 FE(DDCAPS_OVERLAY), 1006 FE(DDCAPS_OVERLAYCANTCLIP), 1007 FE(DDCAPS_OVERLAYFOURCC), 1008 FE(DDCAPS_OVERLAYSTRETCH), 1009 FE(DDCAPS_PALETTE), 1010 FE(DDCAPS_PALETTEVSYNC), 1011 FE(DDCAPS_READSCANLINE), 1012 FE(DDCAPS_STEREOVIEW), 1013 FE(DDCAPS_VBI), 1014 FE(DDCAPS_ZBLTS), 1015 FE(DDCAPS_ZOVERLAYS), 1016 FE(DDCAPS_COLORKEY), 1017 FE(DDCAPS_ALPHA), 1018 FE(DDCAPS_COLORKEYHWASSIST), 1019 FE(DDCAPS_NOHARDWARE), 1020 FE(DDCAPS_BLTCOLORFILL), 1021 FE(DDCAPS_BANKSWITCHED), 1022 FE(DDCAPS_BLTDEPTHFILL), 1023 FE(DDCAPS_CANCLIP), 1024 FE(DDCAPS_CANCLIPSTRETCHED), 1025 FE(DDCAPS_CANBLTSYSMEM) 1026 }; 1027 static const struct flag_info flags2[] = 1028 { 1029 FE(DDCAPS2_CERTIFIED), 1030 FE(DDCAPS2_NO2DDURING3DSCENE), 1031 FE(DDCAPS2_VIDEOPORT), 1032 FE(DDCAPS2_AUTOFLIPOVERLAY), 1033 FE(DDCAPS2_CANBOBINTERLEAVED), 1034 FE(DDCAPS2_CANBOBNONINTERLEAVED), 1035 FE(DDCAPS2_COLORCONTROLOVERLAY), 1036 FE(DDCAPS2_COLORCONTROLPRIMARY), 1037 FE(DDCAPS2_CANDROPZ16BIT), 1038 FE(DDCAPS2_NONLOCALVIDMEM), 1039 FE(DDCAPS2_NONLOCALVIDMEMCAPS), 1040 FE(DDCAPS2_NOPAGELOCKREQUIRED), 1041 FE(DDCAPS2_WIDESURFACES), 1042 FE(DDCAPS2_CANFLIPODDEVEN), 1043 FE(DDCAPS2_CANBOBHARDWARE), 1044 FE(DDCAPS2_COPYFOURCC), 1045 FE(DDCAPS2_PRIMARYGAMMA), 1046 FE(DDCAPS2_CANRENDERWINDOWED), 1047 FE(DDCAPS2_CANCALIBRATEGAMMA), 1048 FE(DDCAPS2_FLIPINTERVAL), 1049 FE(DDCAPS2_FLIPNOVSYNC), 1050 FE(DDCAPS2_CANMANAGETEXTURE), 1051 FE(DDCAPS2_TEXMANINNONLOCALVIDMEM), 1052 FE(DDCAPS2_STEREO), 1053 FE(DDCAPS2_SYSTONONLOCAL_AS_SYSTOLOCAL) 1054 }; 1055 static const struct flag_info flags3[] = 1056 { 1057 FE(DDCKEYCAPS_DESTBLT), 1058 FE(DDCKEYCAPS_DESTBLTCLRSPACE), 1059 FE(DDCKEYCAPS_DESTBLTCLRSPACEYUV), 1060 FE(DDCKEYCAPS_DESTBLTYUV), 1061 FE(DDCKEYCAPS_DESTOVERLAY), 1062 FE(DDCKEYCAPS_DESTOVERLAYCLRSPACE), 1063 FE(DDCKEYCAPS_DESTOVERLAYCLRSPACEYUV), 1064 FE(DDCKEYCAPS_DESTOVERLAYONEACTIVE), 1065 FE(DDCKEYCAPS_DESTOVERLAYYUV), 1066 FE(DDCKEYCAPS_SRCBLT), 1067 FE(DDCKEYCAPS_SRCBLTCLRSPACE), 1068 FE(DDCKEYCAPS_SRCBLTCLRSPACEYUV), 1069 FE(DDCKEYCAPS_SRCBLTYUV), 1070 FE(DDCKEYCAPS_SRCOVERLAY), 1071 FE(DDCKEYCAPS_SRCOVERLAYCLRSPACE), 1072 FE(DDCKEYCAPS_SRCOVERLAYCLRSPACEYUV), 1073 FE(DDCKEYCAPS_SRCOVERLAYONEACTIVE), 1074 FE(DDCKEYCAPS_SRCOVERLAYYUV), 1075 FE(DDCKEYCAPS_NOCOSTOVERLAY) 1076 }; 1077 static const struct flag_info flags4[] = 1078 { 1079 FE(DDFXCAPS_BLTALPHA), 1080 FE(DDFXCAPS_OVERLAYALPHA), 1081 FE(DDFXCAPS_BLTARITHSTRETCHYN), 1082 FE(DDFXCAPS_BLTARITHSTRETCHY), 1083 FE(DDFXCAPS_BLTMIRRORLEFTRIGHT), 1084 FE(DDFXCAPS_BLTMIRRORUPDOWN), 1085 FE(DDFXCAPS_BLTROTATION), 1086 FE(DDFXCAPS_BLTROTATION90), 1087 FE(DDFXCAPS_BLTSHRINKX), 1088 FE(DDFXCAPS_BLTSHRINKXN), 1089 FE(DDFXCAPS_BLTSHRINKY), 1090 FE(DDFXCAPS_BLTSHRINKYN), 1091 FE(DDFXCAPS_BLTSTRETCHX), 1092 FE(DDFXCAPS_BLTSTRETCHXN), 1093 FE(DDFXCAPS_BLTSTRETCHY), 1094 FE(DDFXCAPS_BLTSTRETCHYN), 1095 FE(DDFXCAPS_OVERLAYARITHSTRETCHY), 1096 FE(DDFXCAPS_OVERLAYARITHSTRETCHYN), 1097 FE(DDFXCAPS_OVERLAYSHRINKX), 1098 FE(DDFXCAPS_OVERLAYSHRINKXN), 1099 FE(DDFXCAPS_OVERLAYSHRINKY), 1100 FE(DDFXCAPS_OVERLAYSHRINKYN), 1101 FE(DDFXCAPS_OVERLAYSTRETCHX), 1102 FE(DDFXCAPS_OVERLAYSTRETCHXN), 1103 FE(DDFXCAPS_OVERLAYSTRETCHY), 1104 FE(DDFXCAPS_OVERLAYSTRETCHYN), 1105 FE(DDFXCAPS_OVERLAYMIRRORLEFTRIGHT), 1106 FE(DDFXCAPS_OVERLAYMIRRORUPDOWN) 1107 }; 1108 static const struct flag_info flags5[] = 1109 { 1110 FE(DDFXALPHACAPS_BLTALPHAEDGEBLEND), 1111 FE(DDFXALPHACAPS_BLTALPHAPIXELS), 1112 FE(DDFXALPHACAPS_BLTALPHAPIXELSNEG), 1113 FE(DDFXALPHACAPS_BLTALPHASURFACES), 1114 FE(DDFXALPHACAPS_BLTALPHASURFACESNEG), 1115 FE(DDFXALPHACAPS_OVERLAYALPHAEDGEBLEND), 1116 FE(DDFXALPHACAPS_OVERLAYALPHAPIXELS), 1117 FE(DDFXALPHACAPS_OVERLAYALPHAPIXELSNEG), 1118 FE(DDFXALPHACAPS_OVERLAYALPHASURFACES), 1119 FE(DDFXALPHACAPS_OVERLAYALPHASURFACESNEG) 1120 }; 1121 static const struct flag_info flags6[] = 1122 { 1123 FE(DDPCAPS_4BIT), 1124 FE(DDPCAPS_8BITENTRIES), 1125 FE(DDPCAPS_8BIT), 1126 FE(DDPCAPS_INITIALIZE), 1127 FE(DDPCAPS_PRIMARYSURFACE), 1128 FE(DDPCAPS_PRIMARYSURFACELEFT), 1129 FE(DDPCAPS_ALLOW256), 1130 FE(DDPCAPS_VSYNC), 1131 FE(DDPCAPS_1BIT), 1132 FE(DDPCAPS_2BIT), 1133 FE(DDPCAPS_ALPHA), 1134 }; 1135 static const struct flag_info flags7[] = 1136 { 1137 FE(DDSVCAPS_RESERVED1), 1138 FE(DDSVCAPS_RESERVED2), 1139 FE(DDSVCAPS_RESERVED3), 1140 FE(DDSVCAPS_RESERVED4), 1141 FE(DDSVCAPS_STEREOSEQUENTIAL), 1142 }; 1143 1144 TRACE(" - dwSize : %d\n", lpcaps->dwSize); 1145 TRACE(" - dwCaps : "); DDRAW_dump_flags(lpcaps->dwCaps, flags1, ARRAY_SIZE(flags1)); 1146 TRACE(" - dwCaps2 : "); DDRAW_dump_flags(lpcaps->dwCaps2, flags2, ARRAY_SIZE(flags2)); 1147 TRACE(" - dwCKeyCaps : "); DDRAW_dump_flags(lpcaps->dwCKeyCaps, flags3, ARRAY_SIZE(flags3)); 1148 TRACE(" - dwFXCaps : "); DDRAW_dump_flags(lpcaps->dwFXCaps, flags4, ARRAY_SIZE(flags4)); 1149 TRACE(" - dwFXAlphaCaps : "); DDRAW_dump_flags(lpcaps->dwFXAlphaCaps, flags5, ARRAY_SIZE(flags5)); 1150 TRACE(" - dwPalCaps : "); DDRAW_dump_flags(lpcaps->dwPalCaps, flags6, ARRAY_SIZE(flags6)); 1151 TRACE(" - dwSVCaps : "); DDRAW_dump_flags(lpcaps->dwSVCaps, flags7, ARRAY_SIZE(flags7)); 1152 TRACE("...\n"); 1153 TRACE(" - dwNumFourCCCodes : %d\n", lpcaps->dwNumFourCCCodes); 1154 TRACE(" - dwCurrVisibleOverlays : %d\n", lpcaps->dwCurrVisibleOverlays); 1155 TRACE(" - dwMinOverlayStretch : %d\n", lpcaps->dwMinOverlayStretch); 1156 TRACE(" - dwMaxOverlayStretch : %d\n", lpcaps->dwMaxOverlayStretch); 1157 TRACE("...\n"); 1158 TRACE(" - ddsCaps : "); DDRAW_dump_DDSCAPS2(&lpcaps->ddsCaps); 1159 } 1160 1161 /***************************************************************************** 1162 * multiply_matrix 1163 * 1164 * Multiplies 2 4x4 matrices src1 and src2, and stores the result in dest. 1165 * 1166 * Params: 1167 * dest: Pointer to the destination matrix 1168 * src1: Pointer to the first source matrix 1169 * src2: Pointer to the second source matrix 1170 * 1171 *****************************************************************************/ 1172 void 1173 multiply_matrix(D3DMATRIX *dest, 1174 const D3DMATRIX *src1, 1175 const D3DMATRIX *src2) 1176 { 1177 D3DMATRIX temp; 1178 1179 /* Now do the multiplication 'by hand'. 1180 I know that all this could be optimised, but this will be done later :-) */ 1181 temp._11 = (src1->_11 * src2->_11) + (src1->_21 * src2->_12) + (src1->_31 * src2->_13) + (src1->_41 * src2->_14); 1182 temp._21 = (src1->_11 * src2->_21) + (src1->_21 * src2->_22) + (src1->_31 * src2->_23) + (src1->_41 * src2->_24); 1183 temp._31 = (src1->_11 * src2->_31) + (src1->_21 * src2->_32) + (src1->_31 * src2->_33) + (src1->_41 * src2->_34); 1184 temp._41 = (src1->_11 * src2->_41) + (src1->_21 * src2->_42) + (src1->_31 * src2->_43) + (src1->_41 * src2->_44); 1185 1186 temp._12 = (src1->_12 * src2->_11) + (src1->_22 * src2->_12) + (src1->_32 * src2->_13) + (src1->_42 * src2->_14); 1187 temp._22 = (src1->_12 * src2->_21) + (src1->_22 * src2->_22) + (src1->_32 * src2->_23) + (src1->_42 * src2->_24); 1188 temp._32 = (src1->_12 * src2->_31) + (src1->_22 * src2->_32) + (src1->_32 * src2->_33) + (src1->_42 * src2->_34); 1189 temp._42 = (src1->_12 * src2->_41) + (src1->_22 * src2->_42) + (src1->_32 * src2->_43) + (src1->_42 * src2->_44); 1190 1191 temp._13 = (src1->_13 * src2->_11) + (src1->_23 * src2->_12) + (src1->_33 * src2->_13) + (src1->_43 * src2->_14); 1192 temp._23 = (src1->_13 * src2->_21) + (src1->_23 * src2->_22) + (src1->_33 * src2->_23) + (src1->_43 * src2->_24); 1193 temp._33 = (src1->_13 * src2->_31) + (src1->_23 * src2->_32) + (src1->_33 * src2->_33) + (src1->_43 * src2->_34); 1194 temp._43 = (src1->_13 * src2->_41) + (src1->_23 * src2->_42) + (src1->_33 * src2->_43) + (src1->_43 * src2->_44); 1195 1196 temp._14 = (src1->_14 * src2->_11) + (src1->_24 * src2->_12) + (src1->_34 * src2->_13) + (src1->_44 * src2->_14); 1197 temp._24 = (src1->_14 * src2->_21) + (src1->_24 * src2->_22) + (src1->_34 * src2->_23) + (src1->_44 * src2->_24); 1198 temp._34 = (src1->_14 * src2->_31) + (src1->_24 * src2->_32) + (src1->_34 * src2->_33) + (src1->_44 * src2->_34); 1199 temp._44 = (src1->_14 * src2->_41) + (src1->_24 * src2->_42) + (src1->_34 * src2->_43) + (src1->_44 * src2->_44); 1200 1201 /* And copy the new matrix in the good storage.. */ 1202 memcpy(dest, &temp, 16 * sizeof(D3DVALUE)); 1203 } 1204 1205 HRESULT 1206 hr_ddraw_from_wined3d(HRESULT hr) 1207 { 1208 switch(hr) 1209 { 1210 case WINED3DERR_INVALIDCALL: return DDERR_INVALIDPARAMS; 1211 default: return hr; 1212 } 1213 } 1214 1215 /* Note that this function writes the full sizeof(DDSURFACEDESC2) size, don't use it 1216 * for writing into application-provided DDSURFACEDESC2 structures if the size may 1217 * be different */ 1218 void DDSD_to_DDSD2(const DDSURFACEDESC *in, DDSURFACEDESC2 *out) 1219 { 1220 /* The output of this function is never passed to the application directly, so 1221 * the memset is not strictly needed. CreateSurface still has problems with this 1222 * though. Don't forget to set ddsCaps.dwCaps2/3/4 to 0 when removing this */ 1223 memset(out, 0x00, sizeof(*out)); 1224 out->dwSize = sizeof(*out); 1225 out->dwFlags = in->dwFlags & ~DDSD_ZBUFFERBITDEPTH; 1226 if (in->dwFlags & DDSD_WIDTH) out->dwWidth = in->dwWidth; 1227 if (in->dwFlags & DDSD_HEIGHT) out->dwHeight = in->dwHeight; 1228 if (in->dwFlags & DDSD_PIXELFORMAT) out->u4.ddpfPixelFormat = in->ddpfPixelFormat; 1229 else if(in->dwFlags & DDSD_ZBUFFERBITDEPTH) 1230 { 1231 out->dwFlags |= DDSD_PIXELFORMAT; 1232 memset(&out->u4.ddpfPixelFormat, 0, sizeof(out->u4.ddpfPixelFormat)); 1233 out->u4.ddpfPixelFormat.dwSize = sizeof(out->u4.ddpfPixelFormat); 1234 out->u4.ddpfPixelFormat.dwFlags = DDPF_ZBUFFER; 1235 out->u4.ddpfPixelFormat.u1.dwZBufferBitDepth = in->u2.dwZBufferBitDepth; 1236 /* 0 is not a valid DDSURFACEDESC / DDPIXELFORMAT on either side of the 1237 * conversion */ 1238 out->u4.ddpfPixelFormat.u3.dwZBitMask = ~0U >> (32 - in->u2.dwZBufferBitDepth); 1239 } 1240 /* ddsCaps is read even without DDSD_CAPS set. See dsurface:no_ddsd_caps_test */ 1241 out->ddsCaps.dwCaps = in->ddsCaps.dwCaps; 1242 if (in->dwFlags & DDSD_PITCH) out->u1.lPitch = in->u1.lPitch; 1243 if (in->dwFlags & DDSD_BACKBUFFERCOUNT) out->u5.dwBackBufferCount = in->dwBackBufferCount; 1244 if (in->dwFlags & DDSD_ALPHABITDEPTH) out->dwAlphaBitDepth = in->dwAlphaBitDepth; 1245 /* DDraw(native, and wine) does not set the DDSD_LPSURFACE, so always copy */ 1246 out->lpSurface = in->lpSurface; 1247 if (in->dwFlags & DDSD_CKDESTOVERLAY) out->u3.ddckCKDestOverlay = in->ddckCKDestOverlay; 1248 if (in->dwFlags & DDSD_CKDESTBLT) out->ddckCKDestBlt = in->ddckCKDestBlt; 1249 if (in->dwFlags & DDSD_CKSRCOVERLAY) out->ddckCKSrcOverlay = in->ddckCKSrcOverlay; 1250 if (in->dwFlags & DDSD_CKSRCBLT) out->ddckCKSrcBlt = in->ddckCKSrcBlt; 1251 if (in->dwFlags & DDSD_MIPMAPCOUNT) out->u2.dwMipMapCount = in->u2.dwMipMapCount; 1252 if (in->dwFlags & DDSD_REFRESHRATE) out->u2.dwRefreshRate = in->u2.dwRefreshRate; 1253 if (in->dwFlags & DDSD_LINEARSIZE) out->u1.dwLinearSize = in->u1.dwLinearSize; 1254 /* Does not exist in DDSURFACEDESC: 1255 * DDSD_TEXTURESTAGE, DDSD_FVF, DDSD_SRCVBHANDLE, 1256 */ 1257 } 1258 1259 /* Note that this function writes the full sizeof(DDSURFACEDESC) size, don't use it 1260 * for writing into application-provided DDSURFACEDESC structures if the size may 1261 * be different */ 1262 void DDSD2_to_DDSD(const DDSURFACEDESC2 *in, DDSURFACEDESC *out) 1263 { 1264 memset(out, 0, sizeof(*out)); 1265 out->dwSize = sizeof(*out); 1266 out->dwFlags = in->dwFlags; 1267 if (in->dwFlags & DDSD_WIDTH) out->dwWidth = in->dwWidth; 1268 if (in->dwFlags & DDSD_HEIGHT) out->dwHeight = in->dwHeight; 1269 if (in->dwFlags & DDSD_PIXELFORMAT) 1270 { 1271 out->ddpfPixelFormat = in->u4.ddpfPixelFormat; 1272 if ((in->dwFlags & DDSD_CAPS) && (in->ddsCaps.dwCaps & DDSCAPS_ZBUFFER)) 1273 { 1274 /* Z buffers have DDSD_ZBUFFERBITDEPTH set, but not DDSD_PIXELFORMAT. They do 1275 * have valid data in ddpfPixelFormat though */ 1276 out->dwFlags &= ~DDSD_PIXELFORMAT; 1277 out->dwFlags |= DDSD_ZBUFFERBITDEPTH; 1278 out->u2.dwZBufferBitDepth = in->u4.ddpfPixelFormat.u1.dwZBufferBitDepth; 1279 } 1280 } 1281 /* ddsCaps is read even without DDSD_CAPS set. See dsurface:no_ddsd_caps_test */ 1282 out->ddsCaps.dwCaps = in->ddsCaps.dwCaps; 1283 if (in->dwFlags & DDSD_PITCH) out->u1.lPitch = in->u1.lPitch; 1284 if (in->dwFlags & DDSD_BACKBUFFERCOUNT) out->dwBackBufferCount = in->u5.dwBackBufferCount; 1285 if (in->dwFlags & DDSD_ZBUFFERBITDEPTH) out->u2.dwZBufferBitDepth = in->u2.dwMipMapCount; /* same union */ 1286 if (in->dwFlags & DDSD_ALPHABITDEPTH) out->dwAlphaBitDepth = in->dwAlphaBitDepth; 1287 /* DDraw(native, and wine) does not set the DDSD_LPSURFACE, so always copy */ 1288 out->lpSurface = in->lpSurface; 1289 if (in->dwFlags & DDSD_CKDESTOVERLAY) out->ddckCKDestOverlay = in->u3.ddckCKDestOverlay; 1290 if (in->dwFlags & DDSD_CKDESTBLT) out->ddckCKDestBlt = in->ddckCKDestBlt; 1291 if (in->dwFlags & DDSD_CKSRCOVERLAY) out->ddckCKSrcOverlay = in->ddckCKSrcOverlay; 1292 if (in->dwFlags & DDSD_CKSRCBLT) out->ddckCKSrcBlt = in->ddckCKSrcBlt; 1293 if (in->dwFlags & DDSD_MIPMAPCOUNT) out->u2.dwMipMapCount = in->u2.dwMipMapCount; 1294 if (in->dwFlags & DDSD_REFRESHRATE) out->u2.dwRefreshRate = in->u2.dwRefreshRate; 1295 if (in->dwFlags & DDSD_LINEARSIZE) out->u1.dwLinearSize = in->u1.dwLinearSize; 1296 /* Does not exist in DDSURFACEDESC: 1297 * DDSD_TEXTURESTAGE, DDSD_FVF, DDSD_SRCVBHANDLE, 1298 */ 1299 if (in->dwFlags & DDSD_TEXTURESTAGE) WARN("Does not exist in DDSURFACEDESC: DDSD_TEXTURESTAGE\n"); 1300 if (in->dwFlags & DDSD_FVF) WARN("Does not exist in DDSURFACEDESC: DDSD_FVF\n"); 1301 if (in->dwFlags & DDSD_SRCVBHANDLE) WARN("Does not exist in DDSURFACEDESC: DDSD_SRCVBHANDLE\n"); 1302 out->dwFlags &= ~(DDSD_TEXTURESTAGE | DDSD_FVF | DDSD_SRCVBHANDLE); 1303 } 1304