1 /************************************************************************** 2 * 3 * Copyright 2007 VMware, Inc. 4 * Copyright (c) 2008 VMware, Inc. 5 * All Rights Reserved. 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a 8 * copy of this software and associated documentation files (the 9 * "Software"), to deal in the Software without restriction, including 10 * without limitation the rights to use, copy, modify, merge, publish, 11 * distribute, sub license, and/or sell copies of the Software, and to 12 * permit persons to whom the Software is furnished to do so, subject to 13 * the following conditions: 14 * 15 * The above copyright notice and this permission notice (including the 16 * next paragraph) shall be included in all copies or substantial portions 17 * of the Software. 18 * 19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 21 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. 22 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR 23 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 24 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 25 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 26 * 27 **************************************************************************/ 28 29 #include "main/imports.h" 30 #include "main/context.h" 31 #include "main/macros.h" 32 #include "main/version.h" 33 34 #include "pipe/p_context.h" 35 #include "pipe/p_defines.h" 36 #include "pipe/p_screen.h" 37 #include "util/u_math.h" 38 39 #include "st_context.h" 40 #include "st_debug.h" 41 #include "st_extensions.h" 42 #include "st_format.h" 43 44 45 /* 46 * Note: we use these function rather than the MIN2, MAX2, CLAMP macros to 47 * avoid evaluating arguments (which are often function calls) more than once. 48 */ 49 50 static unsigned _min(unsigned a, unsigned b) 51 { 52 return (a < b) ? a : b; 53 } 54 55 static float _maxf(float a, float b) 56 { 57 return (a > b) ? a : b; 58 } 59 60 static int _clamp(int a, int min, int max) 61 { 62 if (a < min) 63 return min; 64 else if (a > max) 65 return max; 66 else 67 return a; 68 } 69 70 71 /** 72 * Query driver to get implementation limits. 73 * Note that we have to limit/clamp against Mesa's internal limits too. 74 */ 75 void st_init_limits(struct pipe_screen *screen, 76 struct gl_constants *c, struct gl_extensions *extensions) 77 { 78 int supported_irs; 79 unsigned sh; 80 boolean can_ubo = TRUE; 81 82 c->MaxTextureLevels 83 = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS), 84 MAX_TEXTURE_LEVELS); 85 86 c->Max3DTextureLevels 87 = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_3D_LEVELS), 88 MAX_3D_TEXTURE_LEVELS); 89 90 c->MaxCubeTextureLevels 91 = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS), 92 MAX_CUBE_TEXTURE_LEVELS); 93 94 c->MaxTextureRectSize 95 = _min(1 << (c->MaxTextureLevels - 1), MAX_TEXTURE_RECT_SIZE); 96 97 c->MaxArrayTextureLayers 98 = screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS); 99 100 /* Define max viewport size and max renderbuffer size in terms of 101 * max texture size (note: max tex RECT size = max tex 2D size). 102 * If this isn't true for some hardware we'll need new PIPE_CAP_ queries. 103 */ 104 c->MaxViewportWidth = 105 c->MaxViewportHeight = 106 c->MaxRenderbufferSize = c->MaxTextureRectSize; 107 108 c->ViewportSubpixelBits = 109 screen->get_param(screen, PIPE_CAP_VIEWPORT_SUBPIXEL_BITS); 110 111 c->MaxDrawBuffers = c->MaxColorAttachments = 112 _clamp(screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS), 113 1, MAX_DRAW_BUFFERS); 114 115 c->MaxDualSourceDrawBuffers = 116 _clamp(screen->get_param(screen, 117 PIPE_CAP_MAX_DUAL_SOURCE_RENDER_TARGETS), 118 0, MAX_DRAW_BUFFERS); 119 120 c->MaxLineWidth = 121 _maxf(1.0f, screen->get_paramf(screen, PIPE_CAPF_MAX_LINE_WIDTH)); 122 c->MaxLineWidthAA = 123 _maxf(1.0f, screen->get_paramf(screen, PIPE_CAPF_MAX_LINE_WIDTH_AA)); 124 125 c->MaxPointSize = 126 _maxf(1.0f, screen->get_paramf(screen, PIPE_CAPF_MAX_POINT_WIDTH)); 127 c->MaxPointSizeAA = 128 _maxf(1.0f, screen->get_paramf(screen, PIPE_CAPF_MAX_POINT_WIDTH_AA)); 129 130 /* these are not queryable. Note that GL basically mandates a 1.0 minimum 131 * for non-aa sizes, but we can go down to 0.0 for aa points. 132 */ 133 c->MinPointSize = 1.0f; 134 c->MinPointSizeAA = 0.0f; 135 136 c->MaxTextureMaxAnisotropy = 137 _maxf(2.0f, 138 screen->get_paramf(screen, PIPE_CAPF_MAX_TEXTURE_ANISOTROPY)); 139 140 c->MaxTextureLodBias = 141 screen->get_paramf(screen, PIPE_CAPF_MAX_TEXTURE_LOD_BIAS); 142 143 c->QuadsFollowProvokingVertexConvention = 144 screen->get_param(screen, 145 PIPE_CAP_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION); 146 147 c->MaxUniformBlockSize = 148 screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT, 149 PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE); 150 if (c->MaxUniformBlockSize < 16384) { 151 can_ubo = FALSE; 152 } 153 154 for (sh = 0; sh < PIPE_SHADER_TYPES; ++sh) { 155 struct gl_shader_compiler_options *options; 156 struct gl_program_constants *pc; 157 158 switch (sh) { 159 case PIPE_SHADER_FRAGMENT: 160 pc = &c->Program[MESA_SHADER_FRAGMENT]; 161 options = &c->ShaderCompilerOptions[MESA_SHADER_FRAGMENT]; 162 break; 163 case PIPE_SHADER_VERTEX: 164 pc = &c->Program[MESA_SHADER_VERTEX]; 165 options = &c->ShaderCompilerOptions[MESA_SHADER_VERTEX]; 166 break; 167 case PIPE_SHADER_GEOMETRY: 168 pc = &c->Program[MESA_SHADER_GEOMETRY]; 169 options = &c->ShaderCompilerOptions[MESA_SHADER_GEOMETRY]; 170 break; 171 case PIPE_SHADER_TESS_CTRL: 172 pc = &c->Program[MESA_SHADER_TESS_CTRL]; 173 options = &c->ShaderCompilerOptions[MESA_SHADER_TESS_CTRL]; 174 break; 175 case PIPE_SHADER_TESS_EVAL: 176 pc = &c->Program[MESA_SHADER_TESS_EVAL]; 177 options = &c->ShaderCompilerOptions[MESA_SHADER_TESS_EVAL]; 178 break; 179 case PIPE_SHADER_COMPUTE: 180 pc = &c->Program[MESA_SHADER_COMPUTE]; 181 options = &c->ShaderCompilerOptions[MESA_SHADER_COMPUTE]; 182 183 if (!screen->get_param(screen, PIPE_CAP_COMPUTE)) 184 continue; 185 supported_irs = 186 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_SUPPORTED_IRS); 187 if (!(supported_irs & (1 << PIPE_SHADER_IR_TGSI))) 188 continue; 189 break; 190 default: 191 assert(0); 192 } 193 194 pc->MaxTextureImageUnits = 195 _min(screen->get_shader_param(screen, sh, 196 PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS), 197 MAX_TEXTURE_IMAGE_UNITS); 198 199 pc->MaxInstructions = 200 pc->MaxNativeInstructions = 201 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INSTRUCTIONS); 202 pc->MaxAluInstructions = 203 pc->MaxNativeAluInstructions = 204 screen->get_shader_param(screen, sh, 205 PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS); 206 pc->MaxTexInstructions = 207 pc->MaxNativeTexInstructions = 208 screen->get_shader_param(screen, sh, 209 PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS); 210 pc->MaxTexIndirections = 211 pc->MaxNativeTexIndirections = 212 screen->get_shader_param(screen, sh, 213 PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS); 214 pc->MaxAttribs = 215 pc->MaxNativeAttribs = 216 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INPUTS); 217 pc->MaxTemps = 218 pc->MaxNativeTemps = 219 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_TEMPS); 220 pc->MaxAddressRegs = 221 pc->MaxNativeAddressRegs = sh == PIPE_SHADER_VERTEX ? 1 : 0; 222 pc->MaxParameters = 223 pc->MaxNativeParameters = 224 screen->get_shader_param(screen, sh, 225 PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE) / sizeof(float[4]); 226 pc->MaxInputComponents = 227 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INPUTS) * 4; 228 pc->MaxOutputComponents = 229 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_OUTPUTS) * 4; 230 231 pc->MaxUniformComponents = 232 4 * MIN2(pc->MaxNativeParameters, MAX_UNIFORMS); 233 234 pc->MaxUniformBlocks = 235 screen->get_shader_param(screen, sh, 236 PIPE_SHADER_CAP_MAX_CONST_BUFFERS); 237 if (pc->MaxUniformBlocks) 238 pc->MaxUniformBlocks -= 1; /* The first one is for ordinary uniforms. */ 239 pc->MaxUniformBlocks = _min(pc->MaxUniformBlocks, MAX_UNIFORM_BUFFERS); 240 241 pc->MaxCombinedUniformComponents = (pc->MaxUniformComponents + 242 c->MaxUniformBlockSize / 4 * 243 pc->MaxUniformBlocks); 244 245 pc->MaxAtomicCounters = MAX_ATOMIC_COUNTERS; 246 pc->MaxAtomicBuffers = screen->get_shader_param( 247 screen, sh, PIPE_SHADER_CAP_MAX_SHADER_BUFFERS) / 2; 248 pc->MaxShaderStorageBlocks = pc->MaxAtomicBuffers; 249 250 pc->MaxImageUniforms = screen->get_shader_param( 251 screen, sh, PIPE_SHADER_CAP_MAX_SHADER_IMAGES); 252 253 /* Gallium doesn't really care about local vs. env parameters so use the 254 * same limits. 255 */ 256 pc->MaxLocalParams = MIN2(pc->MaxParameters, MAX_PROGRAM_LOCAL_PARAMS); 257 pc->MaxEnvParams = MIN2(pc->MaxParameters, MAX_PROGRAM_ENV_PARAMS); 258 259 if (screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_INTEGERS)) { 260 pc->LowInt.RangeMin = 31; 261 pc->LowInt.RangeMax = 30; 262 pc->LowInt.Precision = 0; 263 pc->MediumInt = pc->HighInt = pc->LowInt; 264 } 265 266 /* TODO: make these more fine-grained if anyone needs it */ 267 options->MaxIfDepth = 268 screen->get_shader_param(screen, sh, 269 PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH); 270 options->EmitNoLoops = 271 !screen->get_shader_param(screen, sh, 272 PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH); 273 options->EmitNoFunctions = true; 274 options->EmitNoMainReturn = 275 !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_SUBROUTINES); 276 277 options->EmitNoCont = 278 !screen->get_shader_param(screen, sh, 279 PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED); 280 281 options->EmitNoIndirectInput = 282 !screen->get_shader_param(screen, sh, 283 PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR); 284 options->EmitNoIndirectOutput = 285 !screen->get_shader_param(screen, sh, 286 PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR); 287 options->EmitNoIndirectTemp = 288 !screen->get_shader_param(screen, sh, 289 PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR); 290 options->EmitNoIndirectUniform = 291 !screen->get_shader_param(screen, sh, 292 PIPE_SHADER_CAP_INDIRECT_CONST_ADDR); 293 294 if (pc->MaxNativeInstructions && 295 (options->EmitNoIndirectUniform || pc->MaxUniformBlocks < 12)) { 296 can_ubo = FALSE; 297 } 298 299 if (options->EmitNoLoops) 300 options->MaxUnrollIterations = 301 MIN2(screen->get_shader_param(screen, sh, 302 PIPE_SHADER_CAP_MAX_INSTRUCTIONS), 303 65536); 304 else 305 options->MaxUnrollIterations = 306 screen->get_shader_param(screen, sh, 307 PIPE_SHADER_CAP_MAX_UNROLL_ITERATIONS_HINT); 308 309 options->LowerCombinedClipCullDistance = true; 310 options->LowerBufferInterfaceBlocks = true; 311 } 312 313 c->GLSLOptimizeConservatively = 314 screen->get_param(screen, PIPE_CAP_GLSL_OPTIMIZE_CONSERVATIVELY); 315 c->LowerTessLevel = true; 316 c->LowerCsDerivedVariables = true; 317 c->PrimitiveRestartForPatches = 318 screen->get_param(screen, PIPE_CAP_PRIMITIVE_RESTART_FOR_PATCHES); 319 320 c->MaxCombinedTextureImageUnits = 321 _min(c->Program[MESA_SHADER_VERTEX].MaxTextureImageUnits + 322 c->Program[MESA_SHADER_TESS_CTRL].MaxTextureImageUnits + 323 c->Program[MESA_SHADER_TESS_EVAL].MaxTextureImageUnits + 324 c->Program[MESA_SHADER_GEOMETRY].MaxTextureImageUnits + 325 c->Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits + 326 c->Program[MESA_SHADER_COMPUTE].MaxTextureImageUnits, 327 MAX_COMBINED_TEXTURE_IMAGE_UNITS); 328 329 /* This depends on program constants. */ 330 c->MaxTextureCoordUnits 331 = _min(c->Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits, 332 MAX_TEXTURE_COORD_UNITS); 333 334 c->MaxTextureUnits = 335 _min(c->Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits, 336 c->MaxTextureCoordUnits); 337 338 c->Program[MESA_SHADER_VERTEX].MaxAttribs = 339 MIN2(c->Program[MESA_SHADER_VERTEX].MaxAttribs, 16); 340 341 /* PIPE_SHADER_CAP_MAX_INPUTS for the FS specifies the maximum number 342 * of inputs. It's always 2 colors + N generic inputs. */ 343 c->MaxVarying = screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT, 344 PIPE_SHADER_CAP_MAX_INPUTS); 345 c->MaxVarying = MIN2(c->MaxVarying, MAX_VARYING); 346 c->MaxGeometryOutputVertices = 347 screen->get_param(screen, PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES); 348 c->MaxGeometryTotalOutputComponents = 349 screen->get_param(screen, PIPE_CAP_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS); 350 c->MaxTessPatchComponents = 351 MIN2(screen->get_param(screen, PIPE_CAP_MAX_SHADER_PATCH_VARYINGS), 352 MAX_VARYING) * 4; 353 354 c->MinProgramTexelOffset = 355 screen->get_param(screen, PIPE_CAP_MIN_TEXEL_OFFSET); 356 c->MaxProgramTexelOffset = 357 screen->get_param(screen, PIPE_CAP_MAX_TEXEL_OFFSET); 358 359 c->MaxProgramTextureGatherComponents = 360 screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_GATHER_COMPONENTS); 361 c->MinProgramTextureGatherOffset = 362 screen->get_param(screen, PIPE_CAP_MIN_TEXTURE_GATHER_OFFSET); 363 c->MaxProgramTextureGatherOffset = 364 screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_GATHER_OFFSET); 365 366 c->MaxTransformFeedbackBuffers = 367 screen->get_param(screen, PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS); 368 c->MaxTransformFeedbackBuffers = MIN2(c->MaxTransformFeedbackBuffers, 369 MAX_FEEDBACK_BUFFERS); 370 c->MaxTransformFeedbackSeparateComponents = 371 screen->get_param(screen, PIPE_CAP_MAX_STREAM_OUTPUT_SEPARATE_COMPONENTS); 372 c->MaxTransformFeedbackInterleavedComponents = 373 screen->get_param(screen, 374 PIPE_CAP_MAX_STREAM_OUTPUT_INTERLEAVED_COMPONENTS); 375 c->MaxVertexStreams = 376 MAX2(1, screen->get_param(screen, PIPE_CAP_MAX_VERTEX_STREAMS)); 377 378 /* The vertex stream must fit into pipe_stream_output_info::stream */ 379 assert(c->MaxVertexStreams <= 4); 380 381 c->MaxVertexAttribStride 382 = screen->get_param(screen, PIPE_CAP_MAX_VERTEX_ATTRIB_STRIDE); 383 384 c->StripTextureBorder = GL_TRUE; 385 386 c->GLSLSkipStrictMaxUniformLimitCheck = 387 screen->get_param(screen, PIPE_CAP_TGSI_CAN_COMPACT_CONSTANTS); 388 389 c->UniformBufferOffsetAlignment = 390 screen->get_param(screen, PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT); 391 392 if (can_ubo) { 393 extensions->ARB_uniform_buffer_object = GL_TRUE; 394 c->MaxCombinedUniformBlocks = c->MaxUniformBufferBindings = 395 c->Program[MESA_SHADER_VERTEX].MaxUniformBlocks + 396 c->Program[MESA_SHADER_TESS_CTRL].MaxUniformBlocks + 397 c->Program[MESA_SHADER_TESS_EVAL].MaxUniformBlocks + 398 c->Program[MESA_SHADER_GEOMETRY].MaxUniformBlocks + 399 c->Program[MESA_SHADER_FRAGMENT].MaxUniformBlocks + 400 c->Program[MESA_SHADER_COMPUTE].MaxUniformBlocks; 401 assert(c->MaxCombinedUniformBlocks <= MAX_COMBINED_UNIFORM_BUFFERS); 402 } 403 404 c->GLSLFragCoordIsSysVal = 405 screen->get_param(screen, PIPE_CAP_TGSI_FS_POSITION_IS_SYSVAL); 406 c->GLSLFrontFacingIsSysVal = 407 screen->get_param(screen, PIPE_CAP_TGSI_FS_FACE_IS_INTEGER_SYSVAL); 408 409 c->MaxAtomicBufferBindings = 410 c->Program[MESA_SHADER_FRAGMENT].MaxAtomicBuffers; 411 c->MaxCombinedAtomicBuffers = 412 c->Program[MESA_SHADER_VERTEX].MaxAtomicBuffers + 413 c->Program[MESA_SHADER_TESS_CTRL].MaxAtomicBuffers + 414 c->Program[MESA_SHADER_TESS_EVAL].MaxAtomicBuffers + 415 c->Program[MESA_SHADER_GEOMETRY].MaxAtomicBuffers + 416 c->Program[MESA_SHADER_FRAGMENT].MaxAtomicBuffers; 417 assert(c->MaxCombinedAtomicBuffers <= MAX_COMBINED_ATOMIC_BUFFERS); 418 419 if (c->MaxCombinedAtomicBuffers > 0) { 420 extensions->ARB_shader_atomic_counters = GL_TRUE; 421 extensions->ARB_shader_atomic_counter_ops = GL_TRUE; 422 } 423 424 c->MaxCombinedShaderOutputResources = c->MaxDrawBuffers; 425 c->ShaderStorageBufferOffsetAlignment = 426 screen->get_param(screen, PIPE_CAP_SHADER_BUFFER_OFFSET_ALIGNMENT); 427 if (c->ShaderStorageBufferOffsetAlignment) { 428 c->MaxCombinedShaderStorageBlocks = c->MaxShaderStorageBufferBindings = 429 c->MaxCombinedAtomicBuffers; 430 c->MaxCombinedShaderOutputResources += 431 c->MaxCombinedShaderStorageBlocks; 432 c->MaxShaderStorageBlockSize = 1 << 27; 433 extensions->ARB_shader_storage_buffer_object = GL_TRUE; 434 } 435 436 c->MaxCombinedImageUniforms = 437 c->Program[MESA_SHADER_VERTEX].MaxImageUniforms + 438 c->Program[MESA_SHADER_TESS_CTRL].MaxImageUniforms + 439 c->Program[MESA_SHADER_TESS_EVAL].MaxImageUniforms + 440 c->Program[MESA_SHADER_GEOMETRY].MaxImageUniforms + 441 c->Program[MESA_SHADER_FRAGMENT].MaxImageUniforms + 442 c->Program[MESA_SHADER_COMPUTE].MaxImageUniforms; 443 c->MaxCombinedShaderOutputResources += c->MaxCombinedImageUniforms; 444 c->MaxImageUnits = MAX_IMAGE_UNITS; 445 if (c->MaxCombinedImageUniforms) { 446 extensions->ARB_shader_image_load_store = GL_TRUE; 447 extensions->ARB_shader_image_size = GL_TRUE; 448 } 449 450 /* ARB_framebuffer_no_attachments */ 451 c->MaxFramebufferWidth = c->MaxViewportWidth; 452 c->MaxFramebufferHeight = c->MaxViewportHeight; 453 /* NOTE: we cheat here a little by assuming that 454 * PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS has the same 455 * number of layers as we need, although we technically 456 * could have more the generality is not really useful 457 * in practicality. 458 */ 459 c->MaxFramebufferLayers = 460 screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS); 461 462 c->MaxWindowRectangles = 463 screen->get_param(screen, PIPE_CAP_MAX_WINDOW_RECTANGLES); 464 } 465 466 467 /** 468 * Given a member \c x of struct gl_extensions, return offset of 469 * \c x in bytes. 470 */ 471 #define o(x) offsetof(struct gl_extensions, x) 472 473 474 struct st_extension_cap_mapping { 475 int extension_offset; 476 int cap; 477 }; 478 479 struct st_extension_format_mapping { 480 int extension_offset[2]; 481 enum pipe_format format[32]; 482 483 /* If TRUE, at least one format must be supported for the extensions to be 484 * advertised. If FALSE, all the formats must be supported. */ 485 GLboolean need_at_least_one; 486 }; 487 488 /** 489 * Enable extensions if certain pipe formats are supported by the driver. 490 * What extensions will be enabled and what formats must be supported is 491 * described by the array of st_extension_format_mapping. 492 * 493 * target and bind_flags are passed to is_format_supported. 494 */ 495 static void 496 init_format_extensions(struct pipe_screen *screen, 497 struct gl_extensions *extensions, 498 const struct st_extension_format_mapping *mapping, 499 unsigned num_mappings, 500 enum pipe_texture_target target, 501 unsigned bind_flags) 502 { 503 GLboolean *extension_table = (GLboolean *) extensions; 504 unsigned i; 505 int j; 506 int num_formats = ARRAY_SIZE(mapping->format); 507 int num_ext = ARRAY_SIZE(mapping->extension_offset); 508 509 for (i = 0; i < num_mappings; i++) { 510 int num_supported = 0; 511 512 /* Examine each format in the list. */ 513 for (j = 0; j < num_formats && mapping[i].format[j]; j++) { 514 if (screen->is_format_supported(screen, mapping[i].format[j], 515 target, 0, bind_flags)) { 516 num_supported++; 517 } 518 } 519 520 if (!num_supported || 521 (!mapping[i].need_at_least_one && num_supported != j)) { 522 continue; 523 } 524 525 /* Enable all extensions in the list. */ 526 for (j = 0; j < num_ext && mapping[i].extension_offset[j]; j++) 527 extension_table[mapping[i].extension_offset[j]] = GL_TRUE; 528 } 529 } 530 531 532 /** 533 * Given a list of formats and bind flags, return the maximum number 534 * of samples supported by any of those formats. 535 */ 536 static unsigned 537 get_max_samples_for_formats(struct pipe_screen *screen, 538 unsigned num_formats, 539 enum pipe_format *formats, 540 unsigned max_samples, 541 unsigned bind) 542 { 543 unsigned i, f; 544 545 for (i = max_samples; i > 0; --i) { 546 for (f = 0; f < num_formats; f++) { 547 if (screen->is_format_supported(screen, formats[f], 548 PIPE_TEXTURE_2D, i, bind)) { 549 return i; 550 } 551 } 552 } 553 return 0; 554 } 555 556 557 /** 558 * Use pipe_screen::get_param() to query PIPE_CAP_ values to determine 559 * which GL extensions are supported. 560 * Quite a few extensions are always supported because they are standard 561 * features or can be built on top of other gallium features. 562 * Some fine tuning may still be needed. 563 */ 564 void st_init_extensions(struct pipe_screen *screen, 565 struct gl_constants *consts, 566 struct gl_extensions *extensions, 567 struct st_config_options *options, 568 boolean has_lib_dxtc) 569 { 570 unsigned i; 571 GLboolean *extension_table = (GLboolean *) extensions; 572 573 static const struct st_extension_cap_mapping cap_mapping[] = { 574 { o(ARB_base_instance), PIPE_CAP_START_INSTANCE }, 575 { o(ARB_buffer_storage), PIPE_CAP_BUFFER_MAP_PERSISTENT_COHERENT }, 576 { o(ARB_clear_texture), PIPE_CAP_CLEAR_TEXTURE }, 577 { o(ARB_clip_control), PIPE_CAP_CLIP_HALFZ }, 578 { o(ARB_color_buffer_float), PIPE_CAP_VERTEX_COLOR_UNCLAMPED }, 579 { o(ARB_conditional_render_inverted), PIPE_CAP_CONDITIONAL_RENDER_INVERTED }, 580 { o(ARB_copy_image), PIPE_CAP_COPY_BETWEEN_COMPRESSED_AND_PLAIN_FORMATS }, 581 { o(OES_copy_image), PIPE_CAP_COPY_BETWEEN_COMPRESSED_AND_PLAIN_FORMATS }, 582 { o(ARB_cull_distance), PIPE_CAP_CULL_DISTANCE }, 583 { o(ARB_depth_clamp), PIPE_CAP_DEPTH_CLIP_DISABLE }, 584 { o(ARB_depth_texture), PIPE_CAP_TEXTURE_SHADOW_MAP }, 585 { o(ARB_derivative_control), PIPE_CAP_TGSI_FS_FINE_DERIVATIVE }, 586 { o(ARB_draw_buffers_blend), PIPE_CAP_INDEP_BLEND_FUNC }, 587 { o(ARB_draw_indirect), PIPE_CAP_DRAW_INDIRECT }, 588 { o(ARB_draw_instanced), PIPE_CAP_TGSI_INSTANCEID }, 589 { o(ARB_fragment_program_shadow), PIPE_CAP_TEXTURE_SHADOW_MAP }, 590 { o(ARB_framebuffer_object), PIPE_CAP_MIXED_FRAMEBUFFER_SIZES }, 591 { o(ARB_indirect_parameters), PIPE_CAP_MULTI_DRAW_INDIRECT_PARAMS }, 592 { o(ARB_instanced_arrays), PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR }, 593 { o(ARB_occlusion_query), PIPE_CAP_OCCLUSION_QUERY }, 594 { o(ARB_occlusion_query2), PIPE_CAP_OCCLUSION_QUERY }, 595 { o(ARB_pipeline_statistics_query), PIPE_CAP_QUERY_PIPELINE_STATISTICS }, 596 { o(ARB_point_sprite), PIPE_CAP_POINT_SPRITE }, 597 { o(ARB_query_buffer_object), PIPE_CAP_QUERY_BUFFER_OBJECT }, 598 { o(ARB_robust_buffer_access_behavior), PIPE_CAP_ROBUST_BUFFER_ACCESS_BEHAVIOR }, 599 { o(ARB_sample_shading), PIPE_CAP_SAMPLE_SHADING }, 600 { o(ARB_seamless_cube_map), PIPE_CAP_SEAMLESS_CUBE_MAP }, 601 { o(ARB_shader_draw_parameters), PIPE_CAP_DRAW_PARAMETERS }, 602 { o(ARB_shader_group_vote), PIPE_CAP_TGSI_VOTE }, 603 { o(ARB_shader_stencil_export), PIPE_CAP_SHADER_STENCIL_EXPORT }, 604 { o(ARB_shader_texture_image_samples), PIPE_CAP_TGSI_TXQS }, 605 { o(ARB_shader_texture_lod), PIPE_CAP_SM3 }, 606 { o(ARB_shadow), PIPE_CAP_TEXTURE_SHADOW_MAP }, 607 { o(ARB_texture_buffer_object), PIPE_CAP_TEXTURE_BUFFER_OBJECTS }, 608 { o(ARB_texture_cube_map_array), PIPE_CAP_CUBE_MAP_ARRAY }, 609 { o(ARB_texture_gather), PIPE_CAP_MAX_TEXTURE_GATHER_COMPONENTS }, 610 { o(ARB_texture_mirror_clamp_to_edge), PIPE_CAP_TEXTURE_MIRROR_CLAMP }, 611 { o(ARB_texture_multisample), PIPE_CAP_TEXTURE_MULTISAMPLE }, 612 { o(ARB_texture_non_power_of_two), PIPE_CAP_NPOT_TEXTURES }, 613 { o(ARB_texture_query_lod), PIPE_CAP_TEXTURE_QUERY_LOD }, 614 { o(ARB_texture_view), PIPE_CAP_SAMPLER_VIEW_TARGET }, 615 { o(ARB_timer_query), PIPE_CAP_QUERY_TIMESTAMP }, 616 { o(ARB_transform_feedback2), PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME }, 617 { o(ARB_transform_feedback3), PIPE_CAP_STREAM_OUTPUT_INTERLEAVE_BUFFERS }, 618 619 { o(KHR_blend_equation_advanced), PIPE_CAP_TGSI_FS_FBFETCH }, 620 621 { o(EXT_blend_equation_separate), PIPE_CAP_BLEND_EQUATION_SEPARATE }, 622 { o(EXT_depth_bounds_test), PIPE_CAP_DEPTH_BOUNDS_TEST }, 623 { o(EXT_draw_buffers2), PIPE_CAP_INDEP_BLEND_ENABLE }, 624 { o(EXT_polygon_offset_clamp), PIPE_CAP_POLYGON_OFFSET_CLAMP }, 625 { o(EXT_stencil_two_side), PIPE_CAP_TWO_SIDED_STENCIL }, 626 { o(EXT_texture_array), PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS }, 627 { o(EXT_texture_filter_anisotropic), PIPE_CAP_ANISOTROPIC_FILTER }, 628 { o(EXT_texture_mirror_clamp), PIPE_CAP_TEXTURE_MIRROR_CLAMP }, 629 { o(EXT_texture_swizzle), PIPE_CAP_TEXTURE_SWIZZLE }, 630 { o(EXT_transform_feedback), PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS }, 631 { o(EXT_window_rectangles), PIPE_CAP_MAX_WINDOW_RECTANGLES }, 632 633 { o(AMD_pinned_memory), PIPE_CAP_RESOURCE_FROM_USER_MEMORY }, 634 { o(ATI_meminfo), PIPE_CAP_QUERY_MEMORY_INFO }, 635 { o(AMD_seamless_cubemap_per_texture), PIPE_CAP_SEAMLESS_CUBE_MAP_PER_TEXTURE }, 636 { o(ATI_separate_stencil), PIPE_CAP_TWO_SIDED_STENCIL }, 637 { o(ATI_texture_mirror_once), PIPE_CAP_TEXTURE_MIRROR_CLAMP }, 638 { o(NV_conditional_render), PIPE_CAP_CONDITIONAL_RENDER }, 639 { o(NV_primitive_restart), PIPE_CAP_PRIMITIVE_RESTART }, 640 { o(NV_texture_barrier), PIPE_CAP_TEXTURE_BARRIER }, 641 { o(NVX_gpu_memory_info), PIPE_CAP_QUERY_MEMORY_INFO }, 642 /* GL_NV_point_sprite is not supported by gallium because we don't 643 * support the GL_POINT_SPRITE_R_MODE_NV option. */ 644 645 { o(OES_standard_derivatives), PIPE_CAP_SM3 }, 646 { o(OES_texture_float_linear), PIPE_CAP_TEXTURE_FLOAT_LINEAR }, 647 { o(OES_texture_half_float_linear), PIPE_CAP_TEXTURE_HALF_FLOAT_LINEAR }, 648 }; 649 650 /* Required: render target and sampler support */ 651 static const struct st_extension_format_mapping rendertarget_mapping[] = { 652 { { o(ARB_texture_float) }, 653 { PIPE_FORMAT_R32G32B32A32_FLOAT, 654 PIPE_FORMAT_R16G16B16A16_FLOAT } }, 655 656 { { o(OES_texture_float) }, 657 { PIPE_FORMAT_R32G32B32A32_FLOAT } }, 658 659 { { o(OES_texture_half_float) }, 660 { PIPE_FORMAT_R16G16B16A16_FLOAT } }, 661 662 { { o(ARB_texture_rgb10_a2ui) }, 663 { PIPE_FORMAT_R10G10B10A2_UINT, 664 PIPE_FORMAT_B10G10R10A2_UINT }, 665 GL_TRUE }, /* at least one format must be supported */ 666 667 { { o(EXT_framebuffer_sRGB) }, 668 { PIPE_FORMAT_A8B8G8R8_SRGB, 669 PIPE_FORMAT_B8G8R8A8_SRGB }, 670 GL_TRUE }, /* at least one format must be supported */ 671 672 { { o(EXT_packed_float) }, 673 { PIPE_FORMAT_R11G11B10_FLOAT } }, 674 675 { { o(EXT_texture_integer) }, 676 { PIPE_FORMAT_R32G32B32A32_UINT, 677 PIPE_FORMAT_R32G32B32A32_SINT } }, 678 679 { { o(ARB_texture_rg) }, 680 { PIPE_FORMAT_R8_UNORM, 681 PIPE_FORMAT_R8G8_UNORM } }, 682 }; 683 684 /* Required: depth stencil and sampler support */ 685 static const struct st_extension_format_mapping depthstencil_mapping[] = { 686 { { o(ARB_depth_buffer_float) }, 687 { PIPE_FORMAT_Z32_FLOAT, 688 PIPE_FORMAT_Z32_FLOAT_S8X24_UINT } }, 689 }; 690 691 /* Required: sampler support */ 692 static const struct st_extension_format_mapping texture_mapping[] = { 693 { { o(ARB_texture_compression_rgtc) }, 694 { PIPE_FORMAT_RGTC1_UNORM, 695 PIPE_FORMAT_RGTC1_SNORM, 696 PIPE_FORMAT_RGTC2_UNORM, 697 PIPE_FORMAT_RGTC2_SNORM } }, 698 699 { { o(EXT_texture_compression_latc) }, 700 { PIPE_FORMAT_LATC1_UNORM, 701 PIPE_FORMAT_LATC1_SNORM, 702 PIPE_FORMAT_LATC2_UNORM, 703 PIPE_FORMAT_LATC2_SNORM } }, 704 705 { { o(EXT_texture_compression_s3tc), 706 o(ANGLE_texture_compression_dxt) }, 707 { PIPE_FORMAT_DXT1_RGB, 708 PIPE_FORMAT_DXT1_RGBA, 709 PIPE_FORMAT_DXT3_RGBA, 710 PIPE_FORMAT_DXT5_RGBA } }, 711 712 { { o(ARB_texture_compression_bptc) }, 713 { PIPE_FORMAT_BPTC_RGBA_UNORM, 714 PIPE_FORMAT_BPTC_SRGBA, 715 PIPE_FORMAT_BPTC_RGB_FLOAT, 716 PIPE_FORMAT_BPTC_RGB_UFLOAT } }, 717 718 { { o(KHR_texture_compression_astc_ldr) }, 719 { PIPE_FORMAT_ASTC_4x4, 720 PIPE_FORMAT_ASTC_5x4, 721 PIPE_FORMAT_ASTC_5x5, 722 PIPE_FORMAT_ASTC_6x5, 723 PIPE_FORMAT_ASTC_6x6, 724 PIPE_FORMAT_ASTC_8x5, 725 PIPE_FORMAT_ASTC_8x6, 726 PIPE_FORMAT_ASTC_8x8, 727 PIPE_FORMAT_ASTC_10x5, 728 PIPE_FORMAT_ASTC_10x6, 729 PIPE_FORMAT_ASTC_10x8, 730 PIPE_FORMAT_ASTC_10x10, 731 PIPE_FORMAT_ASTC_12x10, 732 PIPE_FORMAT_ASTC_12x12, 733 PIPE_FORMAT_ASTC_4x4_SRGB, 734 PIPE_FORMAT_ASTC_5x4_SRGB, 735 PIPE_FORMAT_ASTC_5x5_SRGB, 736 PIPE_FORMAT_ASTC_6x5_SRGB, 737 PIPE_FORMAT_ASTC_6x6_SRGB, 738 PIPE_FORMAT_ASTC_8x5_SRGB, 739 PIPE_FORMAT_ASTC_8x6_SRGB, 740 PIPE_FORMAT_ASTC_8x8_SRGB, 741 PIPE_FORMAT_ASTC_10x5_SRGB, 742 PIPE_FORMAT_ASTC_10x6_SRGB, 743 PIPE_FORMAT_ASTC_10x8_SRGB, 744 PIPE_FORMAT_ASTC_10x10_SRGB, 745 PIPE_FORMAT_ASTC_12x10_SRGB, 746 PIPE_FORMAT_ASTC_12x12_SRGB } }, 747 748 { { o(EXT_texture_shared_exponent) }, 749 { PIPE_FORMAT_R9G9B9E5_FLOAT } }, 750 751 { { o(EXT_texture_snorm) }, 752 { PIPE_FORMAT_R8G8B8A8_SNORM } }, 753 754 { { o(EXT_texture_sRGB), 755 o(EXT_texture_sRGB_decode) }, 756 { PIPE_FORMAT_A8B8G8R8_SRGB, 757 PIPE_FORMAT_B8G8R8A8_SRGB }, 758 GL_TRUE }, /* at least one format must be supported */ 759 760 { { o(ATI_texture_compression_3dc) }, 761 { PIPE_FORMAT_LATC2_UNORM } }, 762 763 { { o(MESA_ycbcr_texture) }, 764 { PIPE_FORMAT_UYVY, 765 PIPE_FORMAT_YUYV }, 766 GL_TRUE }, /* at least one format must be supported */ 767 768 { { o(OES_compressed_ETC1_RGB8_texture) }, 769 { PIPE_FORMAT_ETC1_RGB8, 770 PIPE_FORMAT_R8G8B8A8_UNORM }, 771 GL_TRUE }, /* at least one format must be supported */ 772 773 { { o(ARB_stencil_texturing), 774 o(ARB_texture_stencil8) }, 775 { PIPE_FORMAT_X24S8_UINT, 776 PIPE_FORMAT_S8X24_UINT }, 777 GL_TRUE }, /* at least one format must be supported */ 778 }; 779 780 /* Required: vertex fetch support. */ 781 static const struct st_extension_format_mapping vertex_mapping[] = { 782 { { o(EXT_vertex_array_bgra) }, 783 { PIPE_FORMAT_B8G8R8A8_UNORM } }, 784 { { o(ARB_vertex_type_2_10_10_10_rev) }, 785 { PIPE_FORMAT_R10G10B10A2_UNORM, 786 PIPE_FORMAT_B10G10R10A2_UNORM, 787 PIPE_FORMAT_R10G10B10A2_SNORM, 788 PIPE_FORMAT_B10G10R10A2_SNORM, 789 PIPE_FORMAT_R10G10B10A2_USCALED, 790 PIPE_FORMAT_B10G10R10A2_USCALED, 791 PIPE_FORMAT_R10G10B10A2_SSCALED, 792 PIPE_FORMAT_B10G10R10A2_SSCALED } }, 793 { { o(ARB_vertex_type_10f_11f_11f_rev) }, 794 { PIPE_FORMAT_R11G11B10_FLOAT } }, 795 }; 796 797 static const struct st_extension_format_mapping tbo_rgb32[] = { 798 { {o(ARB_texture_buffer_object_rgb32) }, 799 { PIPE_FORMAT_R32G32B32_FLOAT, 800 PIPE_FORMAT_R32G32B32_UINT, 801 PIPE_FORMAT_R32G32B32_SINT, 802 } }, 803 }; 804 805 /* 806 * Extensions that are supported by all Gallium drivers: 807 */ 808 extensions->ARB_ES2_compatibility = GL_TRUE; 809 extensions->ARB_draw_elements_base_vertex = GL_TRUE; 810 extensions->ARB_explicit_attrib_location = GL_TRUE; 811 extensions->ARB_explicit_uniform_location = GL_TRUE; 812 extensions->ARB_fragment_coord_conventions = GL_TRUE; 813 extensions->ARB_fragment_program = GL_TRUE; 814 extensions->ARB_fragment_shader = GL_TRUE; 815 extensions->ARB_half_float_vertex = GL_TRUE; 816 extensions->ARB_internalformat_query = GL_TRUE; 817 extensions->ARB_internalformat_query2 = GL_TRUE; 818 extensions->ARB_map_buffer_range = GL_TRUE; 819 extensions->ARB_texture_border_clamp = GL_TRUE; /* XXX temp */ 820 extensions->ARB_texture_cube_map = GL_TRUE; 821 extensions->ARB_texture_env_combine = GL_TRUE; 822 extensions->ARB_texture_env_crossbar = GL_TRUE; 823 extensions->ARB_texture_env_dot3 = GL_TRUE; 824 extensions->ARB_vertex_program = GL_TRUE; 825 extensions->ARB_vertex_shader = GL_TRUE; 826 827 extensions->EXT_blend_color = GL_TRUE; 828 extensions->EXT_blend_func_separate = GL_TRUE; 829 extensions->EXT_blend_minmax = GL_TRUE; 830 extensions->EXT_gpu_program_parameters = GL_TRUE; 831 extensions->EXT_pixel_buffer_object = GL_TRUE; 832 extensions->EXT_point_parameters = GL_TRUE; 833 extensions->EXT_provoking_vertex = GL_TRUE; 834 835 extensions->EXT_texture_env_dot3 = GL_TRUE; 836 837 extensions->ATI_fragment_shader = GL_TRUE; 838 extensions->ATI_texture_env_combine3 = GL_TRUE; 839 840 extensions->MESA_pack_invert = GL_TRUE; 841 842 extensions->NV_fog_distance = GL_TRUE; 843 extensions->NV_texture_env_combine4 = GL_TRUE; 844 extensions->NV_texture_rectangle = GL_TRUE; 845 846 extensions->OES_EGL_image = GL_TRUE; 847 extensions->OES_EGL_image_external = GL_TRUE; 848 extensions->OES_draw_texture = GL_TRUE; 849 850 /* Expose the extensions which directly correspond to gallium caps. */ 851 for (i = 0; i < ARRAY_SIZE(cap_mapping); i++) { 852 if (screen->get_param(screen, cap_mapping[i].cap)) { 853 extension_table[cap_mapping[i].extension_offset] = GL_TRUE; 854 } 855 } 856 857 /* Expose the extensions which directly correspond to gallium formats. */ 858 init_format_extensions(screen, extensions, rendertarget_mapping, 859 ARRAY_SIZE(rendertarget_mapping), PIPE_TEXTURE_2D, 860 PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW); 861 init_format_extensions(screen, extensions, depthstencil_mapping, 862 ARRAY_SIZE(depthstencil_mapping), PIPE_TEXTURE_2D, 863 PIPE_BIND_DEPTH_STENCIL | PIPE_BIND_SAMPLER_VIEW); 864 init_format_extensions(screen, extensions, texture_mapping, 865 ARRAY_SIZE(texture_mapping), PIPE_TEXTURE_2D, 866 PIPE_BIND_SAMPLER_VIEW); 867 init_format_extensions(screen, extensions, vertex_mapping, 868 ARRAY_SIZE(vertex_mapping), PIPE_BUFFER, 869 PIPE_BIND_VERTEX_BUFFER); 870 871 /* Figure out GLSL support and set GLSLVersion to it. */ 872 consts->GLSLVersion = screen->get_param(screen, PIPE_CAP_GLSL_FEATURE_LEVEL); 873 874 _mesa_override_glsl_version(consts); 875 876 if (options->force_glsl_version > 0 && 877 options->force_glsl_version <= consts->GLSLVersion) { 878 consts->ForceGLSLVersion = options->force_glsl_version; 879 } 880 881 if (consts->GLSLVersion >= 400) 882 extensions->ARB_gpu_shader5 = GL_TRUE; 883 if (consts->GLSLVersion >= 410) 884 extensions->ARB_shader_precision = GL_TRUE; 885 886 /* This extension needs full OpenGL 3.2, but we don't know if that's 887 * supported at this point. Only check the GLSL version. */ 888 if (consts->GLSLVersion >= 150 && 889 screen->get_param(screen, PIPE_CAP_TGSI_VS_LAYER_VIEWPORT)) { 890 extensions->AMD_vertex_shader_layer = GL_TRUE; 891 } 892 893 if (consts->GLSLVersion >= 140) { 894 if (screen->get_param(screen, PIPE_CAP_TGSI_ARRAY_COMPONENTS) && 895 screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT, 896 PIPE_SHADER_CAP_PREFERRED_IR) == PIPE_SHADER_IR_TGSI) 897 extensions->ARB_enhanced_layouts = GL_TRUE; 898 } 899 900 if (consts->GLSLVersion >= 130) { 901 consts->NativeIntegers = GL_TRUE; 902 consts->MaxClipPlanes = 8; 903 904 if (screen->get_param(screen, PIPE_CAP_VERTEXID_NOBASE)) { 905 consts->VertexID_is_zero_based = GL_TRUE; 906 } 907 908 /* Extensions that either depend on GLSL 1.30 or are a subset thereof. */ 909 extensions->ARB_conservative_depth = GL_TRUE; 910 extensions->ARB_shading_language_packing = GL_TRUE; 911 extensions->OES_depth_texture_cube_map = GL_TRUE; 912 extensions->ARB_shading_language_420pack = GL_TRUE; 913 extensions->ARB_texture_query_levels = GL_TRUE; 914 extensions->ARB_shader_subroutine = GL_TRUE; 915 916 if (!options->disable_shader_bit_encoding) { 917 extensions->ARB_shader_bit_encoding = GL_TRUE; 918 } 919 920 extensions->EXT_shader_integer_mix = GL_TRUE; 921 extensions->ARB_arrays_of_arrays = GL_TRUE; 922 extensions->MESA_shader_integer_functions = GL_TRUE; 923 } else { 924 /* Optional integer support for GLSL 1.2. */ 925 if (screen->get_shader_param(screen, PIPE_SHADER_VERTEX, 926 PIPE_SHADER_CAP_INTEGERS) && 927 screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT, 928 PIPE_SHADER_CAP_INTEGERS)) { 929 consts->NativeIntegers = GL_TRUE; 930 931 extensions->EXT_shader_integer_mix = GL_TRUE; 932 } 933 934 /* Integer textures make no sense before GLSL 1.30 */ 935 extensions->EXT_texture_integer = GL_FALSE; 936 } 937 938 consts->GLSLZeroInit = options->glsl_zero_init; 939 940 consts->UniformBooleanTrue = consts->NativeIntegers ? ~0U : fui(1.0f); 941 942 /* Below are the cases which cannot be moved into tables easily. */ 943 944 if (!has_lib_dxtc && !options->force_s3tc_enable) { 945 extensions->EXT_texture_compression_s3tc = GL_FALSE; 946 extensions->ANGLE_texture_compression_dxt = GL_FALSE; 947 } 948 949 if (screen->get_shader_param(screen, PIPE_SHADER_TESS_CTRL, 950 PIPE_SHADER_CAP_MAX_INSTRUCTIONS) > 0) { 951 extensions->ARB_tessellation_shader = GL_TRUE; 952 } 953 954 /* What this is really checking for is the ability to support multiple 955 * invocations of a geometry shader. There is no separate cap for that, so 956 * we check the GLSLVersion. 957 */ 958 if (consts->GLSLVersion >= 400 && 959 screen->get_shader_param(screen, PIPE_SHADER_GEOMETRY, 960 PIPE_SHADER_CAP_MAX_INSTRUCTIONS) > 0) { 961 extensions->OES_geometry_shader = GL_TRUE; 962 } 963 964 if (screen->fence_finish) { 965 extensions->ARB_sync = GL_TRUE; 966 } 967 968 /* Needs PIPE_CAP_SAMPLE_SHADING + all the sample-related bits of 969 * ARB_gpu_shader5. This enables all the per-sample shading ES extensions. 970 */ 971 extensions->OES_sample_variables = extensions->ARB_sample_shading && 972 extensions->ARB_gpu_shader5; 973 974 /* Maximum sample count. */ 975 { 976 enum pipe_format color_formats[] = { 977 PIPE_FORMAT_R8G8B8A8_UNORM, 978 PIPE_FORMAT_B8G8R8A8_UNORM, 979 PIPE_FORMAT_A8R8G8B8_UNORM, 980 PIPE_FORMAT_A8B8G8R8_UNORM, 981 }; 982 enum pipe_format depth_formats[] = { 983 PIPE_FORMAT_Z16_UNORM, 984 PIPE_FORMAT_Z24X8_UNORM, 985 PIPE_FORMAT_X8Z24_UNORM, 986 PIPE_FORMAT_Z32_UNORM, 987 PIPE_FORMAT_Z32_FLOAT 988 }; 989 enum pipe_format int_formats[] = { 990 PIPE_FORMAT_R8G8B8A8_SINT 991 }; 992 enum pipe_format void_formats[] = { 993 PIPE_FORMAT_NONE 994 }; 995 996 consts->MaxSamples = 997 get_max_samples_for_formats(screen, ARRAY_SIZE(color_formats), 998 color_formats, 16, 999 PIPE_BIND_RENDER_TARGET); 1000 1001 consts->MaxImageSamples = 1002 get_max_samples_for_formats(screen, ARRAY_SIZE(color_formats), 1003 color_formats, 16, 1004 PIPE_BIND_SHADER_IMAGE); 1005 1006 consts->MaxColorTextureSamples = 1007 get_max_samples_for_formats(screen, ARRAY_SIZE(color_formats), 1008 color_formats, consts->MaxSamples, 1009 PIPE_BIND_SAMPLER_VIEW); 1010 1011 consts->MaxDepthTextureSamples = 1012 get_max_samples_for_formats(screen, ARRAY_SIZE(depth_formats), 1013 depth_formats, consts->MaxSamples, 1014 PIPE_BIND_SAMPLER_VIEW); 1015 1016 consts->MaxIntegerSamples = 1017 get_max_samples_for_formats(screen, ARRAY_SIZE(int_formats), 1018 int_formats, consts->MaxSamples, 1019 PIPE_BIND_SAMPLER_VIEW); 1020 1021 /* ARB_framebuffer_no_attachments, assume max no. of samples 32 */ 1022 consts->MaxFramebufferSamples = 1023 get_max_samples_for_formats(screen, ARRAY_SIZE(void_formats), 1024 void_formats, 32, 1025 PIPE_BIND_RENDER_TARGET); 1026 } 1027 if (consts->MaxSamples == 1) { 1028 /* one sample doesn't really make sense */ 1029 consts->MaxSamples = 0; 1030 } 1031 else if (consts->MaxSamples >= 2) { 1032 extensions->EXT_framebuffer_multisample = GL_TRUE; 1033 extensions->EXT_framebuffer_multisample_blit_scaled = GL_TRUE; 1034 } 1035 1036 if (consts->MaxSamples == 0 && screen->get_param(screen, PIPE_CAP_FAKE_SW_MSAA)) { 1037 consts->FakeSWMSAA = GL_TRUE; 1038 extensions->EXT_framebuffer_multisample = GL_TRUE; 1039 extensions->EXT_framebuffer_multisample_blit_scaled = GL_TRUE; 1040 extensions->ARB_texture_multisample = GL_TRUE; 1041 } 1042 1043 if (consts->MaxDualSourceDrawBuffers > 0 && 1044 !options->disable_blend_func_extended) 1045 extensions->ARB_blend_func_extended = GL_TRUE; 1046 1047 if (screen->get_param(screen, PIPE_CAP_QUERY_TIME_ELAPSED) || 1048 extensions->ARB_timer_query) { 1049 extensions->EXT_timer_query = GL_TRUE; 1050 } 1051 1052 if (extensions->ARB_transform_feedback2 && 1053 extensions->ARB_draw_instanced) { 1054 extensions->ARB_transform_feedback_instanced = GL_TRUE; 1055 } 1056 if (options->force_glsl_extensions_warn) 1057 consts->ForceGLSLExtensionsWarn = 1; 1058 1059 if (options->disable_glsl_line_continuations) 1060 consts->DisableGLSLLineContinuations = 1; 1061 1062 if (options->allow_glsl_extension_directive_midshader) 1063 consts->AllowGLSLExtensionDirectiveMidShader = GL_TRUE; 1064 1065 consts->MinMapBufferAlignment = 1066 screen->get_param(screen, PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT); 1067 1068 if (extensions->ARB_texture_buffer_object) { 1069 consts->MaxTextureBufferSize = 1070 _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_BUFFER_SIZE), 1071 (1u << 31) - 1); 1072 consts->TextureBufferOffsetAlignment = 1073 screen->get_param(screen, PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT); 1074 1075 if (consts->TextureBufferOffsetAlignment) 1076 extensions->ARB_texture_buffer_range = GL_TRUE; 1077 1078 init_format_extensions(screen, extensions, tbo_rgb32, 1079 ARRAY_SIZE(tbo_rgb32), PIPE_BUFFER, 1080 PIPE_BIND_SAMPLER_VIEW); 1081 } 1082 1083 extensions->OES_texture_buffer = 1084 extensions->ARB_texture_buffer_object && 1085 extensions->ARB_texture_buffer_range && 1086 extensions->ARB_texture_buffer_object_rgb32 && 1087 extensions->ARB_shader_image_load_store; 1088 1089 /* Unpacking a varying in the fragment shader costs 1 texture indirection. 1090 * If the number of available texture indirections is very limited, then we 1091 * prefer to disable varying packing rather than run the risk of varying 1092 * packing preventing a shader from running. 1093 */ 1094 if (screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT, 1095 PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS) <= 8) { 1096 /* We can't disable varying packing if transform feedback is available, 1097 * because transform feedback code assumes a packed varying layout. 1098 */ 1099 if (!extensions->EXT_transform_feedback) 1100 consts->DisableVaryingPacking = GL_TRUE; 1101 } 1102 1103 consts->MaxViewports = screen->get_param(screen, PIPE_CAP_MAX_VIEWPORTS); 1104 if (consts->MaxViewports >= 16) { 1105 if (consts->GLSLVersion >= 400) { 1106 consts->ViewportBounds.Min = -32768.0; 1107 consts->ViewportBounds.Max = 32767.0; 1108 } else { 1109 consts->ViewportBounds.Min = -16384.0; 1110 consts->ViewportBounds.Max = 16383.0; 1111 } 1112 extensions->ARB_viewport_array = GL_TRUE; 1113 extensions->ARB_fragment_layer_viewport = GL_TRUE; 1114 if (extensions->AMD_vertex_shader_layer) 1115 extensions->AMD_vertex_shader_viewport_index = GL_TRUE; 1116 } 1117 1118 /* ARB_framebuffer_no_attachments */ 1119 if (screen->get_param(screen, PIPE_CAP_FRAMEBUFFER_NO_ATTACHMENT) && 1120 ((consts->MaxSamples >= 4 && consts->MaxFramebufferLayers >= 2048) || 1121 (consts->MaxFramebufferSamples >= consts->MaxSamples && 1122 consts->MaxFramebufferLayers >= consts->MaxArrayTextureLayers))) 1123 extensions->ARB_framebuffer_no_attachments = GL_TRUE; 1124 1125 /* GL_ARB_ES3_compatibility. 1126 * 1127 * Assume that ES3 is supported if GLSL 3.30 is supported. 1128 * (OpenGL 3.3 is a requirement for that extension.) 1129 */ 1130 if (consts->GLSLVersion >= 330 && 1131 /* Requirements for ETC2 emulation. */ 1132 screen->is_format_supported(screen, PIPE_FORMAT_R8G8B8A8_UNORM, 1133 PIPE_TEXTURE_2D, 0, 1134 PIPE_BIND_SAMPLER_VIEW) && 1135 screen->is_format_supported(screen, PIPE_FORMAT_B8G8R8A8_SRGB, 1136 PIPE_TEXTURE_2D, 0, 1137 PIPE_BIND_SAMPLER_VIEW) && 1138 screen->is_format_supported(screen, PIPE_FORMAT_R16_UNORM, 1139 PIPE_TEXTURE_2D, 0, 1140 PIPE_BIND_SAMPLER_VIEW) && 1141 screen->is_format_supported(screen, PIPE_FORMAT_R16G16_UNORM, 1142 PIPE_TEXTURE_2D, 0, 1143 PIPE_BIND_SAMPLER_VIEW) && 1144 screen->is_format_supported(screen, PIPE_FORMAT_R16_SNORM, 1145 PIPE_TEXTURE_2D, 0, 1146 PIPE_BIND_SAMPLER_VIEW) && 1147 screen->is_format_supported(screen, PIPE_FORMAT_R16G16_SNORM, 1148 PIPE_TEXTURE_2D, 0, 1149 PIPE_BIND_SAMPLER_VIEW)) { 1150 extensions->ARB_ES3_compatibility = GL_TRUE; 1151 } 1152 1153 #ifdef HAVE_ST_VDPAU 1154 if (screen->get_video_param && 1155 screen->get_video_param(screen, PIPE_VIDEO_PROFILE_UNKNOWN, 1156 PIPE_VIDEO_ENTRYPOINT_BITSTREAM, 1157 PIPE_VIDEO_CAP_SUPPORTS_INTERLACED)) { 1158 extensions->NV_vdpau_interop = GL_TRUE; 1159 } 1160 #endif 1161 1162 if (screen->get_shader_param(screen, PIPE_SHADER_VERTEX, 1163 PIPE_SHADER_CAP_DOUBLES) && 1164 screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT, 1165 PIPE_SHADER_CAP_DOUBLES)) { 1166 extensions->ARB_gpu_shader_fp64 = GL_TRUE; 1167 extensions->ARB_vertex_attrib_64bit = GL_TRUE; 1168 } 1169 1170 if ((ST_DEBUG & DEBUG_GREMEDY) && 1171 screen->get_param(screen, PIPE_CAP_STRING_MARKER)) 1172 extensions->GREMEDY_string_marker = GL_TRUE; 1173 1174 if (screen->get_param(screen, PIPE_CAP_COMPUTE)) { 1175 int compute_supported_irs = 1176 screen->get_shader_param(screen, PIPE_SHADER_COMPUTE, 1177 PIPE_SHADER_CAP_SUPPORTED_IRS); 1178 if (compute_supported_irs & (1 << PIPE_SHADER_IR_TGSI)) { 1179 uint64_t grid_size[3], block_size[3]; 1180 uint64_t max_local_size, max_threads_per_block; 1181 1182 screen->get_compute_param(screen, PIPE_SHADER_IR_TGSI, 1183 PIPE_COMPUTE_CAP_MAX_GRID_SIZE, grid_size); 1184 screen->get_compute_param(screen, PIPE_SHADER_IR_TGSI, 1185 PIPE_COMPUTE_CAP_MAX_BLOCK_SIZE, block_size); 1186 screen->get_compute_param(screen, PIPE_SHADER_IR_TGSI, 1187 PIPE_COMPUTE_CAP_MAX_THREADS_PER_BLOCK, 1188 &max_threads_per_block); 1189 screen->get_compute_param(screen, PIPE_SHADER_IR_TGSI, 1190 PIPE_COMPUTE_CAP_MAX_LOCAL_SIZE, 1191 &max_local_size); 1192 1193 consts->MaxComputeWorkGroupInvocations = max_threads_per_block; 1194 consts->MaxComputeSharedMemorySize = max_local_size; 1195 1196 for (i = 0; i < 3; i++) { 1197 consts->MaxComputeWorkGroupCount[i] = grid_size[i]; 1198 consts->MaxComputeWorkGroupSize[i] = block_size[i]; 1199 } 1200 1201 extensions->ARB_compute_shader = 1202 extensions->ARB_shader_image_load_store && 1203 extensions->ARB_shader_atomic_counters; 1204 1205 if (extensions->ARB_compute_shader) { 1206 uint64_t max_variable_threads_per_block = 0; 1207 1208 screen->get_compute_param(screen, PIPE_SHADER_IR_TGSI, 1209 PIPE_COMPUTE_CAP_MAX_VARIABLE_THREADS_PER_BLOCK, 1210 &max_variable_threads_per_block); 1211 1212 for (i = 0; i < 3; i++) { 1213 /* Clamp the values to avoid having a local work group size 1214 * greater than the maximum number of invocations. 1215 */ 1216 consts->MaxComputeVariableGroupSize[i] = 1217 MIN2(consts->MaxComputeWorkGroupSize[i], 1218 max_variable_threads_per_block); 1219 } 1220 consts->MaxComputeVariableGroupInvocations = 1221 max_variable_threads_per_block; 1222 1223 extensions->ARB_compute_variable_group_size = 1224 max_variable_threads_per_block > 0; 1225 } 1226 } 1227 } 1228 1229 extensions->KHR_robustness = extensions->ARB_robust_buffer_access_behavior; 1230 1231 /* If we support ES 3.1, we support the ES3_1_compatibility ext. However 1232 * there's no clean way of telling whether we would support ES 3.1 from 1233 * here, so copy the condition from compute_version_es2 here. A lot of 1234 * these are redunant, but simpler to just have a (near-)exact copy here. 1235 */ 1236 extensions->ARB_ES3_1_compatibility = 1237 extensions->ARB_ES3_compatibility && 1238 extensions->ARB_arrays_of_arrays && 1239 extensions->ARB_compute_shader && 1240 extensions->ARB_draw_indirect && 1241 extensions->ARB_explicit_uniform_location && 1242 extensions->ARB_framebuffer_no_attachments && 1243 extensions->ARB_shader_atomic_counters && 1244 extensions->ARB_shader_image_load_store && 1245 extensions->ARB_shader_image_size && 1246 extensions->ARB_shader_storage_buffer_object && 1247 extensions->ARB_shading_language_packing && 1248 extensions->ARB_stencil_texturing && 1249 extensions->ARB_texture_multisample && 1250 extensions->ARB_gpu_shader5 && 1251 extensions->EXT_shader_integer_mix; 1252 1253 extensions->OES_texture_cube_map_array = 1254 extensions->ARB_ES3_1_compatibility && 1255 extensions->OES_geometry_shader && 1256 extensions->ARB_texture_cube_map_array; 1257 1258 extensions->OES_viewport_array = 1259 extensions->ARB_ES3_1_compatibility && 1260 extensions->OES_geometry_shader && 1261 extensions->ARB_viewport_array; 1262 1263 extensions->OES_primitive_bounding_box = extensions->ARB_ES3_1_compatibility; 1264 consts->NoPrimitiveBoundingBoxOutput = true; 1265 1266 extensions->ANDROID_extension_pack_es31a = 1267 extensions->KHR_texture_compression_astc_ldr && 1268 extensions->KHR_blend_equation_advanced && 1269 extensions->OES_sample_variables && 1270 extensions->ARB_shader_image_load_store && 1271 extensions->ARB_texture_stencil8 && 1272 extensions->ARB_texture_multisample && 1273 extensions->OES_copy_image && 1274 extensions->ARB_draw_buffers_blend && 1275 extensions->OES_geometry_shader && 1276 extensions->ARB_gpu_shader5 && 1277 extensions->OES_primitive_bounding_box && 1278 extensions->ARB_tessellation_shader && 1279 extensions->ARB_texture_border_clamp && 1280 extensions->OES_texture_buffer && 1281 extensions->OES_texture_cube_map_array && 1282 extensions->EXT_texture_sRGB_decode; 1283 1284 /* Same deal as for ARB_ES3_1_compatibility - this has to be computed 1285 * before overall versions are selected. Also it's actually a subset of ES 1286 * 3.2, since it doesn't require ASTC or advanced blending. 1287 */ 1288 extensions->ARB_ES3_2_compatibility = 1289 extensions->ARB_ES3_1_compatibility && 1290 extensions->KHR_robustness && 1291 extensions->ARB_copy_image && 1292 extensions->ARB_draw_buffers_blend && 1293 extensions->ARB_draw_elements_base_vertex && 1294 extensions->OES_geometry_shader && 1295 extensions->ARB_gpu_shader5 && 1296 extensions->ARB_sample_shading && 1297 extensions->ARB_tessellation_shader && 1298 extensions->ARB_texture_border_clamp && 1299 extensions->OES_texture_buffer && 1300 extensions->ARB_texture_cube_map_array && 1301 extensions->ARB_texture_stencil8 && 1302 extensions->ARB_texture_multisample; 1303 } 1304
