st_extensions.c 28.4 KB
Newer Older
1 2 3
/**************************************************************************
 * 
 * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
4
 * Copyright (c) 2008 VMware, Inc.
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
 * All Rights Reserved.
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sub license, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 * 
 * The above copyright notice and this permission notice (including the
 * next paragraph) shall be included in all copies or substantial portions
 * of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 * 
 **************************************************************************/

#include "main/imports.h"
#include "main/context.h"
#include "main/macros.h"
32
#include "main/mfeatures.h"
33
#include "main/version.h"
34 35 36

#include "pipe/p_context.h"
#include "pipe/p_defines.h"
37
#include "pipe/p_screen.h"
38 39 40 41 42

#include "st_context.h"
#include "st_extensions.h"


43
static int _min(int a, int b)
44 45 46 47
{
   return (a < b) ? a : b;
}

48
static float _maxf(float a, float b)
49 50 51 52
{
   return (a > b) ? a : b;
}

53
static int _clamp(int a, int min, int max)
54
{
55 56 57 58 59 60
   if (a < min)
      return min;
   else if (a > max)
      return max;
   else
      return a;
61 62 63
}


64 65 66 67
/**
 * Query driver to get implementation limits.
 * Note that we have to limit/clamp against Mesa's internal limits too.
 */
68 69
void st_init_limits(struct st_context *st)
{
70
   struct pipe_screen *screen = st->pipe->screen;
71
   struct gl_constants *c = &st->ctx->Const;
72
   gl_shader_type sh;
73 74

   c->MaxTextureLevels
75
      = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS),
76
            MAX_TEXTURE_LEVELS);
77

78
   c->Max3DTextureLevels
79
      = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_3D_LEVELS),
80
            MAX_3D_TEXTURE_LEVELS);
81

82
   c->MaxCubeTextureLevels
83
      = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS),
84
            MAX_CUBE_TEXTURE_LEVELS);
85

86
   c->MaxTextureRectSize
87
      = _min(1 << (c->MaxTextureLevels - 1), MAX_TEXTURE_RECT_SIZE);
88

89 90 91
   c->MaxArrayTextureLayers
      = screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS);

92
   c->MaxTextureImageUnits
93 94
      = _min(screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
                                      PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS),
95
            MAX_TEXTURE_IMAGE_UNITS);
96

97
   c->MaxVertexTextureImageUnits
98 99
      = _min(screen->get_shader_param(screen, PIPE_SHADER_VERTEX,
                                      PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS),
100
             MAX_VERTEX_TEXTURE_IMAGE_UNITS);
101

102 103 104 105
   c->MaxCombinedTextureImageUnits
      = _min(screen->get_param(screen, PIPE_CAP_MAX_COMBINED_SAMPLERS),
             MAX_COMBINED_TEXTURE_IMAGE_UNITS);

106 107
   c->MaxTextureCoordUnits
      = _min(c->MaxTextureImageUnits, MAX_TEXTURE_COORD_UNITS);
108

109
   c->MaxTextureUnits = _min(c->MaxTextureImageUnits, c->MaxTextureCoordUnits);
110

111
   c->MaxDrawBuffers
112
      = _clamp(screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS),
113
              1, MAX_DRAW_BUFFERS);
114 115

   c->MaxLineWidth
116 117
      = _maxf(1.0f, screen->get_paramf(screen,
                                       PIPE_CAPF_MAX_LINE_WIDTH));
118
   c->MaxLineWidthAA
119 120
      = _maxf(1.0f, screen->get_paramf(screen,
                                       PIPE_CAPF_MAX_LINE_WIDTH_AA));
121 122

   c->MaxPointSize
123 124
      = _maxf(1.0f, screen->get_paramf(screen,
                                       PIPE_CAPF_MAX_POINT_WIDTH));
125
   c->MaxPointSizeAA
126 127
      = _maxf(1.0f, screen->get_paramf(screen,
                                       PIPE_CAPF_MAX_POINT_WIDTH_AA));
128 129 130 131
   /* called after _mesa_create_context/_mesa_init_point, fix default user
    * settable max point size up
    */
   st->ctx->Point.MaxSize = MAX2(c->MaxPointSize, c->MaxPointSizeAA);
132 133 134 135 136
   /* these are not queryable. Note that GL basically mandates a 1.0 minimum
    * for non-aa sizes, but we can go down to 0.0 for aa points.
    */
   c->MinPointSize = 1.0f;
   c->MinPointSizeAA = 0.0f;
137 138

   c->MaxTextureMaxAnisotropy
139 140
      = _maxf(2.0f, screen->get_paramf(screen,
                                 PIPE_CAPF_MAX_TEXTURE_ANISOTROPY));
141 142

   c->MaxTextureLodBias
143
      = screen->get_paramf(screen, PIPE_CAPF_MAX_TEXTURE_LOD_BIAS);
144

Brian's avatar
Brian committed
145 146 147
   c->MaxDrawBuffers
      = CLAMP(screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS),
              1, MAX_DRAW_BUFFERS);
148

149 150
   /* Quads always follow GL provoking rules. */
   c->QuadsFollowProvokingVertexConvention = GL_FALSE;
151

152 153 154
   for (sh = 0; sh < MESA_SHADER_TYPES; ++sh) {
      struct gl_shader_compiler_options *options =
         &st->ctx->ShaderCompilerOptions[sh];
155
      struct gl_program_constants *pc;
156 157

      switch (sh) {
158 159 160 161 162 163 164 165 166
      case PIPE_SHADER_FRAGMENT:
         pc = &c->FragmentProgram;
         break;
      case PIPE_SHADER_VERTEX:
         pc = &c->VertexProgram;
         break;
      case PIPE_SHADER_GEOMETRY:
         pc = &c->GeometryProgram;
         break;
167 168 169
      default:
         assert(0);
         continue;
170 171
      }

172 173 174 175 176 177 178 179
      pc->MaxNativeInstructions    = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INSTRUCTIONS);
      pc->MaxNativeAluInstructions = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS);
      pc->MaxNativeTexInstructions = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS);
      pc->MaxNativeTexIndirections = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS);
      pc->MaxNativeAttribs         = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INPUTS);
      pc->MaxNativeTemps           = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_TEMPS);
      pc->MaxNativeAddressRegs     = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_ADDRS);
      pc->MaxNativeParameters      = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_CONSTS);
180
      pc->MaxUniformComponents     = 4 * MIN2(pc->MaxNativeParameters, MAX_UNIFORMS);
181 182
      /* raise MaxParameters if native support is higher */
      pc->MaxParameters            = MAX2(pc->MaxParameters, pc->MaxNativeParameters);
183

184 185 186
      /* Gallium doesn't really care about local vs. env parameters so use the
       * same limits.
       */
187 188
      pc->MaxLocalParams = MIN2(pc->MaxParameters, MAX_PROGRAM_LOCAL_PARAMS);
      pc->MaxEnvParams = MIN2(pc->MaxParameters, MAX_PROGRAM_ENV_PARAMS);
189

190 191
      options->EmitNoNoise = TRUE;

192
      /* TODO: make these more fine-grained if anyone needs it */
193
      options->MaxIfDepth = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH);
194 195 196
      options->EmitNoLoops = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH);
      options->EmitNoFunctions = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_SUBROUTINES);
      options->EmitNoMainReturn = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_SUBROUTINES);
197

198
      options->EmitNoCont = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED);
199

200
      options->EmitNoIndirectInput = !screen->get_shader_param(screen, sh,
201
                                        PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR);
202
      options->EmitNoIndirectOutput = !screen->get_shader_param(screen, sh,
203
                                        PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR);
204
      options->EmitNoIndirectTemp = !screen->get_shader_param(screen, sh,
205
                                        PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR);
206
      options->EmitNoIndirectUniform = !screen->get_shader_param(screen, sh,
207 208
                                        PIPE_SHADER_CAP_INDIRECT_CONST_ADDR);

Brian Paul's avatar
Brian Paul committed
209
      if (options->EmitNoLoops)
210
         options->MaxUnrollIterations = MIN2(screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INSTRUCTIONS), 65536);
211
   }
212

213 214 215 216
   /* PIPE_SHADER_CAP_MAX_INPUTS for the FS specifies the maximum number
    * of inputs. It's always 2 colors + N generic inputs. */
   c->MaxVarying = screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
                                            PIPE_SHADER_CAP_MAX_INPUTS);
217
   c->MaxVarying = MIN2(c->MaxVarying, MAX_VARYING);
218

219 220 221 222
   c->MinProgramTexelOffset = screen->get_param(screen, PIPE_CAP_MIN_TEXEL_OFFSET);
   c->MaxProgramTexelOffset = screen->get_param(screen, PIPE_CAP_MAX_TEXEL_OFFSET);

   c->UniformBooleanTrue = ~0;
223

224
   c->MaxTransformFeedbackSeparateAttribs =
225
      screen->get_param(screen, PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS);
226 227 228 229 230
   c->MaxTransformFeedbackSeparateComponents =
      screen->get_param(screen, PIPE_CAP_MAX_STREAM_OUTPUT_SEPARATE_COMPONENTS);
   c->MaxTransformFeedbackInterleavedComponents =
      screen->get_param(screen, PIPE_CAP_MAX_STREAM_OUTPUT_INTERLEAVED_COMPONENTS);

231
   c->StripTextureBorder = GL_TRUE;
232 233 234 235 236 237

   c->GLSLSkipStrictMaxUniformLimitCheck =
      screen->get_param(screen, PIPE_CAP_TGSI_CAN_COMPACT_CONSTANTS);

   c->GLSLSkipStrictMaxVaryingLimitCheck =
      screen->get_param(screen, PIPE_CAP_TGSI_CAN_COMPACT_VARYINGS);
238 239 240
}


241 242 243 244 245 246 247 248
static GLboolean st_get_s3tc_override(void)
{
   const char *override = _mesa_getenv("force_s3tc_enable");
   if (override && !strcmp(override, "true"))
      return GL_TRUE;
   return GL_FALSE;
}

249 250 251 252 253 254 255 256 257 258 259 260
/**
 * Given a member \c x of struct gl_extensions, return offset of
 * \c x in bytes.
 */
#define o(x) offsetof(struct gl_extensions, x)


struct st_extension_cap_mapping {
   int extension_offset;
   int cap;
};

261

262
/**
263 264 265 266 267
 * Use pipe_screen::get_param() to query PIPE_CAP_ values to determine
 * which GL extensions are supported.
 * Quite a few extensions are always supported because they are standard
 * features or can be built on top of other gallium features.
 * Some fine tuning may still be needed.
268 269 270
 */
void st_init_extensions(struct st_context *st)
{
271
   struct pipe_screen *screen = st->pipe->screen;
272
   struct gl_context *ctx = st->ctx;
273
   int i, glsl_feature_level;
274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312
   GLboolean *extensions = (GLboolean *) &ctx->Extensions;

   static const struct st_extension_cap_mapping cap_mapping[] = {
      { o(ARB_depth_clamp),                  PIPE_CAP_DEPTH_CLIP_DISABLE               },
      { o(ARB_depth_texture),                PIPE_CAP_TEXTURE_SHADOW_MAP               },
      { o(ARB_draw_buffers_blend),           PIPE_CAP_INDEP_BLEND_FUNC                 },
      { o(ARB_draw_instanced),               PIPE_CAP_TGSI_INSTANCEID                  },
      { o(ARB_fragment_program_shadow),      PIPE_CAP_TEXTURE_SHADOW_MAP               },
      { o(ARB_instanced_arrays),             PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR  },
      { o(ARB_occlusion_query),              PIPE_CAP_OCCLUSION_QUERY                  },
      { o(ARB_occlusion_query2),             PIPE_CAP_OCCLUSION_QUERY                  },
      { o(ARB_point_sprite),                 PIPE_CAP_POINT_SPRITE                     },
      { o(ARB_seamless_cube_map),            PIPE_CAP_SEAMLESS_CUBE_MAP                },
      { o(ARB_shader_stencil_export),        PIPE_CAP_SHADER_STENCIL_EXPORT            },
      { o(ARB_shader_texture_lod),           PIPE_CAP_SM3                              },
      { o(ARB_shadow),                       PIPE_CAP_TEXTURE_SHADOW_MAP               },
      { o(ARB_texture_non_power_of_two),     PIPE_CAP_NPOT_TEXTURES                    },
      { o(ARB_transform_feedback2),          PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME       },

      { o(EXT_blend_equation_separate),      PIPE_CAP_BLEND_EQUATION_SEPARATE          },
      { o(EXT_draw_buffers2),                PIPE_CAP_INDEP_BLEND_ENABLE               },
      { o(EXT_shadow_funcs),                 PIPE_CAP_TEXTURE_SHADOW_MAP               },
      { o(EXT_stencil_two_side),             PIPE_CAP_TWO_SIDED_STENCIL                },
      { o(EXT_texture_array),                PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS         },
      { o(EXT_texture_filter_anisotropic),   PIPE_CAP_ANISOTROPIC_FILTER               },
      { o(EXT_texture_mirror_clamp),         PIPE_CAP_TEXTURE_MIRROR_CLAMP             },
      { o(EXT_texture_swizzle),              PIPE_CAP_TEXTURE_SWIZZLE                  },
      { o(EXT_timer_query),                  PIPE_CAP_TIMER_QUERY                      },
      { o(EXT_transform_feedback),           PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS        },

      { o(AMD_seamless_cubemap_per_texture), PIPE_CAP_SEAMLESS_CUBE_MAP_PER_TEXTURE    },
      { o(ATI_separate_stencil),             PIPE_CAP_TWO_SIDED_STENCIL                },
      { o(ATI_texture_mirror_once),          PIPE_CAP_TEXTURE_MIRROR_CLAMP             },
      { o(NV_conditional_render),            PIPE_CAP_CONDITIONAL_RENDER               },
      { o(NV_texture_barrier),               PIPE_CAP_TEXTURE_BARRIER                  },
      /* GL_NV_point_sprite is not supported by gallium because we don't
       * support the GL_POINT_SPRITE_R_MODE_NV option. */
      { o(MESA_texture_array),               PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS         },
   };
313

314 315 316
   /*
    * Extensions that are supported by all Gallium drivers:
    */
317
   ctx->Extensions.ARB_copy_buffer = GL_TRUE;
318
   ctx->Extensions.ARB_draw_elements_base_vertex = GL_TRUE;
319
   ctx->Extensions.ARB_explicit_attrib_location = GL_TRUE;
320
   ctx->Extensions.ARB_fragment_coord_conventions = GL_TRUE;
Brian Paul's avatar
Brian Paul committed
321
   ctx->Extensions.ARB_fragment_program = GL_TRUE;
322
   ctx->Extensions.ARB_fragment_shader = GL_TRUE;
323
   ctx->Extensions.ARB_half_float_pixel = GL_TRUE;
324
   ctx->Extensions.ARB_map_buffer_range = GL_TRUE;
325
   ctx->Extensions.ARB_sampler_objects = GL_TRUE;
326 327
   ctx->Extensions.ARB_shader_objects = GL_TRUE;
   ctx->Extensions.ARB_shading_language_100 = GL_TRUE;
328
   ctx->Extensions.ARB_texture_border_clamp = GL_TRUE; /* XXX temp */
329 330 331 332
   ctx->Extensions.ARB_texture_cube_map = GL_TRUE;
   ctx->Extensions.ARB_texture_env_combine = GL_TRUE;
   ctx->Extensions.ARB_texture_env_crossbar = GL_TRUE;
   ctx->Extensions.ARB_texture_env_dot3 = GL_TRUE;
333
   ctx->Extensions.ARB_texture_storage = GL_TRUE;
334
   ctx->Extensions.ARB_vertex_array_object = GL_TRUE;
Brian Paul's avatar
Brian Paul committed
335
   ctx->Extensions.ARB_vertex_program = GL_TRUE;
336
   ctx->Extensions.ARB_vertex_shader = GL_TRUE;
337
   ctx->Extensions.ARB_window_pos = GL_TRUE;
338 339 340 341

   ctx->Extensions.EXT_blend_color = GL_TRUE;
   ctx->Extensions.EXT_blend_func_separate = GL_TRUE;
   ctx->Extensions.EXT_blend_minmax = GL_TRUE;
342
   ctx->Extensions.EXT_framebuffer_blit = GL_TRUE;
343
   ctx->Extensions.EXT_framebuffer_object = GL_TRUE;
344
   ctx->Extensions.EXT_framebuffer_multisample = GL_TRUE;
345
   ctx->Extensions.EXT_fog_coord = GL_TRUE;
346
   ctx->Extensions.EXT_gpu_program_parameters = GL_TRUE;
347 348
   ctx->Extensions.EXT_pixel_buffer_object = GL_TRUE;
   ctx->Extensions.EXT_point_parameters = GL_TRUE;
349
   ctx->Extensions.EXT_provoking_vertex = GL_TRUE;
350
   ctx->Extensions.EXT_secondary_color = GL_TRUE;
351
   ctx->Extensions.EXT_separate_shader_objects = GL_TRUE;
352
   ctx->Extensions.EXT_texture_env_dot3 = GL_TRUE;
353
   ctx->Extensions.EXT_vertex_array_bgra = GL_TRUE;
354

355 356
   ctx->Extensions.APPLE_vertex_array_object = GL_TRUE;

357 358
   ctx->Extensions.ATI_texture_env_combine3 = GL_TRUE;

359 360
   ctx->Extensions.MESA_pack_invert = GL_TRUE;

361
   ctx->Extensions.NV_blend_square = GL_TRUE;
362
   ctx->Extensions.NV_fog_distance = GL_TRUE;
363
   ctx->Extensions.NV_texgen_reflection = GL_TRUE;
364
   ctx->Extensions.NV_texture_env_combine4 = GL_TRUE;
365
   ctx->Extensions.NV_texture_rectangle = GL_TRUE;
366 367
#if 0
   /* possibly could support the following two */
368 369
   ctx->Extensions.NV_vertex_program = GL_TRUE;
   ctx->Extensions.NV_vertex_program1_1 = GL_TRUE;
370
#endif
371

372 373
#if FEATURE_OES_EGL_image
   ctx->Extensions.OES_EGL_image = GL_TRUE;
374 375
   if (ctx->API != API_OPENGL)
      ctx->Extensions.OES_EGL_image_external = GL_TRUE;
376
#endif
377 378 379 380
#if FEATURE_OES_draw_texture
   ctx->Extensions.OES_draw_texture = GL_TRUE;
#endif

381 382 383 384 385 386 387
   /* Expose the extensions which directly correspond to gallium caps. */
   for (i = 0; i < Elements(cap_mapping); i++) {
      if (screen->get_param(screen, cap_mapping[i].cap)) {
         extensions[cap_mapping[i].extension_offset] = GL_TRUE;
      }
   }

388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414
   /* Figure out GLSL support. */
   glsl_feature_level = screen->get_param(screen, PIPE_CAP_GLSL_FEATURE_LEVEL);

   if (glsl_feature_level >= 130) {
      ctx->Const.GLSLVersion = 130;
   } else {
      ctx->Const.GLSLVersion = 120;
   }

   _mesa_override_glsl_version(st->ctx);

   if (ctx->Const.GLSLVersion >= 130) {
      ctx->Const.NativeIntegers = GL_TRUE;
      ctx->Const.MaxClipPlanes = 8;

      /* Extensions that only depend on GLSL 1.3. */
      ctx->Extensions.ARB_conservative_depth = GL_TRUE;
   } else {
      /* Optional integer support for GLSL 1.2. */
      if (screen->get_shader_param(screen, PIPE_SHADER_VERTEX,
                                   PIPE_SHADER_CAP_INTEGERS) &&
          screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
                                   PIPE_SHADER_CAP_INTEGERS)) {
         ctx->Const.NativeIntegers = GL_TRUE;
      }
   }

415 416 417
   /*
    * Extensions that depend on the driver/hardware:
    */
418 419 420
   /* GL_EXT_packed_depth_stencil requires both the ability to render to
    * a depth/stencil buffer and texture from depth/stencil source.
    */
421
   if (screen->is_format_supported(screen, PIPE_FORMAT_S8_UINT_Z24_UNORM,
422
                                   PIPE_TEXTURE_2D, 0,
423 424 425
                                   PIPE_BIND_DEPTH_STENCIL |
                                   PIPE_BIND_SAMPLER_VIEW) ||
       screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_UINT,
426
                                   PIPE_TEXTURE_2D, 0,
427
                                   PIPE_BIND_DEPTH_STENCIL |
428
                                   PIPE_BIND_SAMPLER_VIEW)) {
429
      ctx->Extensions.EXT_packed_depth_stencil = GL_TRUE;
430
      ctx->Extensions.ARB_framebuffer_object = GL_TRUE;
431 432
   }

433 434 435 436 437 438 439 440 441 442 443 444
   /* float support - assume nothing exclusively supports 64-bit floats */
   if (screen->is_format_supported(screen, PIPE_FORMAT_R32G32B32A32_FLOAT,
                                   PIPE_TEXTURE_2D, 0,
                                   PIPE_BIND_SAMPLER_VIEW |
                                   PIPE_BIND_RENDER_TARGET) &&
      screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_FLOAT,
                                   PIPE_TEXTURE_2D, 0,
                                   PIPE_BIND_SAMPLER_VIEW |
                                   PIPE_BIND_RENDER_TARGET)) {
      ctx->Extensions.ARB_texture_float = GL_TRUE;
   }

445
   /* sRGB support */
Jose Fonseca's avatar
Jose Fonseca committed
446
   if (screen->is_format_supported(screen, PIPE_FORMAT_A8B8G8R8_SRGB,
447
                                   PIPE_TEXTURE_2D, 0,
448
                                   PIPE_BIND_SAMPLER_VIEW) ||
Jose Fonseca's avatar
Jose Fonseca committed
449
      screen->is_format_supported(screen, PIPE_FORMAT_B8G8R8A8_SRGB,
450
                                   PIPE_TEXTURE_2D, 0,
451
                                   PIPE_BIND_SAMPLER_VIEW)) {
452
      ctx->Extensions.EXT_texture_sRGB = GL_TRUE;
453
      ctx->Extensions.EXT_texture_sRGB_decode = GL_TRUE;
454 455
      if (screen->is_format_supported(screen, PIPE_FORMAT_A8B8G8R8_SRGB,
                                   PIPE_TEXTURE_2D, 0,
456
                                   PIPE_BIND_RENDER_TARGET) ||
457 458
          screen->is_format_supported(screen, PIPE_FORMAT_B8G8R8A8_SRGB,
                                   PIPE_TEXTURE_2D, 0,
459
                                   PIPE_BIND_RENDER_TARGET)) {
460 461
         ctx->Extensions.EXT_framebuffer_sRGB = GL_TRUE;
      }
462
   }
463

464 465
   if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8_UNORM,
                                   PIPE_TEXTURE_2D, 0,
466
                                   PIPE_BIND_SAMPLER_VIEW)) {
467 468 469
      ctx->Extensions.ARB_texture_rg = GL_TRUE;
   }

470
   /* s3tc support */
471 472 473 474 475 476 477 478 479 480
   if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGB,
                                   PIPE_TEXTURE_2D, 0,
                                   PIPE_BIND_SAMPLER_VIEW) &&
       screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGBA,
                                   PIPE_TEXTURE_2D, 0,
                                   PIPE_BIND_SAMPLER_VIEW) &&
       screen->is_format_supported(screen, PIPE_FORMAT_DXT3_RGBA,
                                   PIPE_TEXTURE_2D, 0,
                                   PIPE_BIND_SAMPLER_VIEW) &&
       screen->is_format_supported(screen, PIPE_FORMAT_DXT5_RGBA,
481
                                   PIPE_TEXTURE_2D, 0,
482
                                   PIPE_BIND_SAMPLER_VIEW) &&
483
       (ctx->Mesa_DXTn || st_get_s3tc_override())) {
484
      ctx->Extensions.EXT_texture_compression_s3tc = GL_TRUE;
Jose Fonseca's avatar
Jose Fonseca committed
485
      ctx->Extensions.S3_s3tc = GL_TRUE;
486
   }
487

488 489
   if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_UNORM,
                                   PIPE_TEXTURE_2D, 0,
490
                                   PIPE_BIND_SAMPLER_VIEW) &&
491 492
       screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_SNORM,
				   PIPE_TEXTURE_2D, 0,
493
                                   PIPE_BIND_SAMPLER_VIEW) &&
494 495
       screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_UNORM,
                                   PIPE_TEXTURE_2D, 0,
496
                                   PIPE_BIND_SAMPLER_VIEW) &&
497 498
       screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_SNORM,
                                   PIPE_TEXTURE_2D, 0,
499
                                   PIPE_BIND_SAMPLER_VIEW)
500 501 502 503
       ) {
     ctx->Extensions.ARB_texture_compression_rgtc = GL_TRUE;
   }

504 505
   if (screen->is_format_supported(screen, PIPE_FORMAT_LATC1_UNORM,
                                   PIPE_TEXTURE_2D, 0,
506
                                   PIPE_BIND_SAMPLER_VIEW) &&
507 508
       screen->is_format_supported(screen, PIPE_FORMAT_LATC1_SNORM,
                                   PIPE_TEXTURE_2D, 0,
509
                                   PIPE_BIND_SAMPLER_VIEW) &&
510 511
       screen->is_format_supported(screen, PIPE_FORMAT_LATC2_UNORM,
                                   PIPE_TEXTURE_2D, 0,
512
                                   PIPE_BIND_SAMPLER_VIEW) &&
513 514
       screen->is_format_supported(screen, PIPE_FORMAT_LATC2_SNORM,
                                   PIPE_TEXTURE_2D, 0,
515
                                   PIPE_BIND_SAMPLER_VIEW)) {
516 517 518 519 520
      ctx->Extensions.EXT_texture_compression_latc = GL_TRUE;
   }

   if (screen->is_format_supported(screen, PIPE_FORMAT_LATC2_UNORM,
                                   PIPE_TEXTURE_2D, 0,
521
                                   PIPE_BIND_SAMPLER_VIEW)) {
522 523 524
      ctx->Extensions.ATI_texture_compression_3dc = GL_TRUE;
   }

525 526 527 528 529 530 531 532
   if (ctx->API != API_OPENGL) {
      if (screen->is_format_supported(screen, PIPE_FORMAT_ETC1_RGB8,
                                      PIPE_TEXTURE_2D, 0,
                                      PIPE_BIND_SAMPLER_VIEW)) {
         ctx->Extensions.OES_compressed_ETC1_RGB8_texture = GL_TRUE;
      }
   }

533 534 535 536 537 538
   if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8B8A8_SNORM,
                                   PIPE_TEXTURE_2D, 0,
                                   PIPE_BIND_SAMPLER_VIEW)) {
      ctx->Extensions.EXT_texture_snorm = GL_TRUE;
   }

539
   /* ycbcr support */
Jose Fonseca's avatar
Jose Fonseca committed
540
   if (screen->is_format_supported(screen, PIPE_FORMAT_UYVY, 
541
                                   PIPE_TEXTURE_2D, 0,
542
                                   PIPE_BIND_SAMPLER_VIEW) ||
Jose Fonseca's avatar
Jose Fonseca committed
543
       screen->is_format_supported(screen, PIPE_FORMAT_YUYV, 
544
                                   PIPE_TEXTURE_2D, 0,
545
                                   PIPE_BIND_SAMPLER_VIEW)) {
546 547
      ctx->Extensions.MESA_ycbcr_texture = GL_TRUE;
   }
548

549 550 551
   /* GL_ARB_half_float_vertex */
   if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_FLOAT,
                                   PIPE_BUFFER, 0,
552
                                   PIPE_BIND_VERTEX_BUFFER)) {
553 554 555
      ctx->Extensions.ARB_half_float_vertex = GL_TRUE;
   }

556 557 558 559 560 561
   if (screen->is_format_supported(screen, PIPE_FORMAT_R32G32B32A32_FIXED,
                                   PIPE_BUFFER, 0,
                                   PIPE_BIND_VERTEX_BUFFER)) {
      ctx->Extensions.ARB_ES2_compatibility = GL_TRUE;
   }

562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588
   if (screen->is_format_supported(screen, PIPE_FORMAT_R10G10B10A2_UNORM,
                                   PIPE_BUFFER, 0,
                                   PIPE_BIND_VERTEX_BUFFER) &&
       screen->is_format_supported(screen, PIPE_FORMAT_B10G10R10A2_UNORM,
                                   PIPE_BUFFER, 0,
                                   PIPE_BIND_VERTEX_BUFFER) &&
       screen->is_format_supported(screen, PIPE_FORMAT_R10G10B10A2_SNORM,
                                   PIPE_BUFFER, 0,
                                   PIPE_BIND_VERTEX_BUFFER) &&
       screen->is_format_supported(screen, PIPE_FORMAT_B10G10R10A2_SNORM,
                                   PIPE_BUFFER, 0,
                                   PIPE_BIND_VERTEX_BUFFER) &&
       screen->is_format_supported(screen, PIPE_FORMAT_R10G10B10A2_USCALED,
                                   PIPE_BUFFER, 0,
                                   PIPE_BIND_VERTEX_BUFFER) &&
       screen->is_format_supported(screen, PIPE_FORMAT_B10G10R10A2_USCALED,
                                   PIPE_BUFFER, 0,
                                   PIPE_BIND_VERTEX_BUFFER) &&
       screen->is_format_supported(screen, PIPE_FORMAT_R10G10B10A2_SSCALED,
                                   PIPE_BUFFER, 0,
                                   PIPE_BIND_VERTEX_BUFFER) &&
       screen->is_format_supported(screen, PIPE_FORMAT_B10G10R10A2_SSCALED,
                                   PIPE_BUFFER, 0,
                                   PIPE_BIND_VERTEX_BUFFER)) {
      ctx->Extensions.ARB_vertex_type_2_10_10_10_rev = GL_TRUE;
   }

589 590
   if (screen->get_shader_param(screen, PIPE_SHADER_GEOMETRY,
                                PIPE_SHADER_CAP_MAX_INSTRUCTIONS) > 0) {
591
#if 0 /* XXX re-enable when GLSL compiler again supports geometry shaders */
592
      ctx->Extensions.ARB_geometry_shader4 = GL_TRUE;
593
#endif
594
   }
Marek Olšák's avatar
Marek Olšák committed
595

596 597 598
   ctx->Extensions.NV_primitive_restart = GL_TRUE;
   if (!screen->get_param(screen, PIPE_CAP_PRIMITIVE_RESTART)) {
      st->sw_primitive_restart = GL_TRUE;
599 600
   }

601
   if (screen->get_param(screen, PIPE_CAP_VERTEX_COLOR_UNCLAMPED)) {
602
      ctx->Extensions.ARB_color_buffer_float = GL_TRUE;
603 604 605 606 607 608 609 610

      if (!screen->get_param(screen, PIPE_CAP_VERTEX_COLOR_CLAMPED)) {
         st->clamp_vert_color_in_shader = TRUE;
      }

      if (!screen->get_param(screen, PIPE_CAP_FRAGMENT_COLOR_CLAMPED)) {
         st->clamp_frag_color_in_shader = TRUE;
      }
611
   }
612

Marek Olšák's avatar
Marek Olšák committed
613 614 615
   if (screen->fence_finish) {
      ctx->Extensions.ARB_sync = GL_TRUE;
   }
616

617 618 619 620 621
   if (screen->is_format_supported(screen, PIPE_FORMAT_R9G9B9E5_FLOAT,
                                   PIPE_TEXTURE_2D, 0,
                                   PIPE_BIND_SAMPLER_VIEW)) {
      ctx->Extensions.EXT_texture_shared_exponent = GL_TRUE;
   }
622 623 624 625 626 627 628

   if (screen->is_format_supported(screen, PIPE_FORMAT_R11G11B10_FLOAT,
                                   PIPE_TEXTURE_2D, 0,
                                   PIPE_BIND_RENDER_TARGET |
                                   PIPE_BIND_SAMPLER_VIEW)) {
      ctx->Extensions.EXT_packed_float = GL_TRUE;
   }
629

630 631 632 633 634 635 636 637 638 639
   /* Maximum sample count. */
   for (i = 16; i > 0; --i) {
      if (screen->is_format_supported(screen, PIPE_FORMAT_B8G8R8A8_UNORM,
                                      PIPE_TEXTURE_2D, i,
                                      PIPE_BIND_RENDER_TARGET)) {
         ctx->Const.MaxSamples = i;
         break;
      }
   }

640 641 642 643
   if (screen->is_format_supported(screen, PIPE_FORMAT_Z32_FLOAT,
                                   PIPE_TEXTURE_2D, 0,
                                   PIPE_BIND_DEPTH_STENCIL |
                                   PIPE_BIND_SAMPLER_VIEW) &&
644
       screen->is_format_supported(screen, PIPE_FORMAT_Z32_FLOAT_S8X24_UINT,
645 646 647 648 649
                                   PIPE_TEXTURE_2D, 0,
                                   PIPE_BIND_DEPTH_STENCIL |
                                   PIPE_BIND_SAMPLER_VIEW)) {
      ctx->Extensions.ARB_depth_buffer_float = GL_TRUE;
   }
650 651 652 653 654 655

   if (screen->is_format_supported(screen, PIPE_FORMAT_B10G10R10A2_UINT,
                                   PIPE_TEXTURE_2D, 0,
                                   PIPE_BIND_SAMPLER_VIEW))
       ctx->Extensions.ARB_texture_rgb10_a2ui = GL_TRUE;

656 657 658 659 660 661
   if (ctx->Const.NativeIntegers &&
       screen->is_format_supported(screen, PIPE_FORMAT_R32G32B32A32_UINT, PIPE_TEXTURE_2D, 0,
                                   PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET) &&
       screen->is_format_supported(screen, PIPE_FORMAT_R32G32B32A32_SINT, PIPE_TEXTURE_2D, 0,
                                   PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET))
      ctx->Extensions.EXT_texture_integer = GL_TRUE;
662
}