1 // 2 // Copyright (c) 2012-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 // renderer11_utils.cpp: Conversion functions and other utility routines 8 // specific to the D3D11 renderer. 9 10 #include "libGLESv2/renderer/d3d/d3d11/renderer11_utils.h" 11 #include "libGLESv2/renderer/d3d/d3d11/formatutils11.h" 12 #include "libGLESv2/renderer/d3d/d3d11/RenderTarget11.h" 13 #include "libGLESv2/ProgramBinary.h" 14 #include "libGLESv2/Framebuffer.h" 15 16 #include "common/debug.h" 17 18 #include <algorithm> 19 20 namespace rx 21 { 22 23 namespace gl_d3d11 24 { 25 26 D3D11_BLEND ConvertBlendFunc(GLenum glBlend, bool isAlpha) 27 { 28 D3D11_BLEND d3dBlend = D3D11_BLEND_ZERO; 29 30 switch (glBlend) 31 { 32 case GL_ZERO: d3dBlend = D3D11_BLEND_ZERO; break; 33 case GL_ONE: d3dBlend = D3D11_BLEND_ONE; break; 34 case GL_SRC_COLOR: d3dBlend = (isAlpha ? D3D11_BLEND_SRC_ALPHA : D3D11_BLEND_SRC_COLOR); break; 35 case GL_ONE_MINUS_SRC_COLOR: d3dBlend = (isAlpha ? D3D11_BLEND_INV_SRC_ALPHA : D3D11_BLEND_INV_SRC_COLOR); break; 36 case GL_DST_COLOR: d3dBlend = (isAlpha ? D3D11_BLEND_DEST_ALPHA : D3D11_BLEND_DEST_COLOR); break; 37 case GL_ONE_MINUS_DST_COLOR: d3dBlend = (isAlpha ? D3D11_BLEND_INV_DEST_ALPHA : D3D11_BLEND_INV_DEST_COLOR); break; 38 case GL_SRC_ALPHA: d3dBlend = D3D11_BLEND_SRC_ALPHA; break; 39 case GL_ONE_MINUS_SRC_ALPHA: d3dBlend = D3D11_BLEND_INV_SRC_ALPHA; break; 40 case GL_DST_ALPHA: d3dBlend = D3D11_BLEND_DEST_ALPHA; break; 41 case GL_ONE_MINUS_DST_ALPHA: d3dBlend = D3D11_BLEND_INV_DEST_ALPHA; break; 42 case GL_CONSTANT_COLOR: d3dBlend = D3D11_BLEND_BLEND_FACTOR; break; 43 case GL_ONE_MINUS_CONSTANT_COLOR: d3dBlend = D3D11_BLEND_INV_BLEND_FACTOR; break; 44 case GL_CONSTANT_ALPHA: d3dBlend = D3D11_BLEND_BLEND_FACTOR; break; 45 case GL_ONE_MINUS_CONSTANT_ALPHA: d3dBlend = D3D11_BLEND_INV_BLEND_FACTOR; break; 46 case GL_SRC_ALPHA_SATURATE: d3dBlend = D3D11_BLEND_SRC_ALPHA_SAT; break; 47 default: UNREACHABLE(); 48 } 49 50 return d3dBlend; 51 } 52 53 D3D11_BLEND_OP ConvertBlendOp(GLenum glBlendOp) 54 { 55 D3D11_BLEND_OP d3dBlendOp = D3D11_BLEND_OP_ADD; 56 57 switch (glBlendOp) 58 { 59 case GL_FUNC_ADD: d3dBlendOp = D3D11_BLEND_OP_ADD; break; 60 case GL_FUNC_SUBTRACT: d3dBlendOp = D3D11_BLEND_OP_SUBTRACT; break; 61 case GL_FUNC_REVERSE_SUBTRACT: d3dBlendOp = D3D11_BLEND_OP_REV_SUBTRACT; break; 62 case GL_MIN: d3dBlendOp = D3D11_BLEND_OP_MIN; break; 63 case GL_MAX: d3dBlendOp = D3D11_BLEND_OP_MAX; break; 64 default: UNREACHABLE(); 65 } 66 67 return d3dBlendOp; 68 } 69 70 UINT8 ConvertColorMask(bool red, bool green, bool blue, bool alpha) 71 { 72 UINT8 mask = 0; 73 if (red) 74 { 75 mask |= D3D11_COLOR_WRITE_ENABLE_RED; 76 } 77 if (green) 78 { 79 mask |= D3D11_COLOR_WRITE_ENABLE_GREEN; 80 } 81 if (blue) 82 { 83 mask |= D3D11_COLOR_WRITE_ENABLE_BLUE; 84 } 85 if (alpha) 86 { 87 mask |= D3D11_COLOR_WRITE_ENABLE_ALPHA; 88 } 89 return mask; 90 } 91 92 D3D11_CULL_MODE ConvertCullMode(bool cullEnabled, GLenum cullMode) 93 { 94 D3D11_CULL_MODE cull = D3D11_CULL_NONE; 95 96 if (cullEnabled) 97 { 98 switch (cullMode) 99 { 100 case GL_FRONT: cull = D3D11_CULL_FRONT; break; 101 case GL_BACK: cull = D3D11_CULL_BACK; break; 102 case GL_FRONT_AND_BACK: cull = D3D11_CULL_NONE; break; 103 default: UNREACHABLE(); 104 } 105 } 106 else 107 { 108 cull = D3D11_CULL_NONE; 109 } 110 111 return cull; 112 } 113 114 D3D11_COMPARISON_FUNC ConvertComparison(GLenum comparison) 115 { 116 D3D11_COMPARISON_FUNC d3dComp = D3D11_COMPARISON_NEVER; 117 switch (comparison) 118 { 119 case GL_NEVER: d3dComp = D3D11_COMPARISON_NEVER; break; 120 case GL_ALWAYS: d3dComp = D3D11_COMPARISON_ALWAYS; break; 121 case GL_LESS: d3dComp = D3D11_COMPARISON_LESS; break; 122 case GL_LEQUAL: d3dComp = D3D11_COMPARISON_LESS_EQUAL; break; 123 case GL_EQUAL: d3dComp = D3D11_COMPARISON_EQUAL; break; 124 case GL_GREATER: d3dComp = D3D11_COMPARISON_GREATER; break; 125 case GL_GEQUAL: d3dComp = D3D11_COMPARISON_GREATER_EQUAL; break; 126 case GL_NOTEQUAL: d3dComp = D3D11_COMPARISON_NOT_EQUAL; break; 127 default: UNREACHABLE(); 128 } 129 130 return d3dComp; 131 } 132 133 D3D11_DEPTH_WRITE_MASK ConvertDepthMask(bool depthWriteEnabled) 134 { 135 return depthWriteEnabled ? D3D11_DEPTH_WRITE_MASK_ALL : D3D11_DEPTH_WRITE_MASK_ZERO; 136 } 137 138 UINT8 ConvertStencilMask(GLuint stencilmask) 139 { 140 return static_cast<UINT8>(stencilmask); 141 } 142 143 D3D11_STENCIL_OP ConvertStencilOp(GLenum stencilOp) 144 { 145 D3D11_STENCIL_OP d3dStencilOp = D3D11_STENCIL_OP_KEEP; 146 147 switch (stencilOp) 148 { 149 case GL_ZERO: d3dStencilOp = D3D11_STENCIL_OP_ZERO; break; 150 case GL_KEEP: d3dStencilOp = D3D11_STENCIL_OP_KEEP; break; 151 case GL_REPLACE: d3dStencilOp = D3D11_STENCIL_OP_REPLACE; break; 152 case GL_INCR: d3dStencilOp = D3D11_STENCIL_OP_INCR_SAT; break; 153 case GL_DECR: d3dStencilOp = D3D11_STENCIL_OP_DECR_SAT; break; 154 case GL_INVERT: d3dStencilOp = D3D11_STENCIL_OP_INVERT; break; 155 case GL_INCR_WRAP: d3dStencilOp = D3D11_STENCIL_OP_INCR; break; 156 case GL_DECR_WRAP: d3dStencilOp = D3D11_STENCIL_OP_DECR; break; 157 default: UNREACHABLE(); 158 } 159 160 return d3dStencilOp; 161 } 162 163 D3D11_FILTER ConvertFilter(GLenum minFilter, GLenum magFilter, float maxAnisotropy, GLenum comparisonMode) 164 { 165 bool comparison = comparisonMode != GL_NONE; 166 167 if (maxAnisotropy > 1.0f) 168 { 169 return D3D11_ENCODE_ANISOTROPIC_FILTER(static_cast<D3D11_COMPARISON_FUNC>(comparison)); 170 } 171 else 172 { 173 D3D11_FILTER_TYPE dxMin = D3D11_FILTER_TYPE_POINT; 174 D3D11_FILTER_TYPE dxMip = D3D11_FILTER_TYPE_POINT; 175 switch (minFilter) 176 { 177 case GL_NEAREST: dxMin = D3D11_FILTER_TYPE_POINT; dxMip = D3D11_FILTER_TYPE_POINT; break; 178 case GL_LINEAR: dxMin = D3D11_FILTER_TYPE_LINEAR; dxMip = D3D11_FILTER_TYPE_POINT; break; 179 case GL_NEAREST_MIPMAP_NEAREST: dxMin = D3D11_FILTER_TYPE_POINT; dxMip = D3D11_FILTER_TYPE_POINT; break; 180 case GL_LINEAR_MIPMAP_NEAREST: dxMin = D3D11_FILTER_TYPE_LINEAR; dxMip = D3D11_FILTER_TYPE_POINT; break; 181 case GL_NEAREST_MIPMAP_LINEAR: dxMin = D3D11_FILTER_TYPE_POINT; dxMip = D3D11_FILTER_TYPE_LINEAR; break; 182 case GL_LINEAR_MIPMAP_LINEAR: dxMin = D3D11_FILTER_TYPE_LINEAR; dxMip = D3D11_FILTER_TYPE_LINEAR; break; 183 default: UNREACHABLE(); 184 } 185 186 D3D11_FILTER_TYPE dxMag = D3D11_FILTER_TYPE_POINT; 187 switch (magFilter) 188 { 189 case GL_NEAREST: dxMag = D3D11_FILTER_TYPE_POINT; break; 190 case GL_LINEAR: dxMag = D3D11_FILTER_TYPE_LINEAR; break; 191 default: UNREACHABLE(); 192 } 193 194 return D3D11_ENCODE_BASIC_FILTER(dxMin, dxMag, dxMip, static_cast<D3D11_COMPARISON_FUNC>(comparison)); 195 } 196 } 197 198 D3D11_TEXTURE_ADDRESS_MODE ConvertTextureWrap(GLenum wrap) 199 { 200 switch (wrap) 201 { 202 case GL_REPEAT: return D3D11_TEXTURE_ADDRESS_WRAP; 203 case GL_CLAMP_TO_EDGE: return D3D11_TEXTURE_ADDRESS_CLAMP; 204 case GL_MIRRORED_REPEAT: return D3D11_TEXTURE_ADDRESS_MIRROR; 205 default: UNREACHABLE(); 206 } 207 208 return D3D11_TEXTURE_ADDRESS_WRAP; 209 } 210 211 D3D11_QUERY ConvertQueryType(GLenum queryType) 212 { 213 switch (queryType) 214 { 215 case GL_ANY_SAMPLES_PASSED_EXT: 216 case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT: return D3D11_QUERY_OCCLUSION; 217 case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: return D3D11_QUERY_SO_STATISTICS; 218 default: UNREACHABLE(); return D3D11_QUERY_EVENT; 219 } 220 } 221 222 } 223 224 225 namespace d3d11_gl 226 { 227 228 static gl::TextureCaps GenerateTextureFormatCaps(GLenum internalFormat, ID3D11Device *device) 229 { 230 gl::TextureCaps textureCaps; 231 232 const d3d11::TextureFormat &formatInfo = d3d11::GetTextureFormatInfo(internalFormat); 233 234 UINT formatSupport; 235 if (SUCCEEDED(device->CheckFormatSupport(formatInfo.texFormat, &formatSupport))) 236 { 237 const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(internalFormat); 238 if (formatInfo.depthBits > 0 || formatInfo.stencilBits > 0) 239 { 240 textureCaps.texturable = ((formatSupport & D3D11_FORMAT_SUPPORT_TEXTURE2D) != 0); 241 } 242 else 243 { 244 textureCaps.texturable = ((formatSupport & D3D11_FORMAT_SUPPORT_TEXTURE2D) != 0) && 245 ((formatSupport & D3D11_FORMAT_SUPPORT_TEXTURECUBE) != 0) && 246 ((formatSupport & D3D11_FORMAT_SUPPORT_TEXTURE3D) != 0); 247 } 248 } 249 250 if (SUCCEEDED(device->CheckFormatSupport(formatInfo.renderFormat, &formatSupport)) && 251 ((formatSupport & D3D11_FORMAT_SUPPORT_MULTISAMPLE_RENDERTARGET) != 0)) 252 { 253 for (size_t sampleCount = 1; sampleCount <= D3D11_MAX_MULTISAMPLE_SAMPLE_COUNT; sampleCount++) 254 { 255 UINT qualityCount = 0; 256 if (SUCCEEDED(device->CheckMultisampleQualityLevels(formatInfo.renderFormat, sampleCount, &qualityCount)) && 257 qualityCount > 0) 258 { 259 textureCaps.sampleCounts.insert(sampleCount); 260 } 261 } 262 } 263 264 textureCaps.filterable = SUCCEEDED(device->CheckFormatSupport(formatInfo.srvFormat, &formatSupport)) && 265 ((formatSupport & D3D11_FORMAT_SUPPORT_SHADER_SAMPLE)) != 0; 266 textureCaps.renderable = (SUCCEEDED(device->CheckFormatSupport(formatInfo.rtvFormat, &formatSupport)) && 267 ((formatSupport & D3D11_FORMAT_SUPPORT_RENDER_TARGET)) != 0) || 268 (SUCCEEDED(device->CheckFormatSupport(formatInfo.dsvFormat, &formatSupport)) && 269 ((formatSupport & D3D11_FORMAT_SUPPORT_DEPTH_STENCIL) != 0)); 270 271 return textureCaps; 272 } 273 274 static bool GetNPOTTextureSupport(D3D_FEATURE_LEVEL featureLevel) 275 { 276 switch (featureLevel) 277 { 278 case D3D_FEATURE_LEVEL_11_1: 279 case D3D_FEATURE_LEVEL_11_0: 280 case D3D_FEATURE_LEVEL_10_1: 281 case D3D_FEATURE_LEVEL_10_0: return true; 282 283 // From http://msdn.microsoft.com/en-us/library/windows/desktop/ff476876.aspx 284 case D3D_FEATURE_LEVEL_9_3: 285 case D3D_FEATURE_LEVEL_9_2: 286 case D3D_FEATURE_LEVEL_9_1: return false; 287 288 default: UNREACHABLE(); return false; 289 } 290 } 291 292 static float GetMaximumAnisotropy(D3D_FEATURE_LEVEL featureLevel) 293 { 294 switch (featureLevel) 295 { 296 case D3D_FEATURE_LEVEL_11_1: 297 case D3D_FEATURE_LEVEL_11_0: return D3D11_MAX_MAXANISOTROPY; 298 299 case D3D_FEATURE_LEVEL_10_1: 300 case D3D_FEATURE_LEVEL_10_0: return D3D10_MAX_MAXANISOTROPY; 301 302 // From http://msdn.microsoft.com/en-us/library/windows/desktop/ff476876.aspx 303 case D3D_FEATURE_LEVEL_9_3: 304 case D3D_FEATURE_LEVEL_9_2: return 16; 305 306 case D3D_FEATURE_LEVEL_9_1: return D3D_FL9_1_DEFAULT_MAX_ANISOTROPY; 307 308 default: UNREACHABLE(); return 0; 309 } 310 } 311 312 static bool GetOcclusionQuerySupport(D3D_FEATURE_LEVEL featureLevel) 313 { 314 switch (featureLevel) 315 { 316 case D3D_FEATURE_LEVEL_11_1: 317 case D3D_FEATURE_LEVEL_11_0: 318 case D3D_FEATURE_LEVEL_10_1: 319 case D3D_FEATURE_LEVEL_10_0: return true; 320 321 // From http://msdn.microsoft.com/en-us/library/windows/desktop/ff476150.aspx ID3D11Device::CreateQuery 322 case D3D_FEATURE_LEVEL_9_3: 323 case D3D_FEATURE_LEVEL_9_2: return true; 324 case D3D_FEATURE_LEVEL_9_1: return false; 325 326 default: UNREACHABLE(); return false; 327 } 328 } 329 330 static bool GetEventQuerySupport(D3D_FEATURE_LEVEL featureLevel) 331 { 332 // From http://msdn.microsoft.com/en-us/library/windows/desktop/ff476150.aspx ID3D11Device::CreateQuery 333 334 switch (featureLevel) 335 { 336 case D3D_FEATURE_LEVEL_11_1: 337 case D3D_FEATURE_LEVEL_11_0: 338 case D3D_FEATURE_LEVEL_10_1: 339 case D3D_FEATURE_LEVEL_10_0: 340 case D3D_FEATURE_LEVEL_9_3: 341 case D3D_FEATURE_LEVEL_9_2: 342 case D3D_FEATURE_LEVEL_9_1: return true; 343 344 default: UNREACHABLE(); return false; 345 } 346 } 347 348 static bool GetInstancingSupport(D3D_FEATURE_LEVEL featureLevel) 349 { 350 // From http://msdn.microsoft.com/en-us/library/windows/desktop/ff476150.aspx ID3D11Device::CreateInputLayout 351 352 switch (featureLevel) 353 { 354 case D3D_FEATURE_LEVEL_11_1: 355 case D3D_FEATURE_LEVEL_11_0: 356 case D3D_FEATURE_LEVEL_10_1: 357 case D3D_FEATURE_LEVEL_10_0: 358 case D3D_FEATURE_LEVEL_9_3: return true; 359 360 case D3D_FEATURE_LEVEL_9_2: 361 case D3D_FEATURE_LEVEL_9_1: return false; 362 363 default: UNREACHABLE(); return false; 364 } 365 } 366 367 static bool GetDerivativeInstructionSupport(D3D_FEATURE_LEVEL featureLevel) 368 { 369 // http://msdn.microsoft.com/en-us/library/windows/desktop/bb509588.aspx states that shader model 370 // ps_2_x is required for the ddx (and other derivative functions). 371 372 // http://msdn.microsoft.com/en-us/library/windows/desktop/ff476876.aspx states that feature level 373 // 9.3 supports shader model ps_2_x. 374 375 switch (featureLevel) 376 { 377 case D3D_FEATURE_LEVEL_11_1: 378 case D3D_FEATURE_LEVEL_11_0: 379 case D3D_FEATURE_LEVEL_10_1: 380 case D3D_FEATURE_LEVEL_10_0: 381 case D3D_FEATURE_LEVEL_9_3: return true; 382 case D3D_FEATURE_LEVEL_9_2: 383 case D3D_FEATURE_LEVEL_9_1: return false; 384 385 default: UNREACHABLE(); return false; 386 } 387 } 388 389 static size_t GetMaximumSimultaneousRenderTargets(D3D_FEATURE_LEVEL featureLevel) 390 { 391 // From http://msdn.microsoft.com/en-us/library/windows/desktop/ff476150.aspx ID3D11Device::CreateInputLayout 392 393 switch (featureLevel) 394 { 395 case D3D_FEATURE_LEVEL_11_1: 396 case D3D_FEATURE_LEVEL_11_0: return D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; 397 398 case D3D_FEATURE_LEVEL_10_1: 399 case D3D_FEATURE_LEVEL_10_0: return D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT; 400 401 case D3D_FEATURE_LEVEL_9_3: return D3D_FL9_3_SIMULTANEOUS_RENDER_TARGET_COUNT; 402 case D3D_FEATURE_LEVEL_9_2: 403 case D3D_FEATURE_LEVEL_9_1: return D3D_FL9_1_SIMULTANEOUS_RENDER_TARGET_COUNT; 404 405 default: UNREACHABLE(); return 0; 406 } 407 } 408 409 static size_t GetMaximum2DTextureSize(D3D_FEATURE_LEVEL featureLevel) 410 { 411 switch (featureLevel) 412 { 413 case D3D_FEATURE_LEVEL_11_1: 414 case D3D_FEATURE_LEVEL_11_0: return D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION; 415 416 case D3D_FEATURE_LEVEL_10_1: 417 case D3D_FEATURE_LEVEL_10_0: return D3D10_REQ_TEXTURE2D_U_OR_V_DIMENSION; 418 419 case D3D_FEATURE_LEVEL_9_3: return D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION; 420 case D3D_FEATURE_LEVEL_9_2: 421 case D3D_FEATURE_LEVEL_9_1: return D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION; 422 423 default: UNREACHABLE(); return 0; 424 } 425 } 426 427 static size_t GetMaximumCubeMapTextureSize(D3D_FEATURE_LEVEL featureLevel) 428 { 429 switch (featureLevel) 430 { 431 case D3D_FEATURE_LEVEL_11_1: 432 case D3D_FEATURE_LEVEL_11_0: return D3D11_REQ_TEXTURECUBE_DIMENSION; 433 434 case D3D_FEATURE_LEVEL_10_1: 435 case D3D_FEATURE_LEVEL_10_0: return D3D10_REQ_TEXTURECUBE_DIMENSION; 436 437 case D3D_FEATURE_LEVEL_9_3: return D3D_FL9_3_REQ_TEXTURECUBE_DIMENSION; 438 case D3D_FEATURE_LEVEL_9_2: 439 case D3D_FEATURE_LEVEL_9_1: return D3D_FL9_1_REQ_TEXTURECUBE_DIMENSION; 440 441 default: UNREACHABLE(); return 0; 442 } 443 } 444 445 static size_t GetMaximum2DTextureArraySize(D3D_FEATURE_LEVEL featureLevel) 446 { 447 switch (featureLevel) 448 { 449 case D3D_FEATURE_LEVEL_11_1: 450 case D3D_FEATURE_LEVEL_11_0: return D3D11_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION; 451 452 case D3D_FEATURE_LEVEL_10_1: 453 case D3D_FEATURE_LEVEL_10_0: return D3D10_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION; 454 455 case D3D_FEATURE_LEVEL_9_3: 456 case D3D_FEATURE_LEVEL_9_2: 457 case D3D_FEATURE_LEVEL_9_1: return 0; 458 459 default: UNREACHABLE(); return 0; 460 } 461 } 462 463 static size_t GetMaximum3DTextureSize(D3D_FEATURE_LEVEL featureLevel) 464 { 465 switch (featureLevel) 466 { 467 case D3D_FEATURE_LEVEL_11_1: 468 case D3D_FEATURE_LEVEL_11_0: return D3D11_REQ_TEXTURE3D_U_V_OR_W_DIMENSION; 469 470 case D3D_FEATURE_LEVEL_10_1: 471 case D3D_FEATURE_LEVEL_10_0: return D3D10_REQ_TEXTURE3D_U_V_OR_W_DIMENSION; 472 473 case D3D_FEATURE_LEVEL_9_3: 474 case D3D_FEATURE_LEVEL_9_2: 475 case D3D_FEATURE_LEVEL_9_1: return D3D_FL9_1_REQ_TEXTURE3D_U_V_OR_W_DIMENSION; 476 477 default: UNREACHABLE(); return 0; 478 } 479 } 480 481 static size_t GetMaximumViewportSize(D3D_FEATURE_LEVEL featureLevel) 482 { 483 switch (featureLevel) 484 { 485 case D3D_FEATURE_LEVEL_11_1: 486 case D3D_FEATURE_LEVEL_11_0: return D3D11_VIEWPORT_BOUNDS_MAX; 487 488 case D3D_FEATURE_LEVEL_10_1: 489 case D3D_FEATURE_LEVEL_10_0: return D3D10_VIEWPORT_BOUNDS_MAX; 490 491 // No constants for D3D9 viewport size limits, use the maximum texture sizes 492 case D3D_FEATURE_LEVEL_9_3: return D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION; 493 case D3D_FEATURE_LEVEL_9_2: 494 case D3D_FEATURE_LEVEL_9_1: return D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION; 495 496 default: UNREACHABLE(); return 0; 497 } 498 } 499 500 static size_t GetMaximumDrawIndexedIndexCount(D3D_FEATURE_LEVEL featureLevel) 501 { 502 // D3D11 allows up to 2^32 elements, but we report max signed int for convenience since that's what's 503 // returned from glGetInteger 504 META_ASSERT(D3D11_REQ_DRAWINDEXED_INDEX_COUNT_2_TO_EXP == 32); 505 META_ASSERT(D3D10_REQ_DRAWINDEXED_INDEX_COUNT_2_TO_EXP == 32); 506 507 switch (featureLevel) 508 { 509 case D3D_FEATURE_LEVEL_11_1: 510 case D3D_FEATURE_LEVEL_11_0: 511 case D3D_FEATURE_LEVEL_10_1: 512 case D3D_FEATURE_LEVEL_10_0: return std::numeric_limits<GLint>::max(); 513 514 case D3D_FEATURE_LEVEL_9_3: 515 case D3D_FEATURE_LEVEL_9_2: return D3D_FL9_2_IA_PRIMITIVE_MAX_COUNT; 516 case D3D_FEATURE_LEVEL_9_1: return D3D_FL9_1_IA_PRIMITIVE_MAX_COUNT; 517 518 default: UNREACHABLE(); return 0; 519 } 520 } 521 522 static size_t GetMaximumDrawVertexCount(D3D_FEATURE_LEVEL featureLevel) 523 { 524 // D3D11 allows up to 2^32 elements, but we report max signed int for convenience since that's what's 525 // returned from glGetInteger 526 META_ASSERT(D3D11_REQ_DRAW_VERTEX_COUNT_2_TO_EXP == 32); 527 META_ASSERT(D3D10_REQ_DRAW_VERTEX_COUNT_2_TO_EXP == 32); 528 529 switch (featureLevel) 530 { 531 case D3D_FEATURE_LEVEL_11_1: 532 case D3D_FEATURE_LEVEL_11_0: 533 case D3D_FEATURE_LEVEL_10_1: 534 case D3D_FEATURE_LEVEL_10_0: return std::numeric_limits<GLint>::max(); 535 536 case D3D_FEATURE_LEVEL_9_3: 537 case D3D_FEATURE_LEVEL_9_2: return D3D_FL9_2_IA_PRIMITIVE_MAX_COUNT; 538 case D3D_FEATURE_LEVEL_9_1: return D3D_FL9_1_IA_PRIMITIVE_MAX_COUNT; 539 540 default: UNREACHABLE(); return 0; 541 } 542 } 543 544 static size_t GetMaximumVertexInputSlots(D3D_FEATURE_LEVEL featureLevel) 545 { 546 switch (featureLevel) 547 { 548 case D3D_FEATURE_LEVEL_11_1: 549 case D3D_FEATURE_LEVEL_11_0: return D3D11_STANDARD_VERTEX_ELEMENT_COUNT; 550 551 case D3D_FEATURE_LEVEL_10_1: return D3D10_1_STANDARD_VERTEX_ELEMENT_COUNT; 552 case D3D_FEATURE_LEVEL_10_0: return D3D10_STANDARD_VERTEX_ELEMENT_COUNT; 553 554 // From http://http://msdn.microsoft.com/en-us/library/windows/desktop/ff476876.aspx "Max Input Slots" 555 case D3D_FEATURE_LEVEL_9_3: 556 case D3D_FEATURE_LEVEL_9_2: 557 case D3D_FEATURE_LEVEL_9_1: return 16; 558 559 default: UNREACHABLE(); return 0; 560 } 561 } 562 563 static size_t GetMaximumVertexUniformVectors(D3D_FEATURE_LEVEL featureLevel) 564 { 565 // TODO(geofflang): Remove hard-coded limit once the gl-uniform-arrays test can pass 566 switch (featureLevel) 567 { 568 case D3D_FEATURE_LEVEL_11_1: 569 case D3D_FEATURE_LEVEL_11_0: return 1024; // D3D11_REQ_CONSTANT_BUFFER_ELEMENT_COUNT; 570 571 case D3D_FEATURE_LEVEL_10_1: 572 case D3D_FEATURE_LEVEL_10_0: return 1024; // D3D10_REQ_CONSTANT_BUFFER_ELEMENT_COUNT; 573 574 // From http://msdn.microsoft.com/en-us/library/windows/desktop/ff476149.aspx ID3D11DeviceContext::VSSetConstantBuffers 575 case D3D_FEATURE_LEVEL_9_3: 576 case D3D_FEATURE_LEVEL_9_2: 577 case D3D_FEATURE_LEVEL_9_1: return 255; 578 579 default: UNREACHABLE(); return 0; 580 } 581 } 582 583 static size_t GetReservedVertexUniformBuffers() 584 { 585 // Reserve one buffer for the application uniforms, and one for driver uniforms 586 return 2; 587 } 588 589 static size_t GetMaximumVertexUniformBlocks(D3D_FEATURE_LEVEL featureLevel) 590 { 591 switch (featureLevel) 592 { 593 case D3D_FEATURE_LEVEL_11_1: 594 case D3D_FEATURE_LEVEL_11_0: return D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - GetReservedVertexUniformBuffers(); 595 596 case D3D_FEATURE_LEVEL_10_1: 597 case D3D_FEATURE_LEVEL_10_0: return D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - GetReservedVertexUniformBuffers(); 598 599 // Uniform blocks not supported in D3D9 feature levels 600 case D3D_FEATURE_LEVEL_9_3: 601 case D3D_FEATURE_LEVEL_9_2: 602 case D3D_FEATURE_LEVEL_9_1: return 0; 603 604 default: UNREACHABLE(); return 0; 605 } 606 } 607 608 static size_t GetReservedVertexOutputVectors() 609 { 610 // We potentially reserve varyings for gl_Position, dx_Position, gl_FragCoord and gl_PointSize 611 return 4; 612 } 613 614 static size_t GetMaximumVertexOutputVectors(D3D_FEATURE_LEVEL featureLevel) 615 { 616 META_ASSERT(gl::IMPLEMENTATION_MAX_VARYING_VECTORS == D3D11_VS_OUTPUT_REGISTER_COUNT); 617 618 switch (featureLevel) 619 { 620 case D3D_FEATURE_LEVEL_11_1: 621 case D3D_FEATURE_LEVEL_11_0: return D3D11_VS_OUTPUT_REGISTER_COUNT - GetReservedVertexOutputVectors(); 622 623 case D3D_FEATURE_LEVEL_10_1: return D3D10_1_VS_OUTPUT_REGISTER_COUNT - GetReservedVertexOutputVectors(); 624 case D3D_FEATURE_LEVEL_10_0: return D3D10_VS_OUTPUT_REGISTER_COUNT - GetReservedVertexOutputVectors(); 625 626 // Use D3D9 SM3 and SM2 limits 627 case D3D_FEATURE_LEVEL_9_3: return 10 - GetReservedVertexOutputVectors(); 628 case D3D_FEATURE_LEVEL_9_2: 629 case D3D_FEATURE_LEVEL_9_1: return 8 - GetReservedVertexOutputVectors(); 630 631 default: UNREACHABLE(); return 0; 632 } 633 } 634 635 static size_t GetMaximumVertexTextureUnits(D3D_FEATURE_LEVEL featureLevel) 636 { 637 switch (featureLevel) 638 { 639 case D3D_FEATURE_LEVEL_11_1: 640 case D3D_FEATURE_LEVEL_11_0: return D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT; 641 642 case D3D_FEATURE_LEVEL_10_1: 643 case D3D_FEATURE_LEVEL_10_0: return D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT; 644 645 // Vertex textures not supported in D3D9 feature levels according to 646 // http://msdn.microsoft.com/en-us/library/windows/desktop/ff476149.aspx 647 // ID3D11DeviceContext::VSSetSamplers and ID3D11DeviceContext::VSSetShaderResources 648 case D3D_FEATURE_LEVEL_9_3: 649 case D3D_FEATURE_LEVEL_9_2: 650 case D3D_FEATURE_LEVEL_9_1: return 0; 651 652 default: UNREACHABLE(); return 0; 653 } 654 } 655 656 static size_t GetMaximumPixelUniformVectors(D3D_FEATURE_LEVEL featureLevel) 657 { 658 // TODO(geofflang): Remove hard-coded limit once the gl-uniform-arrays test can pass 659 switch (featureLevel) 660 { 661 case D3D_FEATURE_LEVEL_11_1: 662 case D3D_FEATURE_LEVEL_11_0: return 1024; // D3D11_REQ_CONSTANT_BUFFER_ELEMENT_COUNT; 663 664 case D3D_FEATURE_LEVEL_10_1: 665 case D3D_FEATURE_LEVEL_10_0: return 1024; // D3D10_REQ_CONSTANT_BUFFER_ELEMENT_COUNT; 666 667 // From http://msdn.microsoft.com/en-us/library/windows/desktop/ff476149.aspx ID3D11DeviceContext::PSSetConstantBuffers 668 case D3D_FEATURE_LEVEL_9_3: 669 case D3D_FEATURE_LEVEL_9_2: 670 case D3D_FEATURE_LEVEL_9_1: return 32; 671 672 default: UNREACHABLE(); return 0; 673 } 674 } 675 676 static size_t GetReservedPixelUniformBuffers() 677 { 678 // Reserve one buffer for the application uniforms, and one for driver uniforms 679 return 2; 680 } 681 682 static size_t GetMaximumPixelUniformBlocks(D3D_FEATURE_LEVEL featureLevel) 683 { 684 switch (featureLevel) 685 { 686 case D3D_FEATURE_LEVEL_11_1: 687 case D3D_FEATURE_LEVEL_11_0: return D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - GetReservedPixelUniformBuffers(); 688 689 case D3D_FEATURE_LEVEL_10_1: 690 case D3D_FEATURE_LEVEL_10_0: return D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - GetReservedPixelUniformBuffers(); 691 692 // Uniform blocks not supported in D3D9 feature levels 693 case D3D_FEATURE_LEVEL_9_3: 694 case D3D_FEATURE_LEVEL_9_2: 695 case D3D_FEATURE_LEVEL_9_1: return 0; 696 697 default: UNREACHABLE(); return 0; 698 } 699 } 700 701 static size_t GetMaximumPixelInputVectors(D3D_FEATURE_LEVEL featureLevel) 702 { 703 switch (featureLevel) 704 { 705 case D3D_FEATURE_LEVEL_11_1: 706 case D3D_FEATURE_LEVEL_11_0: return D3D11_PS_INPUT_REGISTER_COUNT - GetReservedVertexOutputVectors(); 707 708 case D3D_FEATURE_LEVEL_10_1: 709 case D3D_FEATURE_LEVEL_10_0: return D3D10_PS_INPUT_REGISTER_COUNT - GetReservedVertexOutputVectors(); 710 711 // Use D3D9 SM3 and SM2 limits 712 case D3D_FEATURE_LEVEL_9_3: return 10 - GetReservedVertexOutputVectors(); 713 case D3D_FEATURE_LEVEL_9_2: 714 case D3D_FEATURE_LEVEL_9_1: return 8 - GetReservedVertexOutputVectors(); 715 716 default: UNREACHABLE(); return 0; 717 } 718 } 719 720 static size_t GetMaximumPixelTextureUnits(D3D_FEATURE_LEVEL featureLevel) 721 { 722 switch (featureLevel) 723 { 724 case D3D_FEATURE_LEVEL_11_1: 725 case D3D_FEATURE_LEVEL_11_0: return D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT; 726 727 case D3D_FEATURE_LEVEL_10_1: 728 case D3D_FEATURE_LEVEL_10_0: return D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT; 729 730 // http://msdn.microsoft.com/en-us/library/windows/desktop/ff476149.aspx ID3D11DeviceContext::PSSetShaderResources 731 case D3D_FEATURE_LEVEL_9_3: 732 case D3D_FEATURE_LEVEL_9_2: 733 case D3D_FEATURE_LEVEL_9_1: return 16; 734 735 default: UNREACHABLE(); return 0; 736 } 737 } 738 739 static int GetMinimumTexelOffset(D3D_FEATURE_LEVEL featureLevel) 740 { 741 switch (featureLevel) 742 { 743 case D3D_FEATURE_LEVEL_11_1: 744 case D3D_FEATURE_LEVEL_11_0: return D3D11_COMMONSHADER_TEXEL_OFFSET_MAX_NEGATIVE; 745 746 case D3D_FEATURE_LEVEL_10_1: 747 case D3D_FEATURE_LEVEL_10_0: return D3D10_COMMONSHADER_TEXEL_OFFSET_MAX_NEGATIVE; 748 749 // Sampling functions with offsets are not available below shader model 4.0. 750 case D3D_FEATURE_LEVEL_9_3: 751 case D3D_FEATURE_LEVEL_9_2: 752 case D3D_FEATURE_LEVEL_9_1: return 0; 753 754 default: UNREACHABLE(); return 0; 755 } 756 } 757 758 static int GetMaximumTexelOffset(D3D_FEATURE_LEVEL featureLevel) 759 { 760 switch (featureLevel) 761 { 762 case D3D_FEATURE_LEVEL_11_1: 763 case D3D_FEATURE_LEVEL_11_0: return D3D11_COMMONSHADER_TEXEL_OFFSET_MAX_POSITIVE; 764 case D3D_FEATURE_LEVEL_10_1: 765 case D3D_FEATURE_LEVEL_10_0: return D3D11_COMMONSHADER_TEXEL_OFFSET_MAX_POSITIVE; 766 767 // Sampling functions with offsets are not available below shader model 4.0. 768 case D3D_FEATURE_LEVEL_9_3: 769 case D3D_FEATURE_LEVEL_9_2: 770 case D3D_FEATURE_LEVEL_9_1: return 0; 771 772 default: UNREACHABLE(); return 0; 773 } 774 } 775 776 static size_t GetMaximumConstantBufferSize(D3D_FEATURE_LEVEL featureLevel) 777 { 778 // Returns a size_t despite the limit being a GLuint64 because size_t is the maximum size of 779 // any buffer that could be allocated. 780 781 const size_t bytesPerComponent = 4 * sizeof(float); 782 783 switch (featureLevel) 784 { 785 case D3D_FEATURE_LEVEL_11_1: 786 case D3D_FEATURE_LEVEL_11_0: return D3D11_REQ_CONSTANT_BUFFER_ELEMENT_COUNT * bytesPerComponent; 787 788 case D3D_FEATURE_LEVEL_10_1: 789 case D3D_FEATURE_LEVEL_10_0: return D3D10_REQ_CONSTANT_BUFFER_ELEMENT_COUNT * bytesPerComponent; 790 791 // Limits from http://msdn.microsoft.com/en-us/library/windows/desktop/ff476501.aspx remarks section 792 case D3D_FEATURE_LEVEL_9_3: 793 case D3D_FEATURE_LEVEL_9_2: 794 case D3D_FEATURE_LEVEL_9_1: return 4096 * bytesPerComponent; 795 796 default: UNREACHABLE(); return 0; 797 } 798 } 799 800 static size_t GetMaximumStreamOutputBuffers(D3D_FEATURE_LEVEL featureLevel) 801 { 802 switch (featureLevel) 803 { 804 case D3D_FEATURE_LEVEL_11_1: 805 case D3D_FEATURE_LEVEL_11_0: return D3D11_SO_BUFFER_SLOT_COUNT; 806 807 case D3D_FEATURE_LEVEL_10_1: return D3D10_1_SO_BUFFER_SLOT_COUNT; 808 case D3D_FEATURE_LEVEL_10_0: return D3D10_SO_BUFFER_SLOT_COUNT; 809 810 case D3D_FEATURE_LEVEL_9_3: 811 case D3D_FEATURE_LEVEL_9_2: 812 case D3D_FEATURE_LEVEL_9_1: return 0; 813 814 default: UNREACHABLE(); return 0; 815 } 816 } 817 818 static size_t GetMaximumStreamOutputInterleavedComponenets(D3D_FEATURE_LEVEL featureLevel) 819 { 820 switch (featureLevel) 821 { 822 case D3D_FEATURE_LEVEL_11_1: 823 case D3D_FEATURE_LEVEL_11_0: 824 825 case D3D_FEATURE_LEVEL_10_1: 826 case D3D_FEATURE_LEVEL_10_0: return GetMaximumVertexOutputVectors(featureLevel) * 4; 827 828 case D3D_FEATURE_LEVEL_9_3: 829 case D3D_FEATURE_LEVEL_9_2: 830 case D3D_FEATURE_LEVEL_9_1: return 0; 831 832 default: UNREACHABLE(); return 0; 833 } 834 } 835 836 static size_t GetMaximumStreamOutputSeparateCompeonents(D3D_FEATURE_LEVEL featureLevel) 837 { 838 switch (featureLevel) 839 { 840 case D3D_FEATURE_LEVEL_11_1: 841 case D3D_FEATURE_LEVEL_11_0: return GetMaximumStreamOutputInterleavedComponenets(featureLevel) / 842 GetMaximumStreamOutputBuffers(featureLevel); 843 844 845 // D3D 10 and 10.1 only allow one output per output slot if an output slot other than zero is used. 846 case D3D_FEATURE_LEVEL_10_1: 847 case D3D_FEATURE_LEVEL_10_0: return 4; 848 849 case D3D_FEATURE_LEVEL_9_3: 850 case D3D_FEATURE_LEVEL_9_2: 851 case D3D_FEATURE_LEVEL_9_1: return 0; 852 853 default: UNREACHABLE(); return 0; 854 } 855 } 856 857 void GenerateCaps(ID3D11Device *device, gl::Caps *caps, gl::TextureCapsMap *textureCapsMap, gl::Extensions *extensions) 858 { 859 GLuint maxSamples = 0; 860 const gl::FormatSet &allFormats = gl::GetAllSizedInternalFormats(); 861 for (gl::FormatSet::const_iterator internalFormat = allFormats.begin(); internalFormat != allFormats.end(); ++internalFormat) 862 { 863 gl::TextureCaps textureCaps = GenerateTextureFormatCaps(*internalFormat, device); 864 textureCapsMap->insert(*internalFormat, textureCaps); 865 866 maxSamples = std::max(maxSamples, textureCaps.getMaxSamples()); 867 868 if (gl::GetInternalFormatInfo(*internalFormat).compressed) 869 { 870 caps->compressedTextureFormats.push_back(*internalFormat); 871 } 872 } 873 874 D3D_FEATURE_LEVEL featureLevel = device->GetFeatureLevel(); 875 876 // GL core feature limits 877 caps->maxElementIndex = static_cast<GLint64>(std::numeric_limits<unsigned int>::max()); 878 caps->max3DTextureSize = GetMaximum3DTextureSize(featureLevel); 879 caps->max2DTextureSize = GetMaximum2DTextureSize(featureLevel); 880 caps->maxCubeMapTextureSize = GetMaximumCubeMapTextureSize(featureLevel); 881 caps->maxArrayTextureLayers = GetMaximum2DTextureArraySize(featureLevel); 882 883 // Unimplemented, set to minimum required 884 caps->maxLODBias = 2.0f; 885 886 // No specific limits on render target size, maximum 2D texture size is equivalent 887 caps->maxRenderbufferSize = caps->max2DTextureSize; 888 889 // Maximum draw buffers and color attachments are the same, max color attachments could eventually be 890 // increased to 16 891 caps->maxDrawBuffers = GetMaximumSimultaneousRenderTargets(featureLevel); 892 caps->maxColorAttachments = GetMaximumSimultaneousRenderTargets(featureLevel); 893 894 // D3D11 has the same limit for viewport width and height 895 caps->maxViewportWidth = GetMaximumViewportSize(featureLevel); 896 caps->maxViewportHeight = caps->maxViewportWidth; 897 898 // Choose a reasonable maximum, enforced in the shader. 899 caps->minAliasedPointSize = 1.0f; 900 caps->maxAliasedPointSize = 1024.0f; 901 902 // Wide lines not supported 903 caps->minAliasedLineWidth = 1.0f; 904 caps->maxAliasedLineWidth = 1.0f; 905 906 // Primitive count limits 907 caps->maxElementsIndices = GetMaximumDrawIndexedIndexCount(featureLevel); 908 caps->maxElementsVertices = GetMaximumDrawVertexCount(featureLevel); 909 910 // Program and shader binary formats (no supported shader binary formats) 911 caps->programBinaryFormats.push_back(GL_PROGRAM_BINARY_ANGLE); 912 913 // We do not wait for server fence objects internally, so report a max timeout of zero. 914 caps->maxServerWaitTimeout = 0; 915 916 // Vertex shader limits 917 caps->maxVertexAttributes = GetMaximumVertexInputSlots(featureLevel); 918 caps->maxVertexUniformComponents = GetMaximumVertexUniformVectors(featureLevel) * 4; 919 caps->maxVertexUniformVectors = GetMaximumVertexUniformVectors(featureLevel); 920 caps->maxVertexUniformBlocks = GetMaximumVertexUniformBlocks(featureLevel); 921 caps->maxVertexOutputComponents = GetMaximumVertexOutputVectors(featureLevel) * 4; 922 caps->maxVertexTextureImageUnits = GetMaximumVertexTextureUnits(featureLevel); 923 924 // Fragment shader limits 925 caps->maxFragmentUniformComponents = GetMaximumPixelUniformVectors(featureLevel) * 4; 926 caps->maxFragmentUniformVectors = GetMaximumPixelUniformVectors(featureLevel); 927 caps->maxFragmentUniformBlocks = GetMaximumPixelUniformBlocks(featureLevel); 928 caps->maxFragmentInputComponents = GetMaximumPixelInputVectors(featureLevel) * 4; 929 caps->maxTextureImageUnits = GetMaximumPixelTextureUnits(featureLevel); 930 caps->minProgramTexelOffset = GetMinimumTexelOffset(featureLevel); 931 caps->maxProgramTexelOffset = GetMaximumTexelOffset(featureLevel); 932 933 // Aggregate shader limits 934 caps->maxUniformBufferBindings = caps->maxVertexUniformBlocks + caps->maxFragmentUniformBlocks; 935 caps->maxUniformBlockSize = GetMaximumConstantBufferSize(featureLevel); 936 937 // Setting a large alignment forces uniform buffers to bind with zero offset 938 caps->uniformBufferOffsetAlignment = static_cast<GLuint>(std::numeric_limits<GLint>::max()); 939 940 caps->maxCombinedUniformBlocks = caps->maxVertexUniformBlocks + caps->maxFragmentUniformBlocks; 941 caps->maxCombinedVertexUniformComponents = (static_cast<GLint64>(caps->maxVertexUniformBlocks) * static_cast<GLint64>(caps->maxUniformBlockSize / 4)) + 942 static_cast<GLint64>(caps->maxVertexUniformComponents); 943 caps->maxCombinedFragmentUniformComponents = (static_cast<GLint64>(caps->maxFragmentUniformBlocks) * static_cast<GLint64>(caps->maxUniformBlockSize / 4)) + 944 static_cast<GLint64>(caps->maxFragmentUniformComponents); 945 caps->maxVaryingComponents = GetMaximumVertexOutputVectors(featureLevel) * 4; 946 caps->maxVaryingVectors = GetMaximumVertexOutputVectors(featureLevel); 947 caps->maxCombinedTextureImageUnits = caps->maxVertexTextureImageUnits + caps->maxTextureImageUnits; 948 949 // Transform feedback limits 950 caps->maxTransformFeedbackInterleavedComponents = GetMaximumStreamOutputInterleavedComponenets(featureLevel); 951 caps->maxTransformFeedbackSeparateAttributes = GetMaximumStreamOutputBuffers(featureLevel); 952 caps->maxTransformFeedbackSeparateComponents = GetMaximumStreamOutputSeparateCompeonents(featureLevel); 953 954 // GL extension support 955 extensions->setTextureExtensionSupport(*textureCapsMap); 956 extensions->elementIndexUint = true; 957 extensions->packedDepthStencil = true; 958 extensions->getProgramBinary = true; 959 extensions->rgb8rgba8 = true; 960 extensions->readFormatBGRA = true; 961 extensions->pixelBufferObject = true; 962 extensions->mapBuffer = true; 963 extensions->mapBufferRange = true; 964 extensions->textureNPOT = GetNPOTTextureSupport(featureLevel); 965 extensions->drawBuffers = GetMaximumSimultaneousRenderTargets(featureLevel) > 1; 966 extensions->textureStorage = true; 967 extensions->textureFilterAnisotropic = true; 968 extensions->maxTextureAnisotropy = GetMaximumAnisotropy(featureLevel); 969 extensions->occlusionQueryBoolean = GetOcclusionQuerySupport(featureLevel); 970 extensions->fence = GetEventQuerySupport(featureLevel); 971 extensions->timerQuery = false; // Unimplemented 972 extensions->robustness = true; 973 extensions->blendMinMax = true; 974 extensions->framebufferBlit = true; 975 extensions->framebufferMultisample = true; 976 extensions->maxSamples = maxSamples; 977 extensions->instancedArrays = GetInstancingSupport(featureLevel); 978 extensions->packReverseRowOrder = true; 979 extensions->standardDerivatives = GetDerivativeInstructionSupport(featureLevel); 980 extensions->shaderTextureLOD = true; 981 extensions->fragDepth = true; 982 extensions->textureUsage = true; // This could be false since it has no effect in D3D11 983 extensions->translatedShaderSource = true; 984 } 985 986 } 987 988 namespace d3d11 989 { 990 991 void MakeValidSize(bool isImage, DXGI_FORMAT format, GLsizei *requestWidth, GLsizei *requestHeight, int *levelOffset) 992 { 993 const DXGIFormat &dxgiFormatInfo = d3d11::GetDXGIFormatInfo(format); 994 995 int upsampleCount = 0; 996 // Don't expand the size of full textures that are at least (blockWidth x blockHeight) already. 997 if (isImage || *requestWidth < static_cast<GLsizei>(dxgiFormatInfo.blockWidth) || 998 *requestHeight < static_cast<GLsizei>(dxgiFormatInfo.blockHeight)) 999 { 1000 while (*requestWidth % dxgiFormatInfo.blockWidth != 0 || *requestHeight % dxgiFormatInfo.blockHeight != 0) 1001 { 1002 *requestWidth <<= 1; 1003 *requestHeight <<= 1; 1004 upsampleCount++; 1005 } 1006 } 1007 *levelOffset = upsampleCount; 1008 } 1009 1010 void GenerateInitialTextureData(GLint internalFormat, GLuint width, GLuint height, GLuint depth, 1011 GLuint mipLevels, std::vector<D3D11_SUBRESOURCE_DATA> *outSubresourceData, 1012 std::vector< std::vector<BYTE> > *outData) 1013 { 1014 const d3d11::TextureFormat &d3dFormatInfo = d3d11::GetTextureFormatInfo(internalFormat); 1015 ASSERT(d3dFormatInfo.dataInitializerFunction != NULL); 1016 1017 const d3d11::DXGIFormat &dxgiFormatInfo = d3d11::GetDXGIFormatInfo(d3dFormatInfo.texFormat); 1018 1019 outSubresourceData->resize(mipLevels); 1020 outData->resize(mipLevels); 1021 1022 for (unsigned int i = 0; i < mipLevels; i++) 1023 { 1024 unsigned int mipWidth = std::max(width >> i, 1U); 1025 unsigned int mipHeight = std::max(height >> i, 1U); 1026 unsigned int mipDepth = std::max(depth >> i, 1U); 1027 1028 unsigned int rowWidth = dxgiFormatInfo.pixelBytes * mipWidth; 1029 unsigned int imageSize = rowWidth * height; 1030 1031 outData->at(i).resize(rowWidth * mipHeight * mipDepth); 1032 d3dFormatInfo.dataInitializerFunction(mipWidth, mipHeight, mipDepth, outData->at(i).data(), rowWidth, imageSize); 1033 1034 outSubresourceData->at(i).pSysMem = outData->at(i).data(); 1035 outSubresourceData->at(i).SysMemPitch = rowWidth; 1036 outSubresourceData->at(i).SysMemSlicePitch = imageSize; 1037 } 1038 } 1039 1040 void SetPositionTexCoordVertex(PositionTexCoordVertex* vertex, float x, float y, float u, float v) 1041 { 1042 vertex->x = x; 1043 vertex->y = y; 1044 vertex->u = u; 1045 vertex->v = v; 1046 } 1047 1048 void SetPositionLayerTexCoord3DVertex(PositionLayerTexCoord3DVertex* vertex, float x, float y, 1049 unsigned int layer, float u, float v, float s) 1050 { 1051 vertex->x = x; 1052 vertex->y = y; 1053 vertex->l = layer; 1054 vertex->u = u; 1055 vertex->v = v; 1056 vertex->s = s; 1057 } 1058 1059 HRESULT SetDebugName(ID3D11DeviceChild *resource, const char *name) 1060 { 1061 #if defined(_DEBUG) 1062 return resource->SetPrivateData(WKPDID_D3DDebugObjectName, strlen(name), name); 1063 #else 1064 return S_OK; 1065 #endif 1066 } 1067 1068 RenderTarget11 *GetAttachmentRenderTarget(gl::FramebufferAttachment *attachment) 1069 { 1070 RenderTarget *renderTarget = rx::GetAttachmentRenderTarget(attachment); 1071 return RenderTarget11::makeRenderTarget11(renderTarget); 1072 } 1073 1074 } 1075 1076 } 1077
