projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
st/mesa: add atomic counter support
[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 "main/imports.h"
30 #include "main/context.h"
31 #include "main/macros.h"
32 #include "main/version.h"
33
34 #include "pipe/p_context.h"
35 #include "pipe/p_defines.h"
36 #include "pipe/p_screen.h"
37 #include "util/u_math.h"
38
39 #include "st_context.h"
40 #include "st_debug.h"
41 #include "st_extensions.h"
42 #include "st_format.h"
43
44
45 /*
46 * Note: we use these function rather than the MIN2, MAX2, CLAMP macros to
47 * avoid evaluating arguments (which are often function calls) more than once.
48 */
49
50 static unsigned _min(unsigned a, unsigned b)
51 {
52 return (a < b) ? a : b;
53 }
54
55 static float _maxf(float a, float b)
56 {
57 return (a > b) ? a : b;
58 }
59
60 static int _clamp(int a, int min, int max)
61 {
62 if (a < min)
63 return min;
64 else if (a > max)
65 return max;
66 else
67 return a;
68 }
69
70
71 /**
72 * Query driver to get implementation limits.
73 * Note that we have to limit/clamp against Mesa's internal limits too.
74 */
75 void st_init_limits(struct pipe_screen *screen,
76 struct gl_constants *c, struct gl_extensions *extensions)
77 {
78 unsigned sh;
79 boolean can_ubo = TRUE;
80
81 c->MaxTextureLevels
82 = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS),
83 MAX_TEXTURE_LEVELS);
84
85 c->Max3DTextureLevels
86 = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_3D_LEVELS),
87 MAX_3D_TEXTURE_LEVELS);
88
89 c->MaxCubeTextureLevels
90 = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS),
91 MAX_CUBE_TEXTURE_LEVELS);
92
93 c->MaxTextureRectSize
94 = _min(1 << (c->MaxTextureLevels - 1), MAX_TEXTURE_RECT_SIZE);
95
96 c->MaxArrayTextureLayers
97 = screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS);
98
99 /* Define max viewport size and max renderbuffer size in terms of
100 * max texture size (note: max tex RECT size = max tex 2D size).
101 * If this isn't true for some hardware we'll need new PIPE_CAP_ queries.
102 */
103 c->MaxViewportWidth =
104 c->MaxViewportHeight =
105 c->MaxRenderbufferSize = c->MaxTextureRectSize;
106
107 c->MaxDrawBuffers = c->MaxColorAttachments =
108 _clamp(screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS),
109 1, MAX_DRAW_BUFFERS);
110
111 c->MaxDualSourceDrawBuffers
112 = _clamp(screen->get_param(screen, PIPE_CAP_MAX_DUAL_SOURCE_RENDER_TARGETS),
113 0, MAX_DRAW_BUFFERS);
114
115 c->MaxLineWidth
116 = _maxf(1.0f, screen->get_paramf(screen,
117 PIPE_CAPF_MAX_LINE_WIDTH));
118 c->MaxLineWidthAA
119 = _maxf(1.0f, screen->get_paramf(screen,
120 PIPE_CAPF_MAX_LINE_WIDTH_AA));
121
122 c->MaxPointSize
123 = _maxf(1.0f, screen->get_paramf(screen,
124 PIPE_CAPF_MAX_POINT_WIDTH));
125 c->MaxPointSizeAA
126 = _maxf(1.0f, screen->get_paramf(screen,
127 PIPE_CAPF_MAX_POINT_WIDTH_AA));
128
129 /* these are not queryable. Note that GL basically mandates a 1.0 minimum
130 * for non-aa sizes, but we can go down to 0.0 for aa points.
131 */
132 c->MinPointSize = 1.0f;
133 c->MinPointSizeAA = 0.0f;
134
135 c->MaxTextureMaxAnisotropy
136 = _maxf(2.0f, screen->get_paramf(screen,
137 PIPE_CAPF_MAX_TEXTURE_ANISOTROPY));
138
139 c->MaxTextureLodBias
140 = screen->get_paramf(screen, PIPE_CAPF_MAX_TEXTURE_LOD_BIAS);
141
142 c->QuadsFollowProvokingVertexConvention = screen->get_param(
143 screen, PIPE_CAP_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION);
144
145 c->MaxUniformBlockSize =
146 screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
147 PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE);
148 if (c->MaxUniformBlockSize < 16384) {
149 can_ubo = FALSE;
150 }
151
152 for (sh = 0; sh < PIPE_SHADER_TYPES; ++sh) {
153 struct gl_shader_compiler_options *options;
154 struct gl_program_constants *pc;
155
156 switch (sh) {
157 case PIPE_SHADER_FRAGMENT:
158 pc = &c->Program[MESA_SHADER_FRAGMENT];
159 options = &c->ShaderCompilerOptions[MESA_SHADER_FRAGMENT];
160 break;
161 case PIPE_SHADER_VERTEX:
162 pc = &c->Program[MESA_SHADER_VERTEX];
163 options = &c->ShaderCompilerOptions[MESA_SHADER_VERTEX];
164 break;
165 case PIPE_SHADER_GEOMETRY:
166 pc = &c->Program[MESA_SHADER_GEOMETRY];
167 options = &c->ShaderCompilerOptions[MESA_SHADER_GEOMETRY];
168 break;
169 case PIPE_SHADER_TESS_CTRL:
170 pc = &c->Program[MESA_SHADER_TESS_CTRL];
171 options = &c->ShaderCompilerOptions[MESA_SHADER_TESS_CTRL];
172 break;
173 case PIPE_SHADER_TESS_EVAL:
174 pc = &c->Program[MESA_SHADER_TESS_EVAL];
175 options = &c->ShaderCompilerOptions[MESA_SHADER_TESS_EVAL];
176 break;
177 default:
178 /* compute shader, etc. */
179 continue;
180 }
181
182 pc->MaxTextureImageUnits =
183 _min(screen->get_shader_param(screen, sh,
184 PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS),
185 MAX_TEXTURE_IMAGE_UNITS);
186
187 pc->MaxInstructions = pc->MaxNativeInstructions =
188 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INSTRUCTIONS);
189 pc->MaxAluInstructions = pc->MaxNativeAluInstructions =
190 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS);
191 pc->MaxTexInstructions = pc->MaxNativeTexInstructions =
192 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS);
193 pc->MaxTexIndirections = pc->MaxNativeTexIndirections =
194 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS);
195 pc->MaxAttribs = pc->MaxNativeAttribs =
196 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INPUTS);
197 pc->MaxTemps = pc->MaxNativeTemps =
198 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_TEMPS);
199 pc->MaxAddressRegs = pc->MaxNativeAddressRegs =
200 sh == PIPE_SHADER_VERTEX ? 1 : 0;
201 pc->MaxParameters = pc->MaxNativeParameters =
202 screen->get_shader_param(screen, sh,
203 PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE) / sizeof(float[4]);
204 pc->MaxInputComponents =
205 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INPUTS) * 4;
206 pc->MaxOutputComponents =
207 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_OUTPUTS) * 4;
208
209 pc->MaxUniformComponents = 4 * MIN2(pc->MaxNativeParameters, MAX_UNIFORMS);
210
211 pc->MaxUniformBlocks =
212 screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_CONST_BUFFERS);
213 if (pc->MaxUniformBlocks)
214 pc->MaxUniformBlocks -= 1; /* The first one is for ordinary uniforms. */
215 pc->MaxUniformBlocks = _min(pc->MaxUniformBlocks, MAX_UNIFORM_BUFFERS);
216
217 pc->MaxCombinedUniformComponents = (pc->MaxUniformComponents +
218 c->MaxUniformBlockSize / 4 *
219 pc->MaxUniformBlocks);
220
221 pc->MaxAtomicCounters = MAX_ATOMIC_COUNTERS;
222 pc->MaxAtomicBuffers = screen->get_shader_param(
223 screen, sh, PIPE_SHADER_CAP_MAX_SHADER_BUFFERS);
224
225 /* Gallium doesn't really care about local vs. env parameters so use the
226 * same limits.
227 */
228 pc->MaxLocalParams = MIN2(pc->MaxParameters, MAX_PROGRAM_LOCAL_PARAMS);
229 pc->MaxEnvParams = MIN2(pc->MaxParameters, MAX_PROGRAM_ENV_PARAMS);
230
231 options->EmitNoNoise = TRUE;
232
233 /* TODO: make these more fine-grained if anyone needs it */
234 options->MaxIfDepth = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH);
235 options->EmitNoLoops = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH);
236 options->EmitNoFunctions = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_SUBROUTINES);
237 options->EmitNoMainReturn = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_SUBROUTINES);
238
239 options->EmitNoCont = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED);
240
241 options->EmitNoIndirectInput = !screen->get_shader_param(screen, sh,
242 PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR);
243 options->EmitNoIndirectOutput = !screen->get_shader_param(screen, sh,
244 PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR);
245 options->EmitNoIndirectTemp = !screen->get_shader_param(screen, sh,
246 PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR);
247 options->EmitNoIndirectUniform = !screen->get_shader_param(screen, sh,
248 PIPE_SHADER_CAP_INDIRECT_CONST_ADDR);
249
250 if (pc->MaxNativeInstructions &&
251 (options->EmitNoIndirectUniform || pc->MaxUniformBlocks < 12)) {
252 can_ubo = FALSE;
253 }
254
255 if (options->EmitNoLoops)
256 options->MaxUnrollIterations = MIN2(screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INSTRUCTIONS), 65536);
257 else
258 options->MaxUnrollIterations = screen->get_shader_param(screen, sh,
259 PIPE_SHADER_CAP_MAX_UNROLL_ITERATIONS_HINT);
260
261 options->LowerClipDistance = true;
262 options->LowerBufferInterfaceBlocks = true;
263 }
264
265 c->LowerTessLevel = true;
266
267 c->MaxCombinedTextureImageUnits =
268 _min(c->Program[MESA_SHADER_VERTEX].MaxTextureImageUnits +
269 c->Program[MESA_SHADER_TESS_CTRL].MaxTextureImageUnits +
270 c->Program[MESA_SHADER_TESS_EVAL].MaxTextureImageUnits +
271 c->Program[MESA_SHADER_GEOMETRY].MaxTextureImageUnits +
272 c->Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits,
273 MAX_COMBINED_TEXTURE_IMAGE_UNITS);
274
275 /* This depends on program constants. */
276 c->MaxTextureCoordUnits
277 = _min(c->Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits, MAX_TEXTURE_COORD_UNITS);
278
279 c->MaxTextureUnits = _min(c->Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits, c->MaxTextureCoordUnits);
280
281 c->Program[MESA_SHADER_VERTEX].MaxAttribs = MIN2(c->Program[MESA_SHADER_VERTEX].MaxAttribs, 16);
282
283 /* PIPE_SHADER_CAP_MAX_INPUTS for the FS specifies the maximum number
284 * of inputs. It's always 2 colors + N generic inputs. */
285 c->MaxVarying = screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
286 PIPE_SHADER_CAP_MAX_INPUTS);
287 c->MaxVarying = MIN2(c->MaxVarying, MAX_VARYING);
288 c->MaxGeometryOutputVertices = screen->get_param(screen, PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES);
289 c->MaxGeometryTotalOutputComponents = screen->get_param(screen, PIPE_CAP_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS);
290 c->MaxTessPatchComponents =
291 MAX2(screen->get_param(screen, PIPE_CAP_MAX_SHADER_PATCH_VARYINGS),
292 MAX_VARYING) * 4;
293
294 c->MinProgramTexelOffset = screen->get_param(screen, PIPE_CAP_MIN_TEXEL_OFFSET);
295 c->MaxProgramTexelOffset = screen->get_param(screen, PIPE_CAP_MAX_TEXEL_OFFSET);
296
297 c->MaxProgramTextureGatherComponents = screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_GATHER_COMPONENTS);
298 c->MinProgramTextureGatherOffset = screen->get_param(screen, PIPE_CAP_MIN_TEXTURE_GATHER_OFFSET);
299 c->MaxProgramTextureGatherOffset = screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_GATHER_OFFSET);
300
301 c->MaxTransformFeedbackBuffers =
302 screen->get_param(screen, PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS);
303 c->MaxTransformFeedbackBuffers = MIN2(c->MaxTransformFeedbackBuffers, MAX_FEEDBACK_BUFFERS);
304 c->MaxTransformFeedbackSeparateComponents =
305 screen->get_param(screen, PIPE_CAP_MAX_STREAM_OUTPUT_SEPARATE_COMPONENTS);
306 c->MaxTransformFeedbackInterleavedComponents =
307 screen->get_param(screen, PIPE_CAP_MAX_STREAM_OUTPUT_INTERLEAVED_COMPONENTS);
308 c->MaxVertexStreams =
309 MAX2(1, screen->get_param(screen, PIPE_CAP_MAX_VERTEX_STREAMS));
310
311 /* The vertex stream must fit into pipe_stream_output_info::stream */
312 assert(c->MaxVertexStreams <= 4);
313
314 c->MaxVertexAttribStride
315 = screen->get_param(screen, PIPE_CAP_MAX_VERTEX_ATTRIB_STRIDE);
316
317 c->StripTextureBorder = GL_TRUE;
318
319 c->GLSLSkipStrictMaxUniformLimitCheck =
320 screen->get_param(screen, PIPE_CAP_TGSI_CAN_COMPACT_CONSTANTS);
321
322 c->UniformBufferOffsetAlignment =
323 screen->get_param(screen, PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT);
324
325 if (can_ubo) {
326 extensions->ARB_uniform_buffer_object = GL_TRUE;
327 c->MaxCombinedUniformBlocks = c->MaxUniformBufferBindings =
328 c->Program[MESA_SHADER_VERTEX].MaxUniformBlocks +
329 c->Program[MESA_SHADER_TESS_CTRL].MaxUniformBlocks +
330 c->Program[MESA_SHADER_TESS_EVAL].MaxUniformBlocks +
331 c->Program[MESA_SHADER_GEOMETRY].MaxUniformBlocks +
332 c->Program[MESA_SHADER_FRAGMENT].MaxUniformBlocks;
333 assert(c->MaxCombinedUniformBlocks <= MAX_COMBINED_UNIFORM_BUFFERS);
334 }
335
336 c->GLSLFragCoordIsSysVal =
337 screen->get_param(screen, PIPE_CAP_TGSI_FS_POSITION_IS_SYSVAL);
338 c->GLSLFrontFacingIsSysVal =
339 screen->get_param(screen, PIPE_CAP_TGSI_FS_FACE_IS_INTEGER_SYSVAL);
340
341 c->MaxAtomicBufferBindings =
342 c->Program[MESA_SHADER_FRAGMENT].MaxAtomicBuffers;
343 c->MaxCombinedAtomicBuffers =
344 c->Program[MESA_SHADER_VERTEX].MaxAtomicBuffers +
345 c->Program[MESA_SHADER_TESS_CTRL].MaxAtomicBuffers +
346 c->Program[MESA_SHADER_TESS_EVAL].MaxAtomicBuffers +
347 c->Program[MESA_SHADER_GEOMETRY].MaxAtomicBuffers +
348 c->Program[MESA_SHADER_FRAGMENT].MaxAtomicBuffers;
349 assert(c->MaxCombinedAtomicBuffers <= MAX_COMBINED_ATOMIC_BUFFERS);
350
351 if (c->MaxCombinedAtomicBuffers > 0)
352 extensions->ARB_shader_atomic_counters = GL_TRUE;
353 }
354
355
356 /**
357 * Given a member \c x of struct gl_extensions, return offset of
358 * \c x in bytes.
359 */
360 #define o(x) offsetof(struct gl_extensions, x)
361
362
363 struct st_extension_cap_mapping {
364 int extension_offset;
365 int cap;
366 };
367
368 struct st_extension_format_mapping {
369 int extension_offset[2];
370 enum pipe_format format[32];
371
372 /* If TRUE, at least one format must be supported for the extensions to be
373 * advertised. If FALSE, all the formats must be supported. */
374 GLboolean need_at_least_one;
375 };
376
377 /**
378 * Enable extensions if certain pipe formats are supported by the driver.
379 * What extensions will be enabled and what formats must be supported is
380 * described by the array of st_extension_format_mapping.
381 *
382 * target and bind_flags are passed to is_format_supported.
383 */
384 static void
385 init_format_extensions(struct pipe_screen *screen,
386 struct gl_extensions *extensions,
387 const struct st_extension_format_mapping *mapping,
388 unsigned num_mappings,
389 enum pipe_texture_target target,
390 unsigned bind_flags)
391 {
392 GLboolean *extension_table = (GLboolean *) extensions;
393 unsigned i;
394 int j;
395 int num_formats = ARRAY_SIZE(mapping->format);
396 int num_ext = ARRAY_SIZE(mapping->extension_offset);
397
398 for (i = 0; i < num_mappings; i++) {
399 int num_supported = 0;
400
401 /* Examine each format in the list. */
402 for (j = 0; j < num_formats && mapping[i].format[j]; j++) {
403 if (screen->is_format_supported(screen, mapping[i].format[j],
404 target, 0, bind_flags)) {
405 num_supported++;
406 }
407 }
408
409 if (!num_supported ||
410 (!mapping[i].need_at_least_one && num_supported != j)) {
411 continue;
412 }
413
414 /* Enable all extensions in the list. */
415 for (j = 0; j < num_ext && mapping[i].extension_offset[j]; j++)
416 extension_table[mapping[i].extension_offset[j]] = GL_TRUE;
417 }
418 }
419
420
421 /**
422 * Given a list of formats and bind flags, return the maximum number
423 * of samples supported by any of those formats.
424 */
425 static unsigned
426 get_max_samples_for_formats(struct pipe_screen *screen,
427 unsigned num_formats,
428 enum pipe_format *formats,
429 unsigned max_samples,
430 unsigned bind)
431 {
432 unsigned i, f;
433
434 for (i = max_samples; i > 0; --i) {
435 for (f = 0; f < num_formats; f++) {
436 if (screen->is_format_supported(screen, formats[f],
437 PIPE_TEXTURE_2D, i, bind)) {
438 return i;
439 }
440 }
441 }
442 return 0;
443 }
444
445
446 /**
447 * Use pipe_screen::get_param() to query PIPE_CAP_ values to determine
448 * which GL extensions are supported.
449 * Quite a few extensions are always supported because they are standard
450 * features or can be built on top of other gallium features.
451 * Some fine tuning may still be needed.
452 */
453 void st_init_extensions(struct pipe_screen *screen,
454 struct gl_constants *consts,
455 struct gl_extensions *extensions,
456 struct st_config_options *options,
457 boolean has_lib_dxtc)
458 {
459 unsigned i;
460 int glsl_feature_level;
461 GLboolean *extension_table = (GLboolean *) extensions;
462
463 static const struct st_extension_cap_mapping cap_mapping[] = {
464 { o(ARB_base_instance), PIPE_CAP_START_INSTANCE },
465 { o(ARB_buffer_storage), PIPE_CAP_BUFFER_MAP_PERSISTENT_COHERENT },
466 { o(ARB_clear_texture), PIPE_CAP_CLEAR_TEXTURE },
467 { o(ARB_clip_control), PIPE_CAP_CLIP_HALFZ },
468 { o(ARB_color_buffer_float), PIPE_CAP_VERTEX_COLOR_UNCLAMPED },
469 { o(ARB_conditional_render_inverted), PIPE_CAP_CONDITIONAL_RENDER_INVERTED },
470 { o(ARB_copy_image), PIPE_CAP_COPY_BETWEEN_COMPRESSED_AND_PLAIN_FORMATS },
471 { o(ARB_depth_clamp), PIPE_CAP_DEPTH_CLIP_DISABLE },
472 { o(ARB_depth_texture), PIPE_CAP_TEXTURE_SHADOW_MAP },
473 { o(ARB_derivative_control), PIPE_CAP_TGSI_FS_FINE_DERIVATIVE },
474 { o(ARB_draw_buffers_blend), PIPE_CAP_INDEP_BLEND_FUNC },
475 { o(ARB_draw_indirect), PIPE_CAP_DRAW_INDIRECT },
476 { o(ARB_draw_instanced), PIPE_CAP_TGSI_INSTANCEID },
477 { o(ARB_fragment_program_shadow), PIPE_CAP_TEXTURE_SHADOW_MAP },
478 { o(ARB_framebuffer_object), PIPE_CAP_MIXED_FRAMEBUFFER_SIZES },
479 { o(ARB_indirect_parameters), PIPE_CAP_MULTI_DRAW_INDIRECT_PARAMS },
480 { o(ARB_instanced_arrays), PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR },
481 { o(ARB_occlusion_query), PIPE_CAP_OCCLUSION_QUERY },
482 { o(ARB_occlusion_query2), PIPE_CAP_OCCLUSION_QUERY },
483 { o(ARB_pipeline_statistics_query), PIPE_CAP_QUERY_PIPELINE_STATISTICS },
484 { o(ARB_point_sprite), PIPE_CAP_POINT_SPRITE },
485 { o(ARB_sample_shading), PIPE_CAP_SAMPLE_SHADING },
486 { o(ARB_seamless_cube_map), PIPE_CAP_SEAMLESS_CUBE_MAP },
487 { o(ARB_shader_draw_parameters), PIPE_CAP_DRAW_PARAMETERS },
488 { o(ARB_shader_stencil_export), PIPE_CAP_SHADER_STENCIL_EXPORT },
489 { o(ARB_shader_texture_image_samples), PIPE_CAP_TGSI_TXQS },
490 { o(ARB_shader_texture_lod), PIPE_CAP_SM3 },
491 { o(ARB_shadow), PIPE_CAP_TEXTURE_SHADOW_MAP },
492 { o(ARB_texture_buffer_object), PIPE_CAP_TEXTURE_BUFFER_OBJECTS },
493 { o(ARB_texture_cube_map_array), PIPE_CAP_CUBE_MAP_ARRAY },
494 { o(ARB_texture_gather), PIPE_CAP_MAX_TEXTURE_GATHER_COMPONENTS },
495 { o(ARB_texture_mirror_clamp_to_edge), PIPE_CAP_TEXTURE_MIRROR_CLAMP },
496 { o(ARB_texture_multisample), PIPE_CAP_TEXTURE_MULTISAMPLE },
497 { o(ARB_texture_non_power_of_two), PIPE_CAP_NPOT_TEXTURES },
498 { o(ARB_texture_query_lod), PIPE_CAP_TEXTURE_QUERY_LOD },
499 { o(ARB_texture_view), PIPE_CAP_SAMPLER_VIEW_TARGET },
500 { o(ARB_timer_query), PIPE_CAP_QUERY_TIMESTAMP },
501 { o(ARB_transform_feedback2), PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME },
502 { o(ARB_transform_feedback3), PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME },
503
504 { o(EXT_blend_equation_separate), PIPE_CAP_BLEND_EQUATION_SEPARATE },
505 { o(EXT_depth_bounds_test), PIPE_CAP_DEPTH_BOUNDS_TEST },
506 { o(EXT_draw_buffers2), PIPE_CAP_INDEP_BLEND_ENABLE },
507 { o(EXT_polygon_offset_clamp), PIPE_CAP_POLYGON_OFFSET_CLAMP },
508 { o(EXT_stencil_two_side), PIPE_CAP_TWO_SIDED_STENCIL },
509 { o(EXT_texture_array), PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS },
510 { o(EXT_texture_filter_anisotropic), PIPE_CAP_ANISOTROPIC_FILTER },
511 { o(EXT_texture_mirror_clamp), PIPE_CAP_TEXTURE_MIRROR_CLAMP },
512 { o(EXT_texture_swizzle), PIPE_CAP_TEXTURE_SWIZZLE },
513 { o(EXT_transform_feedback), PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS },
514
515 { o(AMD_pinned_memory), PIPE_CAP_RESOURCE_FROM_USER_MEMORY },
516 { o(AMD_seamless_cubemap_per_texture), PIPE_CAP_SEAMLESS_CUBE_MAP_PER_TEXTURE },
517 { o(ATI_separate_stencil), PIPE_CAP_TWO_SIDED_STENCIL },
518 { o(ATI_texture_mirror_once), PIPE_CAP_TEXTURE_MIRROR_CLAMP },
519 { o(NV_conditional_render), PIPE_CAP_CONDITIONAL_RENDER },
520 { o(NV_primitive_restart), PIPE_CAP_PRIMITIVE_RESTART },
521 { o(NV_texture_barrier), PIPE_CAP_TEXTURE_BARRIER },
522 /* GL_NV_point_sprite is not supported by gallium because we don't
523 * support the GL_POINT_SPRITE_R_MODE_NV option. */
524
525 { o(OES_standard_derivatives), PIPE_CAP_SM3 },
526 { o(OES_texture_float_linear), PIPE_CAP_TEXTURE_FLOAT_LINEAR },
527 { o(OES_texture_half_float_linear), PIPE_CAP_TEXTURE_HALF_FLOAT_LINEAR },
528 };
529
530 /* Required: render target and sampler support */
531 static const struct st_extension_format_mapping rendertarget_mapping[] = {
532 { { o(ARB_texture_float) },
533 { PIPE_FORMAT_R32G32B32A32_FLOAT,
534 PIPE_FORMAT_R16G16B16A16_FLOAT } },
535
536 { { o(OES_texture_float) },
537 { PIPE_FORMAT_R32G32B32A32_FLOAT } },
538
539 { { o(OES_texture_half_float) },
540 { PIPE_FORMAT_R16G16B16A16_FLOAT } },
541
542 { { o(ARB_texture_rgb10_a2ui) },
543 { PIPE_FORMAT_R10G10B10A2_UINT,
544 PIPE_FORMAT_B10G10R10A2_UINT },
545 GL_TRUE }, /* at least one format must be supported */
546
547 { { o(EXT_framebuffer_sRGB) },
548 { PIPE_FORMAT_A8B8G8R8_SRGB,
549 PIPE_FORMAT_B8G8R8A8_SRGB },
550 GL_TRUE }, /* at least one format must be supported */
551
552 { { o(EXT_packed_float) },
553 { PIPE_FORMAT_R11G11B10_FLOAT } },
554
555 { { o(EXT_texture_integer) },
556 { PIPE_FORMAT_R32G32B32A32_UINT,
557 PIPE_FORMAT_R32G32B32A32_SINT } },
558
559 { { o(ARB_texture_rg) },
560 { PIPE_FORMAT_R8_UNORM,
561 PIPE_FORMAT_R8G8_UNORM } },
562 };
563
564 /* Required: depth stencil and sampler support */
565 static const struct st_extension_format_mapping depthstencil_mapping[] = {
566 { { o(ARB_depth_buffer_float) },
567 { PIPE_FORMAT_Z32_FLOAT,
568 PIPE_FORMAT_Z32_FLOAT_S8X24_UINT } },
569 };
570
571 /* Required: sampler support */
572 static const struct st_extension_format_mapping texture_mapping[] = {
573 { { o(ARB_texture_compression_rgtc) },
574 { PIPE_FORMAT_RGTC1_UNORM,
575 PIPE_FORMAT_RGTC1_SNORM,
576 PIPE_FORMAT_RGTC2_UNORM,
577 PIPE_FORMAT_RGTC2_SNORM } },
578
579 { { o(EXT_texture_compression_latc) },
580 { PIPE_FORMAT_LATC1_UNORM,
581 PIPE_FORMAT_LATC1_SNORM,
582 PIPE_FORMAT_LATC2_UNORM,
583 PIPE_FORMAT_LATC2_SNORM } },
584
585 { { o(EXT_texture_compression_s3tc),
586 o(ANGLE_texture_compression_dxt) },
587 { PIPE_FORMAT_DXT1_RGB,
588 PIPE_FORMAT_DXT1_RGBA,
589 PIPE_FORMAT_DXT3_RGBA,
590 PIPE_FORMAT_DXT5_RGBA } },
591
592 { { o(ARB_texture_compression_bptc) },
593 { PIPE_FORMAT_BPTC_RGBA_UNORM,
594 PIPE_FORMAT_BPTC_SRGBA,
595 PIPE_FORMAT_BPTC_RGB_FLOAT,
596 PIPE_FORMAT_BPTC_RGB_UFLOAT } },
597
598 { { o(KHR_texture_compression_astc_ldr) },
599 { PIPE_FORMAT_ASTC_4x4,
600 PIPE_FORMAT_ASTC_5x4,
601 PIPE_FORMAT_ASTC_5x5,
602 PIPE_FORMAT_ASTC_6x5,
603 PIPE_FORMAT_ASTC_6x6,
604 PIPE_FORMAT_ASTC_8x5,
605 PIPE_FORMAT_ASTC_8x6,
606 PIPE_FORMAT_ASTC_8x8,
607 PIPE_FORMAT_ASTC_10x5,
608 PIPE_FORMAT_ASTC_10x6,
609 PIPE_FORMAT_ASTC_10x8,
610 PIPE_FORMAT_ASTC_10x10,
611 PIPE_FORMAT_ASTC_12x10,
612 PIPE_FORMAT_ASTC_12x12,
613 PIPE_FORMAT_ASTC_4x4_SRGB,
614 PIPE_FORMAT_ASTC_5x4_SRGB,
615 PIPE_FORMAT_ASTC_5x5_SRGB,
616 PIPE_FORMAT_ASTC_6x5_SRGB,
617 PIPE_FORMAT_ASTC_6x6_SRGB,
618 PIPE_FORMAT_ASTC_8x5_SRGB,
619 PIPE_FORMAT_ASTC_8x6_SRGB,
620 PIPE_FORMAT_ASTC_8x8_SRGB,
621 PIPE_FORMAT_ASTC_10x5_SRGB,
622 PIPE_FORMAT_ASTC_10x6_SRGB,
623 PIPE_FORMAT_ASTC_10x8_SRGB,
624 PIPE_FORMAT_ASTC_10x10_SRGB,
625 PIPE_FORMAT_ASTC_12x10_SRGB,
626 PIPE_FORMAT_ASTC_12x12_SRGB } },
627
628 { { o(EXT_texture_shared_exponent) },
629 { PIPE_FORMAT_R9G9B9E5_FLOAT } },
630
631 { { o(EXT_texture_snorm) },
632 { PIPE_FORMAT_R8G8B8A8_SNORM } },
633
634 { { o(EXT_texture_sRGB),
635 o(EXT_texture_sRGB_decode) },
636 { PIPE_FORMAT_A8B8G8R8_SRGB,
637 PIPE_FORMAT_B8G8R8A8_SRGB },
638 GL_TRUE }, /* at least one format must be supported */
639
640 { { o(ATI_texture_compression_3dc) },
641 { PIPE_FORMAT_LATC2_UNORM } },
642
643 { { o(MESA_ycbcr_texture) },
644 { PIPE_FORMAT_UYVY,
645 PIPE_FORMAT_YUYV },
646 GL_TRUE }, /* at least one format must be supported */
647
648 { { o(OES_compressed_ETC1_RGB8_texture) },
649 { PIPE_FORMAT_ETC1_RGB8,
650 PIPE_FORMAT_R8G8B8A8_UNORM },
651 GL_TRUE }, /* at least one format must be supported */
652
653 { { o(ARB_stencil_texturing),
654 o(ARB_texture_stencil8) },
655 { PIPE_FORMAT_X24S8_UINT,
656 PIPE_FORMAT_S8X24_UINT },
657 GL_TRUE }, /* at least one format must be supported */
658 };
659
660 /* Required: vertex fetch support. */
661 static const struct st_extension_format_mapping vertex_mapping[] = {
662 { { o(ARB_vertex_type_2_10_10_10_rev) },
663 { PIPE_FORMAT_R10G10B10A2_UNORM,
664 PIPE_FORMAT_B10G10R10A2_UNORM,
665 PIPE_FORMAT_R10G10B10A2_SNORM,
666 PIPE_FORMAT_B10G10R10A2_SNORM,
667 PIPE_FORMAT_R10G10B10A2_USCALED,
668 PIPE_FORMAT_B10G10R10A2_USCALED,
669 PIPE_FORMAT_R10G10B10A2_SSCALED,
670 PIPE_FORMAT_B10G10R10A2_SSCALED } },
671 { { o(ARB_vertex_type_10f_11f_11f_rev) },
672 { PIPE_FORMAT_R11G11B10_FLOAT } },
673 };
674
675 static const struct st_extension_format_mapping tbo_rgb32[] = {
676 { {o(ARB_texture_buffer_object_rgb32) },
677 { PIPE_FORMAT_R32G32B32_FLOAT,
678 PIPE_FORMAT_R32G32B32_UINT,
679 PIPE_FORMAT_R32G32B32_SINT,
680 } },
681 };
682
683 /*
684 * Extensions that are supported by all Gallium drivers:
685 */
686 extensions->ARB_ES2_compatibility = GL_TRUE;
687 extensions->ARB_draw_elements_base_vertex = GL_TRUE;
688 extensions->ARB_explicit_attrib_location = GL_TRUE;
689 extensions->ARB_explicit_uniform_location = GL_TRUE;
690 extensions->ARB_fragment_coord_conventions = GL_TRUE;
691 extensions->ARB_fragment_program = GL_TRUE;
692 extensions->ARB_fragment_shader = GL_TRUE;
693 extensions->ARB_half_float_vertex = GL_TRUE;
694 extensions->ARB_internalformat_query = GL_TRUE;
695 extensions->ARB_map_buffer_range = GL_TRUE;
696 extensions->ARB_texture_border_clamp = GL_TRUE; /* XXX temp */
697 extensions->ARB_texture_cube_map = GL_TRUE;
698 extensions->ARB_texture_env_combine = GL_TRUE;
699 extensions->ARB_texture_env_crossbar = GL_TRUE;
700 extensions->ARB_texture_env_dot3 = GL_TRUE;
701 extensions->ARB_vertex_program = GL_TRUE;
702 extensions->ARB_vertex_shader = GL_TRUE;
703
704 extensions->EXT_blend_color = GL_TRUE;
705 extensions->EXT_blend_func_separate = GL_TRUE;
706 extensions->EXT_blend_minmax = GL_TRUE;
707 extensions->EXT_gpu_program_parameters = GL_TRUE;
708 extensions->EXT_pixel_buffer_object = GL_TRUE;
709 extensions->EXT_point_parameters = GL_TRUE;
710 extensions->EXT_provoking_vertex = GL_TRUE;
711
712 extensions->EXT_texture_env_dot3 = GL_TRUE;
713 extensions->EXT_vertex_array_bgra = GL_TRUE;
714
715 extensions->ATI_texture_env_combine3 = GL_TRUE;
716
717 extensions->MESA_pack_invert = GL_TRUE;
718
719 extensions->NV_fog_distance = GL_TRUE;
720 extensions->NV_texture_env_combine4 = GL_TRUE;
721 extensions->NV_texture_rectangle = GL_TRUE;
722
723 extensions->OES_EGL_image = GL_TRUE;
724 extensions->OES_EGL_image_external = GL_TRUE;
725 extensions->OES_draw_texture = GL_TRUE;
726
727 /* Expose the extensions which directly correspond to gallium caps. */
728 for (i = 0; i < ARRAY_SIZE(cap_mapping); i++) {
729 if (screen->get_param(screen, cap_mapping[i].cap)) {
730 extension_table[cap_mapping[i].extension_offset] = GL_TRUE;
731 }
732 }
733
734 /* Expose the extensions which directly correspond to gallium formats. */
735 init_format_extensions(screen, extensions, rendertarget_mapping,
736 ARRAY_SIZE(rendertarget_mapping), PIPE_TEXTURE_2D,
737 PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW);
738 init_format_extensions(screen, extensions, depthstencil_mapping,
739 ARRAY_SIZE(depthstencil_mapping), PIPE_TEXTURE_2D,
740 PIPE_BIND_DEPTH_STENCIL | PIPE_BIND_SAMPLER_VIEW);
741 init_format_extensions(screen, extensions, texture_mapping,
742 ARRAY_SIZE(texture_mapping), PIPE_TEXTURE_2D,
743 PIPE_BIND_SAMPLER_VIEW);
744 init_format_extensions(screen, extensions, vertex_mapping,
745 ARRAY_SIZE(vertex_mapping), PIPE_BUFFER,
746 PIPE_BIND_VERTEX_BUFFER);
747
748 /* Figure out GLSL support. */
749 glsl_feature_level = screen->get_param(screen, PIPE_CAP_GLSL_FEATURE_LEVEL);
750
751 consts->GLSLVersion = glsl_feature_level;
752 if (glsl_feature_level >= 410)
753 consts->GLSLVersion = 410;
754
755 _mesa_override_glsl_version(consts);
756
757 if (options->force_glsl_version > 0 &&
758 options->force_glsl_version <= consts->GLSLVersion) {
759 consts->ForceGLSLVersion = options->force_glsl_version;
760 }
761
762 if (glsl_feature_level >= 400)
763 extensions->ARB_gpu_shader5 = GL_TRUE;
764 if (glsl_feature_level >= 410)
765 extensions->ARB_shader_precision = GL_TRUE;
766
767 /* This extension needs full OpenGL 3.2, but we don't know if that's
768 * supported at this point. Only check the GLSL version. */
769 if (consts->GLSLVersion >= 150 &&
770 screen->get_param(screen, PIPE_CAP_TGSI_VS_LAYER_VIEWPORT)) {
771 extensions->AMD_vertex_shader_layer = GL_TRUE;
772 }
773
774 if (consts->GLSLVersion >= 130) {
775 consts->NativeIntegers = GL_TRUE;
776 consts->MaxClipPlanes = 8;
777
778 if (screen->get_param(screen, PIPE_CAP_VERTEXID_NOBASE)) {
779 consts->VertexID_is_zero_based = GL_TRUE;
780 }
781
782 /* Extensions that either depend on GLSL 1.30 or are a subset thereof. */
783 extensions->ARB_conservative_depth = GL_TRUE;
784 extensions->ARB_shading_language_packing = GL_TRUE;
785 extensions->OES_depth_texture_cube_map = GL_TRUE;
786 extensions->ARB_shading_language_420pack = GL_TRUE;
787 extensions->ARB_texture_query_levels = GL_TRUE;
788 extensions->ARB_shader_subroutine = GL_TRUE;
789
790 if (!options->disable_shader_bit_encoding) {
791 extensions->ARB_shader_bit_encoding = GL_TRUE;
792 }
793
794 extensions->EXT_shader_integer_mix = GL_TRUE;
795 } else {
796 /* Optional integer support for GLSL 1.2. */
797 if (screen->get_shader_param(screen, PIPE_SHADER_VERTEX,
798 PIPE_SHADER_CAP_INTEGERS) &&
799 screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
800 PIPE_SHADER_CAP_INTEGERS)) {
801 consts->NativeIntegers = GL_TRUE;
802
803 extensions->EXT_shader_integer_mix = GL_TRUE;
804 }
805
806 /* Integer textures make no sense before GLSL 1.30 */
807 extensions->EXT_texture_integer = GL_FALSE;
808 }
809
810 consts->UniformBooleanTrue = consts->NativeIntegers ? ~0U : fui(1.0f);
811
812 /* Below are the cases which cannot be moved into tables easily. */
813
814 if (!has_lib_dxtc && !options->force_s3tc_enable) {
815 extensions->EXT_texture_compression_s3tc = GL_FALSE;
816 extensions->ANGLE_texture_compression_dxt = GL_FALSE;
817 }
818
819 if (screen->get_shader_param(screen, PIPE_SHADER_TESS_CTRL,
820 PIPE_SHADER_CAP_MAX_INSTRUCTIONS) > 0) {
821 extensions->ARB_tessellation_shader = GL_TRUE;
822 }
823
824 if (screen->fence_finish) {
825 extensions->ARB_sync = GL_TRUE;
826 }
827
828 /* Maximum sample count. */
829 {
830 enum pipe_format color_formats[] = {
831 PIPE_FORMAT_R8G8B8A8_UNORM,
832 PIPE_FORMAT_B8G8R8A8_UNORM,
833 PIPE_FORMAT_A8R8G8B8_UNORM,
834 PIPE_FORMAT_A8B8G8R8_UNORM,
835 };
836 enum pipe_format depth_formats[] = {
837 PIPE_FORMAT_Z16_UNORM,
838 PIPE_FORMAT_Z24X8_UNORM,
839 PIPE_FORMAT_X8Z24_UNORM,
840 PIPE_FORMAT_Z32_UNORM,
841 PIPE_FORMAT_Z32_FLOAT
842 };
843 enum pipe_format int_formats[] = {
844 PIPE_FORMAT_R8G8B8A8_SINT
845 };
846
847 consts->MaxSamples =
848 get_max_samples_for_formats(screen, ARRAY_SIZE(color_formats),
849 color_formats, 16,
850 PIPE_BIND_RENDER_TARGET);
851
852 consts->MaxColorTextureSamples =
853 get_max_samples_for_formats(screen, ARRAY_SIZE(color_formats),
854 color_formats, consts->MaxSamples,
855 PIPE_BIND_SAMPLER_VIEW);
856
857 consts->MaxDepthTextureSamples =
858 get_max_samples_for_formats(screen, ARRAY_SIZE(depth_formats),
859 depth_formats, consts->MaxSamples,
860 PIPE_BIND_SAMPLER_VIEW);
861
862 consts->MaxIntegerSamples =
863 get_max_samples_for_formats(screen, ARRAY_SIZE(int_formats),
864 int_formats, consts->MaxSamples,
865 PIPE_BIND_SAMPLER_VIEW);
866 }
867 if (consts->MaxSamples == 1) {
868 /* one sample doesn't really make sense */
869 consts->MaxSamples = 0;
870 }
871 else if (consts->MaxSamples >= 2) {
872 extensions->EXT_framebuffer_multisample = GL_TRUE;
873 extensions->EXT_framebuffer_multisample_blit_scaled = GL_TRUE;
874 }
875
876 if (consts->MaxSamples == 0 && screen->get_param(screen, PIPE_CAP_FAKE_SW_MSAA)) {
877 consts->FakeSWMSAA = GL_TRUE;
878 extensions->EXT_framebuffer_multisample = GL_TRUE;
879 extensions->EXT_framebuffer_multisample_blit_scaled = GL_TRUE;
880 extensions->ARB_texture_multisample = GL_TRUE;
881 }
882
883 if (consts->MaxDualSourceDrawBuffers > 0 &&
884 !options->disable_blend_func_extended)
885 extensions->ARB_blend_func_extended = GL_TRUE;
886
887 if (screen->get_param(screen, PIPE_CAP_QUERY_TIME_ELAPSED) ||
888 extensions->ARB_timer_query) {
889 extensions->EXT_timer_query = GL_TRUE;
890 }
891
892 if (extensions->ARB_transform_feedback2 &&
893 extensions->ARB_draw_instanced) {
894 extensions->ARB_transform_feedback_instanced = GL_TRUE;
895 }
896 if (options->force_glsl_extensions_warn)
897 consts->ForceGLSLExtensionsWarn = 1;
898
899 if (options->disable_glsl_line_continuations)
900 consts->DisableGLSLLineContinuations = 1;
901
902 if (options->allow_glsl_extension_directive_midshader)
903 consts->AllowGLSLExtensionDirectiveMidShader = GL_TRUE;
904
905 consts->MinMapBufferAlignment =
906 screen->get_param(screen, PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT);
907
908 if (extensions->ARB_texture_buffer_object) {
909 consts->MaxTextureBufferSize =
910 _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_BUFFER_SIZE),
911 (1u << 31) - 1);
912 consts->TextureBufferOffsetAlignment =
913 screen->get_param(screen, PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT);
914
915 if (consts->TextureBufferOffsetAlignment)
916 extensions->ARB_texture_buffer_range = GL_TRUE;
917
918 init_format_extensions(screen, extensions, tbo_rgb32,
919 ARRAY_SIZE(tbo_rgb32), PIPE_BUFFER,
920 PIPE_BIND_SAMPLER_VIEW);
921 }
922
923 /* Unpacking a varying in the fragment shader costs 1 texture indirection.
924 * If the number of available texture indirections is very limited, then we
925 * prefer to disable varying packing rather than run the risk of varying
926 * packing preventing a shader from running.
927 */
928 if (screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
929 PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS) <= 8) {
930 /* We can't disable varying packing if transform feedback is available,
931 * because transform feedback code assumes a packed varying layout.
932 */
933 if (!extensions->EXT_transform_feedback)
934 consts->DisableVaryingPacking = GL_TRUE;
935 }
936
937 consts->MaxViewports = screen->get_param(screen, PIPE_CAP_MAX_VIEWPORTS);
938 if (consts->MaxViewports >= 16) {
939 if (glsl_feature_level >= 400) {
940 consts->ViewportBounds.Min = -32768.0;
941 consts->ViewportBounds.Max = 32767.0;
942 } else {
943 consts->ViewportBounds.Min = -16384.0;
944 consts->ViewportBounds.Max = 16383.0;
945 }
946 extensions->ARB_viewport_array = GL_TRUE;
947 extensions->ARB_fragment_layer_viewport = GL_TRUE;
948 if (extensions->AMD_vertex_shader_layer)
949 extensions->AMD_vertex_shader_viewport_index = GL_TRUE;
950 }
951
952 /* GL_ARB_ES3_compatibility.
953 *
954 * Assume that ES3 is supported if GLSL 3.30 is supported.
955 * (OpenGL 3.3 is a requirement for that extension.)
956 */
957 if (consts->GLSLVersion >= 330 &&
958 /* Requirements for ETC2 emulation. */
959 screen->is_format_supported(screen, PIPE_FORMAT_R8G8B8A8_UNORM,
960 PIPE_TEXTURE_2D, 0,
961 PIPE_BIND_SAMPLER_VIEW) &&
962 screen->is_format_supported(screen, PIPE_FORMAT_B8G8R8A8_SRGB,
963 PIPE_TEXTURE_2D, 0,
964 PIPE_BIND_SAMPLER_VIEW) &&
965 screen->is_format_supported(screen, PIPE_FORMAT_R16_UNORM,
966 PIPE_TEXTURE_2D, 0,
967 PIPE_BIND_SAMPLER_VIEW) &&
968 screen->is_format_supported(screen, PIPE_FORMAT_R16G16_UNORM,
969 PIPE_TEXTURE_2D, 0,
970 PIPE_BIND_SAMPLER_VIEW) &&
971 screen->is_format_supported(screen, PIPE_FORMAT_R16_SNORM,
972 PIPE_TEXTURE_2D, 0,
973 PIPE_BIND_SAMPLER_VIEW) &&
974 screen->is_format_supported(screen, PIPE_FORMAT_R16G16_SNORM,
975 PIPE_TEXTURE_2D, 0,
976 PIPE_BIND_SAMPLER_VIEW)) {
977 extensions->ARB_ES3_compatibility = GL_TRUE;
978 }
979
980 if (screen->get_video_param &&
981 screen->get_video_param(screen, PIPE_VIDEO_PROFILE_UNKNOWN,
982 PIPE_VIDEO_ENTRYPOINT_BITSTREAM,
983 PIPE_VIDEO_CAP_SUPPORTS_INTERLACED)) {
984 extensions->NV_vdpau_interop = GL_TRUE;
985 }
986
987 if (screen->get_shader_param(screen, PIPE_SHADER_VERTEX,
988 PIPE_SHADER_CAP_DOUBLES) &&
989 screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
990 PIPE_SHADER_CAP_DOUBLES)) {
991 extensions->ARB_gpu_shader_fp64 = GL_TRUE;
992 extensions->ARB_vertex_attrib_64bit = GL_TRUE;
993 }
994
995 if ((ST_DEBUG & DEBUG_GREMEDY) &&
996 screen->get_param(screen, PIPE_CAP_STRING_MARKER))
997 extensions->GREMEDY_string_marker = GL_TRUE;
998 }