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
_min(unsigned a, unsigned b)56 static unsigned _min(unsigned a, unsigned b)
57 {
58 return (a < b) ? a : b;
59 }
60
_maxf(float a, float b)61 static float _maxf(float a, float b)
62 {
63 return (a > b) ? a : b;
64 }
65
_clamp(int a, int min, int max)66 static 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 */
st_init_limits(struct pipe_screen *screen, struct gl_constants *c, struct gl_extensions *extensions)81 void 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
643 struct st_extension_cap_mapping {
644 int extension_offset;
645 int cap;
646 };
647
648 struct 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 */
664 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)665 init_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 */
705 static unsigned
get_max_samples_for_formats(struct pipe_screen *screen, unsigned num_formats, const enum pipe_format *formats, unsigned max_samples, unsigned bind)706 get_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
725 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)726 get_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 */
st_init_extensions(struct pipe_screen *screen, struct gl_constants *consts, struct gl_extensions *extensions, struct st_config_options *options, gl_api api)753 void 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