* Note that we have to limit/clamp against Mesa's internal limits too.
*/
void st_init_limits(struct pipe_screen *screen,
- struct gl_constants *c, struct gl_extensions *extensions,
- gl_api api)
+ struct gl_constants *c, struct gl_extensions *extensions)
{
int supported_irs;
unsigned sh;
bool can_ubo = true;
int temp;
- c->MaxTextureLevels
- = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS),
- MAX_TEXTURE_LEVELS);
+ c->MaxTextureSize = screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_2D_SIZE);
+ c->MaxTextureSize = MIN2(c->MaxTextureSize, 1 << (MAX_TEXTURE_LEVELS - 1));
c->Max3DTextureLevels
= _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_3D_LEVELS),
= _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS),
MAX_CUBE_TEXTURE_LEVELS);
- c->MaxTextureRectSize
- = _min(1 << (c->MaxTextureLevels - 1), MAX_TEXTURE_RECT_SIZE);
+ c->MaxTextureRectSize = _min(c->MaxTextureSize, MAX_TEXTURE_RECT_SIZE);
c->MaxArrayTextureLayers
= screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS);
pc->MaxUniformComponents = MIN2(pc->MaxUniformComponents,
MAX_UNIFORMS * 4);
+ /* For ARB programs, prog_src_register::Index is a signed 13-bit number.
+ * This gives us a limit of 4096 values - but we may need to generate
+ * internal values in addition to what the source program uses. So, we
+ * drop the limit one step lower, to 2048, to be safe.
+ */
pc->MaxParameters =
- pc->MaxNativeParameters = pc->MaxUniformComponents / 4;
+ pc->MaxNativeParameters = MIN2(pc->MaxUniformComponents / 4, 2048);
pc->MaxInputComponents =
screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INPUTS) * 4;
pc->MaxOutputComponents =
*/
pc->MaxAtomicCounters = temp;
pc->MaxAtomicBuffers = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTER_BUFFERS);
- } else {
+ } else if (pc->MaxShaderStorageBlocks) {
pc->MaxAtomicCounters = MAX_ATOMIC_COUNTERS;
/*
* without separate atomic counters, reserve half of the available
screen->get_shader_param(screen, sh,
PIPE_SHADER_CAP_MAX_UNROLL_ITERATIONS_HINT);
- options->LowerCombinedClipCullDistance = true;
- options->LowerBufferInterfaceBlocks = true;
+ if (!screen->get_param(screen, PIPE_CAP_NIR_COMPACT_ARRAYS))
+ options->LowerCombinedClipCullDistance = true;
+
+ bool prefer_nir = PIPE_SHADER_IR_NIR ==
+ screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_PREFERRED_IR);
+
+ /* NIR can do the lowering on our behalf and we'll get better results
+ * because it can actually optimize SSBO access.
+ */
+ options->LowerBufferInterfaceBlocks = !prefer_nir;
}
c->MaxUserAssignableUniformLocations =
screen->get_param(screen, PIPE_CAP_GLSL_OPTIMIZE_CONSERVATIVELY);
c->GLSLTessLevelsAsInputs =
screen->get_param(screen, PIPE_CAP_GLSL_TESS_LEVELS_AS_INPUTS);
- c->LowerTessLevel = true;
- c->LowerCsDerivedVariables = true;
+ c->LowerTessLevel =
+ !screen->get_param(screen, PIPE_CAP_NIR_COMPACT_ARRAYS);
+ c->LowerCsDerivedVariables =
+ !screen->get_param(screen, PIPE_CAP_CS_DERIVED_SYSTEM_VALUES_SUPPORTED);
c->PrimitiveRestartForPatches =
screen->get_param(screen, PIPE_CAP_PRIMITIVE_RESTART_FOR_PATCHES);
c->Program[MESA_SHADER_VERTEX].MaxAttribs =
MIN2(c->Program[MESA_SHADER_VERTEX].MaxAttribs, 16);
- /* 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);
+ c->MaxVarying = screen->get_param(screen, PIPE_CAP_MAX_VARYINGS);
c->MaxVarying = MIN2(c->MaxVarying, MAX_VARYING);
c->MaxGeometryOutputVertices =
screen->get_param(screen, PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES);
c->GLSLFragCoordIsSysVal =
screen->get_param(screen, PIPE_CAP_TGSI_FS_POSITION_IS_SYSVAL);
+ c->GLSLPointCoordIsSysVal =
+ screen->get_param(screen, PIPE_CAP_TGSI_FS_POINT_IS_SYSVAL);
c->GLSLFrontFacingIsSysVal =
screen->get_param(screen, PIPE_CAP_TGSI_FS_FACE_IS_INTEGER_SYSVAL);
- /* GL_ARB_get_program_binary
- *
- * The QT framework has a bug in their shader program cache, which is built
- * on GL_ARB_get_program_binary. In an effort to allow them to fix the bug
- * we don't enable more than 1 binary format for compatibility profiles.
- */
- if (api != API_OPENGL_COMPAT &&
- screen->get_disk_shader_cache && screen->get_disk_shader_cache(screen))
+ /* GL_ARB_get_program_binary */
+ if (screen->get_disk_shader_cache && screen->get_disk_shader_cache(screen))
c->NumProgramBinaryFormats = 1;
c->MaxAtomicBufferBindings =
{ o(ARB_shader_clock), PIPE_CAP_TGSI_CLOCK },
{ o(ARB_shader_draw_parameters), PIPE_CAP_DRAW_PARAMETERS },
{ o(ARB_shader_group_vote), PIPE_CAP_TGSI_VOTE },
+ { o(EXT_shader_image_load_formatted), PIPE_CAP_IMAGE_LOAD_FORMATTED },
+ { o(EXT_shader_image_load_store), PIPE_CAP_TGSI_ATOMINC_WRAP },
{ o(ARB_shader_stencil_export), PIPE_CAP_SHADER_STENCIL_EXPORT },
{ o(ARB_shader_texture_image_samples), PIPE_CAP_TGSI_TXQS },
- { o(ARB_shader_texture_lod), PIPE_CAP_SM3 },
+ { o(ARB_shader_texture_lod), PIPE_CAP_FRAGMENT_SHADER_TEXTURE_LOD },
{ o(ARB_sparse_buffer), PIPE_CAP_SPARSE_BUFFER_PAGE_SIZE },
{ o(ARB_texture_buffer_object), PIPE_CAP_TEXTURE_BUFFER_OBJECTS },
{ o(ARB_texture_cube_map_array), PIPE_CAP_CUBE_MAP_ARRAY },
{ o(ARB_transform_feedback2), PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME },
{ o(ARB_transform_feedback3), PIPE_CAP_STREAM_OUTPUT_INTERLEAVE_BUFFERS },
{ o(ARB_transform_feedback_overflow_query), PIPE_CAP_QUERY_SO_OVERFLOW },
-
- { o(KHR_blend_equation_advanced), PIPE_CAP_TGSI_FS_FBFETCH },
+ { o(ARB_fragment_shader_interlock), PIPE_CAP_FRAGMENT_SHADER_INTERLOCK },
{ o(EXT_blend_equation_separate), PIPE_CAP_BLEND_EQUATION_SEPARATE },
{ o(EXT_depth_bounds_test), PIPE_CAP_DEPTH_BOUNDS_TEST },
{ o(EXT_multisampled_render_to_texture), PIPE_CAP_SURFACE_SAMPLE_COUNT },
{ o(EXT_semaphore), PIPE_CAP_FENCE_SIGNAL },
{ o(EXT_semaphore_fd), PIPE_CAP_FENCE_SIGNAL },
+ { o(EXT_shader_samples_identical), PIPE_CAP_SHADER_SAMPLES_IDENTICAL },
{ 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_shadow_lod), PIPE_CAP_TEXTURE_SHADOW_LOD },
{ o(EXT_texture_swizzle), PIPE_CAP_TEXTURE_SWIZZLE },
{ o(EXT_transform_feedback), PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS },
{ o(EXT_window_rectangles), PIPE_CAP_MAX_WINDOW_RECTANGLES },
{ o(ATI_meminfo), PIPE_CAP_QUERY_MEMORY_INFO },
{ o(AMD_seamless_cubemap_per_texture), PIPE_CAP_SEAMLESS_CUBE_MAP_PER_TEXTURE },
{ o(ATI_texture_mirror_once), PIPE_CAP_TEXTURE_MIRROR_CLAMP },
+ { o(INTEL_conservative_rasterization), PIPE_CAP_CONSERVATIVE_RASTER_INNER_COVERAGE },
+ { o(INTEL_shader_atomic_float_minmax), PIPE_CAP_ATOMIC_FLOAT_MINMAX },
{ o(MESA_tile_raster_order), PIPE_CAP_TILE_RASTER_ORDER },
+ { o(NV_compute_shader_derivatives), PIPE_CAP_COMPUTE_SHADER_DERIVATIVES },
{ o(NV_conditional_render), PIPE_CAP_CONDITIONAL_RENDER },
{ o(NV_fill_rectangle), PIPE_CAP_POLYGON_MODE_FILL_RECTANGLE },
{ o(NV_primitive_restart), PIPE_CAP_PRIMITIVE_RESTART },
/* GL_NV_point_sprite is not supported by gallium because we don't
* support the GL_POINT_SPRITE_R_MODE_NV option. */
- { o(OES_standard_derivatives), PIPE_CAP_SM3 },
+ { o(OES_standard_derivatives), PIPE_CAP_FRAGMENT_SHADER_DERIVATIVES },
{ o(OES_texture_float_linear), PIPE_CAP_TEXTURE_FLOAT_LINEAR },
{ o(OES_texture_half_float_linear), PIPE_CAP_TEXTURE_HALF_FLOAT_LINEAR },
{ o(OES_texture_view), PIPE_CAP_SAMPLER_VIEW_TARGET },
PIPE_FORMAT_R16G16B16A16_SNORM } },
};
+ /* Required: render target, sampler, and blending */
+ static const struct st_extension_format_mapping rt_blendable[] = {
+ { { o(EXT_float_blend) },
+ { PIPE_FORMAT_R32G32B32A32_FLOAT } },
+ };
+
/* Required: depth stencil and sampler support */
static const struct st_extension_format_mapping depthstencil_mapping[] = {
{ { o(ARB_depth_buffer_float) },
PIPE_FORMAT_DXT3_RGBA,
PIPE_FORMAT_DXT5_RGBA } },
+ { { o(EXT_texture_compression_s3tc_srgb) },
+ { PIPE_FORMAT_DXT1_SRGB,
+ PIPE_FORMAT_DXT1_SRGBA,
+ PIPE_FORMAT_DXT3_SRGBA,
+ PIPE_FORMAT_DXT5_SRGBA } },
+
{ { o(ARB_texture_compression_bptc) },
{ PIPE_FORMAT_BPTC_RGBA_UNORM,
PIPE_FORMAT_BPTC_SRGBA,
{ PIPE_FORMAT_X24S8_UINT,
PIPE_FORMAT_S8X24_UINT },
GL_TRUE }, /* at least one format must be supported */
+
+ { { o(AMD_compressed_ATC_texture) },
+ { PIPE_FORMAT_ATC_RGB,
+ PIPE_FORMAT_ATC_RGBA_EXPLICIT,
+ PIPE_FORMAT_ATC_RGBA_INTERPOLATED } },
};
/* Required: vertex fetch support. */
init_format_extensions(screen, extensions, rendertarget_mapping,
ARRAY_SIZE(rendertarget_mapping), PIPE_TEXTURE_2D,
PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW);
+ init_format_extensions(screen, extensions, rt_blendable,
+ ARRAY_SIZE(rt_blendable), PIPE_TEXTURE_2D,
+ PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW |
+ PIPE_BIND_BLENDABLE);
init_format_extensions(screen, extensions, depthstencil_mapping,
ARRAY_SIZE(depthstencil_mapping), PIPE_TEXTURE_2D,
PIPE_BIND_DEPTH_STENCIL | PIPE_BIND_SAMPLER_VIEW);
consts->GLSLVersionCompat =
screen->get_param(screen, PIPE_CAP_GLSL_FEATURE_LEVEL_COMPATIBILITY);
+ const unsigned ESSLVersion =
+ screen->get_param(screen, PIPE_CAP_ESSL_FEATURE_LEVEL);
const unsigned GLSLVersion =
api == API_OPENGL_COMPAT ? consts->GLSLVersionCompat :
consts->GLSLVersion;
consts->AllowGLSLCrossStageInterpolationMismatch = options->allow_glsl_cross_stage_interpolation_mismatch;
+ /* Technically we are turning on the EXT_gpu_shader5 extension,
+ * ARB_gpu_shader5 does not exist in GLES, but this flag is what
+ * switches on EXT_gpu_shader5:
+ */
+ if (api == API_OPENGLES2 && ESSLVersion >= 320)
+ extensions->ARB_gpu_shader5 = GL_TRUE;
+
if (GLSLVersion >= 400)
extensions->ARB_gpu_shader5 = GL_TRUE;
if (GLSLVersion >= 410)
}
if (GLSLVersion >= 140) {
+ /* Since GLSL 1.40 has support for all of the features of gpu_shader4,
+ * we can always expose it if the driver can do 140. Supporting
+ * gpu_shader4 on drivers without GLSL 1.40 is left for a future
+ * pipe cap.
+ */
+ extensions->EXT_gpu_shader4 = GL_TRUE;
+ extensions->EXT_texture_buffer_object = GL_TRUE;
+
if (screen->get_param(screen, PIPE_CAP_TGSI_ARRAY_COMPONENTS))
extensions->ARB_enhanced_layouts = GL_TRUE;
}
consts->GLSLZeroInit = options->glsl_zero_init;
+ consts->VendorOverride = options->force_gl_vendor;
+
consts->UniformBooleanTrue = consts->NativeIntegers ? ~0U : fui(1.0f);
/* Below are the cases which cannot be moved into tables easily. */
consts->DisableVaryingPacking = GL_TRUE;
}
+ unsigned max_fb_fetch_rts = screen->get_param(screen, PIPE_CAP_FBFETCH);
+ bool coherent_fb_fetch =
+ screen->get_param(screen, PIPE_CAP_FBFETCH_COHERENT);
+
+ if (max_fb_fetch_rts > 0) {
+ extensions->KHR_blend_equation_advanced = true;
+ extensions->KHR_blend_equation_advanced_coherent = coherent_fb_fetch;
+
+ if (max_fb_fetch_rts >=
+ screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS)) {
+ extensions->EXT_shader_framebuffer_fetch_non_coherent = true;
+ extensions->EXT_shader_framebuffer_fetch = coherent_fb_fetch;
+ }
+ }
+
consts->MaxViewports = screen->get_param(screen, PIPE_CAP_MAX_VIEWPORTS);
if (consts->MaxViewports >= 16) {
if (GLSLVersion >= 400) {
extensions->EXT_shader_integer_mix;
extensions->OES_texture_cube_map_array =
- extensions->ARB_ES3_1_compatibility &&
+ (extensions->ARB_ES3_1_compatibility || ESSLVersion >= 310) &&
extensions->OES_geometry_shader &&
extensions->ARB_texture_cube_map_array;
extensions->OES_viewport_array =
- extensions->ARB_ES3_1_compatibility &&
+ (extensions->ARB_ES3_1_compatibility || ESSLVersion >= 310) &&
extensions->OES_geometry_shader &&
extensions->ARB_viewport_array;
- extensions->OES_primitive_bounding_box = extensions->ARB_ES3_1_compatibility;
+ extensions->OES_primitive_bounding_box =
+ extensions->ARB_ES3_1_compatibility || ESSLVersion >= 310;
+
consts->NoPrimitiveBoundingBoxOutput = true;
extensions->ANDROID_extension_pack_es31a =
projects / mesa.git / blobdiff