src/third_party/angle/src/libGLESv2/renderer/d3d/d3d9/renderer9_utils.cpp

   1 //
   2 // Copyright (c) 2002-2014 The ANGLE Project Authors. All rights reserved.
   3 // Use of this source code is governed by a BSD-style license that can be
   4 // found in the LICENSE file.
   5 //
   6
   7 // renderer9_utils.cpp: Conversion functions and other utility routines
   8 // specific to the D3D9 renderer.
   9
  10 #include "libGLESv2/renderer/d3d/d3d9/renderer9_utils.h"
  11 #include "libGLESv2/renderer/d3d/d3d9/formatutils9.h"
  12 #include "libGLESv2/formatutils.h"
  13 #include "libGLESv2/Framebuffer.h"
  14 #include "libGLESv2/renderer/d3d/d3d9/RenderTarget9.h"
  15
  16 #include "common/mathutil.h"
  17 #include "common/debug.h"
  18
  19 #include "third_party/systeminfo/SystemInfo.h"
  20
  21 namespace rx
  22 {
  23
  24 namespace gl_d3d9
  25 {
  26
  27 D3DCMPFUNC ConvertComparison(GLenum comparison)
  28 {
  29     D3DCMPFUNC d3dComp = D3DCMP_ALWAYS;
  30     switch (comparison)
  31     {
  32       case GL_NEVER:    d3dComp = D3DCMP_NEVER;        break;
  33       case GL_ALWAYS:   d3dComp = D3DCMP_ALWAYS;       break;
  34       case GL_LESS:     d3dComp = D3DCMP_LESS;         break;
  35       case GL_LEQUAL:   d3dComp = D3DCMP_LESSEQUAL;    break;
  36       case GL_EQUAL:    d3dComp = D3DCMP_EQUAL;        break;
  37       case GL_GREATER:  d3dComp = D3DCMP_GREATER;      break;
  38       case GL_GEQUAL:   d3dComp = D3DCMP_GREATEREQUAL; break;
  39       case GL_NOTEQUAL: d3dComp = D3DCMP_NOTEQUAL;     break;
  40       default: UNREACHABLE();
  41     }
  42
  43     return d3dComp;
  44 }
  45
  46 D3DCOLOR ConvertColor(gl::ColorF color)
  47 {
  48     return D3DCOLOR_RGBA(gl::unorm<8>(color.red),
  49                          gl::unorm<8>(color.green),
  50                          gl::unorm<8>(color.blue),
  51                          gl::unorm<8>(color.alpha));
  52 }
  53
  54 D3DBLEND ConvertBlendFunc(GLenum blend)
  55 {
  56     D3DBLEND d3dBlend = D3DBLEND_ZERO;
  57
  58     switch (blend)
  59     {
  60       case GL_ZERO:                     d3dBlend = D3DBLEND_ZERO;           break;
  61       case GL_ONE:                      d3dBlend = D3DBLEND_ONE;            break;
  62       case GL_SRC_COLOR:                d3dBlend = D3DBLEND_SRCCOLOR;       break;
  63       case GL_ONE_MINUS_SRC_COLOR:      d3dBlend = D3DBLEND_INVSRCCOLOR;    break;
  64       case GL_DST_COLOR:                d3dBlend = D3DBLEND_DESTCOLOR;      break;
  65       case GL_ONE_MINUS_DST_COLOR:      d3dBlend = D3DBLEND_INVDESTCOLOR;   break;
  66       case GL_SRC_ALPHA:                d3dBlend = D3DBLEND_SRCALPHA;       break;
  67       case GL_ONE_MINUS_SRC_ALPHA:      d3dBlend = D3DBLEND_INVSRCALPHA;    break;
  68       case GL_DST_ALPHA:                d3dBlend = D3DBLEND_DESTALPHA;      break;
  69       case GL_ONE_MINUS_DST_ALPHA:      d3dBlend = D3DBLEND_INVDESTALPHA;   break;
  70       case GL_CONSTANT_COLOR:           d3dBlend = D3DBLEND_BLENDFACTOR;    break;
  71       case GL_ONE_MINUS_CONSTANT_COLOR: d3dBlend = D3DBLEND_INVBLENDFACTOR; break;
  72       case GL_CONSTANT_ALPHA:           d3dBlend = D3DBLEND_BLENDFACTOR;    break;
  73       case GL_ONE_MINUS_CONSTANT_ALPHA: d3dBlend = D3DBLEND_INVBLENDFACTOR; break;
  74       case GL_SRC_ALPHA_SATURATE:       d3dBlend = D3DBLEND_SRCALPHASAT;    break;
  75       default: UNREACHABLE();
  76     }
  77
  78     return d3dBlend;
  79 }
  80
  81 D3DBLENDOP ConvertBlendOp(GLenum blendOp)
  82 {
  83     D3DBLENDOP d3dBlendOp = D3DBLENDOP_ADD;
  84
  85     switch (blendOp)
  86     {
  87       case GL_FUNC_ADD:              d3dBlendOp = D3DBLENDOP_ADD;         break;
  88       case GL_FUNC_SUBTRACT:         d3dBlendOp = D3DBLENDOP_SUBTRACT;    break;
  89       case GL_FUNC_REVERSE_SUBTRACT: d3dBlendOp = D3DBLENDOP_REVSUBTRACT; break;
  90       case GL_MIN_EXT:               d3dBlendOp = D3DBLENDOP_MIN;         break;
  91       case GL_MAX_EXT:               d3dBlendOp = D3DBLENDOP_MAX;         break;
  92       default: UNREACHABLE();
  93     }
  94
  95     return d3dBlendOp;
  96 }
  97
  98 D3DSTENCILOP ConvertStencilOp(GLenum stencilOp)
  99 {
 100     D3DSTENCILOP d3dStencilOp = D3DSTENCILOP_KEEP;
 101
 102     switch (stencilOp)
 103     {
 104       case GL_ZERO:      d3dStencilOp = D3DSTENCILOP_ZERO;    break;
 105       case GL_KEEP:      d3dStencilOp = D3DSTENCILOP_KEEP;    break;
 106       case GL_REPLACE:   d3dStencilOp = D3DSTENCILOP_REPLACE; break;
 107       case GL_INCR:      d3dStencilOp = D3DSTENCILOP_INCRSAT; break;
 108       case GL_DECR:      d3dStencilOp = D3DSTENCILOP_DECRSAT; break;
 109       case GL_INVERT:    d3dStencilOp = D3DSTENCILOP_INVERT;  break;
 110       case GL_INCR_WRAP: d3dStencilOp = D3DSTENCILOP_INCR;    break;
 111       case GL_DECR_WRAP: d3dStencilOp = D3DSTENCILOP_DECR;    break;
 112       default: UNREACHABLE();
 113     }
 114
 115     return d3dStencilOp;
 116 }
 117
 118 D3DTEXTUREADDRESS ConvertTextureWrap(GLenum wrap)
 119 {
 120     D3DTEXTUREADDRESS d3dWrap = D3DTADDRESS_WRAP;
 121
 122     switch (wrap)
 123     {
 124       case GL_REPEAT:            d3dWrap = D3DTADDRESS_WRAP;   break;
 125       case GL_CLAMP_TO_EDGE:     d3dWrap = D3DTADDRESS_CLAMP;  break;
 126       case GL_MIRRORED_REPEAT:   d3dWrap = D3DTADDRESS_MIRROR; break;
 127       default: UNREACHABLE();
 128     }
 129
 130     return d3dWrap;
 131 }
 132
 133 D3DCULL ConvertCullMode(GLenum cullFace, GLenum frontFace)
 134 {
 135     D3DCULL cull = D3DCULL_CCW;
 136     switch (cullFace)
 137     {
 138       case GL_FRONT:
 139         cull = (frontFace == GL_CCW ? D3DCULL_CW : D3DCULL_CCW);
 140         break;
 141       case GL_BACK:
 142         cull = (frontFace == GL_CCW ? D3DCULL_CCW : D3DCULL_CW);
 143         break;
 144       case GL_FRONT_AND_BACK:
 145         cull = D3DCULL_NONE; // culling will be handled during draw
 146         break;
 147       default: UNREACHABLE();
 148     }
 149
 150     return cull;
 151 }
 152
 153 D3DCUBEMAP_FACES ConvertCubeFace(GLenum cubeFace)
 154 {
 155     D3DCUBEMAP_FACES face = D3DCUBEMAP_FACE_POSITIVE_X;
 156
 157     switch (cubeFace)
 158     {
 159       case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
 160         face = D3DCUBEMAP_FACE_POSITIVE_X;
 161         break;
 162       case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
 163         face = D3DCUBEMAP_FACE_NEGATIVE_X;
 164         break;
 165       case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
 166         face = D3DCUBEMAP_FACE_POSITIVE_Y;
 167         break;
 168       case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
 169         face = D3DCUBEMAP_FACE_NEGATIVE_Y;
 170         break;
 171       case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
 172         face = D3DCUBEMAP_FACE_POSITIVE_Z;
 173         break;
 174       case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
 175         face = D3DCUBEMAP_FACE_NEGATIVE_Z;
 176         break;
 177       default: UNREACHABLE();
 178     }
 179
 180     return face;
 181 }
 182
 183 DWORD ConvertColorMask(bool red, bool green, bool blue, bool alpha)
 184 {
 185     return (red   ? D3DCOLORWRITEENABLE_RED   : 0) |
 186            (green ? D3DCOLORWRITEENABLE_GREEN : 0) |
 187            (blue  ? D3DCOLORWRITEENABLE_BLUE  : 0) |
 188            (alpha ? D3DCOLORWRITEENABLE_ALPHA : 0);
 189 }
 190
 191 D3DTEXTUREFILTERTYPE ConvertMagFilter(GLenum magFilter, float maxAnisotropy)
 192 {
 193     if (maxAnisotropy > 1.0f)
 194     {
 195         return D3DTEXF_ANISOTROPIC;
 196     }
 197
 198     D3DTEXTUREFILTERTYPE d3dMagFilter = D3DTEXF_POINT;
 199     switch (magFilter)
 200     {
 201       case GL_NEAREST: d3dMagFilter = D3DTEXF_POINT;  break;
 202       case GL_LINEAR:  d3dMagFilter = D3DTEXF_LINEAR; break;
 203       default: UNREACHABLE();
 204     }
 205
 206     return d3dMagFilter;
 207 }
 208
 209 void ConvertMinFilter(GLenum minFilter, D3DTEXTUREFILTERTYPE *d3dMinFilter, D3DTEXTUREFILTERTYPE *d3dMipFilter, float maxAnisotropy)
 210 {
 211     switch (minFilter)
 212     {
 213       case GL_NEAREST:
 214         *d3dMinFilter = D3DTEXF_POINT;
 215         *d3dMipFilter = D3DTEXF_NONE;
 216         break;
 217       case GL_LINEAR:
 218         *d3dMinFilter = D3DTEXF_LINEAR;
 219         *d3dMipFilter = D3DTEXF_NONE;
 220         break;
 221       case GL_NEAREST_MIPMAP_NEAREST:
 222         *d3dMinFilter = D3DTEXF_POINT;
 223         *d3dMipFilter = D3DTEXF_POINT;
 224         break;
 225       case GL_LINEAR_MIPMAP_NEAREST:
 226         *d3dMinFilter = D3DTEXF_LINEAR;
 227         *d3dMipFilter = D3DTEXF_POINT;
 228         break;
 229       case GL_NEAREST_MIPMAP_LINEAR:
 230         *d3dMinFilter = D3DTEXF_POINT;
 231         *d3dMipFilter = D3DTEXF_LINEAR;
 232         break;
 233       case GL_LINEAR_MIPMAP_LINEAR:
 234         *d3dMinFilter = D3DTEXF_LINEAR;
 235         *d3dMipFilter = D3DTEXF_LINEAR;
 236         break;
 237       default:
 238         *d3dMinFilter = D3DTEXF_POINT;
 239         *d3dMipFilter = D3DTEXF_NONE;
 240         UNREACHABLE();
 241     }
 242
 243     if (maxAnisotropy > 1.0f)
 244     {
 245         *d3dMinFilter = D3DTEXF_ANISOTROPIC;
 246     }
 247 }
 248
 249 D3DMULTISAMPLE_TYPE GetMultisampleType(GLuint samples)
 250 {
 251     return (samples > 1) ? static_cast<D3DMULTISAMPLE_TYPE>(samples) : D3DMULTISAMPLE_NONE;
 252 }
 253
 254 }
 255
 256 namespace d3d9_gl
 257 {
 258
 259 GLsizei GetSamplesCount(D3DMULTISAMPLE_TYPE type)
 260 {
 261     return (type != D3DMULTISAMPLE_NONMASKABLE) ? type : 0;
 262 }
 263
 264 bool IsFormatChannelEquivalent(D3DFORMAT d3dformat, GLenum format)
 265 {
 266     GLenum internalFormat = d3d9::GetD3DFormatInfo(d3dformat).internalFormat;
 267     GLenum convertedFormat = gl::GetInternalFormatInfo(internalFormat).format;
 268     return convertedFormat == format;
 269 }
 270
 271 static gl::TextureCaps GenerateTextureFormatCaps(GLenum internalFormat, IDirect3D9 *d3d9, D3DDEVTYPE deviceType,
 272                                                  UINT adapter, D3DFORMAT adapterFormat)
 273 {
 274     gl::TextureCaps textureCaps;
 275
 276     const d3d9::TextureFormat &d3dFormatInfo = d3d9::GetTextureFormatInfo(internalFormat);
 277     const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(internalFormat);
 278     if (formatInfo.depthBits > 0 || formatInfo.stencilBits > 0)
 279     {
 280         textureCaps.texturable = SUCCEEDED(d3d9->CheckDeviceFormat(adapter, deviceType, adapterFormat, 0, D3DRTYPE_TEXTURE, d3dFormatInfo.renderFormat));
 281         textureCaps.filterable = SUCCEEDED(d3d9->CheckDeviceFormat(adapter, deviceType, adapterFormat, D3DUSAGE_QUERY_FILTER, D3DRTYPE_TEXTURE, d3dFormatInfo.renderFormat));
 282         textureCaps.renderable = SUCCEEDED(d3d9->CheckDeviceFormat(adapter, deviceType, adapterFormat, D3DUSAGE_RENDERTARGET, D3DRTYPE_TEXTURE, d3dFormatInfo.renderFormat)) ||
 283                                  SUCCEEDED(d3d9->CheckDeviceFormat(adapter, deviceType, adapterFormat, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_TEXTURE, d3dFormatInfo.renderFormat));
 284     }
 285     else
 286     {
 287         textureCaps.texturable = SUCCEEDED(d3d9->CheckDeviceFormat(adapter, deviceType, adapterFormat, 0, D3DRTYPE_TEXTURE, d3dFormatInfo.texFormat)) &&
 288                                  SUCCEEDED(d3d9->CheckDeviceFormat(adapter, deviceType, adapterFormat, 0, D3DRTYPE_CUBETEXTURE, d3dFormatInfo.texFormat));
 289         textureCaps.filterable = SUCCEEDED(d3d9->CheckDeviceFormat(adapter, deviceType, adapterFormat, D3DUSAGE_QUERY_FILTER, D3DRTYPE_TEXTURE, d3dFormatInfo.texFormat));
 290         textureCaps.renderable = SUCCEEDED(d3d9->CheckDeviceFormat(adapter, deviceType, adapterFormat, D3DUSAGE_RENDERTARGET, D3DRTYPE_TEXTURE, d3dFormatInfo.texFormat)) ||
 291                                  SUCCEEDED(d3d9->CheckDeviceFormat(adapter, deviceType, adapterFormat, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_TEXTURE, d3dFormatInfo.texFormat));
 292     }
 293
 294     textureCaps.sampleCounts.insert(1);
 295     for (size_t i = D3DMULTISAMPLE_2_SAMPLES; i <= D3DMULTISAMPLE_16_SAMPLES; i++)
 296     {
 297         D3DMULTISAMPLE_TYPE multisampleType = D3DMULTISAMPLE_TYPE(i);
 298
 299         HRESULT result = d3d9->CheckDeviceMultiSampleType(adapter, deviceType, d3dFormatInfo.renderFormat, TRUE, multisampleType, NULL);
 300         if (SUCCEEDED(result))
 301         {
 302             textureCaps.sampleCounts.insert(i);
 303         }
 304     }
 305
 306     return textureCaps;
 307 }
 308
 309 void GenerateCaps(IDirect3D9 *d3d9, IDirect3DDevice9 *device, D3DDEVTYPE deviceType, UINT adapter, gl::Caps *caps,
 310                   gl::TextureCapsMap *textureCapsMap, gl::Extensions *extensions)
 311 {
 312     D3DCAPS9 deviceCaps;
 313     if (FAILED(d3d9->GetDeviceCaps(adapter, deviceType, &deviceCaps)))
 314     {
 315         // Can't continue with out device caps
 316         return;
 317     }
 318
 319     D3DDISPLAYMODE currentDisplayMode;
 320     d3d9->GetAdapterDisplayMode(adapter, &currentDisplayMode);
 321
 322     GLuint maxSamples = 0;
 323     const gl::FormatSet &allFormats = gl::GetAllSizedInternalFormats();
 324     for (gl::FormatSet::const_iterator internalFormat = allFormats.begin(); internalFormat != allFormats.end(); ++internalFormat)
 325     {
 326         gl::TextureCaps textureCaps = GenerateTextureFormatCaps(*internalFormat, d3d9, deviceType, adapter,
 327                                                                 currentDisplayMode.Format);
 328         textureCapsMap->insert(*internalFormat, textureCaps);
 329
 330         maxSamples = std::max(maxSamples, textureCaps.getMaxSamples());
 331
 332         if (gl::GetInternalFormatInfo(*internalFormat).compressed)
 333         {
 334             caps->compressedTextureFormats.push_back(*internalFormat);
 335         }
 336     }
 337
 338     // GL core feature limits
 339     caps->maxElementIndex = static_cast<GLint64>(std::numeric_limits<unsigned int>::max());
 340
 341     // 3D textures are unimplemented in D3D9
 342     caps->max3DTextureSize = 1;
 343
 344     // Only one limit in GL, use the minimum dimension
 345     caps->max2DTextureSize = std::min(deviceCaps.MaxTextureWidth, deviceCaps.MaxTextureHeight);
 346
 347     // D3D treats cube maps as a special case of 2D textures
 348     caps->maxCubeMapTextureSize = caps->max2DTextureSize;
 349
 350     // Array textures are not available in D3D9
 351     caps->maxArrayTextureLayers = 1;
 352
 353     // ES3-only feature
 354     caps->maxLODBias = 0.0f;
 355
 356     // No specific limits on render target size, maximum 2D texture size is equivalent
 357     caps->maxRenderbufferSize = caps->max2DTextureSize;
 358
 359     // Draw buffers are not supported in D3D9
 360     caps->maxDrawBuffers = 1;
 361     caps->maxColorAttachments = 1;
 362
 363     // No specific limits on viewport size, maximum 2D texture size is equivalent
 364     caps->maxViewportWidth = caps->max2DTextureSize;
 365     caps->maxViewportHeight = caps->maxViewportWidth;
 366
 367     // Point size is clamped to 1.0f when the shader model is less than 3
 368     caps->minAliasedPointSize = 1.0f;
 369     caps->maxAliasedPointSize = ((D3DSHADER_VERSION_MAJOR(deviceCaps.PixelShaderVersion) >= 3) ? deviceCaps.MaxPointSize : 1.0f);
 370
 371     // Wide lines not supported
 372     caps->minAliasedLineWidth = 1.0f;
 373     caps->maxAliasedLineWidth = 1.0f;
 374
 375     // Primitive count limits (unused in ES2)
 376     caps->maxElementsIndices = 0;
 377     caps->maxElementsVertices = 0;
 378
 379     // Program and shader binary formats (no supported shader binary formats)
 380     caps->programBinaryFormats.push_back(GL_PROGRAM_BINARY_ANGLE);
 381
 382     // WaitSync is ES3-only, set to zero
 383     caps->maxServerWaitTimeout = 0;
 384
 385     // Vertex shader limits
 386     caps->maxVertexAttributes = 16;
 387
 388     const size_t reservedVertexUniformVectors = 2; // dx_ViewAdjust and dx_DepthRange.
 389     const size_t MAX_VERTEX_CONSTANT_VECTORS_D3D9 = 256;
 390     caps->maxVertexUniformVectors = MAX_VERTEX_CONSTANT_VECTORS_D3D9 - reservedVertexUniformVectors;
 391     caps->maxVertexUniformComponents = caps->maxVertexUniformVectors * 4;
 392
 393     caps->maxVertexUniformBlocks = 0;
 394
 395     const size_t MAX_VERTEX_OUTPUT_VECTORS_SM3 = 10;
 396     const size_t MAX_VERTEX_OUTPUT_VECTORS_SM2 = 8;
 397     caps->maxVertexOutputComponents = ((deviceCaps.VertexShaderVersion >= D3DVS_VERSION(3, 0)) ? MAX_VERTEX_OUTPUT_VECTORS_SM3
 398                                                                                                : MAX_VERTEX_OUTPUT_VECTORS_SM2) * 4;
 399
 400     // Only Direct3D 10 ready devices support all the necessary vertex texture formats.
 401     // We test this using D3D9 by checking support for the R16F format.
 402     if (deviceCaps.VertexShaderVersion >= D3DVS_VERSION(3, 0) &&
 403         SUCCEEDED(d3d9->CheckDeviceFormat(adapter, deviceType, currentDisplayMode.Format,
 404                                           D3DUSAGE_QUERY_VERTEXTEXTURE, D3DRTYPE_TEXTURE, D3DFMT_R16F)))
 405     {
 406         const size_t MAX_TEXTURE_IMAGE_UNITS_VTF_SM3 = 4;
 407         caps->maxVertexTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS_VTF_SM3;
 408     }
 409     else
 410     {
 411         caps->maxVertexTextureImageUnits = 0;
 412     }
 413
 414     // Fragment shader limits
 415     const size_t reservedPixelUniformVectors = 3; // dx_ViewCoords, dx_DepthFront and dx_DepthRange.
 416
 417     const size_t MAX_PIXEL_CONSTANT_VECTORS_SM3 = 224;
 418     const size_t MAX_PIXEL_CONSTANT_VECTORS_SM2 = 32;
 419     caps->maxFragmentUniformVectors = ((deviceCaps.PixelShaderVersion >= D3DPS_VERSION(3, 0)) ? MAX_PIXEL_CONSTANT_VECTORS_SM3
 420                                                                                               : MAX_PIXEL_CONSTANT_VECTORS_SM2) - reservedPixelUniformVectors;
 421     caps->maxFragmentUniformComponents = caps->maxFragmentUniformVectors * 4;
 422     caps->maxFragmentUniformBlocks = 0;
 423     caps->maxFragmentInputComponents = caps->maxVertexOutputComponents;
 424     caps->maxTextureImageUnits = 16;
 425     caps->minProgramTexelOffset = 0;
 426     caps->maxProgramTexelOffset = 0;
 427
 428     // Aggregate shader limits (unused in ES2)
 429     caps->maxUniformBufferBindings = 0;
 430     caps->maxUniformBlockSize = 0;
 431     caps->uniformBufferOffsetAlignment = 0;
 432     caps->maxCombinedUniformBlocks = 0;
 433     caps->maxCombinedVertexUniformComponents = 0;
 434     caps->maxCombinedFragmentUniformComponents = 0;
 435     caps->maxVaryingComponents = 0;
 436
 437     // Aggregate shader limits
 438     caps->maxVaryingVectors = caps->maxVertexOutputComponents / 4;
 439     caps->maxCombinedTextureImageUnits = caps->maxVertexTextureImageUnits + caps->maxTextureImageUnits;
 440
 441     // Transform feedback limits
 442     caps->maxTransformFeedbackInterleavedComponents = 0;
 443     caps->maxTransformFeedbackSeparateAttributes = 0;
 444     caps->maxTransformFeedbackSeparateComponents = 0;
 445
 446     // GL extension support
 447     extensions->setTextureExtensionSupport(*textureCapsMap);
 448     extensions->elementIndexUint = deviceCaps.MaxVertexIndex >= (1 << 16);
 449     extensions->packedDepthStencil = true;
 450     extensions->getProgramBinary = true;
 451     extensions->rgb8rgba8 = true;
 452     extensions->readFormatBGRA = true;
 453     extensions->pixelBufferObject = false;
 454     extensions->mapBuffer = false;
 455     extensions->mapBufferRange = false;
 456
 457     // ATI cards on XP have problems with non-power-of-two textures.
 458     D3DADAPTER_IDENTIFIER9 adapterId = { 0 };
 459     if (SUCCEEDED(d3d9->GetAdapterIdentifier(adapter, 0, &adapterId)))
 460     {
 461         extensions->textureNPOT = !(deviceCaps.TextureCaps & D3DPTEXTURECAPS_POW2) &&
 462                                       !(deviceCaps.TextureCaps & D3DPTEXTURECAPS_CUBEMAP_POW2) &&
 463                                       !(deviceCaps.TextureCaps & D3DPTEXTURECAPS_NONPOW2CONDITIONAL) &&
 464                                       !(isWindowsVistaOrGreater() && adapterId.VendorId == VENDOR_ID_AMD);
 465     }
 466     else
 467     {
 468         extensions->textureNPOT = false;
 469     }
 470
 471     extensions->drawBuffers = false;
 472     extensions->textureStorage = true;
 473
 474     // Must support a minimum of 2:1 anisotropy for max anisotropy to be considered supported, per the spec
 475     extensions->textureFilterAnisotropic = (deviceCaps.RasterCaps & D3DPRASTERCAPS_ANISOTROPY) != 0 && deviceCaps.MaxAnisotropy >= 2;
 476     extensions->maxTextureAnisotropy = static_cast<GLfloat>(deviceCaps.MaxAnisotropy);
 477
 478     // Check occlusion query support by trying to create one
 479     IDirect3DQuery9 *occlusionQuery = NULL;
 480     extensions->occlusionQueryBoolean = SUCCEEDED(device->CreateQuery(D3DQUERYTYPE_OCCLUSION, &occlusionQuery)) && occlusionQuery;
 481     SafeRelease(occlusionQuery);
 482
 483     // Check event query support by trying to create one
 484     IDirect3DQuery9 *eventQuery = NULL;
 485     extensions->fence = SUCCEEDED(device->CreateQuery(D3DQUERYTYPE_EVENT, &eventQuery)) && eventQuery;
 486     SafeRelease(eventQuery);
 487
 488     extensions->timerQuery = false; // Unimplemented
 489     extensions->robustness = true;
 490     extensions->blendMinMax = true;
 491     extensions->framebufferBlit = true;
 492     extensions->framebufferMultisample = true;
 493     extensions->maxSamples = maxSamples;
 494     extensions->instancedArrays = deviceCaps.PixelShaderVersion >= D3DPS_VERSION(3, 0);
 495     extensions->packReverseRowOrder = true;
 496     extensions->standardDerivatives = (deviceCaps.PS20Caps.Caps & D3DPS20CAPS_GRADIENTINSTRUCTIONS) != 0;
 497     extensions->shaderTextureLOD = true;
 498     extensions->fragDepth = true;
 499     extensions->textureUsage = true;
 500     extensions->translatedShaderSource = true;
 501     extensions->colorBufferFloat = false;
 502 }
 503
 504 }
 505
 506 namespace d3d9
 507 {
 508
 509 GLuint ComputeBlockSize(D3DFORMAT format, GLuint width, GLuint height)
 510 {
 511     const D3DFormat &d3dFormatInfo = d3d9::GetD3DFormatInfo(format);
 512     GLuint numBlocksWide = (width + d3dFormatInfo.blockWidth - 1) / d3dFormatInfo.blockWidth;
 513     GLuint numBlocksHight = (height + d3dFormatInfo.blockHeight - 1) / d3dFormatInfo.blockHeight;
 514     return (d3dFormatInfo.pixelBytes * numBlocksWide * numBlocksHight);
 515 }
 516
 517 void MakeValidSize(bool isImage, D3DFORMAT format, GLsizei *requestWidth, GLsizei *requestHeight, int *levelOffset)
 518 {
 519     const D3DFormat &d3dFormatInfo = d3d9::GetD3DFormatInfo(format);
 520
 521     int upsampleCount = 0;
 522     // Don't expand the size of full textures that are at least (blockWidth x blockHeight) already.
 523     if (isImage || *requestWidth < static_cast<GLsizei>(d3dFormatInfo.blockWidth) ||
 524         *requestHeight < static_cast<GLsizei>(d3dFormatInfo.blockHeight))
 525     {
 526         while (*requestWidth % d3dFormatInfo.blockWidth != 0 || *requestHeight % d3dFormatInfo.blockHeight != 0)
 527         {
 528             *requestWidth <<= 1;
 529             *requestHeight <<= 1;
 530             upsampleCount++;
 531         }
 532     }
 533     *levelOffset = upsampleCount;
 534 }
 535
 536 RenderTarget9 *GetAttachmentRenderTarget(gl::FramebufferAttachment *attachment)
 537 {
 538     RenderTarget *renderTarget = rx::GetAttachmentRenderTarget(attachment);
 539     return RenderTarget9::makeRenderTarget9(renderTarget);
 540 }
 541
 542 }
 543
 544 }