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