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 "compiler/nir/nir.h" 30 31 32#include "main/context.h" 33#include "main/macros.h" 34#include "main/spirv_extensions.h" 35#include "main/version.h" 36#include "nir/nir_to_tgsi.h" 37 38#include "pipe/p_context.h" 39#include "pipe/p_defines.h" 40#include "pipe/p_screen.h" 41#include "tgsi/tgsi_from_mesa.h" 42#include "util/u_math.h" 43#include "util/u_memory.h" 44 45#include "st_context.h" 46#include "st_debug.h" 47#include "st_extensions.h" 48#include "st_format.h" 49 50 51/* 52 * Note: we use these function rather than the MIN2, MAX2, CLAMP macros to 53 * avoid evaluating arguments (which are often function calls) more than once. 54 */ 55 56static unsigned _min(unsigned a, unsigned b) 57{ 58 return (a < b) ? a : b; 59} 60 61static float _maxf(float a, float b) 62{ 63 return (a > b) ? a : b; 64} 65 66static int _clamp(int a, int min, int max) 67{ 68 if (a < min) 69 return min; 70 else if (a > max) 71 return max; 72 else 73 return a; 74} 75 76 77/** 78 * Query driver to get implementation limits. 79 * Note that we have to limit/clamp against Mesa's internal limits too. 80 */ 81void st_init_limits(struct pipe_screen *screen, 82 struct gl_constants *c, struct gl_extensions *extensions) 83{ 84 int supported_irs; 85 unsigned sh; 86 bool can_ubo = true; 87 int temp; 88 89 c->MaxTextureSize = screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_2D_SIZE); 90 c->MaxTextureSize = MIN2(c->MaxTextureSize, 1 << (MAX_TEXTURE_LEVELS - 1)); 91 c->MaxTextureMbytes = MAX2(c->MaxTextureMbytes, 92 screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_MB)); 93 94 c->Max3DTextureLevels 95 = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_3D_LEVELS), 96 MAX_TEXTURE_LEVELS); 97 extensions->OES_texture_3D = c->Max3DTextureLevels != 0; 98 99 c->MaxCubeTextureLevels 100 = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS), 101 MAX_TEXTURE_LEVELS); 102 103 c->MaxTextureRectSize = _min(c->MaxTextureSize, MAX_TEXTURE_RECT_SIZE); 104 105 c->MaxArrayTextureLayers 106 = screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS); 107 108 /* Define max viewport size and max renderbuffer size in terms of 109 * max texture size (note: max tex RECT size = max tex 2D size). 110 * If this isn't true for some hardware we'll need new PIPE_CAP_ queries. 111 */ 112 c->MaxViewportWidth = 113 c->MaxViewportHeight = 114 c->MaxRenderbufferSize = c->MaxTextureRectSize; 115 116 c->SubPixelBits = 117 screen->get_param(screen, PIPE_CAP_RASTERIZER_SUBPIXEL_BITS); 118 c->ViewportSubpixelBits = 119 screen->get_param(screen, PIPE_CAP_VIEWPORT_SUBPIXEL_BITS); 120 121 c->MaxDrawBuffers = c->MaxColorAttachments = 122 _clamp(screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS), 123 1, MAX_DRAW_BUFFERS); 124 125 c->MaxDualSourceDrawBuffers = 126 _clamp(screen->get_param(screen, 127 PIPE_CAP_MAX_DUAL_SOURCE_RENDER_TARGETS), 128 0, MAX_DRAW_BUFFERS); 129 130 c->MaxLineWidth = 131 _maxf(1.0f, screen->get_paramf(screen, PIPE_CAPF_MAX_LINE_WIDTH)); 132 c->MaxLineWidthAA = 133 _maxf(1.0f, screen->get_paramf(screen, PIPE_CAPF_MAX_LINE_WIDTH_AA)); 134 135 c->MinLineWidth = screen->get_paramf(screen, PIPE_CAPF_MIN_LINE_WIDTH); 136 c->MinLineWidthAA = screen->get_paramf(screen, PIPE_CAPF_MIN_LINE_WIDTH_AA); 137 c->LineWidthGranularity = screen->get_paramf(screen, PIPE_CAPF_LINE_WIDTH_GRANULARITY); 138 139 c->MaxPointSize = 140 _maxf(1.0f, screen->get_paramf(screen, PIPE_CAPF_MAX_POINT_SIZE)); 141 c->MaxPointSizeAA = 142 _maxf(1.0f, screen->get_paramf(screen, PIPE_CAPF_MAX_POINT_SIZE_AA)); 143 144 c->MinPointSize = MAX2(screen->get_paramf(screen, PIPE_CAPF_MIN_POINT_SIZE), 0.01); 145 c->MinPointSizeAA = MAX2(screen->get_paramf(screen, PIPE_CAPF_MIN_POINT_SIZE_AA), 0.01); 146 c->PointSizeGranularity = screen->get_paramf(screen, PIPE_CAPF_POINT_SIZE_GRANULARITY); 147 148 c->MaxTextureMaxAnisotropy = 149 _maxf(2.0f, 150 screen->get_paramf(screen, PIPE_CAPF_MAX_TEXTURE_ANISOTROPY)); 151 152 c->MaxTextureLodBias = 153 screen->get_paramf(screen, PIPE_CAPF_MAX_TEXTURE_LOD_BIAS); 154 155 c->QuadsFollowProvokingVertexConvention = 156 screen->get_param(screen, 157 PIPE_CAP_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION); 158 159 c->MaxUniformBlockSize = 160 screen->get_param(screen, PIPE_CAP_MAX_CONSTANT_BUFFER_SIZE_UINT); 161 162 if (c->MaxUniformBlockSize < 16384) { 163 can_ubo = false; 164 } 165 166 /* Round down to a multiple of 4 to make piglit happy. Bytes are not 167 * addressible by UBOs anyway. 168 */ 169 c->MaxUniformBlockSize &= ~3; 170 171 for (sh = 0; sh < PIPE_SHADER_TYPES; ++sh) { 172 const gl_shader_stage stage = tgsi_processor_to_shader_stage(sh); 173 struct gl_shader_compiler_options *options = 174 &c->ShaderCompilerOptions[stage]; 175 struct gl_program_constants *pc = &c->Program[stage]; 176 177 bool prefer_nir = PIPE_SHADER_IR_NIR == 178 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_PREFERRED_IR); 179 if (screen->get_compiler_options) 180 options->NirOptions = screen->get_compiler_options(screen, PIPE_SHADER_IR_NIR, sh); 181 182 if (!options->NirOptions) { 183 options->NirOptions = 184 nir_to_tgsi_get_compiler_options(screen, PIPE_SHADER_IR_NIR, sh); 185 } 186 187 if (sh == PIPE_SHADER_COMPUTE) { 188 if (!screen->get_param(screen, PIPE_CAP_COMPUTE)) 189 continue; 190 supported_irs = 191 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_SUPPORTED_IRS); 192 if (!(supported_irs & ((1 << PIPE_SHADER_IR_TGSI) | 193 (1 << PIPE_SHADER_IR_NIR)))) 194 continue; 195 } 196 197 pc->MaxTextureImageUnits = 198 _min(screen->get_shader_param(screen, sh, 199 PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS), 200 MAX_TEXTURE_IMAGE_UNITS); 201 202 pc->MaxInstructions = 203 pc->MaxNativeInstructions = 204 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INSTRUCTIONS); 205 pc->MaxAluInstructions = 206 pc->MaxNativeAluInstructions = 207 screen->get_shader_param(screen, sh, 208 PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS); 209 pc->MaxTexInstructions = 210 pc->MaxNativeTexInstructions = 211 screen->get_shader_param(screen, sh, 212 PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS); 213 pc->MaxTexIndirections = 214 pc->MaxNativeTexIndirections = 215 screen->get_shader_param(screen, sh, 216 PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS); 217 pc->MaxAttribs = 218 pc->MaxNativeAttribs = 219 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INPUTS); 220 pc->MaxTemps = 221 pc->MaxNativeTemps = 222 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_TEMPS); 223 pc->MaxAddressRegs = 224 pc->MaxNativeAddressRegs = sh == PIPE_SHADER_VERTEX ? 1 : 0; 225 226 pc->MaxUniformComponents = 227 screen->get_shader_param(screen, sh, 228 PIPE_SHADER_CAP_MAX_CONST_BUFFER0_SIZE) / 4; 229 230 /* reserve space in the default-uniform for lowered state */ 231 if (sh == PIPE_SHADER_VERTEX || 232 sh == PIPE_SHADER_TESS_EVAL || 233 sh == PIPE_SHADER_GEOMETRY) { 234 235 if (!screen->get_param(screen, PIPE_CAP_CLIP_PLANES)) 236 pc->MaxUniformComponents -= 4 * MAX_CLIP_PLANES; 237 238 if (!screen->get_param(screen, PIPE_CAP_POINT_SIZE_FIXED)) 239 pc->MaxUniformComponents -= 4; 240 } else if (sh == PIPE_SHADER_FRAGMENT) { 241 if (!screen->get_param(screen, PIPE_CAP_ALPHA_TEST)) 242 pc->MaxUniformComponents -= 4; 243 } 244 245 246 pc->MaxUniformComponents = MIN2(pc->MaxUniformComponents, 247 MAX_UNIFORMS * 4); 248 249 /* For ARB programs, prog_src_register::Index is a signed 13-bit number. 250 * This gives us a limit of 4096 values - but we may need to generate 251 * internal values in addition to what the source program uses. So, we 252 * drop the limit one step lower, to 2048, to be safe. 253 */ 254 pc->MaxParameters = 255 pc->MaxNativeParameters = MIN2(pc->MaxUniformComponents / 4, 2048); 256 pc->MaxInputComponents = 257 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INPUTS) * 4; 258 pc->MaxOutputComponents = 259 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_OUTPUTS) * 4; 260 261 262 pc->MaxUniformBlocks = 263 screen->get_shader_param(screen, sh, 264 PIPE_SHADER_CAP_MAX_CONST_BUFFERS); 265 if (pc->MaxUniformBlocks) 266 pc->MaxUniformBlocks -= 1; /* The first one is for ordinary uniforms. */ 267 pc->MaxUniformBlocks = _min(pc->MaxUniformBlocks, MAX_UNIFORM_BUFFERS); 268 269 pc->MaxCombinedUniformComponents = 270 pc->MaxUniformComponents + 271 (uint64_t)c->MaxUniformBlockSize / 4 * pc->MaxUniformBlocks; 272 273 pc->MaxShaderStorageBlocks = 274 screen->get_shader_param(screen, sh, 275 PIPE_SHADER_CAP_MAX_SHADER_BUFFERS); 276 277 temp = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTERS); 278 if (temp) { 279 /* 280 * for separate atomic counters get the actual hw limits 281 * per stage on atomic counters and buffers 282 */ 283 pc->MaxAtomicCounters = temp; 284 pc->MaxAtomicBuffers = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTER_BUFFERS); 285 } else if (pc->MaxShaderStorageBlocks) { 286 pc->MaxAtomicCounters = MAX_ATOMIC_COUNTERS; 287 /* 288 * without separate atomic counters, reserve half of the available 289 * SSBOs for atomic buffers, and the other half for normal SSBOs. 290 */ 291 pc->MaxAtomicBuffers = pc->MaxShaderStorageBlocks / 2; 292 pc->MaxShaderStorageBlocks -= pc->MaxAtomicBuffers; 293 } 294 pc->MaxImageUniforms = 295 _min(screen->get_shader_param(screen, sh, 296 PIPE_SHADER_CAP_MAX_SHADER_IMAGES), 297 MAX_IMAGE_UNIFORMS); 298 299 /* Gallium doesn't really care about local vs. env parameters so use the 300 * same limits. 301 */ 302 pc->MaxLocalParams = MIN2(pc->MaxParameters, MAX_PROGRAM_LOCAL_PARAMS); 303 pc->MaxEnvParams = MIN2(pc->MaxParameters, MAX_PROGRAM_ENV_PARAMS); 304 305 if (screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_INTEGERS)) { 306 pc->LowInt.RangeMin = 31; 307 pc->LowInt.RangeMax = 30; 308 pc->LowInt.Precision = 0; 309 pc->MediumInt = pc->HighInt = pc->LowInt; 310 311 if (screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_INT16)) { 312 pc->LowInt.RangeMin = 15; 313 pc->LowInt.RangeMax = 14; 314 pc->MediumInt = pc->LowInt; 315 } 316 } 317 318 if (screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_FP16)) { 319 pc->LowFloat.RangeMin = 15; 320 pc->LowFloat.RangeMax = 15; 321 pc->LowFloat.Precision = 10; 322 pc->MediumFloat = pc->LowFloat; 323 } 324 325 /* TODO: make these more fine-grained if anyone needs it */ 326 options->MaxIfDepth = 327 screen->get_shader_param(screen, sh, 328 PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH); 329 330 options->EmitNoMainReturn = 331 !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_SUBROUTINES); 332 333 options->EmitNoCont = 334 !screen->get_shader_param(screen, sh, 335 PIPE_SHADER_CAP_CONT_SUPPORTED); 336 337 options->EmitNoIndirectInput = 338 !screen->get_shader_param(screen, sh, 339 PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR); 340 options->EmitNoIndirectOutput = 341 !screen->get_shader_param(screen, sh, 342 PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR); 343 options->EmitNoIndirectTemp = 344 !screen->get_shader_param(screen, sh, 345 PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR); 346 options->EmitNoIndirectUniform = 347 !screen->get_shader_param(screen, sh, 348 PIPE_SHADER_CAP_INDIRECT_CONST_ADDR); 349 350 if (pc->MaxNativeInstructions && 351 (options->EmitNoIndirectUniform || pc->MaxUniformBlocks < 12)) { 352 can_ubo = false; 353 } 354 355 if (!screen->get_param(screen, PIPE_CAP_NIR_COMPACT_ARRAYS)) 356 options->LowerCombinedClipCullDistance = true; 357 358 if (sh == PIPE_SHADER_VERTEX || sh == PIPE_SHADER_GEOMETRY) { 359 if (screen->get_param(screen, PIPE_CAP_VIEWPORT_TRANSFORM_LOWERED)) 360 options->LowerBuiltinVariablesXfb |= VARYING_BIT_POS; 361 if (screen->get_param(screen, PIPE_CAP_PSIZ_CLAMPED)) 362 options->LowerBuiltinVariablesXfb |= VARYING_BIT_PSIZ; 363 } 364 365 /* Note: If the driver doesn't prefer NIR, then st_create_nir_shader() 366 * will call nir_to_tgsi, and TGSI doesn't support 16-bit ops. 367 */ 368 if (prefer_nir) { 369 options->LowerPrecisionFloat16 = 370 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_FP16); 371 options->LowerPrecisionDerivatives = 372 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_FP16_DERIVATIVES); 373 options->LowerPrecisionInt16 = 374 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_INT16); 375 options->LowerPrecisionConstants = 376 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_GLSL_16BIT_CONSTS); 377 options->LowerPrecisionFloat16Uniforms = 378 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_FP16_CONST_BUFFERS); 379 } 380 } 381 382 c->MaxUserAssignableUniformLocations = 383 c->Program[MESA_SHADER_VERTEX].MaxUniformComponents + 384 c->Program[MESA_SHADER_TESS_CTRL].MaxUniformComponents + 385 c->Program[MESA_SHADER_TESS_EVAL].MaxUniformComponents + 386 c->Program[MESA_SHADER_GEOMETRY].MaxUniformComponents + 387 c->Program[MESA_SHADER_FRAGMENT].MaxUniformComponents; 388 389 c->GLSLLowerConstArrays = 390 screen->get_param(screen, PIPE_CAP_PREFER_IMM_ARRAYS_AS_CONSTBUF); 391 c->GLSLTessLevelsAsInputs = 392 screen->get_param(screen, PIPE_CAP_GLSL_TESS_LEVELS_AS_INPUTS); 393 c->LowerTessLevel = 394 !screen->get_param(screen, PIPE_CAP_NIR_COMPACT_ARRAYS); 395 c->LowerCsDerivedVariables = 396 !screen->get_param(screen, PIPE_CAP_CS_DERIVED_SYSTEM_VALUES_SUPPORTED); 397 c->PrimitiveRestartForPatches = false; 398 399 c->MaxCombinedTextureImageUnits = 400 _min(c->Program[MESA_SHADER_VERTEX].MaxTextureImageUnits + 401 c->Program[MESA_SHADER_TESS_CTRL].MaxTextureImageUnits + 402 c->Program[MESA_SHADER_TESS_EVAL].MaxTextureImageUnits + 403 c->Program[MESA_SHADER_GEOMETRY].MaxTextureImageUnits + 404 c->Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits + 405 c->Program[MESA_SHADER_COMPUTE].MaxTextureImageUnits, 406 MAX_COMBINED_TEXTURE_IMAGE_UNITS); 407 408 /* This depends on program constants. */ 409 c->MaxTextureCoordUnits 410 = _min(c->Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits, 411 MAX_TEXTURE_COORD_UNITS); 412 413 c->MaxTextureUnits = 414 _min(c->Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits, 415 c->MaxTextureCoordUnits); 416 417 c->Program[MESA_SHADER_VERTEX].MaxAttribs = 418 MIN2(c->Program[MESA_SHADER_VERTEX].MaxAttribs, 16); 419 420 c->MaxVarying = screen->get_param(screen, PIPE_CAP_MAX_VARYINGS); 421 c->MaxVarying = MIN2(c->MaxVarying, MAX_VARYING); 422 c->MaxGeometryOutputVertices = 423 screen->get_param(screen, PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES); 424 c->MaxGeometryTotalOutputComponents = 425 screen->get_param(screen, PIPE_CAP_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS); 426 c->MaxGeometryShaderInvocations = 427 screen->get_param(screen, PIPE_CAP_MAX_GS_INVOCATIONS); 428 c->MaxTessPatchComponents = 429 MIN2(screen->get_param(screen, PIPE_CAP_MAX_SHADER_PATCH_VARYINGS), 430 MAX_VARYING) * 4; 431 432 c->MinProgramTexelOffset = 433 screen->get_param(screen, PIPE_CAP_MIN_TEXEL_OFFSET); 434 c->MaxProgramTexelOffset = 435 screen->get_param(screen, PIPE_CAP_MAX_TEXEL_OFFSET); 436 437 c->MaxProgramTextureGatherComponents = 438 screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_GATHER_COMPONENTS); 439 c->MinProgramTextureGatherOffset = 440 screen->get_param(screen, PIPE_CAP_MIN_TEXTURE_GATHER_OFFSET); 441 c->MaxProgramTextureGatherOffset = 442 screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_GATHER_OFFSET); 443 444 c->MaxTransformFeedbackBuffers = 445 screen->get_param(screen, PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS); 446 c->MaxTransformFeedbackBuffers = MIN2(c->MaxTransformFeedbackBuffers, 447 MAX_FEEDBACK_BUFFERS); 448 c->MaxTransformFeedbackSeparateComponents = 449 screen->get_param(screen, PIPE_CAP_MAX_STREAM_OUTPUT_SEPARATE_COMPONENTS); 450 c->MaxTransformFeedbackInterleavedComponents = 451 screen->get_param(screen, 452 PIPE_CAP_MAX_STREAM_OUTPUT_INTERLEAVED_COMPONENTS); 453 c->MaxVertexStreams = 454 MAX2(1, screen->get_param(screen, PIPE_CAP_MAX_VERTEX_STREAMS)); 455 456 /* The vertex stream must fit into pipe_stream_output_info::stream */ 457 assert(c->MaxVertexStreams <= 4); 458 459 c->MaxVertexAttribStride 460 = screen->get_param(screen, PIPE_CAP_MAX_VERTEX_ATTRIB_STRIDE); 461 462 /* The value cannot be larger than that since pipe_vertex_buffer::src_offset 463 * is only 16 bits. 464 */ 465 temp = screen->get_param(screen, PIPE_CAP_MAX_VERTEX_ELEMENT_SRC_OFFSET); 466 c->MaxVertexAttribRelativeOffset = MIN2(0xffff, temp); 467 468 c->GLSLSkipStrictMaxUniformLimitCheck = 469 screen->get_param(screen, PIPE_CAP_TGSI_CAN_COMPACT_CONSTANTS); 470 471 c->UniformBufferOffsetAlignment = 472 screen->get_param(screen, PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT); 473 474 if (can_ubo) { 475 extensions->ARB_uniform_buffer_object = GL_TRUE; 476 c->MaxCombinedUniformBlocks = c->MaxUniformBufferBindings = 477 c->Program[MESA_SHADER_VERTEX].MaxUniformBlocks + 478 c->Program[MESA_SHADER_TESS_CTRL].MaxUniformBlocks + 479 c->Program[MESA_SHADER_TESS_EVAL].MaxUniformBlocks + 480 c->Program[MESA_SHADER_GEOMETRY].MaxUniformBlocks + 481 c->Program[MESA_SHADER_FRAGMENT].MaxUniformBlocks + 482 c->Program[MESA_SHADER_COMPUTE].MaxUniformBlocks; 483 assert(c->MaxCombinedUniformBlocks <= MAX_COMBINED_UNIFORM_BUFFERS); 484 } 485 486 c->GLSLFragCoordIsSysVal = 487 screen->get_param(screen, PIPE_CAP_FS_POSITION_IS_SYSVAL); 488 c->GLSLPointCoordIsSysVal = 489 screen->get_param(screen, PIPE_CAP_FS_POINT_IS_SYSVAL); 490 c->GLSLFrontFacingIsSysVal = 491 screen->get_param(screen, PIPE_CAP_FS_FACE_IS_INTEGER_SYSVAL); 492 493 /* GL_ARB_get_program_binary */ 494 if (screen->get_disk_shader_cache && screen->get_disk_shader_cache(screen)) 495 c->NumProgramBinaryFormats = 1; 496 497 c->MaxAtomicBufferBindings = 498 MAX2(c->Program[MESA_SHADER_FRAGMENT].MaxAtomicBuffers, 499 c->Program[MESA_SHADER_COMPUTE].MaxAtomicBuffers); 500 c->MaxAtomicBufferSize = ATOMIC_COUNTER_SIZE * 501 MAX2(c->Program[MESA_SHADER_FRAGMENT].MaxAtomicCounters, 502 c->Program[MESA_SHADER_COMPUTE].MaxAtomicCounters); 503 504 c->MaxCombinedAtomicBuffers = 505 MIN2(screen->get_param(screen, 506 PIPE_CAP_MAX_COMBINED_HW_ATOMIC_COUNTER_BUFFERS), 507 MAX_COMBINED_ATOMIC_BUFFERS); 508 if (!c->MaxCombinedAtomicBuffers) { 509 c->MaxCombinedAtomicBuffers = MAX2( 510 c->Program[MESA_SHADER_VERTEX].MaxAtomicBuffers + 511 c->Program[MESA_SHADER_TESS_CTRL].MaxAtomicBuffers + 512 c->Program[MESA_SHADER_TESS_EVAL].MaxAtomicBuffers + 513 c->Program[MESA_SHADER_GEOMETRY].MaxAtomicBuffers + 514 c->Program[MESA_SHADER_FRAGMENT].MaxAtomicBuffers, 515 c->Program[MESA_SHADER_COMPUTE].MaxAtomicBuffers); 516 assert(c->MaxCombinedAtomicBuffers <= MAX_COMBINED_ATOMIC_BUFFERS); 517 } 518 519 c->MaxCombinedAtomicCounters = 520 screen->get_param(screen, PIPE_CAP_MAX_COMBINED_HW_ATOMIC_COUNTERS); 521 if (!c->MaxCombinedAtomicCounters) 522 c->MaxCombinedAtomicCounters = MAX_ATOMIC_COUNTERS; 523 524 if (c->Program[MESA_SHADER_FRAGMENT].MaxAtomicBuffers) { 525 extensions->ARB_shader_atomic_counters = GL_TRUE; 526 extensions->ARB_shader_atomic_counter_ops = GL_TRUE; 527 } 528 529 c->MaxCombinedShaderOutputResources = c->MaxDrawBuffers; 530 c->ShaderStorageBufferOffsetAlignment = 531 screen->get_param(screen, PIPE_CAP_SHADER_BUFFER_OFFSET_ALIGNMENT); 532 if (c->ShaderStorageBufferOffsetAlignment) { 533 c->MaxCombinedShaderStorageBlocks = 534 MIN2(screen->get_param(screen, PIPE_CAP_MAX_COMBINED_SHADER_BUFFERS), 535 MAX_COMBINED_SHADER_STORAGE_BUFFERS); 536 if (!c->MaxCombinedShaderStorageBlocks) { 537 c->MaxCombinedShaderStorageBlocks = MAX2( 538 c->Program[MESA_SHADER_VERTEX].MaxShaderStorageBlocks + 539 c->Program[MESA_SHADER_TESS_CTRL].MaxShaderStorageBlocks + 540 c->Program[MESA_SHADER_TESS_EVAL].MaxShaderStorageBlocks + 541 c->Program[MESA_SHADER_GEOMETRY].MaxShaderStorageBlocks + 542 c->Program[MESA_SHADER_FRAGMENT].MaxShaderStorageBlocks, 543 c->Program[MESA_SHADER_COMPUTE].MaxShaderStorageBlocks); 544 assert(c->MaxCombinedShaderStorageBlocks < MAX_COMBINED_SHADER_STORAGE_BUFFERS); 545 } 546 c->MaxShaderStorageBufferBindings = c->MaxCombinedShaderStorageBlocks; 547 548 c->MaxCombinedShaderOutputResources += 549 c->MaxCombinedShaderStorageBlocks; 550 c->MaxShaderStorageBlockSize = 551 screen->get_param(screen, PIPE_CAP_MAX_SHADER_BUFFER_SIZE_UINT); 552 if (c->Program[MESA_SHADER_FRAGMENT].MaxShaderStorageBlocks) 553 extensions->ARB_shader_storage_buffer_object = GL_TRUE; 554 } 555 556 c->MaxCombinedImageUniforms = 557 c->Program[MESA_SHADER_VERTEX].MaxImageUniforms + 558 c->Program[MESA_SHADER_TESS_CTRL].MaxImageUniforms + 559 c->Program[MESA_SHADER_TESS_EVAL].MaxImageUniforms + 560 c->Program[MESA_SHADER_GEOMETRY].MaxImageUniforms + 561 c->Program[MESA_SHADER_FRAGMENT].MaxImageUniforms + 562 c->Program[MESA_SHADER_COMPUTE].MaxImageUniforms; 563 c->MaxCombinedShaderOutputResources += c->MaxCombinedImageUniforms; 564 c->MaxImageUnits = MAX_IMAGE_UNITS; 565 if (c->Program[MESA_SHADER_FRAGMENT].MaxImageUniforms && 566 screen->get_param(screen, PIPE_CAP_IMAGE_STORE_FORMATTED)) { 567 extensions->ARB_shader_image_load_store = GL_TRUE; 568 extensions->ARB_shader_image_size = GL_TRUE; 569 } 570 571 /* ARB_framebuffer_no_attachments */ 572 c->MaxFramebufferWidth = c->MaxViewportWidth; 573 c->MaxFramebufferHeight = c->MaxViewportHeight; 574 /* NOTE: we cheat here a little by assuming that 575 * PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS has the same 576 * number of layers as we need, although we technically 577 * could have more the generality is not really useful 578 * in practicality. 579 */ 580 c->MaxFramebufferLayers = 581 screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS); 582 583 c->MaxWindowRectangles = 584 screen->get_param(screen, PIPE_CAP_MAX_WINDOW_RECTANGLES); 585 586 c->SparseBufferPageSize = 587 screen->get_param(screen, PIPE_CAP_SPARSE_BUFFER_PAGE_SIZE); 588 589 c->AllowMappedBuffersDuringExecution = 590 screen->get_param(screen, PIPE_CAP_ALLOW_MAPPED_BUFFERS_DURING_EXECUTION); 591 592 c->BufferCreateMapUnsynchronizedThreadSafe = 593 screen->get_param(screen, PIPE_CAP_MAP_UNSYNCHRONIZED_THREAD_SAFE); 594 595 c->UseSTD430AsDefaultPacking = 596 screen->get_param(screen, PIPE_CAP_LOAD_CONSTBUF); 597 598 c->MaxSubpixelPrecisionBiasBits = 599 screen->get_param(screen, PIPE_CAP_MAX_CONSERVATIVE_RASTER_SUBPIXEL_PRECISION_BIAS); 600 601 c->ConservativeRasterDilateRange[0] = 602 screen->get_paramf(screen, PIPE_CAPF_MIN_CONSERVATIVE_RASTER_DILATE); 603 c->ConservativeRasterDilateRange[1] = 604 screen->get_paramf(screen, PIPE_CAPF_MAX_CONSERVATIVE_RASTER_DILATE); 605 c->ConservativeRasterDilateGranularity = 606 screen->get_paramf(screen, PIPE_CAPF_CONSERVATIVE_RASTER_DILATE_GRANULARITY); 607 608 /* limit the max combined shader output resources to a driver limit */ 609 temp = screen->get_param(screen, PIPE_CAP_MAX_COMBINED_SHADER_OUTPUT_RESOURCES); 610 if (temp > 0 && c->MaxCombinedShaderOutputResources > temp) 611 c->MaxCombinedShaderOutputResources = temp; 612 613 c->VertexBufferOffsetIsInt32 = 614 screen->get_param(screen, PIPE_CAP_SIGNED_VERTEX_BUFFER_OFFSET); 615 616 c->AllowDynamicVAOFastPath = 617 screen->get_param(screen, PIPE_CAP_ALLOW_DYNAMIC_VAO_FASTPATH); 618 619 c->glBeginEndBufferSize = 620 screen->get_param(screen, PIPE_CAP_GL_BEGIN_END_BUFFER_SIZE); 621 622 c->MaxSparseTextureSize = 623 screen->get_param(screen, PIPE_CAP_MAX_SPARSE_TEXTURE_SIZE); 624 c->MaxSparse3DTextureSize = 625 screen->get_param(screen, PIPE_CAP_MAX_SPARSE_3D_TEXTURE_SIZE); 626 c->MaxSparseArrayTextureLayers = 627 screen->get_param(screen, PIPE_CAP_MAX_SPARSE_ARRAY_TEXTURE_LAYERS); 628 c->SparseTextureFullArrayCubeMipmaps = 629 screen->get_param(screen, PIPE_CAP_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS); 630 631 c->HardwareAcceleratedSelect = 632 screen->get_param(screen, PIPE_CAP_HARDWARE_GL_SELECT); 633} 634 635 636/** 637 * Given a member \c x of struct gl_extensions, return offset of 638 * \c x in bytes. 639 */ 640#define o(x) offsetof(struct gl_extensions, x) 641 642 643struct st_extension_cap_mapping { 644 int extension_offset; 645 int cap; 646}; 647 648struct st_extension_format_mapping { 649 int extension_offset[2]; 650 enum pipe_format format[32]; 651 652 /* If TRUE, at least one format must be supported for the extensions to be 653 * advertised. If FALSE, all the formats must be supported. */ 654 GLboolean need_at_least_one; 655}; 656 657/** 658 * Enable extensions if certain pipe formats are supported by the driver. 659 * What extensions will be enabled and what formats must be supported is 660 * described by the array of st_extension_format_mapping. 661 * 662 * target and bind_flags are passed to is_format_supported. 663 */ 664static void 665init_format_extensions(struct pipe_screen *screen, 666 struct gl_extensions *extensions, 667 const struct st_extension_format_mapping *mapping, 668 unsigned num_mappings, 669 enum pipe_texture_target target, 670 unsigned bind_flags) 671{ 672 GLboolean *extension_table = (GLboolean *) extensions; 673 unsigned i; 674 int j; 675 int num_formats = ARRAY_SIZE(mapping->format); 676 int num_ext = ARRAY_SIZE(mapping->extension_offset); 677 678 for (i = 0; i < num_mappings; i++) { 679 int num_supported = 0; 680 681 /* Examine each format in the list. */ 682 for (j = 0; j < num_formats && mapping[i].format[j]; j++) { 683 if (screen->is_format_supported(screen, mapping[i].format[j], 684 target, 0, 0, bind_flags)) { 685 num_supported++; 686 } 687 } 688 689 if (!num_supported || 690 (!mapping[i].need_at_least_one && num_supported != j)) { 691 continue; 692 } 693 694 /* Enable all extensions in the list. */ 695 for (j = 0; j < num_ext && mapping[i].extension_offset[j]; j++) 696 extension_table[mapping[i].extension_offset[j]] = GL_TRUE; 697 } 698} 699 700 701/** 702 * Given a list of formats and bind flags, return the maximum number 703 * of samples supported by any of those formats. 704 */ 705static unsigned 706get_max_samples_for_formats(struct pipe_screen *screen, 707 unsigned num_formats, 708 const enum pipe_format *formats, 709 unsigned max_samples, 710 unsigned bind) 711{ 712 unsigned i, f; 713 714 for (i = max_samples; i > 0; --i) { 715 for (f = 0; f < num_formats; f++) { 716 if (screen->is_format_supported(screen, formats[f], 717 PIPE_TEXTURE_2D, i, i, bind)) { 718 return i; 719 } 720 } 721 } 722 return 0; 723} 724 725static unsigned 726get_max_samples_for_formats_advanced(struct pipe_screen *screen, 727 unsigned num_formats, 728 const enum pipe_format *formats, 729 unsigned max_samples, 730 unsigned num_storage_samples, 731 unsigned bind) 732{ 733 unsigned i, f; 734 735 for (i = max_samples; i > 0; --i) { 736 for (f = 0; f < num_formats; f++) { 737 if (screen->is_format_supported(screen, formats[f], PIPE_TEXTURE_2D, 738 i, num_storage_samples, bind)) { 739 return i; 740 } 741 } 742 } 743 return 0; 744} 745 746/** 747 * Use pipe_screen::get_param() to query PIPE_CAP_ values to determine 748 * which GL extensions are supported. 749 * Quite a few extensions are always supported because they are standard 750 * features or can be built on top of other gallium features. 751 * Some fine tuning may still be needed. 752 */ 753void st_init_extensions(struct pipe_screen *screen, 754 struct gl_constants *consts, 755 struct gl_extensions *extensions, 756 struct st_config_options *options, 757 gl_api api) 758{ 759 unsigned i; 760 GLboolean *extension_table = (GLboolean *) extensions; 761 762 static const struct st_extension_cap_mapping cap_mapping[] = { 763 { o(ARB_base_instance), PIPE_CAP_START_INSTANCE }, 764 { o(ARB_bindless_texture), PIPE_CAP_BINDLESS_TEXTURE }, 765 { o(ARB_buffer_storage), PIPE_CAP_BUFFER_MAP_PERSISTENT_COHERENT }, 766 { o(ARB_clear_texture), PIPE_CAP_CLEAR_TEXTURE }, 767 { o(ARB_clip_control), PIPE_CAP_CLIP_HALFZ }, 768 { o(ARB_color_buffer_float), PIPE_CAP_VERTEX_COLOR_UNCLAMPED }, 769 { o(ARB_conditional_render_inverted), PIPE_CAP_CONDITIONAL_RENDER_INVERTED }, 770 { o(ARB_copy_image), PIPE_CAP_COPY_BETWEEN_COMPRESSED_AND_PLAIN_FORMATS }, 771 { o(OES_copy_image), PIPE_CAP_COPY_BETWEEN_COMPRESSED_AND_PLAIN_FORMATS }, 772 { o(ARB_cull_distance), PIPE_CAP_CULL_DISTANCE }, 773 { o(ARB_depth_clamp), PIPE_CAP_DEPTH_CLIP_DISABLE }, 774 { o(ARB_derivative_control), PIPE_CAP_FS_FINE_DERIVATIVE }, 775 { o(ARB_draw_buffers_blend), PIPE_CAP_INDEP_BLEND_FUNC }, 776 { o(ARB_draw_indirect), PIPE_CAP_DRAW_INDIRECT }, 777 { o(ARB_draw_instanced), PIPE_CAP_VS_INSTANCEID }, 778 { o(ARB_fragment_program_shadow), PIPE_CAP_TEXTURE_SHADOW_MAP }, 779 { o(ARB_framebuffer_object), PIPE_CAP_MIXED_FRAMEBUFFER_SIZES }, 780 { o(ARB_gpu_shader_int64), PIPE_CAP_INT64 }, 781 { o(ARB_gl_spirv), PIPE_CAP_GL_SPIRV }, 782 { o(ARB_indirect_parameters), PIPE_CAP_MULTI_DRAW_INDIRECT_PARAMS }, 783 { o(ARB_instanced_arrays), PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR }, 784 { o(ARB_occlusion_query2), PIPE_CAP_OCCLUSION_QUERY }, 785 { o(ARB_pipeline_statistics_query), PIPE_CAP_QUERY_PIPELINE_STATISTICS }, 786 { o(ARB_pipeline_statistics_query), PIPE_CAP_QUERY_PIPELINE_STATISTICS_SINGLE }, 787 { o(ARB_point_sprite), PIPE_CAP_POINT_SPRITE }, 788 { o(ARB_polygon_offset_clamp), PIPE_CAP_POLYGON_OFFSET_CLAMP }, 789 { o(ARB_post_depth_coverage), PIPE_CAP_POST_DEPTH_COVERAGE }, 790 { o(ARB_query_buffer_object), PIPE_CAP_QUERY_BUFFER_OBJECT }, 791 { o(ARB_robust_buffer_access_behavior), PIPE_CAP_ROBUST_BUFFER_ACCESS_BEHAVIOR }, 792 { o(ARB_sample_shading), PIPE_CAP_SAMPLE_SHADING }, 793 { o(ARB_sample_locations), PIPE_CAP_PROGRAMMABLE_SAMPLE_LOCATIONS }, 794 { o(ARB_seamless_cube_map), PIPE_CAP_SEAMLESS_CUBE_MAP }, 795 { o(ARB_shader_ballot), PIPE_CAP_SHADER_BALLOT }, 796 { o(ARB_shader_clock), PIPE_CAP_SHADER_CLOCK }, 797 { o(ARB_shader_draw_parameters), PIPE_CAP_DRAW_PARAMETERS }, 798 { o(ARB_shader_group_vote), PIPE_CAP_SHADER_GROUP_VOTE }, 799 { o(EXT_shader_image_load_formatted), PIPE_CAP_IMAGE_LOAD_FORMATTED }, 800 { o(EXT_shader_image_load_store), PIPE_CAP_IMAGE_ATOMIC_INC_WRAP }, 801 { o(ARB_shader_stencil_export), PIPE_CAP_SHADER_STENCIL_EXPORT }, 802 { o(ARB_shader_texture_image_samples), PIPE_CAP_TEXTURE_QUERY_SAMPLES }, 803 { o(ARB_shader_texture_lod), PIPE_CAP_FRAGMENT_SHADER_TEXTURE_LOD }, 804 { o(ARB_shadow), PIPE_CAP_TEXTURE_SHADOW_MAP }, 805 { o(ARB_sparse_buffer), PIPE_CAP_SPARSE_BUFFER_PAGE_SIZE }, 806 { o(ARB_sparse_texture), PIPE_CAP_MAX_SPARSE_TEXTURE_SIZE }, 807 { o(ARB_sparse_texture2), PIPE_CAP_QUERY_SPARSE_TEXTURE_RESIDENCY }, 808 { o(ARB_sparse_texture_clamp), PIPE_CAP_CLAMP_SPARSE_TEXTURE_LOD }, 809 { o(ARB_spirv_extensions), PIPE_CAP_GL_SPIRV }, 810 { o(ARB_texture_buffer_object), PIPE_CAP_TEXTURE_BUFFER_OBJECTS }, 811 { o(ARB_texture_cube_map_array), PIPE_CAP_CUBE_MAP_ARRAY }, 812 { o(ARB_texture_filter_minmax), PIPE_CAP_SAMPLER_REDUCTION_MINMAX_ARB }, 813 { o(ARB_texture_gather), PIPE_CAP_MAX_TEXTURE_GATHER_COMPONENTS }, 814 { o(ARB_texture_mirror_clamp_to_edge), PIPE_CAP_TEXTURE_MIRROR_CLAMP_TO_EDGE }, 815 { o(ARB_texture_multisample), PIPE_CAP_TEXTURE_MULTISAMPLE }, 816 { o(ARB_texture_non_power_of_two), PIPE_CAP_NPOT_TEXTURES }, 817 { o(ARB_texture_query_lod), PIPE_CAP_TEXTURE_QUERY_LOD }, 818 { o(ARB_texture_view), PIPE_CAP_SAMPLER_VIEW_TARGET }, 819 { o(ARB_timer_query), PIPE_CAP_QUERY_TIMESTAMP }, 820 { o(ARB_transform_feedback2), PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME }, 821 { o(ARB_transform_feedback3), PIPE_CAP_STREAM_OUTPUT_INTERLEAVE_BUFFERS }, 822 { o(ARB_transform_feedback_overflow_query), PIPE_CAP_QUERY_SO_OVERFLOW }, 823 { o(ARB_fragment_shader_interlock), PIPE_CAP_FRAGMENT_SHADER_INTERLOCK }, 824 825 { o(EXT_blend_equation_separate), PIPE_CAP_BLEND_EQUATION_SEPARATE }, 826 { o(EXT_demote_to_helper_invocation), PIPE_CAP_DEMOTE_TO_HELPER_INVOCATION }, 827 { o(EXT_depth_bounds_test), PIPE_CAP_DEPTH_BOUNDS_TEST }, 828 { o(EXT_disjoint_timer_query), PIPE_CAP_QUERY_TIMESTAMP }, 829 { o(EXT_draw_buffers2), PIPE_CAP_INDEP_BLEND_ENABLE }, 830 { o(EXT_memory_object), PIPE_CAP_MEMOBJ }, 831#ifndef _WIN32 832 { o(EXT_memory_object_fd), PIPE_CAP_MEMOBJ }, 833#else 834 { o(EXT_memory_object_win32), PIPE_CAP_MEMOBJ }, 835#endif 836 { o(EXT_multisampled_render_to_texture), PIPE_CAP_SURFACE_SAMPLE_COUNT }, 837 { o(EXT_semaphore), PIPE_CAP_FENCE_SIGNAL }, 838#ifndef _WIN32 839 { o(EXT_semaphore_fd), PIPE_CAP_FENCE_SIGNAL }, 840#else 841 { o(EXT_semaphore_win32), PIPE_CAP_FENCE_SIGNAL }, 842#endif 843 { o(EXT_shader_samples_identical), PIPE_CAP_SHADER_SAMPLES_IDENTICAL }, 844 { o(EXT_texture_array), PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS }, 845 { o(EXT_texture_filter_anisotropic), PIPE_CAP_ANISOTROPIC_FILTER }, 846 { o(EXT_texture_filter_minmax), PIPE_CAP_SAMPLER_REDUCTION_MINMAX }, 847 { o(EXT_texture_mirror_clamp), PIPE_CAP_TEXTURE_MIRROR_CLAMP }, 848 { o(EXT_texture_shadow_lod), PIPE_CAP_TEXTURE_SHADOW_LOD }, 849 { o(EXT_texture_swizzle), PIPE_CAP_TEXTURE_SWIZZLE }, 850 { o(EXT_transform_feedback), PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS }, 851 { o(EXT_window_rectangles), PIPE_CAP_MAX_WINDOW_RECTANGLES }, 852 853 { o(AMD_depth_clamp_separate), PIPE_CAP_DEPTH_CLIP_DISABLE_SEPARATE }, 854 { o(AMD_framebuffer_multisample_advanced), PIPE_CAP_FRAMEBUFFER_MSAA_CONSTRAINTS }, 855 { o(AMD_pinned_memory), PIPE_CAP_RESOURCE_FROM_USER_MEMORY }, 856 { o(ATI_meminfo), PIPE_CAP_QUERY_MEMORY_INFO }, 857 { o(AMD_seamless_cubemap_per_texture), PIPE_CAP_SEAMLESS_CUBE_MAP_PER_TEXTURE }, 858 { o(ATI_texture_mirror_once), PIPE_CAP_TEXTURE_MIRROR_CLAMP }, 859 { o(INTEL_conservative_rasterization), PIPE_CAP_CONSERVATIVE_RASTER_INNER_COVERAGE }, 860 { o(INTEL_shader_atomic_float_minmax), PIPE_CAP_ATOMIC_FLOAT_MINMAX }, 861 { o(MESA_tile_raster_order), PIPE_CAP_TILE_RASTER_ORDER }, 862 { o(NV_alpha_to_coverage_dither_control), PIPE_CAP_ALPHA_TO_COVERAGE_DITHER_CONTROL }, 863 { o(NV_compute_shader_derivatives), PIPE_CAP_COMPUTE_SHADER_DERIVATIVES }, 864 { o(NV_conditional_render), PIPE_CAP_CONDITIONAL_RENDER }, 865 { o(NV_fill_rectangle), PIPE_CAP_POLYGON_MODE_FILL_RECTANGLE }, 866 { o(NV_primitive_restart), PIPE_CAP_PRIMITIVE_RESTART }, 867 { o(NV_shader_atomic_float), PIPE_CAP_IMAGE_ATOMIC_FLOAT_ADD }, 868 { o(NV_shader_atomic_int64), PIPE_CAP_SHADER_ATOMIC_INT64 }, 869 { o(NV_texture_barrier), PIPE_CAP_TEXTURE_BARRIER }, 870 { o(NV_viewport_array2), PIPE_CAP_VIEWPORT_MASK }, 871 { o(NV_viewport_swizzle), PIPE_CAP_VIEWPORT_SWIZZLE }, 872 { o(NVX_gpu_memory_info), PIPE_CAP_QUERY_MEMORY_INFO }, 873 874 { o(OES_standard_derivatives), PIPE_CAP_FRAGMENT_SHADER_DERIVATIVES }, 875 { o(OES_texture_float_linear), PIPE_CAP_TEXTURE_FLOAT_LINEAR }, 876 { o(OES_texture_half_float_linear), PIPE_CAP_TEXTURE_HALF_FLOAT_LINEAR }, 877 { o(OES_texture_view), PIPE_CAP_SAMPLER_VIEW_TARGET }, 878 { o(INTEL_blackhole_render), PIPE_CAP_FRONTEND_NOOP }, 879 { o(ARM_shader_framebuffer_fetch_depth_stencil), PIPE_CAP_FBFETCH_ZS }, 880 }; 881 882 /* Required: render target and sampler support */ 883 static const struct st_extension_format_mapping rendertarget_mapping[] = { 884 { { o(OES_texture_float) }, 885 { PIPE_FORMAT_R32G32B32A32_FLOAT } }, 886 887 { { o(OES_texture_half_float) }, 888 { PIPE_FORMAT_R16G16B16A16_FLOAT } }, 889 890 { { o(ARB_texture_rgb10_a2ui) }, 891 { PIPE_FORMAT_R10G10B10A2_UINT, 892 PIPE_FORMAT_B10G10R10A2_UINT }, 893 GL_TRUE }, /* at least one format must be supported */ 894 895 { { o(EXT_sRGB) }, 896 { PIPE_FORMAT_A8B8G8R8_SRGB, 897 PIPE_FORMAT_B8G8R8A8_SRGB, 898 PIPE_FORMAT_R8G8B8A8_SRGB }, 899 GL_TRUE }, /* at least one format must be supported */ 900 901 { { o(EXT_packed_float) }, 902 { PIPE_FORMAT_R11G11B10_FLOAT } }, 903 904 { { o(EXT_texture_integer) }, 905 { PIPE_FORMAT_R32G32B32A32_UINT, 906 PIPE_FORMAT_R32G32B32A32_SINT } }, 907 908 { { o(ARB_texture_rg) }, 909 { PIPE_FORMAT_R8_UNORM, 910 PIPE_FORMAT_R8G8_UNORM } }, 911 912 { { o(EXT_texture_norm16) }, 913 { PIPE_FORMAT_R16_UNORM, 914 PIPE_FORMAT_R16G16_UNORM, 915 PIPE_FORMAT_R16G16B16A16_UNORM } }, 916 917 { { o(EXT_render_snorm) }, 918 { PIPE_FORMAT_R8_SNORM, 919 PIPE_FORMAT_R8G8_SNORM, 920 PIPE_FORMAT_R8G8B8A8_SNORM, 921 PIPE_FORMAT_R16_SNORM, 922 PIPE_FORMAT_R16G16_SNORM, 923 PIPE_FORMAT_R16G16B16A16_SNORM } }, 924 925 { { o(EXT_color_buffer_half_float) }, 926 { PIPE_FORMAT_R16_FLOAT, 927 PIPE_FORMAT_R16G16_FLOAT, 928 PIPE_FORMAT_R16G16B16X16_FLOAT, 929 PIPE_FORMAT_R16G16B16A16_FLOAT } }, 930 }; 931 932 /* Required: render target, sampler, and blending */ 933 static const struct st_extension_format_mapping rt_blendable[] = { 934 { { o(EXT_float_blend) }, 935 { PIPE_FORMAT_R32G32B32A32_FLOAT } }, 936 }; 937 938 /* Required: depth stencil and sampler support */ 939 static const struct st_extension_format_mapping depthstencil_mapping[] = { 940 { { o(ARB_depth_buffer_float) }, 941 { PIPE_FORMAT_Z32_FLOAT, 942 PIPE_FORMAT_Z32_FLOAT_S8X24_UINT } }, 943 }; 944 945 /* Required: sampler support */ 946 static const struct st_extension_format_mapping texture_mapping[] = { 947 { { o(ARB_texture_compression_rgtc) }, 948 { PIPE_FORMAT_RGTC1_UNORM, 949 PIPE_FORMAT_RGTC1_SNORM, 950 PIPE_FORMAT_RGTC2_UNORM, 951 PIPE_FORMAT_RGTC2_SNORM } }, 952 953 { { o(EXT_texture_compression_latc) }, 954 { PIPE_FORMAT_LATC1_UNORM, 955 PIPE_FORMAT_LATC1_SNORM, 956 PIPE_FORMAT_LATC2_UNORM, 957 PIPE_FORMAT_LATC2_SNORM } }, 958 959 { { o(EXT_texture_compression_s3tc), 960 o(ANGLE_texture_compression_dxt) }, 961 { PIPE_FORMAT_DXT1_RGB, 962 PIPE_FORMAT_DXT1_RGBA, 963 PIPE_FORMAT_DXT3_RGBA, 964 PIPE_FORMAT_DXT5_RGBA } }, 965 966 { { o(EXT_texture_compression_s3tc_srgb) }, 967 { PIPE_FORMAT_DXT1_SRGB, 968 PIPE_FORMAT_DXT1_SRGBA, 969 PIPE_FORMAT_DXT3_SRGBA, 970 PIPE_FORMAT_DXT5_SRGBA } }, 971 972 { { o(ARB_texture_compression_bptc) }, 973 { PIPE_FORMAT_BPTC_RGBA_UNORM, 974 PIPE_FORMAT_BPTC_SRGBA, 975 PIPE_FORMAT_BPTC_RGB_FLOAT, 976 PIPE_FORMAT_BPTC_RGB_UFLOAT } }, 977 978 { { o(TDFX_texture_compression_FXT1) }, 979 { PIPE_FORMAT_FXT1_RGB, 980 PIPE_FORMAT_FXT1_RGBA } }, 981 982 { { o(KHR_texture_compression_astc_ldr), 983 o(KHR_texture_compression_astc_sliced_3d) }, 984 { PIPE_FORMAT_ASTC_4x4, 985 PIPE_FORMAT_ASTC_5x4, 986 PIPE_FORMAT_ASTC_5x5, 987 PIPE_FORMAT_ASTC_6x5, 988 PIPE_FORMAT_ASTC_6x6, 989 PIPE_FORMAT_ASTC_8x5, 990 PIPE_FORMAT_ASTC_8x6, 991 PIPE_FORMAT_ASTC_8x8, 992 PIPE_FORMAT_ASTC_10x5, 993 PIPE_FORMAT_ASTC_10x6, 994 PIPE_FORMAT_ASTC_10x8, 995 PIPE_FORMAT_ASTC_10x10, 996 PIPE_FORMAT_ASTC_12x10, 997 PIPE_FORMAT_ASTC_12x12, 998 PIPE_FORMAT_ASTC_4x4_SRGB, 999 PIPE_FORMAT_ASTC_5x4_SRGB, 1000 PIPE_FORMAT_ASTC_5x5_SRGB, 1001 PIPE_FORMAT_ASTC_6x5_SRGB, 1002 PIPE_FORMAT_ASTC_6x6_SRGB, 1003 PIPE_FORMAT_ASTC_8x5_SRGB, 1004 PIPE_FORMAT_ASTC_8x6_SRGB, 1005 PIPE_FORMAT_ASTC_8x8_SRGB, 1006 PIPE_FORMAT_ASTC_10x5_SRGB, 1007 PIPE_FORMAT_ASTC_10x6_SRGB, 1008 PIPE_FORMAT_ASTC_10x8_SRGB, 1009 PIPE_FORMAT_ASTC_10x10_SRGB, 1010 PIPE_FORMAT_ASTC_12x10_SRGB, 1011 PIPE_FORMAT_ASTC_12x12_SRGB } }, 1012 1013 /* ASTC software fallback support. */ 1014 { { o(KHR_texture_compression_astc_ldr), 1015 o(KHR_texture_compression_astc_sliced_3d) }, 1016 { PIPE_FORMAT_R8G8B8A8_UNORM, 1017 PIPE_FORMAT_R8G8B8A8_SRGB } }, 1018 1019 { { o(EXT_texture_shared_exponent) }, 1020 { PIPE_FORMAT_R9G9B9E5_FLOAT } }, 1021 1022 { { o(EXT_texture_snorm) }, 1023 { PIPE_FORMAT_R8G8B8A8_SNORM } }, 1024 1025 { { o(EXT_texture_sRGB), 1026 o(EXT_texture_sRGB_decode) }, 1027 { PIPE_FORMAT_A8B8G8R8_SRGB, 1028 PIPE_FORMAT_B8G8R8A8_SRGB, 1029 PIPE_FORMAT_A8R8G8B8_SRGB, 1030 PIPE_FORMAT_R8G8B8A8_SRGB}, 1031 GL_TRUE }, /* at least one format must be supported */ 1032 1033 { { o(EXT_texture_sRGB_R8) }, 1034 { PIPE_FORMAT_R8_SRGB }, }, 1035 1036 { { o(EXT_texture_sRGB_RG8) }, 1037 { PIPE_FORMAT_R8G8_SRGB }, }, 1038 1039 { { o(EXT_texture_type_2_10_10_10_REV) }, 1040 { PIPE_FORMAT_R10G10B10A2_UNORM, 1041 PIPE_FORMAT_B10G10R10A2_UNORM }, 1042 GL_TRUE }, /* at least one format must be supported */ 1043 1044 { { o(ATI_texture_compression_3dc) }, 1045 { PIPE_FORMAT_LATC2_UNORM } }, 1046 1047 { { o(MESA_ycbcr_texture) }, 1048 { PIPE_FORMAT_UYVY, 1049 PIPE_FORMAT_YUYV }, 1050 GL_TRUE }, /* at least one format must be supported */ 1051 1052 { { o(OES_compressed_ETC1_RGB8_texture) }, 1053 { PIPE_FORMAT_ETC1_RGB8, 1054 PIPE_FORMAT_R8G8B8A8_UNORM }, 1055 GL_TRUE }, /* at least one format must be supported */ 1056 1057 { { o(ARB_stencil_texturing), 1058 o(ARB_texture_stencil8) }, 1059 { PIPE_FORMAT_X24S8_UINT, 1060 PIPE_FORMAT_S8X24_UINT }, 1061 GL_TRUE }, /* at least one format must be supported */ 1062 1063 { { o(AMD_compressed_ATC_texture) }, 1064 { PIPE_FORMAT_ATC_RGB, 1065 PIPE_FORMAT_ATC_RGBA_EXPLICIT, 1066 PIPE_FORMAT_ATC_RGBA_INTERPOLATED } }, 1067 }; 1068 1069 /* Required: vertex fetch support. */ 1070 static const struct st_extension_format_mapping vertex_mapping[] = { 1071 { { o(EXT_vertex_array_bgra) }, 1072 { PIPE_FORMAT_B8G8R8A8_UNORM } }, 1073 { { o(ARB_vertex_type_2_10_10_10_rev) }, 1074 { PIPE_FORMAT_R10G10B10A2_UNORM, 1075 PIPE_FORMAT_B10G10R10A2_UNORM, 1076 PIPE_FORMAT_R10G10B10A2_SNORM, 1077 PIPE_FORMAT_B10G10R10A2_SNORM, 1078 PIPE_FORMAT_R10G10B10A2_USCALED, 1079 PIPE_FORMAT_B10G10R10A2_USCALED, 1080 PIPE_FORMAT_R10G10B10A2_SSCALED, 1081 PIPE_FORMAT_B10G10R10A2_SSCALED } }, 1082 { { o(ARB_vertex_type_10f_11f_11f_rev) }, 1083 { PIPE_FORMAT_R11G11B10_FLOAT } }, 1084 }; 1085 1086 static const struct st_extension_format_mapping tbo_rgb32[] = { 1087 { {o(ARB_texture_buffer_object_rgb32) }, 1088 { PIPE_FORMAT_R32G32B32_FLOAT, 1089 PIPE_FORMAT_R32G32B32_UINT, 1090 PIPE_FORMAT_R32G32B32_SINT, 1091 } }, 1092 }; 1093 1094 /* Expose the extensions which directly correspond to gallium caps. */ 1095 for (i = 0; i < ARRAY_SIZE(cap_mapping); i++) { 1096 if (screen->get_param(screen, cap_mapping[i].cap)) { 1097 extension_table[cap_mapping[i].extension_offset] = GL_TRUE; 1098 } 1099 } 1100 1101 /* EXT implies ARB here */ 1102 if (extensions->EXT_texture_filter_minmax) 1103 extensions->ARB_texture_filter_minmax = GL_TRUE; 1104 1105 /* Expose the extensions which directly correspond to gallium formats. */ 1106 init_format_extensions(screen, extensions, rendertarget_mapping, 1107 ARRAY_SIZE(rendertarget_mapping), PIPE_TEXTURE_2D, 1108 PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW); 1109 init_format_extensions(screen, extensions, rt_blendable, 1110 ARRAY_SIZE(rt_blendable), PIPE_TEXTURE_2D, 1111 PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW | 1112 PIPE_BIND_BLENDABLE); 1113 init_format_extensions(screen, extensions, depthstencil_mapping, 1114 ARRAY_SIZE(depthstencil_mapping), PIPE_TEXTURE_2D, 1115 PIPE_BIND_DEPTH_STENCIL | PIPE_BIND_SAMPLER_VIEW); 1116 init_format_extensions(screen, extensions, texture_mapping, 1117 ARRAY_SIZE(texture_mapping), PIPE_TEXTURE_2D, 1118 PIPE_BIND_SAMPLER_VIEW); 1119 init_format_extensions(screen, extensions, vertex_mapping, 1120 ARRAY_SIZE(vertex_mapping), PIPE_BUFFER, 1121 PIPE_BIND_VERTEX_BUFFER); 1122 1123 /* Figure out GLSL support and set GLSLVersion to it. */ 1124 consts->GLSLVersion = screen->get_param(screen, PIPE_CAP_GLSL_FEATURE_LEVEL); 1125 consts->GLSLVersionCompat = 1126 screen->get_param(screen, PIPE_CAP_GLSL_FEATURE_LEVEL_COMPATIBILITY); 1127 1128 const unsigned ESSLVersion = 1129 screen->get_param(screen, PIPE_CAP_ESSL_FEATURE_LEVEL); 1130 const unsigned GLSLVersion = 1131 api == API_OPENGL_COMPAT ? consts->GLSLVersionCompat : 1132 consts->GLSLVersion; 1133 1134 _mesa_override_glsl_version(consts); 1135 1136 if (options->force_glsl_version > 0 && 1137 options->force_glsl_version <= GLSLVersion) { 1138 consts->ForceGLSLVersion = options->force_glsl_version; 1139 } 1140 1141 consts->ForceCompatShaders = options->force_compat_shaders; 1142 1143 consts->AllowExtraPPTokens = options->allow_extra_pp_tokens; 1144 1145 consts->AllowHigherCompatVersion = options->allow_higher_compat_version; 1146 consts->AllowGLSLCompatShaders = options->allow_glsl_compat_shaders; 1147 1148 consts->ForceGLSLAbsSqrt = options->force_glsl_abs_sqrt; 1149 1150 consts->AllowGLSLBuiltinVariableRedeclaration = options->allow_glsl_builtin_variable_redeclaration; 1151 1152 consts->dri_config_options_sha1 = options->config_options_sha1; 1153 1154 consts->AllowGLSLCrossStageInterpolationMismatch = options->allow_glsl_cross_stage_interpolation_mismatch; 1155 1156 consts->DoDCEBeforeClipCullAnalysis = options->do_dce_before_clip_cull_analysis; 1157 1158 consts->GLSLIgnoreWriteToReadonlyVar = options->glsl_ignore_write_to_readonly_var; 1159 1160 consts->ForceMapBufferSynchronized = options->force_gl_map_buffer_synchronized; 1161 1162 consts->PrimitiveRestartFixedIndex = 1163 screen->get_param(screen, PIPE_CAP_PRIMITIVE_RESTART_FIXED_INDEX); 1164 1165 /* Technically we are turning on the EXT_gpu_shader5 extension, 1166 * ARB_gpu_shader5 does not exist in GLES, but this flag is what 1167 * switches on EXT_gpu_shader5: 1168 */ 1169 if (api == API_OPENGLES2 && ESSLVersion >= 320) 1170 extensions->ARB_gpu_shader5 = GL_TRUE; 1171 1172 if (GLSLVersion >= 400 && !options->disable_arb_gpu_shader5) 1173 extensions->ARB_gpu_shader5 = GL_TRUE; 1174 if (GLSLVersion >= 410) 1175 extensions->ARB_shader_precision = GL_TRUE; 1176 1177 /* This extension needs full OpenGL 3.2, but we don't know if that's 1178 * supported at this point. Only check the GLSL version. */ 1179 if (GLSLVersion >= 150 && 1180 screen->get_param(screen, PIPE_CAP_VS_LAYER_VIEWPORT)) { 1181 extensions->AMD_vertex_shader_layer = GL_TRUE; 1182 } 1183 1184 if (GLSLVersion >= 140) { 1185 /* Since GLSL 1.40 has support for all of the features of gpu_shader4, 1186 * we can always expose it if the driver can do 140. Supporting 1187 * gpu_shader4 on drivers without GLSL 1.40 is left for a future 1188 * pipe cap. 1189 */ 1190 extensions->EXT_gpu_shader4 = GL_TRUE; 1191 extensions->EXT_texture_buffer_object = GL_TRUE; 1192 1193 if (consts->MaxTransformFeedbackBuffers && 1194 screen->get_param(screen, PIPE_CAP_SHADER_ARRAY_COMPONENTS)) 1195 extensions->ARB_enhanced_layouts = GL_TRUE; 1196 } 1197 1198 if (GLSLVersion >= 130) { 1199 consts->NativeIntegers = GL_TRUE; 1200 consts->MaxClipPlanes = 8; 1201 1202 uint32_t drv_clip_planes = screen->get_param(screen, PIPE_CAP_CLIP_PLANES); 1203 /* only override for > 1 - 0 if none, 1 is MAX, >2 overrides MAX */ 1204 if (drv_clip_planes > 1) 1205 consts->MaxClipPlanes = drv_clip_planes; 1206 1207 if (screen->get_param(screen, PIPE_CAP_VERTEXID_NOBASE)) { 1208 consts->VertexID_is_zero_based = GL_TRUE; 1209 } 1210 1211 /* Extensions that either depend on GLSL 1.30 or are a subset thereof. */ 1212 extensions->ARB_conservative_depth = GL_TRUE; 1213 extensions->ARB_shading_language_packing = GL_TRUE; 1214 extensions->OES_depth_texture_cube_map = GL_TRUE; 1215 extensions->ARB_shading_language_420pack = GL_TRUE; 1216 extensions->ARB_texture_query_levels = GL_TRUE; 1217 1218 extensions->ARB_shader_bit_encoding = GL_TRUE; 1219 1220 extensions->EXT_shader_integer_mix = GL_TRUE; 1221 extensions->ARB_arrays_of_arrays = GL_TRUE; 1222 extensions->MESA_shader_integer_functions = GL_TRUE; 1223 1224 if (screen->get_param(screen, PIPE_CAP_OPENCL_INTEGER_FUNCTIONS) && 1225 screen->get_param(screen, PIPE_CAP_INTEGER_MULTIPLY_32X16)) { 1226 extensions->INTEL_shader_integer_functions2 = GL_TRUE; 1227 } 1228 } else { 1229 /* Optional integer support for GLSL 1.2. */ 1230 if (screen->get_shader_param(screen, PIPE_SHADER_VERTEX, 1231 PIPE_SHADER_CAP_INTEGERS) && 1232 screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT, 1233 PIPE_SHADER_CAP_INTEGERS)) { 1234 consts->NativeIntegers = GL_TRUE; 1235 1236 extensions->EXT_shader_integer_mix = GL_TRUE; 1237 } 1238 1239 /* Integer textures make no sense before GLSL 1.30 */ 1240 extensions->EXT_texture_integer = GL_FALSE; 1241 extensions->ARB_texture_rgb10_a2ui = GL_FALSE; 1242 } 1243 1244 if (options->glsl_zero_init) { 1245 consts->GLSLZeroInit = 1; 1246 } else { 1247 consts->GLSLZeroInit = screen->get_param(screen, PIPE_CAP_GLSL_ZERO_INIT); 1248 } 1249 1250 consts->ForceGLNamesReuse = options->force_gl_names_reuse; 1251 1252 consts->ForceIntegerTexNearest = options->force_integer_tex_nearest; 1253 1254 consts->VendorOverride = options->force_gl_vendor; 1255 consts->RendererOverride = options->force_gl_renderer; 1256 1257 consts->UniformBooleanTrue = consts->NativeIntegers ? ~0U : fui(1.0f); 1258 1259 /* Below are the cases which cannot be moved into tables easily. */ 1260 1261 /* The compatibility profile also requires GLSLVersionCompat >= 400. */ 1262 if (screen->get_shader_param(screen, PIPE_SHADER_TESS_CTRL, 1263 PIPE_SHADER_CAP_MAX_INSTRUCTIONS) > 0 && 1264 (api != API_OPENGL_COMPAT || consts->GLSLVersionCompat >= 400)) { 1265 extensions->ARB_tessellation_shader = GL_TRUE; 1266 } 1267 1268 /* OES_geometry_shader requires instancing */ 1269 if ((GLSLVersion >= 400 || ESSLVersion >= 310) && 1270 screen->get_shader_param(screen, PIPE_SHADER_GEOMETRY, 1271 PIPE_SHADER_CAP_MAX_INSTRUCTIONS) > 0 && 1272 consts->MaxGeometryShaderInvocations >= 32) { 1273 extensions->OES_geometry_shader = GL_TRUE; 1274 } 1275 1276 /* Some hardware may not support indirect draws, but still wants ES 1277 * 3.1. This allows the extension to be enabled only in ES contexts to 1278 * avoid claiming hw support when there is none, and using a software 1279 * fallback for ES. 1280 */ 1281 if (api == API_OPENGLES2 && ESSLVersion >= 310) { 1282 extensions->ARB_draw_indirect = GL_TRUE; 1283 } 1284 1285 /* Needs PIPE_CAP_SAMPLE_SHADING + all the sample-related bits of 1286 * ARB_gpu_shader5. This enables all the per-sample shading ES extensions. 1287 */ 1288 extensions->OES_sample_variables = extensions->ARB_sample_shading && 1289 extensions->ARB_gpu_shader5; 1290 1291 /* Maximum sample count. */ 1292 { 1293 static const enum pipe_format color_formats[] = { 1294 PIPE_FORMAT_R8G8B8A8_UNORM, 1295 PIPE_FORMAT_B8G8R8A8_UNORM, 1296 PIPE_FORMAT_A8R8G8B8_UNORM, 1297 PIPE_FORMAT_A8B8G8R8_UNORM, 1298 }; 1299 static const enum pipe_format depth_formats[] = { 1300 PIPE_FORMAT_Z16_UNORM, 1301 PIPE_FORMAT_Z24X8_UNORM, 1302 PIPE_FORMAT_X8Z24_UNORM, 1303 PIPE_FORMAT_Z32_UNORM, 1304 PIPE_FORMAT_Z32_FLOAT 1305 }; 1306 static const enum pipe_format int_formats[] = { 1307 PIPE_FORMAT_R8G8B8A8_SINT 1308 }; 1309 static const enum pipe_format void_formats[] = { 1310 PIPE_FORMAT_NONE 1311 }; 1312 1313 consts->MaxSamples = 1314 get_max_samples_for_formats(screen, ARRAY_SIZE(color_formats), 1315 color_formats, 16, 1316 PIPE_BIND_RENDER_TARGET); 1317 1318 consts->MaxImageSamples = 1319 get_max_samples_for_formats(screen, ARRAY_SIZE(color_formats), 1320 color_formats, 16, 1321 PIPE_BIND_SHADER_IMAGE); 1322 1323 consts->MaxColorTextureSamples = 1324 get_max_samples_for_formats(screen, ARRAY_SIZE(color_formats), 1325 color_formats, consts->MaxSamples, 1326 PIPE_BIND_SAMPLER_VIEW); 1327 1328 consts->MaxDepthTextureSamples = 1329 get_max_samples_for_formats(screen, ARRAY_SIZE(depth_formats), 1330 depth_formats, consts->MaxSamples, 1331 PIPE_BIND_SAMPLER_VIEW); 1332 1333 consts->MaxIntegerSamples = 1334 get_max_samples_for_formats(screen, ARRAY_SIZE(int_formats), 1335 int_formats, consts->MaxSamples, 1336 PIPE_BIND_SAMPLER_VIEW); 1337 1338 /* ARB_framebuffer_no_attachments, assume max no. of samples 32 */ 1339 consts->MaxFramebufferSamples = 1340 get_max_samples_for_formats(screen, ARRAY_SIZE(void_formats), 1341 void_formats, 32, 1342 PIPE_BIND_RENDER_TARGET); 1343 1344 if (extensions->AMD_framebuffer_multisample_advanced) { 1345 /* AMD_framebuffer_multisample_advanced */ 1346 /* This can be greater than storage samples. */ 1347 consts->MaxColorFramebufferSamples = 1348 get_max_samples_for_formats_advanced(screen, 1349 ARRAY_SIZE(color_formats), 1350 color_formats, 16, 1351 consts->MaxSamples, 1352 PIPE_BIND_RENDER_TARGET); 1353 1354 /* If the driver supports N color samples, it means it supports 1355 * N samples and N storage samples. N samples >= N storage 1356 * samples. 1357 */ 1358 consts->MaxColorFramebufferStorageSamples = consts->MaxSamples; 1359 consts->MaxDepthStencilFramebufferSamples = 1360 consts->MaxDepthTextureSamples; 1361 1362 assert(consts->MaxColorFramebufferSamples >= 1363 consts->MaxDepthStencilFramebufferSamples); 1364 assert(consts->MaxDepthStencilFramebufferSamples >= 1365 consts->MaxColorFramebufferStorageSamples); 1366 1367 consts->NumSupportedMultisampleModes = 0; 1368 1369 unsigned depth_samples_supported = 0; 1370 1371 for (unsigned samples = 2; 1372 samples <= consts->MaxDepthStencilFramebufferSamples; 1373 samples++) { 1374 if (screen->is_format_supported(screen, PIPE_FORMAT_Z32_FLOAT, 1375 PIPE_TEXTURE_2D, samples, samples, 1376 PIPE_BIND_DEPTH_STENCIL)) 1377 depth_samples_supported |= 1 << samples; 1378 } 1379 1380 for (unsigned samples = 2; 1381 samples <= consts->MaxColorFramebufferSamples; 1382 samples++) { 1383 for (unsigned depth_samples = 2; 1384 depth_samples <= samples; depth_samples++) { 1385 if (!(depth_samples_supported & (1 << depth_samples))) 1386 continue; 1387 1388 for (unsigned storage_samples = 2; 1389 storage_samples <= depth_samples; storage_samples++) { 1390 if (screen->is_format_supported(screen, 1391 PIPE_FORMAT_R8G8B8A8_UNORM, 1392 PIPE_TEXTURE_2D, 1393 samples, 1394 storage_samples, 1395 PIPE_BIND_RENDER_TARGET)) { 1396 unsigned i = consts->NumSupportedMultisampleModes; 1397 1398 assert(i < ARRAY_SIZE(consts->SupportedMultisampleModes)); 1399 consts->SupportedMultisampleModes[i].NumColorSamples = 1400 samples; 1401 consts->SupportedMultisampleModes[i].NumColorStorageSamples = 1402 storage_samples; 1403 consts->SupportedMultisampleModes[i].NumDepthStencilSamples = 1404 depth_samples; 1405 consts->NumSupportedMultisampleModes++; 1406 } 1407 } 1408 } 1409 } 1410 } 1411 } 1412 1413 if (consts->MaxSamples >= 2) { 1414 /* Real MSAA support */ 1415 extensions->EXT_framebuffer_multisample = GL_TRUE; 1416 extensions->EXT_framebuffer_multisample_blit_scaled = GL_TRUE; 1417 } 1418 else if (consts->MaxSamples > 0 && 1419 screen->get_param(screen, PIPE_CAP_FAKE_SW_MSAA)) { 1420 /* fake MSAA support */ 1421 consts->FakeSWMSAA = GL_TRUE; 1422 extensions->EXT_framebuffer_multisample = GL_TRUE; 1423 extensions->EXT_framebuffer_multisample_blit_scaled = GL_TRUE; 1424 extensions->ARB_texture_multisample = GL_TRUE; 1425 } 1426 1427 if (consts->MaxDualSourceDrawBuffers > 0 && 1428 !options->disable_blend_func_extended) 1429 extensions->ARB_blend_func_extended = GL_TRUE; 1430 1431 if (screen->get_param(screen, PIPE_CAP_QUERY_TIME_ELAPSED) || 1432 extensions->ARB_timer_query) { 1433 extensions->EXT_timer_query = GL_TRUE; 1434 } 1435 1436 if (extensions->ARB_transform_feedback2 && 1437 extensions->ARB_draw_instanced) { 1438 extensions->ARB_transform_feedback_instanced = GL_TRUE; 1439 } 1440 if (options->force_glsl_extensions_warn) 1441 consts->ForceGLSLExtensionsWarn = 1; 1442 1443 if (options->disable_glsl_line_continuations) 1444 consts->DisableGLSLLineContinuations = 1; 1445 1446 if (options->allow_glsl_extension_directive_midshader) 1447 consts->AllowGLSLExtensionDirectiveMidShader = GL_TRUE; 1448 1449 if (options->allow_glsl_120_subset_in_110) 1450 consts->AllowGLSL120SubsetIn110 = GL_TRUE; 1451 1452 if (options->allow_glsl_builtin_const_expression) 1453 consts->AllowGLSLBuiltinConstantExpression = GL_TRUE; 1454 1455 if (options->allow_glsl_relaxed_es) 1456 consts->AllowGLSLRelaxedES = GL_TRUE; 1457 1458 consts->MinMapBufferAlignment = 1459 screen->get_param(screen, PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT); 1460 1461 /* The OpenGL Compatibility profile requires arbitrary buffer swizzling. */ 1462 if (api == API_OPENGL_COMPAT && 1463 screen->get_param(screen, PIPE_CAP_BUFFER_SAMPLER_VIEW_RGBA_ONLY)) 1464 extensions->ARB_texture_buffer_object = GL_FALSE; 1465 1466 if (extensions->ARB_texture_buffer_object) { 1467 consts->MaxTextureBufferSize = 1468 screen->get_param(screen, PIPE_CAP_MAX_TEXEL_BUFFER_ELEMENTS_UINT); 1469 consts->TextureBufferOffsetAlignment = 1470 screen->get_param(screen, PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT); 1471 1472 if (consts->TextureBufferOffsetAlignment) 1473 extensions->ARB_texture_buffer_range = GL_TRUE; 1474 1475 init_format_extensions(screen, extensions, tbo_rgb32, 1476 ARRAY_SIZE(tbo_rgb32), PIPE_BUFFER, 1477 PIPE_BIND_SAMPLER_VIEW); 1478 } 1479 1480 extensions->OES_texture_buffer = 1481 consts->Program[MESA_SHADER_COMPUTE].MaxImageUniforms && 1482 extensions->ARB_texture_buffer_object && 1483 extensions->ARB_texture_buffer_range && 1484 extensions->ARB_texture_buffer_object_rgb32; 1485 1486 extensions->EXT_framebuffer_sRGB = 1487 screen->get_param(screen, PIPE_CAP_DEST_SURFACE_SRGB_CONTROL) && 1488 extensions->EXT_sRGB; 1489 1490 /* Unpacking a varying in the fragment shader costs 1 texture indirection. 1491 * If the number of available texture indirections is very limited, then we 1492 * prefer to disable varying packing rather than run the risk of varying 1493 * packing preventing a shader from running. 1494 */ 1495 if (screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT, 1496 PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS) <= 8) { 1497 /* We can't disable varying packing if transform feedback is available, 1498 * because transform feedback code assumes a packed varying layout. 1499 */ 1500 if (!extensions->EXT_transform_feedback) 1501 consts->DisableVaryingPacking = GL_TRUE; 1502 } 1503 1504 if (!screen->get_param(screen, PIPE_CAP_PACKED_STREAM_OUTPUT)) 1505 consts->DisableTransformFeedbackPacking = GL_TRUE; 1506 1507 if (screen->get_param(screen, PIPE_CAP_PREFER_POT_ALIGNED_VARYINGS)) 1508 consts->PreferPOTAlignedVaryings = GL_TRUE; 1509 1510 unsigned max_fb_fetch_rts = screen->get_param(screen, PIPE_CAP_FBFETCH); 1511 bool coherent_fb_fetch = 1512 screen->get_param(screen, PIPE_CAP_FBFETCH_COHERENT); 1513 1514 if (screen->get_param(screen, PIPE_CAP_BLEND_EQUATION_ADVANCED)) 1515 extensions->KHR_blend_equation_advanced = true; 1516 1517 if (max_fb_fetch_rts > 0) { 1518 extensions->KHR_blend_equation_advanced = true; 1519 extensions->KHR_blend_equation_advanced_coherent = coherent_fb_fetch; 1520 1521 if (max_fb_fetch_rts >= 1522 screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS)) { 1523 extensions->EXT_shader_framebuffer_fetch_non_coherent = true; 1524 extensions->EXT_shader_framebuffer_fetch = coherent_fb_fetch; 1525 } 1526 } 1527 1528 consts->MaxViewports = screen->get_param(screen, PIPE_CAP_MAX_VIEWPORTS); 1529 if (consts->MaxViewports >= 16) { 1530 if (GLSLVersion >= 400) { 1531 consts->ViewportBounds.Min = -32768.0; 1532 consts->ViewportBounds.Max = 32767.0; 1533 } else { 1534 consts->ViewportBounds.Min = -16384.0; 1535 consts->ViewportBounds.Max = 16383.0; 1536 } 1537 extensions->ARB_viewport_array = GL_TRUE; 1538 extensions->ARB_fragment_layer_viewport = GL_TRUE; 1539 if (extensions->AMD_vertex_shader_layer) 1540 extensions->AMD_vertex_shader_viewport_index = GL_TRUE; 1541 } 1542 1543 if (extensions->AMD_vertex_shader_layer && 1544 extensions->AMD_vertex_shader_viewport_index && 1545 screen->get_param(screen, PIPE_CAP_TES_LAYER_VIEWPORT)) 1546 extensions->ARB_shader_viewport_layer_array = GL_TRUE; 1547 1548 /* ARB_framebuffer_no_attachments */ 1549 if (screen->get_param(screen, PIPE_CAP_FRAMEBUFFER_NO_ATTACHMENT) && 1550 ((consts->MaxSamples >= 4 && consts->MaxFramebufferLayers >= 2048) || 1551 (consts->MaxFramebufferSamples >= consts->MaxSamples && 1552 consts->MaxFramebufferLayers >= consts->MaxArrayTextureLayers))) 1553 extensions->ARB_framebuffer_no_attachments = GL_TRUE; 1554 1555 /* GL_ARB_ES3_compatibility. 1556 * Check requirements for GLSL ES 3.00. 1557 */ 1558 if (GLSLVersion >= 130 && 1559 extensions->ARB_uniform_buffer_object && 1560 (extensions->NV_primitive_restart || 1561 consts->PrimitiveRestartFixedIndex) && 1562 screen->get_shader_param(screen, PIPE_SHADER_VERTEX, 1563 PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS) >= 16 && 1564 /* Requirements for ETC2 emulation. */ 1565 screen->is_format_supported(screen, PIPE_FORMAT_R8G8B8A8_UNORM, 1566 PIPE_TEXTURE_2D, 0, 0, 1567 PIPE_BIND_SAMPLER_VIEW) && 1568 screen->is_format_supported(screen, PIPE_FORMAT_R8G8B8A8_SRGB, 1569 PIPE_TEXTURE_2D, 0, 0, 1570 PIPE_BIND_SAMPLER_VIEW) && 1571 screen->is_format_supported(screen, PIPE_FORMAT_R16_UNORM, 1572 PIPE_TEXTURE_2D, 0, 0, 1573 PIPE_BIND_SAMPLER_VIEW) && 1574 screen->is_format_supported(screen, PIPE_FORMAT_R16G16_UNORM, 1575 PIPE_TEXTURE_2D, 0, 0, 1576 PIPE_BIND_SAMPLER_VIEW) && 1577 screen->is_format_supported(screen, PIPE_FORMAT_R16_SNORM, 1578 PIPE_TEXTURE_2D, 0, 0, 1579 PIPE_BIND_SAMPLER_VIEW) && 1580 screen->is_format_supported(screen, PIPE_FORMAT_R16G16_SNORM, 1581 PIPE_TEXTURE_2D, 0, 0, 1582 PIPE_BIND_SAMPLER_VIEW)) { 1583 extensions->ARB_ES3_compatibility = GL_TRUE; 1584 } 1585 1586#ifdef HAVE_ST_VDPAU 1587 if (screen->get_video_param && 1588 screen->get_video_param(screen, PIPE_VIDEO_PROFILE_UNKNOWN, 1589 PIPE_VIDEO_ENTRYPOINT_BITSTREAM, 1590 PIPE_VIDEO_CAP_SUPPORTS_INTERLACED)) { 1591 extensions->NV_vdpau_interop = GL_TRUE; 1592 } 1593#endif 1594 1595 if (screen->get_param(screen, PIPE_CAP_DOUBLES)) { 1596 extensions->ARB_gpu_shader_fp64 = GL_TRUE; 1597 extensions->ARB_vertex_attrib_64bit = GL_TRUE; 1598 } 1599 1600 if ((ST_DEBUG & DEBUG_GREMEDY) && 1601 screen->get_param(screen, PIPE_CAP_STRING_MARKER)) 1602 extensions->GREMEDY_string_marker = GL_TRUE; 1603 1604 if (screen->get_param(screen, PIPE_CAP_COMPUTE)) { 1605 int compute_supported_irs = 1606 screen->get_shader_param(screen, PIPE_SHADER_COMPUTE, 1607 PIPE_SHADER_CAP_SUPPORTED_IRS); 1608 if (compute_supported_irs & ((1 << PIPE_SHADER_IR_TGSI) | 1609 (1 << PIPE_SHADER_IR_NIR))) { 1610 enum pipe_shader_ir ir = 1611 (compute_supported_irs & PIPE_SHADER_IR_NIR) ? 1612 PIPE_SHADER_IR_NIR : PIPE_SHADER_IR_TGSI; 1613 uint64_t grid_size[3], block_size[3]; 1614 uint64_t max_local_size, max_threads_per_block; 1615 1616 screen->get_compute_param(screen, ir, 1617 PIPE_COMPUTE_CAP_MAX_GRID_SIZE, grid_size); 1618 screen->get_compute_param(screen, ir, 1619 PIPE_COMPUTE_CAP_MAX_BLOCK_SIZE, block_size); 1620 screen->get_compute_param(screen, ir, 1621 PIPE_COMPUTE_CAP_MAX_THREADS_PER_BLOCK, 1622 &max_threads_per_block); 1623 screen->get_compute_param(screen, ir, 1624 PIPE_COMPUTE_CAP_MAX_LOCAL_SIZE, 1625 &max_local_size); 1626 1627 consts->MaxComputeWorkGroupInvocations = max_threads_per_block; 1628 consts->MaxComputeSharedMemorySize = max_local_size; 1629 1630 for (i = 0; i < 3; i++) { 1631 /* There are tests that fail if we report more that INT_MAX - 1. */ 1632 consts->MaxComputeWorkGroupCount[i] = MIN2(grid_size[i], INT_MAX - 1); 1633 consts->MaxComputeWorkGroupSize[i] = block_size[i]; 1634 } 1635 1636 extensions->ARB_compute_shader = 1637 max_threads_per_block >= 1024 && 1638 extensions->ARB_shader_image_load_store && 1639 extensions->ARB_shader_atomic_counters; 1640 1641 if (extensions->ARB_compute_shader) { 1642 uint64_t max_variable_threads_per_block = 0; 1643 1644 screen->get_compute_param(screen, ir, 1645 PIPE_COMPUTE_CAP_MAX_VARIABLE_THREADS_PER_BLOCK, 1646 &max_variable_threads_per_block); 1647 1648 for (i = 0; i < 3; i++) { 1649 /* Clamp the values to avoid having a local work group size 1650 * greater than the maximum number of invocations. 1651 */ 1652 consts->MaxComputeVariableGroupSize[i] = 1653 MIN2(consts->MaxComputeWorkGroupSize[i], 1654 max_variable_threads_per_block); 1655 } 1656 consts->MaxComputeVariableGroupInvocations = 1657 max_variable_threads_per_block; 1658 1659 extensions->ARB_compute_variable_group_size = 1660 max_variable_threads_per_block > 0; 1661 } 1662 } 1663 } 1664 1665 extensions->ARB_texture_float = 1666 extensions->OES_texture_half_float && 1667 extensions->OES_texture_float; 1668 1669 if (extensions->EXT_texture_filter_anisotropic && 1670 screen->get_paramf(screen, PIPE_CAPF_MAX_TEXTURE_ANISOTROPY) >= 16.0) 1671 extensions->ARB_texture_filter_anisotropic = GL_TRUE; 1672 1673 extensions->KHR_robustness = extensions->ARB_robust_buffer_access_behavior; 1674 1675 /* If we support ES 3.1, we support the ES3_1_compatibility ext. However 1676 * there's no clean way of telling whether we would support ES 3.1 from 1677 * here, so copy the condition from compute_version_es2 here. A lot of 1678 * these are redunant, but simpler to just have a (near-)exact copy here. 1679 */ 1680 extensions->ARB_ES3_1_compatibility = 1681 consts->Program[MESA_SHADER_FRAGMENT].MaxImageUniforms && 1682 extensions->ARB_ES3_compatibility && 1683 extensions->ARB_arrays_of_arrays && 1684 extensions->ARB_compute_shader && 1685 extensions->ARB_draw_indirect && 1686 extensions->ARB_explicit_uniform_location && 1687 extensions->ARB_framebuffer_no_attachments && 1688 extensions->ARB_shader_atomic_counters && 1689 extensions->ARB_shader_image_load_store && 1690 extensions->ARB_shader_image_size && 1691 extensions->ARB_shader_storage_buffer_object && 1692 extensions->ARB_shading_language_packing && 1693 extensions->ARB_stencil_texturing && 1694 extensions->ARB_texture_multisample && 1695 extensions->ARB_gpu_shader5 && 1696 extensions->EXT_shader_integer_mix; 1697 1698 extensions->OES_texture_cube_map_array = 1699 (extensions->ARB_ES3_1_compatibility || ESSLVersion >= 310) && 1700 extensions->OES_geometry_shader && 1701 extensions->ARB_texture_cube_map_array; 1702 1703 extensions->OES_viewport_array = 1704 (extensions->ARB_ES3_1_compatibility || ESSLVersion >= 310) && 1705 extensions->OES_geometry_shader && 1706 extensions->ARB_viewport_array; 1707 1708 extensions->OES_primitive_bounding_box = 1709 extensions->ARB_ES3_1_compatibility || ESSLVersion >= 310; 1710 1711 consts->NoPrimitiveBoundingBoxOutput = true; 1712 1713 extensions->ANDROID_extension_pack_es31a = 1714 consts->Program[MESA_SHADER_FRAGMENT].MaxImageUniforms && 1715 extensions->KHR_texture_compression_astc_ldr && 1716 extensions->KHR_blend_equation_advanced && 1717 extensions->OES_sample_variables && 1718 extensions->ARB_texture_stencil8 && 1719 extensions->ARB_texture_multisample && 1720 extensions->OES_copy_image && 1721 extensions->ARB_draw_buffers_blend && 1722 extensions->OES_geometry_shader && 1723 extensions->ARB_gpu_shader5 && 1724 extensions->OES_primitive_bounding_box && 1725 extensions->ARB_tessellation_shader && 1726 extensions->OES_texture_buffer && 1727 extensions->OES_texture_cube_map_array && 1728 extensions->EXT_texture_sRGB_decode; 1729 1730 /* Same deal as for ARB_ES3_1_compatibility - this has to be computed 1731 * before overall versions are selected. Also it's actually a subset of ES 1732 * 3.2, since it doesn't require ASTC or advanced blending. 1733 */ 1734 extensions->ARB_ES3_2_compatibility = 1735 extensions->ARB_ES3_1_compatibility && 1736 extensions->KHR_robustness && 1737 extensions->ARB_copy_image && 1738 extensions->ARB_draw_buffers_blend && 1739 extensions->ARB_draw_elements_base_vertex && 1740 extensions->OES_geometry_shader && 1741 extensions->ARB_gpu_shader5 && 1742 extensions->ARB_sample_shading && 1743 extensions->ARB_tessellation_shader && 1744 extensions->OES_texture_buffer && 1745 extensions->ARB_texture_cube_map_array && 1746 extensions->ARB_texture_stencil8 && 1747 extensions->ARB_texture_multisample; 1748 1749 if (screen->get_param(screen, PIPE_CAP_CONSERVATIVE_RASTER_POST_SNAP_TRIANGLES) && 1750 screen->get_param(screen, PIPE_CAP_CONSERVATIVE_RASTER_POST_SNAP_POINTS_LINES) && 1751 screen->get_param(screen, PIPE_CAP_CONSERVATIVE_RASTER_POST_DEPTH_COVERAGE)) { 1752 float max_dilate; 1753 bool pre_snap_triangles, pre_snap_points_lines; 1754 1755 max_dilate = screen->get_paramf(screen, PIPE_CAPF_MAX_CONSERVATIVE_RASTER_DILATE); 1756 1757 pre_snap_triangles = 1758 screen->get_param(screen, PIPE_CAP_CONSERVATIVE_RASTER_PRE_SNAP_TRIANGLES); 1759 pre_snap_points_lines = 1760 screen->get_param(screen, PIPE_CAP_CONSERVATIVE_RASTER_PRE_SNAP_POINTS_LINES); 1761 1762 extensions->NV_conservative_raster = 1763 screen->get_param(screen, PIPE_CAP_MAX_CONSERVATIVE_RASTER_SUBPIXEL_PRECISION_BIAS) > 1; 1764 1765 if (extensions->NV_conservative_raster) { 1766 extensions->NV_conservative_raster_dilate = max_dilate >= 0.75; 1767 extensions->NV_conservative_raster_pre_snap_triangles = pre_snap_triangles; 1768 extensions->NV_conservative_raster_pre_snap = 1769 pre_snap_triangles && pre_snap_points_lines; 1770 } 1771 } 1772 1773 if (extensions->ARB_gl_spirv) { 1774 struct spirv_supported_capabilities *spirv_caps = &consts->SpirVCapabilities; 1775 1776 spirv_caps->atomic_storage = extensions->ARB_shader_atomic_counters; 1777 spirv_caps->demote_to_helper_invocation = extensions->EXT_demote_to_helper_invocation; 1778 spirv_caps->draw_parameters = extensions->ARB_shader_draw_parameters; 1779 spirv_caps->derivative_group = extensions->NV_compute_shader_derivatives; 1780 spirv_caps->float64 = extensions->ARB_gpu_shader_fp64; 1781 spirv_caps->geometry_streams = extensions->ARB_gpu_shader5; 1782 spirv_caps->image_ms_array = extensions->ARB_shader_image_load_store && 1783 consts->MaxImageSamples > 1; 1784 spirv_caps->image_read_without_format = extensions->EXT_shader_image_load_formatted; 1785 spirv_caps->image_write_without_format = extensions->ARB_shader_image_load_store; 1786 spirv_caps->int64 = extensions->ARB_gpu_shader_int64; 1787 spirv_caps->int64_atomics = extensions->NV_shader_atomic_int64; 1788 spirv_caps->post_depth_coverage = extensions->ARB_post_depth_coverage; 1789 spirv_caps->shader_clock = extensions->ARB_shader_clock; 1790 spirv_caps->shader_viewport_index_layer = extensions->ARB_shader_viewport_layer_array; 1791 spirv_caps->stencil_export = extensions->ARB_shader_stencil_export; 1792 spirv_caps->storage_image_ms = extensions->ARB_shader_image_load_store && 1793 consts->MaxImageSamples > 1; 1794 spirv_caps->subgroup_ballot = extensions->ARB_shader_ballot; 1795 spirv_caps->subgroup_vote = extensions->ARB_shader_group_vote; 1796 spirv_caps->tessellation = extensions->ARB_tessellation_shader; 1797 spirv_caps->transform_feedback = extensions->ARB_transform_feedback3; 1798 spirv_caps->variable_pointers = 1799 screen->get_param(screen, PIPE_CAP_GL_SPIRV_VARIABLE_POINTERS); 1800 spirv_caps->integer_functions2 = extensions->INTEL_shader_integer_functions2; 1801 1802 consts->SpirVExtensions = CALLOC_STRUCT(spirv_supported_extensions); 1803 _mesa_fill_supported_spirv_extensions(consts->SpirVExtensions, spirv_caps); 1804 } 1805 1806 consts->AllowDrawOutOfOrder = 1807 api == API_OPENGL_COMPAT && 1808 options->allow_draw_out_of_order && 1809 screen->get_param(screen, PIPE_CAP_ALLOW_DRAW_OUT_OF_ORDER); 1810 consts->GLThreadNopCheckFramebufferStatus = options->glthread_nop_check_framebuffer_status; 1811 1812 bool prefer_nir = PIPE_SHADER_IR_NIR == 1813 screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_PREFERRED_IR); 1814 const struct nir_shader_compiler_options *nir_options = 1815 consts->ShaderCompilerOptions[MESA_SHADER_FRAGMENT].NirOptions; 1816 1817 if (prefer_nir && 1818 screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_INTEGERS) && 1819 extensions->ARB_stencil_texturing && 1820 screen->get_param(screen, PIPE_CAP_DOUBLES) && 1821 !(nir_options->lower_doubles_options & nir_lower_fp64_full_software)) 1822 extensions->NV_copy_depth_to_color = TRUE; 1823 1824 if (prefer_nir) 1825 extensions->ARB_point_sprite = GL_TRUE; 1826} 1827