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