ReactOS Development > Doxygen
utils.c
Go to the documentation of this file.
00001 /* 00002 * DirectDraw helper functions 00003 * 00004 * Copyright (c) 1997-2000 Marcus Meissner 00005 * Copyright (c) 1998 Lionel Ulmer 00006 * Copyright (c) 2000 TransGaming Technologies Inc. 00007 * Copyright (c) 2006 Stefan Dösinger 00008 * 00009 * This library is free software; you can redistribute it and/or 00010 * modify it under the terms of the GNU Lesser General Public 00011 * License as published by the Free Software Foundation; either 00012 * version 2.1 of the License, or (at your option) any later version. 00013 * 00014 * This library is distributed in the hope that it will be useful, 00015 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00016 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00017 * Lesser General Public License for more details. 00018 * 00019 * You should have received a copy of the GNU Lesser General Public 00020 * License along with this library; if not, write to the Free Software 00021 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 00022 */ 00023 00024 #include "config.h" 00025 #include "wine/port.h" 00026 00027 #include "ddraw_private.h" 00028 00029 WINE_DEFAULT_DEBUG_CHANNEL(ddraw); 00030 00031 static void DDRAW_dump_pixelformat(const DDPIXELFORMAT *pf); 00032 00033 /***************************************************************************** 00034 * PixelFormat_WineD3DtoDD 00035 * 00036 * Converts an wined3d format ID into a DDPIXELFORMAT structure 00037 * 00038 * Params: 00039 * DDPixelFormat: Address of the structure to write the pixel format to 00040 * WineD3DFormat: Source format 00041 * 00042 *****************************************************************************/ 00043 void PixelFormat_WineD3DtoDD(DDPIXELFORMAT *DDPixelFormat, enum wined3d_format_id WineD3DFormat) 00044 { 00045 DWORD Size = DDPixelFormat->dwSize; 00046 TRACE("Converting wined3d format %#x to DDRAW.\n", WineD3DFormat); 00047 00048 if(Size==0) return; 00049 00050 memset(DDPixelFormat, 0x00, Size); 00051 DDPixelFormat->dwSize = Size; 00052 switch(WineD3DFormat) 00053 { 00054 case WINED3DFMT_B8G8R8_UNORM: 00055 DDPixelFormat->dwFlags = DDPF_RGB; 00056 DDPixelFormat->dwFourCC = 0; 00057 DDPixelFormat->u1.dwRGBBitCount = 24; 00058 DDPixelFormat->u2.dwRBitMask = 0x00ff0000; 00059 DDPixelFormat->u3.dwGBitMask = 0x0000ff00; 00060 DDPixelFormat->u4.dwBBitMask = 0x000000ff; 00061 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0; 00062 break; 00063 00064 case WINED3DFMT_B8G8R8A8_UNORM: 00065 DDPixelFormat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS; 00066 DDPixelFormat->dwFourCC = 0; 00067 DDPixelFormat->u1.dwRGBBitCount = 32; 00068 DDPixelFormat->u2.dwRBitMask = 0x00ff0000; 00069 DDPixelFormat->u3.dwGBitMask = 0x0000ff00; 00070 DDPixelFormat->u4.dwBBitMask = 0x000000ff; 00071 DDPixelFormat->u5.dwRGBAlphaBitMask = 0xff000000; 00072 break; 00073 00074 case WINED3DFMT_B8G8R8X8_UNORM: 00075 DDPixelFormat->dwFlags = DDPF_RGB; 00076 DDPixelFormat->dwFourCC = 0; 00077 DDPixelFormat->u1.dwRGBBitCount = 32; 00078 DDPixelFormat->u2.dwRBitMask = 0x00ff0000; 00079 DDPixelFormat->u3.dwGBitMask = 0x0000ff00; 00080 DDPixelFormat->u4.dwBBitMask = 0x000000ff; 00081 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0; 00082 break; 00083 00084 case WINED3DFMT_R8G8B8X8_UNORM: 00085 DDPixelFormat->dwFlags = DDPF_RGB; 00086 DDPixelFormat->dwFourCC = 0; 00087 DDPixelFormat->u1.dwRGBBitCount = 32; 00088 DDPixelFormat->u2.dwRBitMask = 0x000000ff; 00089 DDPixelFormat->u3.dwGBitMask = 0x0000ff00; 00090 DDPixelFormat->u4.dwBBitMask = 0x00ff0000; 00091 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0; 00092 break; 00093 00094 case WINED3DFMT_B5G6R5_UNORM: 00095 DDPixelFormat->dwFlags = DDPF_RGB; 00096 DDPixelFormat->dwFourCC = 0; 00097 DDPixelFormat->u1.dwRGBBitCount = 16; 00098 DDPixelFormat->u2.dwRBitMask = 0xF800; 00099 DDPixelFormat->u3.dwGBitMask = 0x07E0; 00100 DDPixelFormat->u4.dwBBitMask = 0x001F; 00101 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0; 00102 break; 00103 00104 case WINED3DFMT_B5G5R5X1_UNORM: 00105 DDPixelFormat->dwFlags = DDPF_RGB; 00106 DDPixelFormat->dwFourCC = 0; 00107 DDPixelFormat->u1.dwRGBBitCount = 16; 00108 DDPixelFormat->u2.dwRBitMask = 0x7C00; 00109 DDPixelFormat->u3.dwGBitMask = 0x03E0; 00110 DDPixelFormat->u4.dwBBitMask = 0x001F; 00111 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0; 00112 break; 00113 00114 case WINED3DFMT_B5G5R5A1_UNORM: 00115 DDPixelFormat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS; 00116 DDPixelFormat->dwFourCC = 0; 00117 DDPixelFormat->u1.dwRGBBitCount = 16; 00118 DDPixelFormat->u2.dwRBitMask = 0x7C00; 00119 DDPixelFormat->u3.dwGBitMask = 0x03E0; 00120 DDPixelFormat->u4.dwBBitMask = 0x001F; 00121 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x8000; 00122 break; 00123 00124 case WINED3DFMT_B4G4R4A4_UNORM: 00125 DDPixelFormat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS; 00126 DDPixelFormat->dwFourCC = 0; 00127 DDPixelFormat->u1.dwRGBBitCount = 16; 00128 DDPixelFormat->u2.dwRBitMask = 0x0F00; 00129 DDPixelFormat->u3.dwGBitMask = 0x00F0; 00130 DDPixelFormat->u4.dwBBitMask = 0x000F; 00131 DDPixelFormat->u5.dwRGBAlphaBitMask = 0xF000; 00132 break; 00133 00134 case WINED3DFMT_B2G3R3_UNORM: 00135 DDPixelFormat->dwFlags = DDPF_RGB; 00136 DDPixelFormat->dwFourCC = 0; 00137 DDPixelFormat->u1.dwRGBBitCount = 8; 00138 DDPixelFormat->u2.dwRBitMask = 0xE0; 00139 DDPixelFormat->u3.dwGBitMask = 0x1C; 00140 DDPixelFormat->u4.dwBBitMask = 0x03; 00141 DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0x0; 00142 break; 00143 00144 case WINED3DFMT_P8_UINT: 00145 DDPixelFormat->dwFlags = DDPF_PALETTEINDEXED8 | DDPF_RGB; 00146 DDPixelFormat->dwFourCC = 0; 00147 DDPixelFormat->u1.dwRGBBitCount = 8; 00148 DDPixelFormat->u2.dwRBitMask = 0x00; 00149 DDPixelFormat->u3.dwGBitMask = 0x00; 00150 DDPixelFormat->u4.dwBBitMask = 0x00; 00151 break; 00152 00153 case WINED3DFMT_A8_UNORM: 00154 DDPixelFormat->dwFlags = DDPF_ALPHA; 00155 DDPixelFormat->dwFourCC = 0; 00156 DDPixelFormat->u1.dwAlphaBitDepth = 8; 00157 DDPixelFormat->u2.dwRBitMask = 0x0; 00158 DDPixelFormat->u3.dwZBitMask = 0x0; 00159 DDPixelFormat->u4.dwStencilBitMask = 0x0; 00160 DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0x0; 00161 break; 00162 00163 case WINED3DFMT_B2G3R3A8_UNORM: 00164 DDPixelFormat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS; 00165 DDPixelFormat->dwFourCC = 0; 00166 DDPixelFormat->u1.dwRGBBitCount = 16; 00167 DDPixelFormat->u2.dwRBitMask = 0x00E0; 00168 DDPixelFormat->u3.dwGBitMask = 0x001C; 00169 DDPixelFormat->u4.dwBBitMask = 0x0003; 00170 DDPixelFormat->u5.dwRGBAlphaBitMask = 0xFF00; 00171 break; 00172 00173 case WINED3DFMT_B4G4R4X4_UNORM: 00174 DDPixelFormat->dwFlags = DDPF_RGB; 00175 DDPixelFormat->dwFourCC = 0; 00176 DDPixelFormat->u1.dwRGBBitCount = 16; 00177 DDPixelFormat->u2.dwRBitMask = 0x0F00; 00178 DDPixelFormat->u3.dwGBitMask = 0x00F0; 00179 DDPixelFormat->u4.dwBBitMask = 0x000F; 00180 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0; 00181 break; 00182 00183 /* How are Z buffer bit depth and Stencil buffer bit depth related? 00184 */ 00185 case WINED3DFMT_D16_UNORM: 00186 DDPixelFormat->dwFlags = DDPF_ZBUFFER; 00187 DDPixelFormat->dwFourCC = 0; 00188 DDPixelFormat->u1.dwZBufferBitDepth = 16; 00189 DDPixelFormat->u2.dwStencilBitDepth = 0; 00190 DDPixelFormat->u3.dwZBitMask = 0x0000FFFF; 00191 DDPixelFormat->u4.dwStencilBitMask = 0x0; 00192 DDPixelFormat->u5.dwRGBZBitMask = 0x00000000; 00193 break; 00194 00195 case WINED3DFMT_D32_UNORM: 00196 DDPixelFormat->dwFlags = DDPF_ZBUFFER; 00197 DDPixelFormat->dwFourCC = 0; 00198 DDPixelFormat->u1.dwZBufferBitDepth = 32; 00199 DDPixelFormat->u2.dwStencilBitDepth = 0; 00200 DDPixelFormat->u3.dwZBitMask = 0xFFFFFFFF; 00201 DDPixelFormat->u4.dwStencilBitMask = 0x0; 00202 DDPixelFormat->u5.dwRGBZBitMask = 0x00000000; 00203 break; 00204 00205 case WINED3DFMT_S4X4_UINT_D24_UNORM: 00206 DDPixelFormat->dwFlags = DDPF_ZBUFFER | DDPF_STENCILBUFFER; 00207 DDPixelFormat->dwFourCC = 0; 00208 /* Should I set dwZBufferBitDepth to 32 here? */ 00209 DDPixelFormat->u1.dwZBufferBitDepth = 32; 00210 DDPixelFormat->u2.dwStencilBitDepth = 4; 00211 DDPixelFormat->u3.dwZBitMask = 0x00FFFFFF; 00212 DDPixelFormat->u4.dwStencilBitMask = 0x0F000000; 00213 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0; 00214 break; 00215 00216 case WINED3DFMT_D24_UNORM_S8_UINT: 00217 DDPixelFormat->dwFlags = DDPF_ZBUFFER | DDPF_STENCILBUFFER; 00218 DDPixelFormat->dwFourCC = 0; 00219 DDPixelFormat->u1.dwZBufferBitDepth = 32; 00220 DDPixelFormat->u2.dwStencilBitDepth = 8; 00221 DDPixelFormat->u3.dwZBitMask = 0x00FFFFFF; 00222 DDPixelFormat->u4.dwStencilBitMask = 0xFF000000; 00223 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0; 00224 break; 00225 00226 case WINED3DFMT_X8D24_UNORM: 00227 DDPixelFormat->dwFlags = DDPF_ZBUFFER; 00228 DDPixelFormat->dwFourCC = 0; 00229 DDPixelFormat->u1.dwZBufferBitDepth = 32; 00230 DDPixelFormat->u2.dwStencilBitDepth = 0; 00231 DDPixelFormat->u3.dwZBitMask = 0x00FFFFFF; 00232 DDPixelFormat->u4.dwStencilBitMask = 0x00000000; 00233 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0; 00234 break; 00235 00236 case WINED3DFMT_S1_UINT_D15_UNORM: 00237 DDPixelFormat->dwFlags = DDPF_ZBUFFER | DDPF_STENCILBUFFER; 00238 DDPixelFormat->dwFourCC = 0; 00239 DDPixelFormat->u1.dwZBufferBitDepth = 16; 00240 DDPixelFormat->u2.dwStencilBitDepth = 1; 00241 DDPixelFormat->u3.dwZBitMask = 0x7fff; 00242 DDPixelFormat->u4.dwStencilBitMask = 0x8000; 00243 DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0; 00244 break; 00245 00246 case WINED3DFMT_UYVY: 00247 case WINED3DFMT_YUY2: 00248 DDPixelFormat->u1.dwYUVBitCount = 16; 00249 DDPixelFormat->dwFlags = DDPF_FOURCC; 00250 DDPixelFormat->dwFourCC = WineD3DFormat; 00251 break; 00252 00253 case WINED3DFMT_YV12: 00254 DDPixelFormat->u1.dwYUVBitCount = 12; 00255 DDPixelFormat->dwFlags = DDPF_FOURCC; 00256 DDPixelFormat->dwFourCC = WineD3DFormat; 00257 break; 00258 00259 case WINED3DFMT_DXT1: 00260 case WINED3DFMT_DXT2: 00261 case WINED3DFMT_DXT3: 00262 case WINED3DFMT_DXT4: 00263 case WINED3DFMT_DXT5: 00264 case WINED3DFMT_MULTI2_ARGB8: 00265 case WINED3DFMT_G8R8_G8B8: 00266 case WINED3DFMT_R8G8_B8G8: 00267 DDPixelFormat->dwFlags = DDPF_FOURCC; 00268 DDPixelFormat->dwFourCC = WineD3DFormat; 00269 break; 00270 00271 /* Luminance */ 00272 case WINED3DFMT_L8_UNORM: 00273 DDPixelFormat->dwFlags = DDPF_LUMINANCE; 00274 DDPixelFormat->dwFourCC = 0; 00275 DDPixelFormat->u1.dwLuminanceBitCount = 8; 00276 DDPixelFormat->u2.dwLuminanceBitMask = 0xff; 00277 DDPixelFormat->u3.dwBumpDvBitMask = 0x0; 00278 DDPixelFormat->u4.dwBumpLuminanceBitMask = 0x0; 00279 DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0x0; 00280 break; 00281 00282 case WINED3DFMT_L4A4_UNORM: 00283 DDPixelFormat->dwFlags = DDPF_ALPHAPIXELS | DDPF_LUMINANCE; 00284 DDPixelFormat->dwFourCC = 0; 00285 DDPixelFormat->u1.dwLuminanceBitCount = 4; 00286 DDPixelFormat->u2.dwLuminanceBitMask = 0x0f; 00287 DDPixelFormat->u3.dwBumpDvBitMask = 0x0; 00288 DDPixelFormat->u4.dwBumpLuminanceBitMask = 0x0; 00289 DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0xf0; 00290 break; 00291 00292 case WINED3DFMT_L8A8_UNORM: 00293 DDPixelFormat->dwFlags = DDPF_ALPHAPIXELS | DDPF_LUMINANCE; 00294 DDPixelFormat->dwFourCC = 0; 00295 DDPixelFormat->u1.dwLuminanceBitCount = 16; 00296 DDPixelFormat->u2.dwLuminanceBitMask = 0x00ff; 00297 DDPixelFormat->u3.dwBumpDvBitMask = 0x0; 00298 DDPixelFormat->u4.dwBumpLuminanceBitMask = 0x0; 00299 DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0xff00; 00300 break; 00301 00302 /* Bump mapping */ 00303 case WINED3DFMT_R8G8_SNORM: 00304 DDPixelFormat->dwFlags = DDPF_BUMPDUDV; 00305 DDPixelFormat->dwFourCC = 0; 00306 DDPixelFormat->u1.dwBumpBitCount = 16; 00307 DDPixelFormat->u2.dwBumpDuBitMask = 0x000000ff; 00308 DDPixelFormat->u3.dwBumpDvBitMask = 0x0000ff00; 00309 DDPixelFormat->u4.dwBumpLuminanceBitMask = 0x00000000; 00310 DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0x00000000; 00311 break; 00312 00313 case WINED3DFMT_R16G16_SNORM: 00314 DDPixelFormat->dwFlags = DDPF_BUMPDUDV; 00315 DDPixelFormat->dwFourCC = 0; 00316 DDPixelFormat->u1.dwBumpBitCount = 32; 00317 DDPixelFormat->u2.dwBumpDuBitMask = 0x0000ffff; 00318 DDPixelFormat->u3.dwBumpDvBitMask = 0xffff0000; 00319 DDPixelFormat->u4.dwBumpLuminanceBitMask = 0x00000000; 00320 DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0x00000000; 00321 break; 00322 00323 case WINED3DFMT_R5G5_SNORM_L6_UNORM: 00324 DDPixelFormat->dwFlags = DDPF_BUMPDUDV; 00325 DDPixelFormat->dwFourCC = 0; 00326 DDPixelFormat->u1.dwBumpBitCount = 16; 00327 DDPixelFormat->u2.dwBumpDuBitMask = 0x0000001f; 00328 DDPixelFormat->u3.dwBumpDvBitMask = 0x000003e0; 00329 DDPixelFormat->u4.dwBumpLuminanceBitMask = 0x0000fc00; 00330 DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0x00000000; 00331 break; 00332 00333 case WINED3DFMT_R8G8_SNORM_L8X8_UNORM: 00334 DDPixelFormat->dwFlags = DDPF_BUMPDUDV; 00335 DDPixelFormat->dwFourCC = 0; 00336 DDPixelFormat->u1.dwBumpBitCount = 32; 00337 DDPixelFormat->u2.dwBumpDuBitMask = 0x000000ff; 00338 DDPixelFormat->u3.dwBumpDvBitMask = 0x0000ff00; 00339 DDPixelFormat->u4.dwBumpLuminanceBitMask = 0x00ff0000; 00340 DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0x00000000; 00341 break; 00342 00343 default: 00344 ERR("Can't translate this Pixelformat %d\n", WineD3DFormat); 00345 } 00346 00347 if(TRACE_ON(ddraw)) { 00348 TRACE("Returning: "); 00349 DDRAW_dump_pixelformat(DDPixelFormat); 00350 } 00351 } 00352 /***************************************************************************** 00353 * PixelFormat_DD2WineD3D 00354 * 00355 * Reads a DDPIXELFORMAT structure and returns the equivalent wined3d 00356 * format ID. 00357 * 00358 * Params: 00359 * DDPixelFormat: The source format 00360 * 00361 * Returns: 00362 * The wined3d format ID equivalent to the DDraw format 00363 * WINED3DFMT_UNKNOWN if a matching format wasn't found 00364 *****************************************************************************/ 00365 enum wined3d_format_id PixelFormat_DD2WineD3D(const DDPIXELFORMAT *DDPixelFormat) 00366 { 00367 TRACE("Convert a DirectDraw Pixelformat to a WineD3D Pixelformat\n"); 00368 if(TRACE_ON(ddraw)) 00369 { 00370 DDRAW_dump_pixelformat(DDPixelFormat); 00371 } 00372 00373 if(DDPixelFormat->dwFlags & DDPF_PALETTEINDEXED8) 00374 { 00375 return WINED3DFMT_P8_UINT; 00376 } 00377 else if(DDPixelFormat->dwFlags & (DDPF_PALETTEINDEXED1 | DDPF_PALETTEINDEXED2 | DDPF_PALETTEINDEXED4) ) 00378 { 00379 FIXME("DDPF_PALETTEINDEXED1 to DDPF_PALETTEINDEXED4 are not supported by WineD3D (yet). Returning WINED3DFMT_P8\n"); 00380 return WINED3DFMT_P8_UINT; 00381 } 00382 else if(DDPixelFormat->dwFlags & DDPF_RGB) 00383 { 00384 switch(DDPixelFormat->u1.dwRGBBitCount) 00385 { 00386 case 8: 00387 /* This is the only format that can match here */ 00388 return WINED3DFMT_B2G3R3_UNORM; 00389 00390 case 16: 00391 /* Read the Color masks */ 00392 if( (DDPixelFormat->u2.dwRBitMask == 0xF800) && 00393 (DDPixelFormat->u3.dwGBitMask == 0x07E0) && 00394 (DDPixelFormat->u4.dwBBitMask == 0x001F) ) 00395 { 00396 return WINED3DFMT_B5G6R5_UNORM; 00397 } 00398 00399 if( (DDPixelFormat->u2.dwRBitMask == 0x7C00) && 00400 (DDPixelFormat->u3.dwGBitMask == 0x03E0) && 00401 (DDPixelFormat->u4.dwBBitMask == 0x001F) ) 00402 { 00403 if( (DDPixelFormat->dwFlags & DDPF_ALPHAPIXELS) && 00404 (DDPixelFormat->u5.dwRGBAlphaBitMask == 0x8000)) 00405 return WINED3DFMT_B5G5R5A1_UNORM; 00406 else 00407 return WINED3DFMT_B5G5R5X1_UNORM; 00408 } 00409 00410 if( (DDPixelFormat->u2.dwRBitMask == 0x0F00) && 00411 (DDPixelFormat->u3.dwGBitMask == 0x00F0) && 00412 (DDPixelFormat->u4.dwBBitMask == 0x000F) ) 00413 { 00414 if( (DDPixelFormat->dwFlags & DDPF_ALPHAPIXELS) && 00415 (DDPixelFormat->u5.dwRGBAlphaBitMask == 0xF000)) 00416 return WINED3DFMT_B4G4R4A4_UNORM; 00417 else 00418 return WINED3DFMT_B4G4R4X4_UNORM; 00419 } 00420 00421 if( (DDPixelFormat->dwFlags & DDPF_ALPHAPIXELS) && 00422 (DDPixelFormat->u5.dwRGBAlphaBitMask == 0xFF00) && 00423 (DDPixelFormat->u2.dwRBitMask == 0x00E0) && 00424 (DDPixelFormat->u3.dwGBitMask == 0x001C) && 00425 (DDPixelFormat->u4.dwBBitMask == 0x0003) ) 00426 { 00427 return WINED3DFMT_B2G3R3A8_UNORM; 00428 } 00429 WARN("16 bit RGB Pixel format does not match.\n"); 00430 return WINED3DFMT_UNKNOWN; 00431 00432 case 24: 00433 return WINED3DFMT_B8G8R8_UNORM; 00434 00435 case 32: 00436 /* Read the Color masks */ 00437 if( (DDPixelFormat->u2.dwRBitMask == 0x00FF0000) && 00438 (DDPixelFormat->u3.dwGBitMask == 0x0000FF00) && 00439 (DDPixelFormat->u4.dwBBitMask == 0x000000FF) ) 00440 { 00441 if( (DDPixelFormat->dwFlags & DDPF_ALPHAPIXELS) && 00442 (DDPixelFormat->u5.dwRGBAlphaBitMask == 0xFF000000)) 00443 return WINED3DFMT_B8G8R8A8_UNORM; 00444 else 00445 return WINED3DFMT_B8G8R8X8_UNORM; 00446 00447 } 00448 WARN("32 bit RGB pixel format does not match.\n"); 00449 00450 default: 00451 WARN("Invalid dwRGBBitCount in Pixelformat structure.\n"); 00452 return WINED3DFMT_UNKNOWN; 00453 } 00454 } 00455 else if( (DDPixelFormat->dwFlags & DDPF_ALPHA) ) 00456 { 00457 /* Alpha only Pixelformat */ 00458 switch(DDPixelFormat->u1.dwAlphaBitDepth) 00459 { 00460 case 1: 00461 case 2: 00462 case 4: 00463 FIXME("Unsupported Alpha-Only bit depth 0x%x.\n", DDPixelFormat->u1.dwAlphaBitDepth); 00464 case 8: 00465 return WINED3DFMT_A8_UNORM; 00466 00467 default: 00468 WARN("Invalid AlphaBitDepth in Alpha-Only Pixelformat.\n"); 00469 return WINED3DFMT_UNKNOWN; 00470 } 00471 } 00472 else if(DDPixelFormat->dwFlags & DDPF_LUMINANCE) 00473 { 00474 /* Luminance-only or luminance-alpha */ 00475 if(DDPixelFormat->dwFlags & DDPF_ALPHAPIXELS) 00476 { 00477 /* Luminance with Alpha */ 00478 switch(DDPixelFormat->u1.dwLuminanceBitCount) 00479 { 00480 case 4: 00481 if(DDPixelFormat->u1.dwAlphaBitDepth == 4) 00482 return WINED3DFMT_L4A4_UNORM; 00483 WARN("Unknown Alpha / Luminance bit depth combination.\n"); 00484 return WINED3DFMT_UNKNOWN; 00485 00486 case 6: 00487 FIXME("A luminance Pixelformat shouldn't have 6 luminance bits. Returning D3DFMT_L6V5U5 for now.\n"); 00488 return WINED3DFMT_R5G5_SNORM_L6_UNORM; 00489 00490 case 8: 00491 if(DDPixelFormat->u1.dwAlphaBitDepth == 8) 00492 return WINED3DFMT_L8A8_UNORM; 00493 WARN("Unknown Alpha / Lumincase bit depth combination.\n"); 00494 return WINED3DFMT_UNKNOWN; 00495 } 00496 } 00497 else 00498 { 00499 /* Luminance-only */ 00500 switch(DDPixelFormat->u1.dwLuminanceBitCount) 00501 { 00502 case 6: 00503 FIXME("A luminance Pixelformat shouldn't have 6 luminance bits. Returning D3DFMT_L6V5U5 for now.\n"); 00504 return WINED3DFMT_R5G5_SNORM_L6_UNORM; 00505 00506 case 8: 00507 return WINED3DFMT_L8_UNORM; 00508 00509 default: 00510 WARN("Unknown luminance-only bit depth 0x%x.\n", DDPixelFormat->u1.dwLuminanceBitCount); 00511 return WINED3DFMT_UNKNOWN; 00512 } 00513 } 00514 } 00515 else if(DDPixelFormat->dwFlags & DDPF_ZBUFFER) 00516 { 00517 /* Z buffer */ 00518 if(DDPixelFormat->dwFlags & DDPF_STENCILBUFFER) 00519 { 00520 switch(DDPixelFormat->u1.dwZBufferBitDepth) 00521 { 00522 case 16: 00523 if (DDPixelFormat->u2.dwStencilBitDepth == 1) return WINED3DFMT_S1_UINT_D15_UNORM; 00524 WARN("Unknown depth stenil format: 16 z bits, %u stencil bits\n", 00525 DDPixelFormat->u2.dwStencilBitDepth); 00526 return WINED3DFMT_UNKNOWN; 00527 00528 case 32: 00529 if (DDPixelFormat->u2.dwStencilBitDepth == 8) return WINED3DFMT_D24_UNORM_S8_UINT; 00530 else if (DDPixelFormat->u2.dwStencilBitDepth == 4) return WINED3DFMT_S4X4_UINT_D24_UNORM; 00531 WARN("Unknown depth stenil format: 32 z bits, %u stencil bits\n", 00532 DDPixelFormat->u2.dwStencilBitDepth); 00533 return WINED3DFMT_UNKNOWN; 00534 00535 default: 00536 WARN("Unknown depth stenil format: %u z bits, %u stencil bits\n", 00537 DDPixelFormat->u1.dwZBufferBitDepth, DDPixelFormat->u2.dwStencilBitDepth); 00538 return WINED3DFMT_UNKNOWN; 00539 } 00540 } 00541 else 00542 { 00543 switch(DDPixelFormat->u1.dwZBufferBitDepth) 00544 { 00545 case 16: 00546 return WINED3DFMT_D16_UNORM; 00547 00548 case 24: 00549 return WINED3DFMT_X8D24_UNORM; 00550 00551 case 32: 00552 if (DDPixelFormat->u3.dwZBitMask == 0x00FFFFFF) return WINED3DFMT_X8D24_UNORM; 00553 else if (DDPixelFormat->u3.dwZBitMask == 0xFFFFFF00) return WINED3DFMT_X8D24_UNORM; 00554 else if (DDPixelFormat->u3.dwZBitMask == 0xFFFFFFFF) return WINED3DFMT_D32_UNORM; 00555 WARN("Unknown depth-only format: 32 z bits, mask 0x%08x\n", 00556 DDPixelFormat->u3.dwZBitMask); 00557 return WINED3DFMT_UNKNOWN; 00558 00559 default: 00560 WARN("Unknown depth-only format: %u z bits, mask 0x%08x\n", 00561 DDPixelFormat->u1.dwZBufferBitDepth, DDPixelFormat->u3.dwZBitMask); 00562 return WINED3DFMT_UNKNOWN; 00563 } 00564 } 00565 } 00566 else if(DDPixelFormat->dwFlags & DDPF_FOURCC) 00567 { 00568 return DDPixelFormat->dwFourCC; 00569 } 00570 else if(DDPixelFormat->dwFlags & DDPF_BUMPDUDV) 00571 { 00572 if( (DDPixelFormat->u1.dwBumpBitCount == 16 ) && 00573 (DDPixelFormat->u2.dwBumpDuBitMask == 0x000000ff) && 00574 (DDPixelFormat->u3.dwBumpDvBitMask == 0x0000ff00) && 00575 (DDPixelFormat->u4.dwBumpLuminanceBitMask == 0x00000000) ) 00576 { 00577 return WINED3DFMT_R8G8_SNORM; 00578 } 00579 else if ( (DDPixelFormat->u1.dwBumpBitCount == 32 ) && 00580 (DDPixelFormat->u2.dwBumpDuBitMask == 0x0000ffff) && 00581 (DDPixelFormat->u3.dwBumpDvBitMask == 0xffff0000) && 00582 (DDPixelFormat->u4.dwBumpLuminanceBitMask == 0x00000000) ) 00583 { 00584 return WINED3DFMT_R16G16_SNORM; 00585 } 00586 else if ( (DDPixelFormat->u1.dwBumpBitCount == 16 ) && 00587 (DDPixelFormat->u2.dwBumpDuBitMask == 0x0000001f) && 00588 (DDPixelFormat->u3.dwBumpDvBitMask == 0x000003e0) && 00589 (DDPixelFormat->u4.dwBumpLuminanceBitMask == 0x0000fc00) ) 00590 { 00591 return WINED3DFMT_R5G5_SNORM_L6_UNORM; 00592 } 00593 else if ( (DDPixelFormat->u1.dwBumpBitCount == 32 ) && 00594 (DDPixelFormat->u2.dwBumpDuBitMask == 0x000000ff) && 00595 (DDPixelFormat->u3.dwBumpDvBitMask == 0x0000ff00) && 00596 (DDPixelFormat->u4.dwBumpLuminanceBitMask == 0x00ff0000) ) 00597 { 00598 return WINED3DFMT_R8G8_SNORM_L8X8_UNORM; 00599 } 00600 } 00601 00602 WARN("Unknown Pixelformat.\n"); 00603 return WINED3DFMT_UNKNOWN; 00604 } 00605 00606 /***************************************************************************** 00607 * Various dumping functions. 00608 * 00609 * They write the contents of a specific function to a TRACE. 00610 * 00611 *****************************************************************************/ 00612 static void 00613 DDRAW_dump_DWORD(const void *in) 00614 { 00615 TRACE("%d\n", *((const DWORD *) in)); 00616 } 00617 static void 00618 DDRAW_dump_PTR(const void *in) 00619 { 00620 TRACE("%p\n", *((const void * const*) in)); 00621 } 00622 static void 00623 DDRAW_dump_DDCOLORKEY(const DDCOLORKEY *ddck) 00624 { 00625 TRACE("Low : %d - High : %d\n", ddck->dwColorSpaceLowValue, ddck->dwColorSpaceHighValue); 00626 } 00627 00628 static void DDRAW_dump_flags_nolf(DWORD flags, const flag_info* names, 00629 size_t num_names) 00630 { 00631 unsigned int i; 00632 00633 for (i=0; i < num_names; i++) 00634 if ((flags & names[i].val) || /* standard flag value */ 00635 ((!flags) && (!names[i].val))) /* zero value only */ 00636 TRACE("%s ", names[i].name); 00637 } 00638 00639 static void DDRAW_dump_flags(DWORD flags, const flag_info* names, size_t num_names) 00640 { 00641 DDRAW_dump_flags_nolf(flags, names, num_names); 00642 TRACE("\n"); 00643 } 00644 00645 void DDRAW_dump_DDSCAPS2(const DDSCAPS2 *in) 00646 { 00647 static const flag_info flags[] = { 00648 FE(DDSCAPS_RESERVED1), 00649 FE(DDSCAPS_ALPHA), 00650 FE(DDSCAPS_BACKBUFFER), 00651 FE(DDSCAPS_COMPLEX), 00652 FE(DDSCAPS_FLIP), 00653 FE(DDSCAPS_FRONTBUFFER), 00654 FE(DDSCAPS_OFFSCREENPLAIN), 00655 FE(DDSCAPS_OVERLAY), 00656 FE(DDSCAPS_PALETTE), 00657 FE(DDSCAPS_PRIMARYSURFACE), 00658 FE(DDSCAPS_PRIMARYSURFACELEFT), 00659 FE(DDSCAPS_SYSTEMMEMORY), 00660 FE(DDSCAPS_TEXTURE), 00661 FE(DDSCAPS_3DDEVICE), 00662 FE(DDSCAPS_VIDEOMEMORY), 00663 FE(DDSCAPS_VISIBLE), 00664 FE(DDSCAPS_WRITEONLY), 00665 FE(DDSCAPS_ZBUFFER), 00666 FE(DDSCAPS_OWNDC), 00667 FE(DDSCAPS_LIVEVIDEO), 00668 FE(DDSCAPS_HWCODEC), 00669 FE(DDSCAPS_MODEX), 00670 FE(DDSCAPS_MIPMAP), 00671 FE(DDSCAPS_RESERVED2), 00672 FE(DDSCAPS_ALLOCONLOAD), 00673 FE(DDSCAPS_VIDEOPORT), 00674 FE(DDSCAPS_LOCALVIDMEM), 00675 FE(DDSCAPS_NONLOCALVIDMEM), 00676 FE(DDSCAPS_STANDARDVGAMODE), 00677 FE(DDSCAPS_OPTIMIZED) 00678 }; 00679 static const flag_info flags2[] = { 00680 FE(DDSCAPS2_HARDWAREDEINTERLACE), 00681 FE(DDSCAPS2_HINTDYNAMIC), 00682 FE(DDSCAPS2_HINTSTATIC), 00683 FE(DDSCAPS2_TEXTUREMANAGE), 00684 FE(DDSCAPS2_RESERVED1), 00685 FE(DDSCAPS2_RESERVED2), 00686 FE(DDSCAPS2_OPAQUE), 00687 FE(DDSCAPS2_HINTANTIALIASING), 00688 FE(DDSCAPS2_CUBEMAP), 00689 FE(DDSCAPS2_CUBEMAP_POSITIVEX), 00690 FE(DDSCAPS2_CUBEMAP_NEGATIVEX), 00691 FE(DDSCAPS2_CUBEMAP_POSITIVEY), 00692 FE(DDSCAPS2_CUBEMAP_NEGATIVEY), 00693 FE(DDSCAPS2_CUBEMAP_POSITIVEZ), 00694 FE(DDSCAPS2_CUBEMAP_NEGATIVEZ), 00695 FE(DDSCAPS2_MIPMAPSUBLEVEL), 00696 FE(DDSCAPS2_D3DTEXTUREMANAGE), 00697 FE(DDSCAPS2_DONOTPERSIST), 00698 FE(DDSCAPS2_STEREOSURFACELEFT) 00699 }; 00700 00701 DDRAW_dump_flags_nolf(in->dwCaps, flags, sizeof(flags)/sizeof(flags[0])); 00702 DDRAW_dump_flags(in->dwCaps2, flags2, sizeof(flags2)/sizeof(flags2[0])); 00703 } 00704 00705 static void 00706 DDRAW_dump_DDSCAPS(const DDSCAPS *in) 00707 { 00708 DDSCAPS2 in_bis; 00709 00710 in_bis.dwCaps = in->dwCaps; 00711 in_bis.dwCaps2 = 0; 00712 in_bis.dwCaps3 = 0; 00713 in_bis.u1.dwCaps4 = 0; 00714 00715 DDRAW_dump_DDSCAPS2(&in_bis); 00716 } 00717 00718 static void 00719 DDRAW_dump_pixelformat_flag(DWORD flagmask) 00720 { 00721 static const flag_info flags[] = 00722 { 00723 FE(DDPF_ALPHAPIXELS), 00724 FE(DDPF_ALPHA), 00725 FE(DDPF_FOURCC), 00726 FE(DDPF_PALETTEINDEXED4), 00727 FE(DDPF_PALETTEINDEXEDTO8), 00728 FE(DDPF_PALETTEINDEXED8), 00729 FE(DDPF_RGB), 00730 FE(DDPF_COMPRESSED), 00731 FE(DDPF_RGBTOYUV), 00732 FE(DDPF_YUV), 00733 FE(DDPF_ZBUFFER), 00734 FE(DDPF_PALETTEINDEXED1), 00735 FE(DDPF_PALETTEINDEXED2), 00736 FE(DDPF_ZPIXELS) 00737 }; 00738 00739 DDRAW_dump_flags_nolf(flagmask, flags, sizeof(flags)/sizeof(flags[0])); 00740 } 00741 00742 static void 00743 DDRAW_dump_members(DWORD flags, 00744 const void* data, 00745 const member_info* mems, 00746 size_t num_mems) 00747 { 00748 unsigned int i; 00749 00750 for (i=0; i < num_mems; i++) 00751 { 00752 if (mems[i].val & flags) 00753 { 00754 TRACE(" - %s : ", mems[i].name); 00755 mems[i].func((const char *)data + mems[i].offset); 00756 } 00757 } 00758 } 00759 00760 static void 00761 DDRAW_dump_pixelformat(const DDPIXELFORMAT *pf) 00762 { 00763 TRACE("( "); 00764 DDRAW_dump_pixelformat_flag(pf->dwFlags); 00765 if (pf->dwFlags & DDPF_FOURCC) 00766 { 00767 TRACE(", dwFourCC code '%c%c%c%c' (0x%08x) - %d bits per pixel", 00768 (unsigned char)( pf->dwFourCC &0xff), 00769 (unsigned char)((pf->dwFourCC>> 8)&0xff), 00770 (unsigned char)((pf->dwFourCC>>16)&0xff), 00771 (unsigned char)((pf->dwFourCC>>24)&0xff), 00772 pf->dwFourCC, 00773 pf->u1.dwYUVBitCount 00774 ); 00775 } 00776 if (pf->dwFlags & DDPF_RGB) 00777 { 00778 const char *cmd; 00779 TRACE(", RGB bits: %d, ", pf->u1.dwRGBBitCount); 00780 switch (pf->u1.dwRGBBitCount) 00781 { 00782 case 4: cmd = "%1lx"; break; 00783 case 8: cmd = "%02lx"; break; 00784 case 16: cmd = "%04lx"; break; 00785 case 24: cmd = "%06lx"; break; 00786 case 32: cmd = "%08lx"; break; 00787 default: ERR("Unexpected bit depth !\n"); cmd = "%d"; break; 00788 } 00789 TRACE(" R "); TRACE(cmd, pf->u2.dwRBitMask); 00790 TRACE(" G "); TRACE(cmd, pf->u3.dwGBitMask); 00791 TRACE(" B "); TRACE(cmd, pf->u4.dwBBitMask); 00792 if (pf->dwFlags & DDPF_ALPHAPIXELS) 00793 { 00794 TRACE(" A "); TRACE(cmd, pf->u5.dwRGBAlphaBitMask); 00795 } 00796 if (pf->dwFlags & DDPF_ZPIXELS) 00797 { 00798 TRACE(" Z "); TRACE(cmd, pf->u5.dwRGBZBitMask); 00799 } 00800 } 00801 if (pf->dwFlags & DDPF_ZBUFFER) 00802 { 00803 TRACE(", Z bits : %d", pf->u1.dwZBufferBitDepth); 00804 } 00805 if (pf->dwFlags & DDPF_ALPHA) 00806 { 00807 TRACE(", Alpha bits : %d", pf->u1.dwAlphaBitDepth); 00808 } 00809 if (pf->dwFlags & DDPF_BUMPDUDV) 00810 { 00811 const char *cmd = "%08lx"; 00812 TRACE(", Bump bits: %d, ", pf->u1.dwBumpBitCount); 00813 TRACE(" U "); TRACE(cmd, pf->u2.dwBumpDuBitMask); 00814 TRACE(" V "); TRACE(cmd, pf->u3.dwBumpDvBitMask); 00815 TRACE(" L "); TRACE(cmd, pf->u4.dwBumpLuminanceBitMask); 00816 } 00817 TRACE(")\n"); 00818 } 00819 00820 void DDRAW_dump_surface_desc(const DDSURFACEDESC2 *lpddsd) 00821 { 00822 #define STRUCT DDSURFACEDESC2 00823 static const member_info members[] = 00824 { 00825 ME(DDSD_HEIGHT, DDRAW_dump_DWORD, dwHeight), 00826 ME(DDSD_WIDTH, DDRAW_dump_DWORD, dwWidth), 00827 ME(DDSD_PITCH, DDRAW_dump_DWORD, u1 /* lPitch */), 00828 ME(DDSD_LINEARSIZE, DDRAW_dump_DWORD, u1 /* dwLinearSize */), 00829 ME(DDSD_BACKBUFFERCOUNT, DDRAW_dump_DWORD, u5.dwBackBufferCount), 00830 ME(DDSD_MIPMAPCOUNT, DDRAW_dump_DWORD, u2 /* dwMipMapCount */), 00831 ME(DDSD_ZBUFFERBITDEPTH, DDRAW_dump_DWORD, u2 /* dwZBufferBitDepth */), /* This is for 'old-style' D3D */ 00832 ME(DDSD_REFRESHRATE, DDRAW_dump_DWORD, u2 /* dwRefreshRate */), 00833 ME(DDSD_ALPHABITDEPTH, DDRAW_dump_DWORD, dwAlphaBitDepth), 00834 ME(DDSD_LPSURFACE, DDRAW_dump_PTR, lpSurface), 00835 ME(DDSD_CKDESTOVERLAY, DDRAW_dump_DDCOLORKEY, u3 /* ddckCKDestOverlay */), 00836 ME(DDSD_CKDESTBLT, DDRAW_dump_DDCOLORKEY, ddckCKDestBlt), 00837 ME(DDSD_CKSRCOVERLAY, DDRAW_dump_DDCOLORKEY, ddckCKSrcOverlay), 00838 ME(DDSD_CKSRCBLT, DDRAW_dump_DDCOLORKEY, ddckCKSrcBlt), 00839 ME(DDSD_PIXELFORMAT, DDRAW_dump_pixelformat, u4 /* ddpfPixelFormat */) 00840 }; 00841 static const member_info members_caps[] = 00842 { 00843 ME(DDSD_CAPS, DDRAW_dump_DDSCAPS, ddsCaps) 00844 }; 00845 static const member_info members_caps2[] = 00846 { 00847 ME(DDSD_CAPS, DDRAW_dump_DDSCAPS2, ddsCaps) 00848 }; 00849 #undef STRUCT 00850 00851 if (NULL == lpddsd) 00852 { 00853 TRACE("(null)\n"); 00854 } 00855 else 00856 { 00857 if (lpddsd->dwSize >= sizeof(DDSURFACEDESC2)) 00858 { 00859 DDRAW_dump_members(lpddsd->dwFlags, lpddsd, members_caps2, 1); 00860 } 00861 else 00862 { 00863 DDRAW_dump_members(lpddsd->dwFlags, lpddsd, members_caps, 1); 00864 } 00865 DDRAW_dump_members(lpddsd->dwFlags, lpddsd, members, 00866 sizeof(members)/sizeof(members[0])); 00867 } 00868 } 00869 00870 void 00871 dump_D3DMATRIX(const D3DMATRIX *mat) 00872 { 00873 TRACE(" %f %f %f %f\n", mat->_11, mat->_12, mat->_13, mat->_14); 00874 TRACE(" %f %f %f %f\n", mat->_21, mat->_22, mat->_23, mat->_24); 00875 TRACE(" %f %f %f %f\n", mat->_31, mat->_32, mat->_33, mat->_34); 00876 TRACE(" %f %f %f %f\n", mat->_41, mat->_42, mat->_43, mat->_44); 00877 } 00878 00879 DWORD 00880 get_flexible_vertex_size(DWORD d3dvtVertexType) 00881 { 00882 DWORD size = 0; 00883 DWORD i; 00884 00885 if (d3dvtVertexType & D3DFVF_NORMAL) size += 3 * sizeof(D3DVALUE); 00886 if (d3dvtVertexType & D3DFVF_DIFFUSE) size += sizeof(DWORD); 00887 if (d3dvtVertexType & D3DFVF_SPECULAR) size += sizeof(DWORD); 00888 if (d3dvtVertexType & D3DFVF_RESERVED1) size += sizeof(DWORD); 00889 switch (d3dvtVertexType & D3DFVF_POSITION_MASK) 00890 { 00891 case D3DFVF_XYZ: size += 3 * sizeof(D3DVALUE); break; 00892 case D3DFVF_XYZRHW: size += 4 * sizeof(D3DVALUE); break; 00893 case D3DFVF_XYZB1: size += 4 * sizeof(D3DVALUE); break; 00894 case D3DFVF_XYZB2: size += 5 * sizeof(D3DVALUE); break; 00895 case D3DFVF_XYZB3: size += 6 * sizeof(D3DVALUE); break; 00896 case D3DFVF_XYZB4: size += 7 * sizeof(D3DVALUE); break; 00897 case D3DFVF_XYZB5: size += 8 * sizeof(D3DVALUE); break; 00898 default: ERR("Unexpected position mask\n"); 00899 } 00900 for (i = 0; i < GET_TEXCOUNT_FROM_FVF(d3dvtVertexType); i++) 00901 { 00902 size += GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, i) * sizeof(D3DVALUE); 00903 } 00904 00905 return size; 00906 } 00907 00908 void DDRAW_Convert_DDSCAPS_1_To_2(const DDSCAPS* pIn, DDSCAPS2* pOut) 00909 { 00910 /* 2 adds three additional caps fields to the end. Both versions 00911 * are unversioned. */ 00912 pOut->dwCaps = pIn->dwCaps; 00913 pOut->dwCaps2 = 0; 00914 pOut->dwCaps3 = 0; 00915 pOut->u1.dwCaps4 = 0; 00916 } 00917 00918 void DDRAW_Convert_DDDEVICEIDENTIFIER_2_To_1(const DDDEVICEIDENTIFIER2* pIn, DDDEVICEIDENTIFIER* pOut) 00919 { 00920 /* 2 adds a dwWHQLLevel field to the end. Both structures are 00921 * unversioned. */ 00922 memcpy(pOut, pIn, sizeof(*pOut)); 00923 } 00924 00925 void DDRAW_dump_cooperativelevel(DWORD cooplevel) 00926 { 00927 static const flag_info flags[] = 00928 { 00929 FE(DDSCL_FULLSCREEN), 00930 FE(DDSCL_ALLOWREBOOT), 00931 FE(DDSCL_NOWINDOWCHANGES), 00932 FE(DDSCL_NORMAL), 00933 FE(DDSCL_ALLOWMODEX), 00934 FE(DDSCL_EXCLUSIVE), 00935 FE(DDSCL_SETFOCUSWINDOW), 00936 FE(DDSCL_SETDEVICEWINDOW), 00937 FE(DDSCL_CREATEDEVICEWINDOW) 00938 }; 00939 00940 if (TRACE_ON(ddraw)) 00941 { 00942 TRACE(" - "); 00943 DDRAW_dump_flags(cooplevel, flags, sizeof(flags)/sizeof(flags[0])); 00944 } 00945 } 00946 00947 void DDRAW_dump_DDCAPS(const DDCAPS *lpcaps) 00948 { 00949 static const flag_info flags1[] = 00950 { 00951 FE(DDCAPS_3D), 00952 FE(DDCAPS_ALIGNBOUNDARYDEST), 00953 FE(DDCAPS_ALIGNSIZEDEST), 00954 FE(DDCAPS_ALIGNBOUNDARYSRC), 00955 FE(DDCAPS_ALIGNSIZESRC), 00956 FE(DDCAPS_ALIGNSTRIDE), 00957 FE(DDCAPS_BLT), 00958 FE(DDCAPS_BLTQUEUE), 00959 FE(DDCAPS_BLTFOURCC), 00960 FE(DDCAPS_BLTSTRETCH), 00961 FE(DDCAPS_GDI), 00962 FE(DDCAPS_OVERLAY), 00963 FE(DDCAPS_OVERLAYCANTCLIP), 00964 FE(DDCAPS_OVERLAYFOURCC), 00965 FE(DDCAPS_OVERLAYSTRETCH), 00966 FE(DDCAPS_PALETTE), 00967 FE(DDCAPS_PALETTEVSYNC), 00968 FE(DDCAPS_READSCANLINE), 00969 FE(DDCAPS_STEREOVIEW), 00970 FE(DDCAPS_VBI), 00971 FE(DDCAPS_ZBLTS), 00972 FE(DDCAPS_ZOVERLAYS), 00973 FE(DDCAPS_COLORKEY), 00974 FE(DDCAPS_ALPHA), 00975 FE(DDCAPS_COLORKEYHWASSIST), 00976 FE(DDCAPS_NOHARDWARE), 00977 FE(DDCAPS_BLTCOLORFILL), 00978 FE(DDCAPS_BANKSWITCHED), 00979 FE(DDCAPS_BLTDEPTHFILL), 00980 FE(DDCAPS_CANCLIP), 00981 FE(DDCAPS_CANCLIPSTRETCHED), 00982 FE(DDCAPS_CANBLTSYSMEM) 00983 }; 00984 static const flag_info flags2[] = 00985 { 00986 FE(DDCAPS2_CERTIFIED), 00987 FE(DDCAPS2_NO2DDURING3DSCENE), 00988 FE(DDCAPS2_VIDEOPORT), 00989 FE(DDCAPS2_AUTOFLIPOVERLAY), 00990 FE(DDCAPS2_CANBOBINTERLEAVED), 00991 FE(DDCAPS2_CANBOBNONINTERLEAVED), 00992 FE(DDCAPS2_COLORCONTROLOVERLAY), 00993 FE(DDCAPS2_COLORCONTROLPRIMARY), 00994 FE(DDCAPS2_CANDROPZ16BIT), 00995 FE(DDCAPS2_NONLOCALVIDMEM), 00996 FE(DDCAPS2_NONLOCALVIDMEMCAPS), 00997 FE(DDCAPS2_NOPAGELOCKREQUIRED), 00998 FE(DDCAPS2_WIDESURFACES), 00999 FE(DDCAPS2_CANFLIPODDEVEN), 01000 FE(DDCAPS2_CANBOBHARDWARE), 01001 FE(DDCAPS2_COPYFOURCC), 01002 FE(DDCAPS2_PRIMARYGAMMA), 01003 FE(DDCAPS2_CANRENDERWINDOWED), 01004 FE(DDCAPS2_CANCALIBRATEGAMMA), 01005 FE(DDCAPS2_FLIPINTERVAL), 01006 FE(DDCAPS2_FLIPNOVSYNC), 01007 FE(DDCAPS2_CANMANAGETEXTURE), 01008 FE(DDCAPS2_TEXMANINNONLOCALVIDMEM), 01009 FE(DDCAPS2_STEREO), 01010 FE(DDCAPS2_SYSTONONLOCAL_AS_SYSTOLOCAL) 01011 }; 01012 static const flag_info flags3[] = 01013 { 01014 FE(DDCKEYCAPS_DESTBLT), 01015 FE(DDCKEYCAPS_DESTBLTCLRSPACE), 01016 FE(DDCKEYCAPS_DESTBLTCLRSPACEYUV), 01017 FE(DDCKEYCAPS_DESTBLTYUV), 01018 FE(DDCKEYCAPS_DESTOVERLAY), 01019 FE(DDCKEYCAPS_DESTOVERLAYCLRSPACE), 01020 FE(DDCKEYCAPS_DESTOVERLAYCLRSPACEYUV), 01021 FE(DDCKEYCAPS_DESTOVERLAYONEACTIVE), 01022 FE(DDCKEYCAPS_DESTOVERLAYYUV), 01023 FE(DDCKEYCAPS_SRCBLT), 01024 FE(DDCKEYCAPS_SRCBLTCLRSPACE), 01025 FE(DDCKEYCAPS_SRCBLTCLRSPACEYUV), 01026 FE(DDCKEYCAPS_SRCBLTYUV), 01027 FE(DDCKEYCAPS_SRCOVERLAY), 01028 FE(DDCKEYCAPS_SRCOVERLAYCLRSPACE), 01029 FE(DDCKEYCAPS_SRCOVERLAYCLRSPACEYUV), 01030 FE(DDCKEYCAPS_SRCOVERLAYONEACTIVE), 01031 FE(DDCKEYCAPS_SRCOVERLAYYUV), 01032 FE(DDCKEYCAPS_NOCOSTOVERLAY) 01033 }; 01034 static const flag_info flags4[] = 01035 { 01036 FE(DDFXCAPS_BLTALPHA), 01037 FE(DDFXCAPS_OVERLAYALPHA), 01038 FE(DDFXCAPS_BLTARITHSTRETCHYN), 01039 FE(DDFXCAPS_BLTARITHSTRETCHY), 01040 FE(DDFXCAPS_BLTMIRRORLEFTRIGHT), 01041 FE(DDFXCAPS_BLTMIRRORUPDOWN), 01042 FE(DDFXCAPS_BLTROTATION), 01043 FE(DDFXCAPS_BLTROTATION90), 01044 FE(DDFXCAPS_BLTSHRINKX), 01045 FE(DDFXCAPS_BLTSHRINKXN), 01046 FE(DDFXCAPS_BLTSHRINKY), 01047 FE(DDFXCAPS_BLTSHRINKYN), 01048 FE(DDFXCAPS_BLTSTRETCHX), 01049 FE(DDFXCAPS_BLTSTRETCHXN), 01050 FE(DDFXCAPS_BLTSTRETCHY), 01051 FE(DDFXCAPS_BLTSTRETCHYN), 01052 FE(DDFXCAPS_OVERLAYARITHSTRETCHY), 01053 FE(DDFXCAPS_OVERLAYARITHSTRETCHYN), 01054 FE(DDFXCAPS_OVERLAYSHRINKX), 01055 FE(DDFXCAPS_OVERLAYSHRINKXN), 01056 FE(DDFXCAPS_OVERLAYSHRINKY), 01057 FE(DDFXCAPS_OVERLAYSHRINKYN), 01058 FE(DDFXCAPS_OVERLAYSTRETCHX), 01059 FE(DDFXCAPS_OVERLAYSTRETCHXN), 01060 FE(DDFXCAPS_OVERLAYSTRETCHY), 01061 FE(DDFXCAPS_OVERLAYSTRETCHYN), 01062 FE(DDFXCAPS_OVERLAYMIRRORLEFTRIGHT), 01063 FE(DDFXCAPS_OVERLAYMIRRORUPDOWN) 01064 }; 01065 static const flag_info flags5[] = 01066 { 01067 FE(DDFXALPHACAPS_BLTALPHAEDGEBLEND), 01068 FE(DDFXALPHACAPS_BLTALPHAPIXELS), 01069 FE(DDFXALPHACAPS_BLTALPHAPIXELSNEG), 01070 FE(DDFXALPHACAPS_BLTALPHASURFACES), 01071 FE(DDFXALPHACAPS_BLTALPHASURFACESNEG), 01072 FE(DDFXALPHACAPS_OVERLAYALPHAEDGEBLEND), 01073 FE(DDFXALPHACAPS_OVERLAYALPHAPIXELS), 01074 FE(DDFXALPHACAPS_OVERLAYALPHAPIXELSNEG), 01075 FE(DDFXALPHACAPS_OVERLAYALPHASURFACES), 01076 FE(DDFXALPHACAPS_OVERLAYALPHASURFACESNEG) 01077 }; 01078 static const flag_info flags6[] = 01079 { 01080 FE(DDPCAPS_4BIT), 01081 FE(DDPCAPS_8BITENTRIES), 01082 FE(DDPCAPS_8BIT), 01083 FE(DDPCAPS_INITIALIZE), 01084 FE(DDPCAPS_PRIMARYSURFACE), 01085 FE(DDPCAPS_PRIMARYSURFACELEFT), 01086 FE(DDPCAPS_ALLOW256), 01087 FE(DDPCAPS_VSYNC), 01088 FE(DDPCAPS_1BIT), 01089 FE(DDPCAPS_2BIT), 01090 FE(DDPCAPS_ALPHA), 01091 }; 01092 static const flag_info flags7[] = 01093 { 01094 FE(DDSVCAPS_RESERVED1), 01095 FE(DDSVCAPS_RESERVED2), 01096 FE(DDSVCAPS_RESERVED3), 01097 FE(DDSVCAPS_RESERVED4), 01098 FE(DDSVCAPS_STEREOSEQUENTIAL), 01099 }; 01100 01101 TRACE(" - dwSize : %d\n", lpcaps->dwSize); 01102 TRACE(" - dwCaps : "); DDRAW_dump_flags(lpcaps->dwCaps, flags1, sizeof(flags1)/sizeof(flags1[0])); 01103 TRACE(" - dwCaps2 : "); DDRAW_dump_flags(lpcaps->dwCaps2, flags2, sizeof(flags2)/sizeof(flags2[0])); 01104 TRACE(" - dwCKeyCaps : "); DDRAW_dump_flags(lpcaps->dwCKeyCaps, flags3, sizeof(flags3)/sizeof(flags3[0])); 01105 TRACE(" - dwFXCaps : "); DDRAW_dump_flags(lpcaps->dwFXCaps, flags4, sizeof(flags4)/sizeof(flags4[0])); 01106 TRACE(" - dwFXAlphaCaps : "); DDRAW_dump_flags(lpcaps->dwFXAlphaCaps, flags5, sizeof(flags5)/sizeof(flags5[0])); 01107 TRACE(" - dwPalCaps : "); DDRAW_dump_flags(lpcaps->dwPalCaps, flags6, sizeof(flags6)/sizeof(flags6[0])); 01108 TRACE(" - dwSVCaps : "); DDRAW_dump_flags(lpcaps->dwSVCaps, flags7, sizeof(flags7)/sizeof(flags7[0])); 01109 TRACE("...\n"); 01110 TRACE(" - dwNumFourCCCodes : %d\n", lpcaps->dwNumFourCCCodes); 01111 TRACE(" - dwCurrVisibleOverlays : %d\n", lpcaps->dwCurrVisibleOverlays); 01112 TRACE(" - dwMinOverlayStretch : %d\n", lpcaps->dwMinOverlayStretch); 01113 TRACE(" - dwMaxOverlayStretch : %d\n", lpcaps->dwMaxOverlayStretch); 01114 TRACE("...\n"); 01115 TRACE(" - ddsCaps : "); DDRAW_dump_DDSCAPS2(&lpcaps->ddsCaps); 01116 } 01117 01118 /***************************************************************************** 01119 * multiply_matrix 01120 * 01121 * Multiplies 2 4x4 matrices src1 and src2, and stores the result in dest. 01122 * 01123 * Params: 01124 * dest: Pointer to the destination matrix 01125 * src1: Pointer to the first source matrix 01126 * src2: Pointer to the second source matrix 01127 * 01128 *****************************************************************************/ 01129 void 01130 multiply_matrix(D3DMATRIX *dest, 01131 const D3DMATRIX *src1, 01132 const D3DMATRIX *src2) 01133 { 01134 D3DMATRIX temp; 01135 01136 /* Now do the multiplication 'by hand'. 01137 I know that all this could be optimised, but this will be done later :-) */ 01138 temp._11 = (src1->_11 * src2->_11) + (src1->_21 * src2->_12) + (src1->_31 * src2->_13) + (src1->_41 * src2->_14); 01139 temp._21 = (src1->_11 * src2->_21) + (src1->_21 * src2->_22) + (src1->_31 * src2->_23) + (src1->_41 * src2->_24); 01140 temp._31 = (src1->_11 * src2->_31) + (src1->_21 * src2->_32) + (src1->_31 * src2->_33) + (src1->_41 * src2->_34); 01141 temp._41 = (src1->_11 * src2->_41) + (src1->_21 * src2->_42) + (src1->_31 * src2->_43) + (src1->_41 * src2->_44); 01142 01143 temp._12 = (src1->_12 * src2->_11) + (src1->_22 * src2->_12) + (src1->_32 * src2->_13) + (src1->_42 * src2->_14); 01144 temp._22 = (src1->_12 * src2->_21) + (src1->_22 * src2->_22) + (src1->_32 * src2->_23) + (src1->_42 * src2->_24); 01145 temp._32 = (src1->_12 * src2->_31) + (src1->_22 * src2->_32) + (src1->_32 * src2->_33) + (src1->_42 * src2->_34); 01146 temp._42 = (src1->_12 * src2->_41) + (src1->_22 * src2->_42) + (src1->_32 * src2->_43) + (src1->_42 * src2->_44); 01147 01148 temp._13 = (src1->_13 * src2->_11) + (src1->_23 * src2->_12) + (src1->_33 * src2->_13) + (src1->_43 * src2->_14); 01149 temp._23 = (src1->_13 * src2->_21) + (src1->_23 * src2->_22) + (src1->_33 * src2->_23) + (src1->_43 * src2->_24); 01150 temp._33 = (src1->_13 * src2->_31) + (src1->_23 * src2->_32) + (src1->_33 * src2->_33) + (src1->_43 * src2->_34); 01151 temp._43 = (src1->_13 * src2->_41) + (src1->_23 * src2->_42) + (src1->_33 * src2->_43) + (src1->_43 * src2->_44); 01152 01153 temp._14 = (src1->_14 * src2->_11) + (src1->_24 * src2->_12) + (src1->_34 * src2->_13) + (src1->_44 * src2->_14); 01154 temp._24 = (src1->_14 * src2->_21) + (src1->_24 * src2->_22) + (src1->_34 * src2->_23) + (src1->_44 * src2->_24); 01155 temp._34 = (src1->_14 * src2->_31) + (src1->_24 * src2->_32) + (src1->_34 * src2->_33) + (src1->_44 * src2->_34); 01156 temp._44 = (src1->_14 * src2->_41) + (src1->_24 * src2->_42) + (src1->_34 * src2->_43) + (src1->_44 * src2->_44); 01157 01158 /* And copy the new matrix in the good storage.. */ 01159 memcpy(dest, &temp, 16 * sizeof(D3DVALUE)); 01160 } 01161 01162 HRESULT 01163 hr_ddraw_from_wined3d(HRESULT hr) 01164 { 01165 switch(hr) 01166 { 01167 case WINED3DERR_INVALIDCALL: return DDERR_INVALIDPARAMS; 01168 default: return hr; 01169 } 01170 } 01171 01172 /* Note that this function writes the full sizeof(DDSURFACEDESC2) size, don't use it 01173 * for writing into application-provided DDSURFACEDESC2 structures if the size may 01174 * be different */ 01175 void DDSD_to_DDSD2(const DDSURFACEDESC *in, DDSURFACEDESC2 *out) 01176 { 01177 /* The output of this function is never passed to the application directly, so 01178 * the memset is not strictly needed. CreateSurface still has problems with this 01179 * though. Don't forget to set ddsCaps.dwCaps2/3/4 to 0 when removing this */ 01180 memset(out, 0x00, sizeof(*out)); 01181 out->dwSize = sizeof(*out); 01182 out->dwFlags = in->dwFlags & ~DDSD_ZBUFFERBITDEPTH; 01183 if (in->dwFlags & DDSD_WIDTH) out->dwWidth = in->dwWidth; 01184 if (in->dwFlags & DDSD_HEIGHT) out->dwHeight = in->dwHeight; 01185 if (in->dwFlags & DDSD_PIXELFORMAT) out->u4.ddpfPixelFormat = in->ddpfPixelFormat; 01186 else if(in->dwFlags & DDSD_ZBUFFERBITDEPTH) 01187 { 01188 out->dwFlags |= DDSD_PIXELFORMAT; 01189 memset(&out->u4.ddpfPixelFormat, 0, sizeof(out->u4.ddpfPixelFormat)); 01190 out->u4.ddpfPixelFormat.dwSize = sizeof(out->u4.ddpfPixelFormat); 01191 out->u4.ddpfPixelFormat.dwFlags = DDPF_ZBUFFER; 01192 out->u4.ddpfPixelFormat.u1.dwZBufferBitDepth = in->u2.dwZBufferBitDepth; 01193 /* 0 is not a valid DDSURFACEDESC / DDPIXELFORMAT on either side of the 01194 * conversion */ 01195 out->u4.ddpfPixelFormat.u3.dwZBitMask = ~0U >> (32 - in->u2.dwZBufferBitDepth); 01196 } 01197 /* ddsCaps is read even without DDSD_CAPS set. See dsurface:no_ddsd_caps_test */ 01198 out->ddsCaps.dwCaps = in->ddsCaps.dwCaps; 01199 if (in->dwFlags & DDSD_PITCH) out->u1.lPitch = in->u1.lPitch; 01200 if (in->dwFlags & DDSD_BACKBUFFERCOUNT) out->u5.dwBackBufferCount = in->dwBackBufferCount; 01201 if (in->dwFlags & DDSD_ALPHABITDEPTH) out->dwAlphaBitDepth = in->dwAlphaBitDepth; 01202 /* DDraw(native, and wine) does not set the DDSD_LPSURFACE, so always copy */ 01203 out->lpSurface = in->lpSurface; 01204 if (in->dwFlags & DDSD_CKDESTOVERLAY) out->u3.ddckCKDestOverlay = in->ddckCKDestOverlay; 01205 if (in->dwFlags & DDSD_CKDESTBLT) out->ddckCKDestBlt = in->ddckCKDestBlt; 01206 if (in->dwFlags & DDSD_CKSRCOVERLAY) out->ddckCKSrcOverlay = in->ddckCKSrcOverlay; 01207 if (in->dwFlags & DDSD_CKSRCBLT) out->ddckCKSrcBlt = in->ddckCKSrcBlt; 01208 if (in->dwFlags & DDSD_MIPMAPCOUNT) out->u2.dwMipMapCount = in->u2.dwMipMapCount; 01209 if (in->dwFlags & DDSD_REFRESHRATE) out->u2.dwRefreshRate = in->u2.dwRefreshRate; 01210 if (in->dwFlags & DDSD_LINEARSIZE) out->u1.dwLinearSize = in->u1.dwLinearSize; 01211 /* Does not exist in DDSURFACEDESC: 01212 * DDSD_TEXTURESTAGE, DDSD_FVF, DDSD_SRCVBHANDLE, 01213 */ 01214 } 01215 01216 /* Note that this function writes the full sizeof(DDSURFACEDESC) size, don't use it 01217 * for writing into application-provided DDSURFACEDESC structures if the size may 01218 * be different */ 01219 void DDSD2_to_DDSD(const DDSURFACEDESC2 *in, DDSURFACEDESC *out) 01220 { 01221 memset(out, 0, sizeof(*out)); 01222 out->dwSize = sizeof(*out); 01223 out->dwFlags = in->dwFlags; 01224 if (in->dwFlags & DDSD_WIDTH) out->dwWidth = in->dwWidth; 01225 if (in->dwFlags & DDSD_HEIGHT) out->dwHeight = in->dwHeight; 01226 if (in->dwFlags & DDSD_PIXELFORMAT) 01227 { 01228 out->ddpfPixelFormat = in->u4.ddpfPixelFormat; 01229 if ((in->dwFlags & DDSD_CAPS) && (in->ddsCaps.dwCaps & DDSCAPS_ZBUFFER)) 01230 { 01231 /* Z buffers have DDSD_ZBUFFERBITDEPTH set, but not DDSD_PIXELFORMAT. They do 01232 * have valid data in ddpfPixelFormat though */ 01233 out->dwFlags &= ~DDSD_PIXELFORMAT; 01234 out->dwFlags |= DDSD_ZBUFFERBITDEPTH; 01235 out->u2.dwZBufferBitDepth = in->u4.ddpfPixelFormat.u1.dwZBufferBitDepth; 01236 } 01237 } 01238 /* ddsCaps is read even without DDSD_CAPS set. See dsurface:no_ddsd_caps_test */ 01239 out->ddsCaps.dwCaps = in->ddsCaps.dwCaps; 01240 if (in->dwFlags & DDSD_PITCH) out->u1.lPitch = in->u1.lPitch; 01241 if (in->dwFlags & DDSD_BACKBUFFERCOUNT) out->dwBackBufferCount = in->u5.dwBackBufferCount; 01242 if (in->dwFlags & DDSD_ZBUFFERBITDEPTH) out->u2.dwZBufferBitDepth = in->u2.dwMipMapCount; /* same union */ 01243 if (in->dwFlags & DDSD_ALPHABITDEPTH) out->dwAlphaBitDepth = in->dwAlphaBitDepth; 01244 /* DDraw(native, and wine) does not set the DDSD_LPSURFACE, so always copy */ 01245 out->lpSurface = in->lpSurface; 01246 if (in->dwFlags & DDSD_CKDESTOVERLAY) out->ddckCKDestOverlay = in->u3.ddckCKDestOverlay; 01247 if (in->dwFlags & DDSD_CKDESTBLT) out->ddckCKDestBlt = in->ddckCKDestBlt; 01248 if (in->dwFlags & DDSD_CKSRCOVERLAY) out->ddckCKSrcOverlay = in->ddckCKSrcOverlay; 01249 if (in->dwFlags & DDSD_CKSRCBLT) out->ddckCKSrcBlt = in->ddckCKSrcBlt; 01250 if (in->dwFlags & DDSD_MIPMAPCOUNT) out->u2.dwMipMapCount = in->u2.dwMipMapCount; 01251 if (in->dwFlags & DDSD_REFRESHRATE) out->u2.dwRefreshRate = in->u2.dwRefreshRate; 01252 if (in->dwFlags & DDSD_LINEARSIZE) out->u1.dwLinearSize = in->u1.dwLinearSize; 01253 /* Does not exist in DDSURFACEDESC: 01254 * DDSD_TEXTURESTAGE, DDSD_FVF, DDSD_SRCVBHANDLE, 01255 */ 01256 if (in->dwFlags & DDSD_TEXTURESTAGE) WARN("Does not exist in DDSURFACEDESC: DDSD_TEXTURESTAGE\n"); 01257 if (in->dwFlags & DDSD_FVF) WARN("Does not exist in DDSURFACEDESC: DDSD_FVF\n"); 01258 if (in->dwFlags & DDSD_SRCVBHANDLE) WARN("Does not exist in DDSURFACEDESC: DDSD_SRCVBHANDLE\n"); 01259 out->dwFlags &= ~(DDSD_TEXTURESTAGE | DDSD_FVF | DDSD_SRCVBHANDLE); 01260 }
Generated on Sun May 27 2012 04:22:15 for ReactOS by
1.7.6.1
