reactos/dll/directx/d3d9/format.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS ReactX
   4  * FILE:            dll/directx/d3d9/format.c
   5  * PURPOSE:         d3d9.dll D3DFORMAT helper functions
   6  * PROGRAMERS:      Gregor Brunmar <gregor (dot) brunmar (at) home (dot) se>
   7  */
   8
   9 #include "format.h"
  10 #include <ddrawi.h>
  11 #include <debug.h>
  12 #include <d3d9types.h>
  13
  14 BOOL IsBackBufferFormat(D3DFORMAT Format)
  15 {
  16     return ((Format >= D3DFMT_A8R8G8B8) && (Format < D3DFMT_A1R5G5B5)) ||
  17             (IsExtendedFormat(Format));
  18 }
  19
  20 BOOL IsExtendedFormat(D3DFORMAT Format)
  21 {
  22     return (Format == D3DFMT_A2R10G10B10);
  23 }
  24
  25 BOOL IsZBufferFormat(D3DFORMAT Format)
  26 {
  27     UNIMPLEMENTED
  28
  29     return TRUE;
  30 }
  31
  32 BOOL IsMultiElementFormat(D3DFORMAT Format)
  33 {
  34     return (Format == D3DFMT_MULTI2_ARGB8);
  35 }
  36
  37 BOOL IsFourCCFormat(D3DFORMAT Format)
  38 {
  39     CHAR* cFormat = (CHAR*)&Format;
  40     if (isalnum(cFormat[0]) &&
  41         isalnum(cFormat[1]) &&
  42         isalnum(cFormat[2]) &&
  43         isalnum(cFormat[3]))
  44     {
  45         return TRUE;
  46     }
  47
  48     return FALSE;
  49 }
  50
  51 BOOL IsStencilFormat(D3DFORMAT Format)
  52 {
  53     switch (Format)
  54     {
  55     case D3DFMT_D15S1:
  56     case D3DFMT_D24S8:
  57     case D3DFMT_D24X4S4:
  58     case D3DFMT_D24FS8:
  59         return TRUE;
  60
  61     default:
  62         return FALSE;
  63     }
  64 }
  65
  66 DWORD GetBytesPerPixel(D3DFORMAT Format)
  67 {
  68     switch (Format)
  69     {
  70     case D3DFMT_R3G3B2:
  71     case D3DFMT_A8:
  72         return 1;
  73
  74     case D3DFMT_R5G6B5:
  75     case D3DFMT_X1R5G5B5:
  76     case D3DFMT_A1R5G5B5:
  77     case D3DFMT_A4R4G4B4:
  78     case D3DFMT_A8R3G3B2:
  79     case D3DFMT_X4R4G4B4:
  80         return 2;
  81
  82     case D3DFMT_R8G8B8:
  83         return 3;
  84
  85     case D3DFMT_A8R8G8B8:
  86     case D3DFMT_X8R8G8B8:
  87     case D3DFMT_A2B10G10R10:
  88     case D3DFMT_A8B8G8R8:
  89     case D3DFMT_X8B8G8R8:
  90     case D3DFMT_G16R16:
  91     case D3DFMT_A2R10G10B10:
  92         return 4;
  93
  94     case D3DFMT_A16B16G16R16:
  95         return 8;
  96
  97
  98     case D3DFMT_P8:
  99     case D3DFMT_L8:
 100     case D3DFMT_A4L4:
 101         return 1;
 102
 103     case D3DFMT_A8P8:
 104     case D3DFMT_A8L8:
 105         return 2;
 106
 107
 108     case D3DFMT_V8U8:
 109     case D3DFMT_L6V5U5:
 110         return 2;
 111
 112     case D3DFMT_X8L8V8U8:
 113     case D3DFMT_Q8W8V8U8:
 114     case D3DFMT_V16U16:
 115     case D3DFMT_A2W10V10U10:
 116         return 4;
 117
 118
 119     case D3DFMT_S8_LOCKABLE:
 120         return 1;
 121
 122     case D3DFMT_D16_LOCKABLE:
 123     case D3DFMT_D15S1:
 124     case D3DFMT_D16:
 125         return 2;
 126
 127     case D3DFMT_D32:
 128     case D3DFMT_D24S8:
 129     case D3DFMT_D24X8:
 130     case D3DFMT_D24X4S4:
 131     case D3DFMT_D32F_LOCKABLE:
 132     case D3DFMT_D24FS8:
 133     case D3DFMT_D32_LOCKABLE:
 134         return 4;
 135
 136
 137     case D3DFMT_L16:
 138         return 2;
 139
 140     /* TODO: Handle D3DFMT_VERTEXDATA? */
 141     case D3DFMT_INDEX16:
 142         return 2;
 143     case D3DFMT_INDEX32:
 144         return 4;
 145
 146
 147     case D3DFMT_Q16W16V16U16:
 148         return 8;
 149
 150
 151     case D3DFMT_R16F:
 152         return 2;
 153     case D3DFMT_G16R16F:
 154         return 4;
 155     case D3DFMT_A16B16G16R16F:
 156         return 8;
 157
 158
 159     case D3DFMT_R32F:
 160         return 4;
 161     case D3DFMT_G32R32F:
 162         return 8;
 163     case D3DFMT_A32B32G32R32F:
 164         return 16;
 165
 166     case D3DFMT_CxV8U8:
 167         return 2;
 168
 169
 170     /* Known FourCC formats */
 171     case D3DFMT_UYVY:
 172     case D3DFMT_R8G8_B8G8:
 173     case D3DFMT_YUY2:
 174     case D3DFMT_G8R8_G8B8:
 175         return 2;
 176
 177     case D3DFMT_DXT1:
 178         return 0xFFFFFFF8;
 179
 180     case D3DFMT_DXT2:
 181     case D3DFMT_DXT3:
 182     case D3DFMT_DXT4:
 183     case D3DFMT_DXT5:
 184         return 0xFFFFFFF0;
 185
 186     case D3DFMT_MULTI2_ARGB8:
 187         return 8;
 188
 189     default:
 190         return 0;
 191     }
 192 }
 193
 194 DWORD GetPixelStride(D3DFORMAT Format)
 195 {
 196     DWORD Bpp = GetBytesPerPixel(Format);
 197
 198     if (0 == Bpp)
 199     {
 200         /* TODO: Handle unknown formats here */
 201     }
 202
 203     return Bpp;
 204 }
 205
 206 BOOL IsSupportedFormatOp(LPD3D9_DRIVERCAPS pDriverCaps, D3DFORMAT DisplayFormat, DWORD FormatOp)
 207 {
 208     const DWORD NumFormatOps = pDriverCaps->NumSupportedFormatOps;
 209     DWORD FormatOpIndex;
 210
 211     for (FormatOpIndex = 0; FormatOpIndex < NumFormatOps; FormatOpIndex++)
 212     {
 213         const LPDDSURFACEDESC pSurfaceDesc = &pDriverCaps->pSupportedFormatOps[FormatOpIndex];
 214         if (pSurfaceDesc->ddpfPixelFormat.dwFourCC == DisplayFormat &&
 215             (pSurfaceDesc->ddpfPixelFormat.dwOperations & FormatOp) == FormatOp)
 216         {
 217             return TRUE;
 218         }
 219     }
 220
 221     return FALSE;
 222 }
 223
 224 HRESULT CheckDeviceType(LPD3D9_DRIVERCAPS pDriverCaps, D3DFORMAT DisplayFormat, D3DFORMAT BackBufferFormat, BOOL Windowed)
 225 {
 226     if (FALSE == IsSupportedFormatOp(pDriverCaps, DisplayFormat, D3DFORMAT_OP_DISPLAYMODE | D3DFORMAT_OP_3DACCELERATION))
 227     {
 228         return D3DERR_NOTAVAILABLE;
 229     }
 230
 231     if (DisplayFormat != BackBufferFormat)
 232     {
 233         D3DFORMAT AdjustedDisplayFormat = DisplayFormat;
 234
 235         if (DisplayFormat == D3DFMT_X8R8G8B8)
 236         {
 237             DisplayFormat = D3DFMT_A8R8G8B8;
 238         }
 239         else if (DisplayFormat == D3DFMT_X1R5G5B5)
 240         {
 241             DisplayFormat = D3DFMT_A1R5G5B5;
 242         }
 243
 244         if (AdjustedDisplayFormat == BackBufferFormat)
 245         {
 246             if (FALSE == IsSupportedFormatOp(pDriverCaps, AdjustedDisplayFormat, D3DFORMAT_OP_SAME_FORMAT_UP_TO_ALPHA_RENDERTARGET))
 247             {
 248                 return D3DERR_NOTAVAILABLE;
 249             }
 250
 251             return D3D_OK;
 252         }
 253         else if (FALSE == Windowed)
 254         {
 255             return D3DERR_NOTAVAILABLE;
 256         }
 257
 258         if (FALSE == IsSupportedFormatOp(pDriverCaps, BackBufferFormat, D3DFORMAT_OP_OFFSCREEN_RENDERTARGET) ||
 259             FALSE == IsSupportedFormatOp(pDriverCaps, BackBufferFormat, D3DFORMAT_OP_CONVERT_TO_ARGB) ||
 260             FALSE == IsSupportedFormatOp(pDriverCaps, BackBufferFormat, D3DFORMAT_MEMBEROFGROUP_ARGB))
 261         {
 262             return D3DERR_NOTAVAILABLE;
 263         }
 264     }
 265     else
 266     {
 267         if (FALSE == IsSupportedFormatOp(pDriverCaps, DisplayFormat, D3DFORMAT_OP_SAME_FORMAT_RENDERTARGET))
 268         {
 269             return D3DERR_NOTAVAILABLE;
 270         }
 271     }
 272
 273     return D3D_OK;
 274 }
 275
 276 static D3DFORMAT GetStencilFormat(LPD3D9_DRIVERCAPS pDriverCaps, D3DFORMAT CheckFormat)
 277 {
 278     switch (CheckFormat)
 279     {
 280     case D3DFMT_D15S1:
 281     case D3DFMT_D24S8:
 282     case D3DFMT_D24X8:
 283     case D3DFMT_D24X4S4:
 284         if (IsSupportedFormatOp(pDriverCaps, CheckFormat - 1, 0))
 285             return CheckFormat - 1;
 286         break;
 287
 288     case D3DFMT_D16:
 289         if (IsSupportedFormatOp(pDriverCaps, CheckFormat, 0))
 290             return CheckFormat;
 291         else
 292             return D3DFMT_D16_LOCKABLE;
 293
 294     default:
 295         /* StencilFormat same as CheckFormat */
 296         break;
 297     }
 298
 299     return CheckFormat;
 300 }
 301
 302 static D3DFORMAT RemoveAlphaChannel(D3DFORMAT CheckFormat)
 303 {
 304     switch (CheckFormat)
 305     {
 306     case D3DFMT_A8R8G8B8:
 307         return D3DFMT_X8R8G8B8;
 308
 309     case D3DFMT_A1R5G5B5:
 310         return D3DFMT_X1R5G5B5;
 311
 312     case D3DFMT_A4R4G4B4:
 313         return D3DFMT_X4R4G4B4;
 314
 315     case D3DFMT_A8B8G8R8:
 316         return D3DFMT_X8B8G8R8;
 317
 318     default:
 319         /* CheckFormat has not relevant alpha channel */
 320         break;
 321     }
 322
 323     return CheckFormat;
 324 }
 325
 326 HRESULT CheckDeviceFormat(LPD3D9_DRIVERCAPS pDriverCaps, D3DFORMAT AdapterFormat, DWORD Usage, D3DRESOURCETYPE RType, D3DFORMAT CheckFormat)
 327 {
 328     const DWORD NumFormatOps = pDriverCaps->NumSupportedFormatOps;
 329     DWORD NonCompatibleOperations = 0, MustSupportOperations = 0;
 330     BOOL bSupportedWithAutogen = FALSE;
 331     DWORD FormatOpIndex;
 332
 333     if (FALSE == IsSupportedFormatOp(pDriverCaps, AdapterFormat, D3DFORMAT_OP_DISPLAYMODE | D3DFORMAT_OP_3DACCELERATION))
 334     {
 335         return D3DERR_NOTAVAILABLE;
 336     }
 337
 338     /* Check for driver auto generated mip map support if requested */
 339     if ((Usage & (D3DUSAGE_AUTOGENMIPMAP)) != 0)
 340     {
 341         switch (RType)
 342         {
 343         case D3DRTYPE_TEXTURE:
 344             if ((pDriverCaps->DriverCaps9.TextureCaps & D3DPTEXTURECAPS_MIPMAP) == 0)
 345                 return D3DERR_NOTAVAILABLE;
 346
 347             break;
 348
 349         case D3DRTYPE_VOLUME:
 350         case D3DRTYPE_VOLUMETEXTURE:
 351             if ((pDriverCaps->DriverCaps9.TextureCaps & D3DPTEXTURECAPS_MIPVOLUMEMAP) == 0)
 352                 return D3DERR_NOTAVAILABLE;
 353
 354             break;
 355
 356         case D3DRTYPE_CUBETEXTURE:
 357             if ((pDriverCaps->DriverCaps9.TextureCaps & D3DPTEXTURECAPS_MIPCUBEMAP) == 0)
 358                 return D3DERR_NOTAVAILABLE;
 359
 360             break;
 361
 362         default:
 363             /* Do nothing */
 364             break;
 365         }
 366
 367         MustSupportOperations |= D3DFORMAT_OP_AUTOGENMIPMAP;
 368     }
 369
 370     /* Translate from RType and Usage parameters to FormatOps */
 371     switch (RType)
 372     {
 373     case D3DRTYPE_TEXTURE:
 374         MustSupportOperations |= D3DFORMAT_OP_TEXTURE;
 375         break;
 376
 377     case D3DRTYPE_VOLUME:
 378     case D3DRTYPE_VOLUMETEXTURE:
 379         MustSupportOperations |= D3DFORMAT_OP_VOLUMETEXTURE;
 380         break;
 381
 382     case D3DRTYPE_CUBETEXTURE:
 383         MustSupportOperations |= D3DFORMAT_OP_CUBETEXTURE;
 384         break;
 385
 386     default:
 387         /* Do nothing */
 388         break;
 389     }
 390
 391     if (Usage == 0 && RType == D3DRTYPE_SURFACE)
 392     {
 393         MustSupportOperations |= D3DFORMAT_OP_OFFSCREENPLAIN;
 394     }
 395
 396     if ((Usage & D3DUSAGE_DEPTHSTENCIL) != 0)
 397     {
 398         MustSupportOperations |= D3DFORMAT_OP_ZSTENCIL;
 399     }
 400
 401     if ((Usage & D3DUSAGE_DMAP) != 0)
 402     {
 403         MustSupportOperations |= D3DFORMAT_OP_DMAP;
 404     }
 405
 406     if ((Usage & D3DUSAGE_QUERY_LEGACYBUMPMAP) != 0)
 407     {
 408         MustSupportOperations |= D3DFORMAT_OP_BUMPMAP;
 409     }
 410
 411     if ((Usage & D3DUSAGE_QUERY_SRGBREAD) != 0)
 412     {
 413         MustSupportOperations |= D3DFORMAT_OP_SRGBREAD;
 414     }
 415
 416     if ((Usage & D3DUSAGE_QUERY_SRGBWRITE) != 0)
 417     {
 418         MustSupportOperations |= D3DFORMAT_OP_SRGBWRITE;
 419     }
 420
 421     if ((Usage & D3DUSAGE_QUERY_VERTEXTEXTURE) != 0)
 422     {
 423         MustSupportOperations |= D3DFORMAT_OP_VERTEXTEXTURE;
 424     }
 425
 426     CheckFormat = GetStencilFormat(pDriverCaps, CheckFormat);
 427
 428     if ((Usage & D3DUSAGE_RENDERTARGET) != 0)
 429     {
 430         if (AdapterFormat == CheckFormat)
 431         {
 432             MustSupportOperations |= D3DFORMAT_OP_SAME_FORMAT_RENDERTARGET;
 433         }
 434         else
 435         {
 436             D3DFORMAT NonAlphaAdapterFormat;
 437             D3DFORMAT NonAlphaCheckFormat;
 438
 439             NonAlphaAdapterFormat = RemoveAlphaChannel(AdapterFormat);
 440             NonAlphaCheckFormat = RemoveAlphaChannel(CheckFormat);
 441
 442             if (NonAlphaAdapterFormat == NonAlphaCheckFormat &&
 443                 NonAlphaCheckFormat != D3DFMT_UNKNOWN)
 444             {
 445                 MustSupportOperations |= D3DFORMAT_OP_SAME_FORMAT_UP_TO_ALPHA_RENDERTARGET;
 446             }
 447             else
 448             {
 449                 MustSupportOperations |= D3DFORMAT_OP_OFFSCREEN_RENDERTARGET;
 450             }
 451         }
 452     }
 453
 454     if ((Usage & D3DUSAGE_QUERY_FILTER) != 0)
 455     {
 456         NonCompatibleOperations |= D3DFORMAT_OP_OFFSCREENPLAIN;
 457     }
 458
 459     if ((Usage & D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING) != 0)
 460     {
 461         NonCompatibleOperations |= D3DFORMAT_OP_NOALPHABLEND;
 462     }
 463
 464     if ((Usage & D3DUSAGE_QUERY_WRAPANDMIP) != 0)
 465     {
 466         NonCompatibleOperations |= D3DFORMAT_OP_NOTEXCOORDWRAPNORMIP;
 467     }
 468
 469     for (FormatOpIndex = 0; FormatOpIndex < NumFormatOps; FormatOpIndex++)
 470     {
 471         DWORD dwOperations;
 472         LPDDSURFACEDESC pSurfaceDesc = &pDriverCaps->pSupportedFormatOps[FormatOpIndex];
 473
 474         if (pSurfaceDesc->ddpfPixelFormat.dwFourCC != CheckFormat)
 475             continue;
 476
 477         dwOperations = pSurfaceDesc->ddpfPixelFormat.dwOperations;
 478
 479         if ((dwOperations & NonCompatibleOperations) != 0)
 480             continue;
 481
 482         if ((dwOperations & MustSupportOperations) == MustSupportOperations)
 483             return D3D_OK;
 484
 485         if (((dwOperations & MustSupportOperations) | D3DFORMAT_OP_AUTOGENMIPMAP) == MustSupportOperations)
 486             bSupportedWithAutogen = TRUE;
 487     }
 488
 489     if (TRUE == bSupportedWithAutogen)
 490         return D3DOK_NOAUTOGEN;
 491
 492     return D3DERR_NOTAVAILABLE;
 493 }
 494
 495 HRESULT CheckDeviceFormatConversion(LPD3D9_DRIVERCAPS pDriverCaps, D3DFORMAT SourceFormat, D3DFORMAT TargetFormat)
 496 {
 497     D3DFORMAT NonAlphaSourceFormat;
 498     D3DFORMAT NonAlphaTargetFormat;
 499
 500     NonAlphaSourceFormat = RemoveAlphaChannel(SourceFormat);
 501     NonAlphaTargetFormat = RemoveAlphaChannel(TargetFormat);
 502
 503     if (NonAlphaSourceFormat == NonAlphaTargetFormat)
 504     {
 505         return D3D_OK;
 506     }
 507
 508     if (FALSE == IsFourCCFormat(SourceFormat))
 509     {
 510         switch (SourceFormat)
 511         {
 512         case D3DFMT_A8R8G8B8:
 513         case D3DFMT_X8R8G8B8:
 514         case D3DFMT_R5G6B5:
 515         case D3DFMT_X1R5G5B5:
 516         case D3DFMT_A1R5G5B5:
 517         case D3DFMT_A2R10G10B10:
 518             /* Do nothing, valid SourceFormat */
 519             break;
 520
 521         default:
 522             return D3DERR_NOTAVAILABLE;
 523         }
 524     }
 525     else if (pDriverCaps->DriverCaps9.DevCaps2 == 0)
 526     {
 527         return D3D_OK;
 528     }
 529
 530     if (FALSE == IsSupportedFormatOp(pDriverCaps, SourceFormat, D3DFORMAT_OP_CONVERT_TO_ARGB) ||
 531         FALSE == IsSupportedFormatOp(pDriverCaps, TargetFormat, D3DFORMAT_MEMBEROFGROUP_ARGB))
 532     {
 533         return D3DERR_NOTAVAILABLE;
 534     }
 535
 536     return D3D_OK;
 537 }
 538
 539 HRESULT CheckDepthStencilMatch(LPD3D9_DRIVERCAPS pDriverCaps, D3DFORMAT AdapterFormat, D3DFORMAT RenderTargetFormat, D3DFORMAT DepthStencilFormat)
 540 {
 541     const DWORD NumFormatOps = pDriverCaps->NumSupportedFormatOps;
 542     BOOL bRenderTargetAvailable = FALSE;
 543     BOOL bDepthStencilAvailable = FALSE;
 544     BOOL bForceSameDepthStencilBits = FALSE;
 545     DWORD FormatIndex;
 546
 547     if (FALSE == IsSupportedFormatOp(pDriverCaps, AdapterFormat, D3DFORMAT_OP_DISPLAYMODE | D3DFORMAT_OP_3DACCELERATION))
 548     {
 549         return D3DERR_NOTAVAILABLE;
 550     }
 551
 552     if (DepthStencilFormat != D3DFMT_D16_LOCKABLE &&
 553         DepthStencilFormat != D3DFMT_D32F_LOCKABLE)
 554     {
 555         if (TRUE == IsStencilFormat(DepthStencilFormat))
 556         {
 557             bForceSameDepthStencilBits = TRUE;
 558         }
 559     }
 560
 561     if (FALSE == bForceSameDepthStencilBits &&
 562         (DepthStencilFormat == D3DFMT_D32 || DepthStencilFormat == D3DFMT_D24X8))
 563     {
 564         bForceSameDepthStencilBits = TRUE;
 565     }
 566
 567     DepthStencilFormat = GetStencilFormat(pDriverCaps, DepthStencilFormat);
 568
 569     /* Observe the multiple conditions */
 570     for (FormatIndex = 0; FormatIndex < NumFormatOps && (bRenderTargetAvailable == FALSE || bDepthStencilAvailable == FALSE); FormatIndex++)
 571     {
 572         const LPDDSURFACEDESC pSurfaceDesc = &pDriverCaps->pSupportedFormatOps[FormatIndex];
 573         const DWORD FourCC = pSurfaceDesc->ddpfPixelFormat.dwFourCC;
 574         const DWORD FormatOperations = pSurfaceDesc->ddpfPixelFormat.dwOperations;
 575
 576         if (FALSE == bRenderTargetAvailable &&
 577             FourCC == RenderTargetFormat &&
 578             (FormatOperations & D3DFORMAT_OP_SAME_FORMAT_RENDERTARGET) != 0)
 579         {
 580             bRenderTargetAvailable = TRUE;
 581         }
 582
 583         if (FALSE == bDepthStencilAvailable &&
 584             FourCC == DepthStencilFormat &&
 585             (FormatOperations & D3DFORMAT_OP_ZSTENCIL) != 0)
 586         {
 587             bDepthStencilAvailable = TRUE;
 588
 589             if ((FormatOperations & D3DFORMAT_OP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH) != 0)
 590             {
 591                 bForceSameDepthStencilBits = FALSE;
 592             }
 593         }
 594     }
 595
 596     if (FALSE == bRenderTargetAvailable || FALSE == bDepthStencilAvailable)
 597     {
 598         return D3DERR_INVALIDCALL;
 599     }
 600
 601     if (TRUE == bForceSameDepthStencilBits)
 602     {
 603         if (GetPixelStride(RenderTargetFormat) != GetPixelStride(DepthStencilFormat))
 604             return D3DERR_NOTAVAILABLE;
 605     }
 606
 607     return D3D_OK;
 608 }