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