st_extensions.c revision 848b8605
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_extensions.h" 41#include "st_format.h" 42 43 44/* 45 * Note: we use these function rather than the MIN2, MAX2, CLAMP macros to 46 * avoid evaluating arguments (which are often function calls) more than once. 47 */ 48 49static unsigned _min(unsigned a, unsigned b) 50{ 51 return (a < b) ? a : b; 52} 53 54static float _maxf(float a, float b) 55{ 56 return (a > b) ? a : b; 57} 58 59static int _clamp(int a, int min, int max) 60{ 61 if (a < min) 62 return min; 63 else if (a > max) 64 return max; 65 else 66 return a; 67} 68 69 70/** 71 * Query driver to get implementation limits. 72 * Note that we have to limit/clamp against Mesa's internal limits too. 73 */ 74void st_init_limits(struct pipe_screen *screen, 75 struct gl_constants *c, struct gl_extensions *extensions) 76{ 77 unsigned sh; 78 boolean can_ubo = TRUE; 79 80 c->MaxTextureLevels 81 = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS), 82 MAX_TEXTURE_LEVELS); 83 84 c->Max3DTextureLevels 85 = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_3D_LEVELS), 86 MAX_3D_TEXTURE_LEVELS); 87 88 c->MaxCubeTextureLevels 89 = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS), 90 MAX_CUBE_TEXTURE_LEVELS); 91 92 c->MaxTextureRectSize 93 = _min(1 << (c->MaxTextureLevels - 1), MAX_TEXTURE_RECT_SIZE); 94 95 c->MaxArrayTextureLayers 96 = screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS); 97 98 /* Define max viewport size and max renderbuffer size in terms of 99 * max texture size (note: max tex RECT size = max tex 2D size). 100 * If this isn't true for some hardware we'll need new PIPE_CAP_ queries. 101 */ 102 c->MaxViewportWidth = 103 c->MaxViewportHeight = 104 c->MaxRenderbufferSize = c->MaxTextureRectSize; 105 106 c->MaxDrawBuffers = c->MaxColorAttachments = 107 _clamp(screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS), 108 1, MAX_DRAW_BUFFERS); 109 110 c->MaxDualSourceDrawBuffers 111 = _clamp(screen->get_param(screen, PIPE_CAP_MAX_DUAL_SOURCE_RENDER_TARGETS), 112 0, MAX_DRAW_BUFFERS); 113 114 c->MaxLineWidth 115 = _maxf(1.0f, screen->get_paramf(screen, 116 PIPE_CAPF_MAX_LINE_WIDTH)); 117 c->MaxLineWidthAA 118 = _maxf(1.0f, screen->get_paramf(screen, 119 PIPE_CAPF_MAX_LINE_WIDTH_AA)); 120 121 c->MaxPointSize 122 = _maxf(1.0f, screen->get_paramf(screen, 123 PIPE_CAPF_MAX_POINT_WIDTH)); 124 c->MaxPointSizeAA 125 = _maxf(1.0f, screen->get_paramf(screen, 126 PIPE_CAPF_MAX_POINT_WIDTH_AA)); 127 128 /* these are not queryable. Note that GL basically mandates a 1.0 minimum 129 * for non-aa sizes, but we can go down to 0.0 for aa points. 130 */ 131 c->MinPointSize = 1.0f; 132 c->MinPointSizeAA = 0.0f; 133 134 c->MaxTextureMaxAnisotropy 135 = _maxf(2.0f, screen->get_paramf(screen, 136 PIPE_CAPF_MAX_TEXTURE_ANISOTROPY)); 137 138 c->MaxTextureLodBias 139 = screen->get_paramf(screen, PIPE_CAPF_MAX_TEXTURE_LOD_BIAS); 140 141 c->QuadsFollowProvokingVertexConvention = screen->get_param( 142 screen, PIPE_CAP_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION); 143 144 c->MaxUniformBlockSize = 145 screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT, 146 PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE); 147 if (c->MaxUniformBlockSize < 16384) { 148 can_ubo = FALSE; 149 } 150 151 for (sh = 0; sh < PIPE_SHADER_TYPES; ++sh) { 152 struct gl_shader_compiler_options *options; 153 struct gl_program_constants *pc; 154 155 switch (sh) { 156 case PIPE_SHADER_FRAGMENT: 157 pc = &c->Program[MESA_SHADER_FRAGMENT]; 158 options = &c->ShaderCompilerOptions[MESA_SHADER_FRAGMENT]; 159 break; 160 case PIPE_SHADER_VERTEX: 161 pc = &c->Program[MESA_SHADER_VERTEX]; 162 options = &c->ShaderCompilerOptions[MESA_SHADER_VERTEX]; 163 break; 164 case PIPE_SHADER_GEOMETRY: 165 pc = &c->Program[MESA_SHADER_GEOMETRY]; 166 options = &c->ShaderCompilerOptions[MESA_SHADER_GEOMETRY]; 167 break; 168 default: 169 /* compute shader, etc. */ 170 continue; 171 } 172 173 pc->MaxTextureImageUnits = 174 _min(screen->get_shader_param(screen, sh, 175 PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS), 176 MAX_TEXTURE_IMAGE_UNITS); 177 178 pc->MaxInstructions = pc->MaxNativeInstructions = 179 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INSTRUCTIONS); 180 pc->MaxAluInstructions = pc->MaxNativeAluInstructions = 181 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS); 182 pc->MaxTexInstructions = pc->MaxNativeTexInstructions = 183 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS); 184 pc->MaxTexIndirections = pc->MaxNativeTexIndirections = 185 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS); 186 pc->MaxAttribs = pc->MaxNativeAttribs = 187 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INPUTS); 188 pc->MaxTemps = pc->MaxNativeTemps = 189 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_TEMPS); 190 pc->MaxAddressRegs = pc->MaxNativeAddressRegs = 191 sh == PIPE_SHADER_VERTEX ? 1 : 0; 192 pc->MaxParameters = pc->MaxNativeParameters = 193 screen->get_shader_param(screen, sh, 194 PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE) / sizeof(float[4]); 195 196 pc->MaxUniformComponents = 4 * MIN2(pc->MaxNativeParameters, MAX_UNIFORMS); 197 198 pc->MaxUniformBlocks = 199 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_CONST_BUFFERS); 200 if (pc->MaxUniformBlocks) 201 pc->MaxUniformBlocks -= 1; /* The first one is for ordinary uniforms. */ 202 pc->MaxUniformBlocks = _min(pc->MaxUniformBlocks, MAX_UNIFORM_BUFFERS); 203 204 pc->MaxCombinedUniformComponents = (pc->MaxUniformComponents + 205 c->MaxUniformBlockSize / 4 * 206 pc->MaxUniformBlocks); 207 208 /* Gallium doesn't really care about local vs. env parameters so use the 209 * same limits. 210 */ 211 pc->MaxLocalParams = MIN2(pc->MaxParameters, MAX_PROGRAM_LOCAL_PARAMS); 212 pc->MaxEnvParams = MIN2(pc->MaxParameters, MAX_PROGRAM_ENV_PARAMS); 213 214 options->EmitNoNoise = TRUE; 215 216 /* TODO: make these more fine-grained if anyone needs it */ 217 options->MaxIfDepth = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH); 218 options->EmitNoLoops = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH); 219 options->EmitNoFunctions = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_SUBROUTINES); 220 options->EmitNoMainReturn = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_SUBROUTINES); 221 222 options->EmitNoCont = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED); 223 224 options->EmitNoIndirectInput = !screen->get_shader_param(screen, sh, 225 PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR); 226 options->EmitNoIndirectOutput = !screen->get_shader_param(screen, sh, 227 PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR); 228 options->EmitNoIndirectTemp = !screen->get_shader_param(screen, sh, 229 PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR); 230 options->EmitNoIndirectUniform = !screen->get_shader_param(screen, sh, 231 PIPE_SHADER_CAP_INDIRECT_CONST_ADDR); 232 233 if (pc->MaxNativeInstructions && 234 (options->EmitNoIndirectUniform || pc->MaxUniformBlocks < 12)) { 235 can_ubo = FALSE; 236 } 237 238 if (options->EmitNoLoops) 239 options->MaxUnrollIterations = MIN2(screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INSTRUCTIONS), 65536); 240 241 options->LowerClipDistance = true; 242 } 243 244 c->MaxCombinedTextureImageUnits = 245 _min(c->Program[MESA_SHADER_VERTEX].MaxTextureImageUnits + 246 c->Program[MESA_SHADER_GEOMETRY].MaxTextureImageUnits + 247 c->Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits, 248 MAX_COMBINED_TEXTURE_IMAGE_UNITS); 249 250 /* This depends on program constants. */ 251 c->MaxTextureCoordUnits 252 = _min(c->Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits, MAX_TEXTURE_COORD_UNITS); 253 254 c->MaxTextureUnits = _min(c->Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits, c->MaxTextureCoordUnits); 255 256 c->Program[MESA_SHADER_VERTEX].MaxAttribs = MIN2(c->Program[MESA_SHADER_VERTEX].MaxAttribs, 16); 257 258 /* PIPE_SHADER_CAP_MAX_INPUTS for the FS specifies the maximum number 259 * of inputs. It's always 2 colors + N generic inputs. */ 260 c->MaxVarying = screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT, 261 PIPE_SHADER_CAP_MAX_INPUTS); 262 c->MaxVarying = MIN2(c->MaxVarying, MAX_VARYING); 263 c->Program[MESA_SHADER_FRAGMENT].MaxInputComponents = c->MaxVarying * 4; 264 c->Program[MESA_SHADER_VERTEX].MaxOutputComponents = c->MaxVarying * 4; 265 c->Program[MESA_SHADER_GEOMETRY].MaxInputComponents = c->MaxVarying * 4; 266 c->Program[MESA_SHADER_GEOMETRY].MaxOutputComponents = c->MaxVarying * 4; 267 c->MaxGeometryOutputVertices = screen->get_param(screen, PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES); 268 c->MaxGeometryTotalOutputComponents = screen->get_param(screen, PIPE_CAP_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS); 269 270 c->MinProgramTexelOffset = screen->get_param(screen, PIPE_CAP_MIN_TEXEL_OFFSET); 271 c->MaxProgramTexelOffset = screen->get_param(screen, PIPE_CAP_MAX_TEXEL_OFFSET); 272 273 c->MaxProgramTextureGatherComponents = screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_GATHER_COMPONENTS); 274 c->MinProgramTextureGatherOffset = screen->get_param(screen, PIPE_CAP_MIN_TEXTURE_GATHER_OFFSET); 275 c->MaxProgramTextureGatherOffset = screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_GATHER_OFFSET); 276 277 c->MaxTransformFeedbackBuffers = 278 screen->get_param(screen, PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS); 279 c->MaxTransformFeedbackBuffers = MIN2(c->MaxTransformFeedbackBuffers, MAX_FEEDBACK_BUFFERS); 280 c->MaxTransformFeedbackSeparateComponents = 281 screen->get_param(screen, PIPE_CAP_MAX_STREAM_OUTPUT_SEPARATE_COMPONENTS); 282 c->MaxTransformFeedbackInterleavedComponents = 283 screen->get_param(screen, PIPE_CAP_MAX_STREAM_OUTPUT_INTERLEAVED_COMPONENTS); 284 c->MaxVertexStreams = 285 MAX2(1, screen->get_param(screen, PIPE_CAP_MAX_VERTEX_STREAMS)); 286 287 /* The vertex stream must fit into pipe_stream_output_info::stream */ 288 assert(c->MaxVertexStreams <= 4); 289 290 c->StripTextureBorder = GL_TRUE; 291 292 c->GLSLSkipStrictMaxUniformLimitCheck = 293 screen->get_param(screen, PIPE_CAP_TGSI_CAN_COMPACT_CONSTANTS); 294 295 if (can_ubo) { 296 extensions->ARB_uniform_buffer_object = GL_TRUE; 297 c->UniformBufferOffsetAlignment = 298 screen->get_param(screen, PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT); 299 c->MaxCombinedUniformBlocks = c->MaxUniformBufferBindings = 300 c->Program[MESA_SHADER_VERTEX].MaxUniformBlocks + 301 c->Program[MESA_SHADER_GEOMETRY].MaxUniformBlocks + 302 c->Program[MESA_SHADER_FRAGMENT].MaxUniformBlocks; 303 assert(c->MaxCombinedUniformBlocks <= MAX_COMBINED_UNIFORM_BUFFERS); 304 } 305} 306 307 308/** 309 * Given a member \c x of struct gl_extensions, return offset of 310 * \c x in bytes. 311 */ 312#define o(x) offsetof(struct gl_extensions, x) 313 314 315struct st_extension_cap_mapping { 316 int extension_offset; 317 int cap; 318}; 319 320struct st_extension_format_mapping { 321 int extension_offset[2]; 322 enum pipe_format format[8]; 323 324 /* If TRUE, at least one format must be supported for the extensions to be 325 * advertised. If FALSE, all the formats must be supported. */ 326 GLboolean need_at_least_one; 327}; 328 329/** 330 * Enable extensions if certain pipe formats are supported by the driver. 331 * What extensions will be enabled and what formats must be supported is 332 * described by the array of st_extension_format_mapping. 333 * 334 * target and bind_flags are passed to is_format_supported. 335 */ 336static void 337init_format_extensions(struct pipe_screen *screen, 338 struct gl_extensions *extensions, 339 const struct st_extension_format_mapping *mapping, 340 unsigned num_mappings, 341 enum pipe_texture_target target, 342 unsigned bind_flags) 343{ 344 GLboolean *extension_table = (GLboolean *) extensions; 345 unsigned i; 346 int j; 347 int num_formats = Elements(mapping->format); 348 int num_ext = Elements(mapping->extension_offset); 349 350 for (i = 0; i < num_mappings; i++) { 351 int num_supported = 0; 352 353 /* Examine each format in the list. */ 354 for (j = 0; j < num_formats && mapping[i].format[j]; j++) { 355 if (screen->is_format_supported(screen, mapping[i].format[j], 356 target, 0, bind_flags)) { 357 num_supported++; 358 } 359 } 360 361 if (!num_supported || 362 (!mapping[i].need_at_least_one && num_supported != j)) { 363 continue; 364 } 365 366 /* Enable all extensions in the list. */ 367 for (j = 0; j < num_ext && mapping[i].extension_offset[j]; j++) 368 extension_table[mapping[i].extension_offset[j]] = GL_TRUE; 369 } 370} 371 372 373/** 374 * Given a list of formats and bind flags, return the maximum number 375 * of samples supported by any of those formats. 376 */ 377static unsigned 378get_max_samples_for_formats(struct pipe_screen *screen, 379 unsigned num_formats, 380 enum pipe_format *formats, 381 unsigned max_samples, 382 unsigned bind) 383{ 384 unsigned i, f; 385 386 for (i = max_samples; i > 0; --i) { 387 for (f = 0; f < num_formats; f++) { 388 if (screen->is_format_supported(screen, formats[f], 389 PIPE_TEXTURE_2D, i, bind)) { 390 return i; 391 } 392 } 393 } 394 return 0; 395} 396 397 398/** 399 * Use pipe_screen::get_param() to query PIPE_CAP_ values to determine 400 * which GL extensions are supported. 401 * Quite a few extensions are always supported because they are standard 402 * features or can be built on top of other gallium features. 403 * Some fine tuning may still be needed. 404 */ 405void st_init_extensions(struct pipe_screen *screen, 406 gl_api api, 407 struct gl_constants *consts, 408 struct gl_extensions *extensions, 409 struct st_config_options *options, 410 boolean has_lib_dxtc) 411{ 412 int i, glsl_feature_level; 413 GLboolean *extension_table = (GLboolean *) extensions; 414 415 static const struct st_extension_cap_mapping cap_mapping[] = { 416 { o(ARB_base_instance), PIPE_CAP_START_INSTANCE }, 417 { o(ARB_buffer_storage), PIPE_CAP_BUFFER_MAP_PERSISTENT_COHERENT }, 418 { o(ARB_depth_clamp), PIPE_CAP_DEPTH_CLIP_DISABLE }, 419 { o(ARB_depth_texture), PIPE_CAP_TEXTURE_SHADOW_MAP }, 420 { o(ARB_draw_buffers_blend), PIPE_CAP_INDEP_BLEND_FUNC }, 421 { o(ARB_draw_instanced), PIPE_CAP_TGSI_INSTANCEID }, 422 { o(ARB_fragment_program_shadow), PIPE_CAP_TEXTURE_SHADOW_MAP }, 423 { o(ARB_instanced_arrays), PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR }, 424 { o(ARB_occlusion_query), PIPE_CAP_OCCLUSION_QUERY }, 425 { o(ARB_occlusion_query2), PIPE_CAP_OCCLUSION_QUERY }, 426 { o(ARB_point_sprite), PIPE_CAP_POINT_SPRITE }, 427 { o(ARB_seamless_cube_map), PIPE_CAP_SEAMLESS_CUBE_MAP }, 428 { o(ARB_shader_stencil_export), PIPE_CAP_SHADER_STENCIL_EXPORT }, 429 { o(ARB_shader_texture_lod), PIPE_CAP_SM3 }, 430 { o(ARB_shadow), PIPE_CAP_TEXTURE_SHADOW_MAP }, 431 { o(ARB_texture_mirror_clamp_to_edge), PIPE_CAP_TEXTURE_MIRROR_CLAMP }, 432 { o(ARB_texture_non_power_of_two), PIPE_CAP_NPOT_TEXTURES }, 433 { o(ARB_timer_query), PIPE_CAP_QUERY_TIMESTAMP }, 434 { o(ARB_transform_feedback2), PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME }, 435 { o(ARB_transform_feedback3), PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME }, 436 437 { o(EXT_blend_equation_separate), PIPE_CAP_BLEND_EQUATION_SEPARATE }, 438 { o(EXT_draw_buffers2), PIPE_CAP_INDEP_BLEND_ENABLE }, 439 { o(EXT_stencil_two_side), PIPE_CAP_TWO_SIDED_STENCIL }, 440 { o(EXT_texture_array), PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS }, 441 { o(EXT_texture_filter_anisotropic), PIPE_CAP_ANISOTROPIC_FILTER }, 442 { o(EXT_texture_mirror_clamp), PIPE_CAP_TEXTURE_MIRROR_CLAMP }, 443 { o(EXT_texture_swizzle), PIPE_CAP_TEXTURE_SWIZZLE }, 444 { o(EXT_transform_feedback), PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS }, 445 446 { o(AMD_seamless_cubemap_per_texture), PIPE_CAP_SEAMLESS_CUBE_MAP_PER_TEXTURE }, 447 { o(ATI_separate_stencil), PIPE_CAP_TWO_SIDED_STENCIL }, 448 { o(ATI_texture_mirror_once), PIPE_CAP_TEXTURE_MIRROR_CLAMP }, 449 { o(NV_conditional_render), PIPE_CAP_CONDITIONAL_RENDER }, 450 { o(NV_texture_barrier), PIPE_CAP_TEXTURE_BARRIER }, 451 /* GL_NV_point_sprite is not supported by gallium because we don't 452 * support the GL_POINT_SPRITE_R_MODE_NV option. */ 453 454 { o(OES_standard_derivatives), PIPE_CAP_SM3 }, 455 { o(ARB_texture_cube_map_array), PIPE_CAP_CUBE_MAP_ARRAY }, 456 { o(ARB_texture_multisample), PIPE_CAP_TEXTURE_MULTISAMPLE }, 457 { o(ARB_texture_query_lod), PIPE_CAP_TEXTURE_QUERY_LOD }, 458 { o(ARB_sample_shading), PIPE_CAP_SAMPLE_SHADING }, 459 { o(ARB_draw_indirect), PIPE_CAP_DRAW_INDIRECT }, 460 { o(ARB_derivative_control), PIPE_CAP_TGSI_FS_FINE_DERIVATIVE }, 461 { o(ARB_conditional_render_inverted), PIPE_CAP_CONDITIONAL_RENDER_INVERTED }, 462 }; 463 464 /* Required: render target and sampler support */ 465 static const struct st_extension_format_mapping rendertarget_mapping[] = { 466 { { o(ARB_texture_float) }, 467 { PIPE_FORMAT_R32G32B32A32_FLOAT, 468 PIPE_FORMAT_R16G16B16A16_FLOAT } }, 469 470 { { o(ARB_texture_rgb10_a2ui) }, 471 { PIPE_FORMAT_R10G10B10A2_UINT, 472 PIPE_FORMAT_B10G10R10A2_UINT }, 473 GL_TRUE }, /* at least one format must be supported */ 474 475 { { o(EXT_framebuffer_sRGB) }, 476 { PIPE_FORMAT_A8B8G8R8_SRGB, 477 PIPE_FORMAT_B8G8R8A8_SRGB }, 478 GL_TRUE }, /* at least one format must be supported */ 479 480 { { o(EXT_packed_float) }, 481 { PIPE_FORMAT_R11G11B10_FLOAT } }, 482 483 { { o(EXT_texture_integer) }, 484 { PIPE_FORMAT_R32G32B32A32_UINT, 485 PIPE_FORMAT_R32G32B32A32_SINT } }, 486 487 { { o(ARB_texture_rg) }, 488 { PIPE_FORMAT_R8_UNORM, 489 PIPE_FORMAT_R8G8_UNORM } }, 490 }; 491 492 /* Required: depth stencil and sampler support */ 493 static const struct st_extension_format_mapping depthstencil_mapping[] = { 494 { { o(ARB_depth_buffer_float) }, 495 { PIPE_FORMAT_Z32_FLOAT, 496 PIPE_FORMAT_Z32_FLOAT_S8X24_UINT } }, 497 }; 498 499 /* Required: sampler support */ 500 static const struct st_extension_format_mapping texture_mapping[] = { 501 { { o(ARB_texture_compression_rgtc) }, 502 { PIPE_FORMAT_RGTC1_UNORM, 503 PIPE_FORMAT_RGTC1_SNORM, 504 PIPE_FORMAT_RGTC2_UNORM, 505 PIPE_FORMAT_RGTC2_SNORM } }, 506 507 { { o(EXT_texture_compression_latc) }, 508 { PIPE_FORMAT_LATC1_UNORM, 509 PIPE_FORMAT_LATC1_SNORM, 510 PIPE_FORMAT_LATC2_UNORM, 511 PIPE_FORMAT_LATC2_SNORM } }, 512 513 { { o(EXT_texture_compression_s3tc), 514 o(ANGLE_texture_compression_dxt) }, 515 { PIPE_FORMAT_DXT1_RGB, 516 PIPE_FORMAT_DXT1_RGBA, 517 PIPE_FORMAT_DXT3_RGBA, 518 PIPE_FORMAT_DXT5_RGBA } }, 519 520 { { o(ARB_texture_compression_bptc) }, 521 { PIPE_FORMAT_BPTC_RGBA_UNORM, 522 PIPE_FORMAT_BPTC_SRGBA, 523 PIPE_FORMAT_BPTC_RGB_FLOAT, 524 PIPE_FORMAT_BPTC_RGB_UFLOAT } }, 525 526 { { o(EXT_texture_shared_exponent) }, 527 { PIPE_FORMAT_R9G9B9E5_FLOAT } }, 528 529 { { o(EXT_texture_snorm) }, 530 { PIPE_FORMAT_R8G8B8A8_SNORM } }, 531 532 { { o(EXT_texture_sRGB), 533 o(EXT_texture_sRGB_decode) }, 534 { PIPE_FORMAT_A8B8G8R8_SRGB, 535 PIPE_FORMAT_B8G8R8A8_SRGB }, 536 GL_TRUE }, /* at least one format must be supported */ 537 538 { { o(ATI_texture_compression_3dc) }, 539 { PIPE_FORMAT_LATC2_UNORM } }, 540 541 { { o(MESA_ycbcr_texture) }, 542 { PIPE_FORMAT_UYVY, 543 PIPE_FORMAT_YUYV }, 544 GL_TRUE }, /* at least one format must be supported */ 545 546 { { o(OES_compressed_ETC1_RGB8_texture) }, 547 { PIPE_FORMAT_ETC1_RGB8, 548 PIPE_FORMAT_R8G8B8A8_UNORM }, 549 GL_TRUE }, /* at least one format must be supported */ 550 551 { { o(ARB_stencil_texturing) }, 552 { PIPE_FORMAT_X24S8_UINT, 553 PIPE_FORMAT_S8X24_UINT }, 554 GL_TRUE }, /* at least one format must be supported */ 555 }; 556 557 /* Required: vertex fetch support. */ 558 static const struct st_extension_format_mapping vertex_mapping[] = { 559 { { o(ARB_vertex_type_2_10_10_10_rev) }, 560 { PIPE_FORMAT_R10G10B10A2_UNORM, 561 PIPE_FORMAT_B10G10R10A2_UNORM, 562 PIPE_FORMAT_R10G10B10A2_SNORM, 563 PIPE_FORMAT_B10G10R10A2_SNORM, 564 PIPE_FORMAT_R10G10B10A2_USCALED, 565 PIPE_FORMAT_B10G10R10A2_USCALED, 566 PIPE_FORMAT_R10G10B10A2_SSCALED, 567 PIPE_FORMAT_B10G10R10A2_SSCALED } }, 568 { { o(ARB_vertex_type_10f_11f_11f_rev) }, 569 { PIPE_FORMAT_R11G11B10_FLOAT } }, 570 }; 571 572 static const struct st_extension_format_mapping tbo_rgb32[] = { 573 { {o(ARB_texture_buffer_object_rgb32) }, 574 { PIPE_FORMAT_R32G32B32_FLOAT, 575 PIPE_FORMAT_R32G32B32_UINT, 576 PIPE_FORMAT_R32G32B32_SINT, 577 } }, 578 }; 579 580 /* 581 * Extensions that are supported by all Gallium drivers: 582 */ 583 extensions->ARB_ES2_compatibility = GL_TRUE; 584 extensions->ARB_draw_elements_base_vertex = GL_TRUE; 585 extensions->ARB_explicit_attrib_location = GL_TRUE; 586 extensions->ARB_explicit_uniform_location = GL_TRUE; 587 extensions->ARB_fragment_coord_conventions = GL_TRUE; 588 extensions->ARB_fragment_program = GL_TRUE; 589 extensions->ARB_fragment_shader = GL_TRUE; 590 extensions->ARB_half_float_vertex = GL_TRUE; 591 extensions->ARB_internalformat_query = GL_TRUE; 592 extensions->ARB_map_buffer_range = GL_TRUE; 593 extensions->ARB_texture_border_clamp = GL_TRUE; /* XXX temp */ 594 extensions->ARB_texture_cube_map = GL_TRUE; 595 extensions->ARB_texture_env_combine = GL_TRUE; 596 extensions->ARB_texture_env_crossbar = GL_TRUE; 597 extensions->ARB_texture_env_dot3 = GL_TRUE; 598 extensions->ARB_vertex_program = GL_TRUE; 599 extensions->ARB_vertex_shader = GL_TRUE; 600 601 extensions->EXT_blend_color = GL_TRUE; 602 extensions->EXT_blend_func_separate = GL_TRUE; 603 extensions->EXT_blend_minmax = GL_TRUE; 604 extensions->EXT_gpu_program_parameters = GL_TRUE; 605 extensions->EXT_pixel_buffer_object = GL_TRUE; 606 extensions->EXT_point_parameters = GL_TRUE; 607 extensions->EXT_provoking_vertex = GL_TRUE; 608 609 extensions->EXT_texture_env_dot3 = GL_TRUE; 610 extensions->EXT_vertex_array_bgra = GL_TRUE; 611 612 extensions->ATI_texture_env_combine3 = GL_TRUE; 613 614 extensions->MESA_pack_invert = GL_TRUE; 615 616 extensions->NV_fog_distance = GL_TRUE; 617 extensions->NV_texture_env_combine4 = GL_TRUE; 618 extensions->NV_texture_rectangle = GL_TRUE; 619 620 extensions->OES_EGL_image = GL_TRUE; 621 extensions->OES_EGL_image_external = GL_TRUE; 622 extensions->OES_draw_texture = GL_TRUE; 623 624 /* Expose the extensions which directly correspond to gallium caps. */ 625 for (i = 0; i < Elements(cap_mapping); i++) { 626 if (screen->get_param(screen, cap_mapping[i].cap)) { 627 extension_table[cap_mapping[i].extension_offset] = GL_TRUE; 628 } 629 } 630 631 /* Expose the extensions which directly correspond to gallium formats. */ 632 init_format_extensions(screen, extensions, rendertarget_mapping, 633 Elements(rendertarget_mapping), PIPE_TEXTURE_2D, 634 PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW); 635 init_format_extensions(screen, extensions, depthstencil_mapping, 636 Elements(depthstencil_mapping), PIPE_TEXTURE_2D, 637 PIPE_BIND_DEPTH_STENCIL | PIPE_BIND_SAMPLER_VIEW); 638 init_format_extensions(screen, extensions, texture_mapping, 639 Elements(texture_mapping), PIPE_TEXTURE_2D, 640 PIPE_BIND_SAMPLER_VIEW); 641 init_format_extensions(screen, extensions, vertex_mapping, 642 Elements(vertex_mapping), PIPE_BUFFER, 643 PIPE_BIND_VERTEX_BUFFER); 644 645 /* Figure out GLSL support. */ 646 glsl_feature_level = screen->get_param(screen, PIPE_CAP_GLSL_FEATURE_LEVEL); 647 648 consts->GLSLVersion = glsl_feature_level; 649 if (glsl_feature_level >= 330) 650 consts->GLSLVersion = 330; 651 652 _mesa_override_glsl_version(consts); 653 654 if (options->force_glsl_version > 0 && 655 options->force_glsl_version <= consts->GLSLVersion) { 656 consts->ForceGLSLVersion = options->force_glsl_version; 657 } 658 659 if (glsl_feature_level >= 400) 660 extensions->ARB_gpu_shader5 = GL_TRUE; 661 662 /* This extension needs full OpenGL 3.2, but we don't know if that's 663 * supported at this point. Only check the GLSL version. */ 664 if (consts->GLSLVersion >= 150 && 665 screen->get_param(screen, PIPE_CAP_TGSI_VS_LAYER_VIEWPORT)) { 666 extensions->AMD_vertex_shader_layer = GL_TRUE; 667 } 668 669 if (consts->GLSLVersion >= 130) { 670 consts->NativeIntegers = GL_TRUE; 671 consts->MaxClipPlanes = 8; 672 673 /* Extensions that either depend on GLSL 1.30 or are a subset thereof. */ 674 extensions->ARB_conservative_depth = GL_TRUE; 675 extensions->ARB_shading_language_packing = GL_TRUE; 676 extensions->OES_depth_texture_cube_map = GL_TRUE; 677 extensions->ARB_shading_language_420pack = GL_TRUE; 678 extensions->ARB_texture_query_levels = GL_TRUE; 679 680 if (!options->disable_shader_bit_encoding) { 681 extensions->ARB_shader_bit_encoding = GL_TRUE; 682 } 683 684 extensions->EXT_shader_integer_mix = GL_TRUE; 685 } else { 686 /* Optional integer support for GLSL 1.2. */ 687 if (screen->get_shader_param(screen, PIPE_SHADER_VERTEX, 688 PIPE_SHADER_CAP_INTEGERS) && 689 screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT, 690 PIPE_SHADER_CAP_INTEGERS)) { 691 consts->NativeIntegers = GL_TRUE; 692 693 extensions->EXT_shader_integer_mix = GL_TRUE; 694 } 695 } 696 697 consts->UniformBooleanTrue = consts->NativeIntegers ? ~0 : fui(1.0f); 698 699 /* Below are the cases which cannot be moved into tables easily. */ 700 701 if (!has_lib_dxtc && !options->force_s3tc_enable) { 702 extensions->EXT_texture_compression_s3tc = GL_FALSE; 703 extensions->ANGLE_texture_compression_dxt = GL_FALSE; 704 } 705 706 if (screen->get_shader_param(screen, PIPE_SHADER_GEOMETRY, 707 PIPE_SHADER_CAP_MAX_INSTRUCTIONS) > 0) { 708#if 0 /* XXX re-enable when GLSL compiler again supports geometry shaders */ 709 extensions->ARB_geometry_shader4 = GL_TRUE; 710#endif 711 } 712 713 extensions->NV_primitive_restart = GL_TRUE; 714 if (!screen->get_param(screen, PIPE_CAP_PRIMITIVE_RESTART)) { 715 consts->PrimitiveRestartInSoftware = GL_TRUE; 716 } 717 718 /* ARB_color_buffer_float. */ 719 if (screen->get_param(screen, PIPE_CAP_VERTEX_COLOR_UNCLAMPED)) { 720 extensions->ARB_color_buffer_float = GL_TRUE; 721 } 722 723 if (screen->fence_finish) { 724 extensions->ARB_sync = GL_TRUE; 725 } 726 727 /* Maximum sample count. */ 728 { 729 enum pipe_format color_formats[] = { 730 PIPE_FORMAT_R8G8B8A8_UNORM, 731 PIPE_FORMAT_B8G8R8A8_UNORM, 732 PIPE_FORMAT_A8R8G8B8_UNORM, 733 PIPE_FORMAT_A8B8G8R8_UNORM, 734 }; 735 enum pipe_format depth_formats[] = { 736 PIPE_FORMAT_Z16_UNORM, 737 PIPE_FORMAT_Z24X8_UNORM, 738 PIPE_FORMAT_X8Z24_UNORM, 739 PIPE_FORMAT_Z32_UNORM, 740 PIPE_FORMAT_Z32_FLOAT 741 }; 742 enum pipe_format int_formats[] = { 743 PIPE_FORMAT_R8G8B8A8_SINT 744 }; 745 746 consts->MaxSamples = 747 get_max_samples_for_formats(screen, Elements(color_formats), 748 color_formats, 16, 749 PIPE_BIND_RENDER_TARGET); 750 751 consts->MaxColorTextureSamples = 752 get_max_samples_for_formats(screen, Elements(color_formats), 753 color_formats, consts->MaxSamples, 754 PIPE_BIND_SAMPLER_VIEW); 755 756 consts->MaxDepthTextureSamples = 757 get_max_samples_for_formats(screen, Elements(depth_formats), 758 depth_formats, consts->MaxSamples, 759 PIPE_BIND_SAMPLER_VIEW); 760 761 consts->MaxIntegerSamples = 762 get_max_samples_for_formats(screen, Elements(int_formats), 763 int_formats, consts->MaxSamples, 764 PIPE_BIND_SAMPLER_VIEW); 765 } 766 if (consts->MaxSamples == 1) { 767 /* one sample doesn't really make sense */ 768 consts->MaxSamples = 0; 769 } 770 else if (consts->MaxSamples >= 2) { 771 extensions->EXT_framebuffer_multisample = GL_TRUE; 772 extensions->EXT_framebuffer_multisample_blit_scaled = GL_TRUE; 773 } 774 775 if (consts->MaxSamples == 0 && screen->get_param(screen, PIPE_CAP_FAKE_SW_MSAA)) { 776 consts->FakeSWMSAA = GL_TRUE; 777 extensions->EXT_framebuffer_multisample = GL_TRUE; 778 extensions->EXT_framebuffer_multisample_blit_scaled = GL_TRUE; 779 extensions->ARB_texture_multisample = GL_TRUE; 780 } 781 782 if (consts->MaxDualSourceDrawBuffers > 0 && 783 !options->disable_blend_func_extended) 784 extensions->ARB_blend_func_extended = GL_TRUE; 785 786 if (screen->get_param(screen, PIPE_CAP_QUERY_TIME_ELAPSED) || 787 extensions->ARB_timer_query) { 788 extensions->EXT_timer_query = GL_TRUE; 789 } 790 791 if (extensions->ARB_transform_feedback2 && 792 extensions->ARB_draw_instanced) { 793 extensions->ARB_transform_feedback_instanced = GL_TRUE; 794 } 795 if (options->force_glsl_extensions_warn) 796 consts->ForceGLSLExtensionsWarn = 1; 797 798 if (options->disable_glsl_line_continuations) 799 consts->DisableGLSLLineContinuations = 1; 800 801 if (options->allow_glsl_extension_directive_midshader) 802 consts->AllowGLSLExtensionDirectiveMidShader = GL_TRUE; 803 804 consts->MinMapBufferAlignment = 805 screen->get_param(screen, PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT); 806 807 if (screen->get_param(screen, PIPE_CAP_TEXTURE_BUFFER_OBJECTS)) { 808 extensions->ARB_texture_buffer_object = GL_TRUE; 809 810 consts->MaxTextureBufferSize = 811 _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_BUFFER_SIZE), 812 (1u << 31) - 1); 813 consts->TextureBufferOffsetAlignment = 814 screen->get_param(screen, PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT); 815 816 if (consts->TextureBufferOffsetAlignment) 817 extensions->ARB_texture_buffer_range = GL_TRUE; 818 819 init_format_extensions(screen, extensions, tbo_rgb32, 820 Elements(tbo_rgb32), PIPE_BUFFER, 821 PIPE_BIND_SAMPLER_VIEW); 822 } 823 824 if (screen->get_param(screen, PIPE_CAP_MIXED_FRAMEBUFFER_SIZES)) { 825 extensions->ARB_framebuffer_object = GL_TRUE; 826 } 827 828 /* Unpacking a varying in the fragment shader costs 1 texture indirection. 829 * If the number of available texture indirections is very limited, then we 830 * prefer to disable varying packing rather than run the risk of varying 831 * packing preventing a shader from running. 832 */ 833 if (screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT, 834 PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS) <= 8) { 835 /* We can't disable varying packing if transform feedback is available, 836 * because transform feedback code assumes a packed varying layout. 837 */ 838 if (!extensions->EXT_transform_feedback) 839 consts->DisableVaryingPacking = GL_TRUE; 840 } 841 842 if (api == API_OPENGL_CORE) { 843 consts->MaxViewports = screen->get_param(screen, PIPE_CAP_MAX_VIEWPORTS); 844 if (consts->MaxViewports >= 16) { 845 consts->ViewportBounds.Min = -16384.0; 846 consts->ViewportBounds.Max = 16384.0; 847 extensions->ARB_viewport_array = GL_TRUE; 848 extensions->ARB_fragment_layer_viewport = GL_TRUE; 849 if (extensions->AMD_vertex_shader_layer) 850 extensions->AMD_vertex_shader_viewport_index = GL_TRUE; 851 } 852 } 853 if (consts->MaxProgramTextureGatherComponents > 0) 854 extensions->ARB_texture_gather = GL_TRUE; 855 856 /* GL_ARB_ES3_compatibility. 857 * 858 * Assume that ES3 is supported if GLSL 3.30 is supported. 859 * (OpenGL 3.3 is a requirement for that extension.) 860 */ 861 if (consts->GLSLVersion >= 330 && 862 /* Requirements for ETC2 emulation. */ 863 screen->is_format_supported(screen, PIPE_FORMAT_R8G8B8A8_UNORM, 864 PIPE_TEXTURE_2D, 0, 865 PIPE_BIND_SAMPLER_VIEW) && 866 screen->is_format_supported(screen, PIPE_FORMAT_B8G8R8A8_SRGB, 867 PIPE_TEXTURE_2D, 0, 868 PIPE_BIND_SAMPLER_VIEW) && 869 screen->is_format_supported(screen, PIPE_FORMAT_R16_UNORM, 870 PIPE_TEXTURE_2D, 0, 871 PIPE_BIND_SAMPLER_VIEW) && 872 screen->is_format_supported(screen, PIPE_FORMAT_R16G16_UNORM, 873 PIPE_TEXTURE_2D, 0, 874 PIPE_BIND_SAMPLER_VIEW) && 875 screen->is_format_supported(screen, PIPE_FORMAT_R16_SNORM, 876 PIPE_TEXTURE_2D, 0, 877 PIPE_BIND_SAMPLER_VIEW) && 878 screen->is_format_supported(screen, PIPE_FORMAT_R16G16_SNORM, 879 PIPE_TEXTURE_2D, 0, 880 PIPE_BIND_SAMPLER_VIEW)) { 881 extensions->ARB_ES3_compatibility = GL_TRUE; 882 } 883 884 if (screen->get_video_param && 885 screen->get_video_param(screen, PIPE_VIDEO_PROFILE_UNKNOWN, 886 PIPE_VIDEO_ENTRYPOINT_BITSTREAM, 887 PIPE_VIDEO_CAP_SUPPORTS_INTERLACED)) { 888 extensions->NV_vdpau_interop = GL_TRUE; 889 } 890} 891