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