OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

egl,gallium,gbm,mesa: replace get_param with pipe_caps access

Browse Source 
Use command:
  find . -path "./.git" -prune -o -type f -exec sed -i ':a;N;$!ba;s/->get_param([^,]*,[[:space:]]*PIPE_CAP_\([^)]*\))/->caps.\L\1/g' {} +

And some manual adjustment.

Reviewed-by: Marek Olšák <marek.olsak@amd.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/32955>
This commit is contained in:
Qiang Yu
2025-01-08 11:34:28 +08:00
committed by Marge Bot
parent b2caa48ec9
commit ef0b6f8262
76 changed files with 397 additions and 455 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/mesa/main/bufferobj.c
View File

@@ -302,7 +302,7 @@ bufferobj_data(struct gl_context *ctx,
return GL_TRUE;
} else if (is_mapped) {
return GL_TRUE; /* can't reallocate, nothing to do */
} else if (screen->get_param(screen, PIPE_CAP_INVALIDATE_BUFFER)) {
} else if (screen->caps.invalidate_buffer) {
pipe->invalidate_resource(pipe, obj->buffer);
return GL_TRUE;
}

4
src/mesa/main/externalobjects.c
View File

@@ -1189,7 +1189,7 @@ _mesa_ImportSemaphoreWin32HandleEXT(GLuint semaphore,
}
if (handleType == GL_HANDLE_TYPE_D3D12_FENCE_EXT &&
!ctx->screen->get_param(ctx->screen, PIPE_CAP_TIMELINE_SEMAPHORE_IMPORT)) {
!ctx->screen->caps.timeline_semaphore_import) {
_mesa_error(ctx, GL_INVALID_ENUM, "%s(handleType=%u)", func, handleType);
}
@@ -1233,7 +1233,7 @@ _mesa_ImportSemaphoreWin32NameEXT(GLuint semaphore,
}
if (handleType == GL_HANDLE_TYPE_D3D12_FENCE_EXT &&
!ctx->screen->get_param(ctx->screen, PIPE_CAP_TIMELINE_SEMAPHORE_IMPORT)) {
!ctx->screen->caps.timeline_semaphore_import) {
_mesa_error(ctx, GL_INVALID_ENUM, "%s(handleType=%u)", func, handleType);
}

2
src/mesa/main/fbobject.c
View File

@@ -1190,7 +1190,7 @@ do_validate_framebuffer(struct gl_context *ctx, struct gl_framebuffer *fb)
GLuint i;
enum pipe_format first_format = PIPE_FORMAT_NONE;
bool mixed_formats =
screen->get_param(screen, PIPE_CAP_MIXED_COLORBUFFER_FORMATS) != 0;
screen->caps.mixed_colorbuffer_formats != 0;
if (depth->Type && stencil->Type && depth->Type != stencil->Type) {
fbo_invalid("Different Depth/Stencil buffer formats");

4
src/mesa/main/glthread.c
View File

@@ -214,8 +214,8 @@ _mesa_glthread_init(struct gl_context *ctx)
struct glthread_state *glthread = &ctx->GLThread;
assert(!glthread->enabled);
if (!screen->get_param(screen, PIPE_CAP_MAP_UNSYNCHRONIZED_THREAD_SAFE) ||
!screen->get_param(screen, PIPE_CAP_ALLOW_MAPPED_BUFFERS_DURING_EXECUTION))
if (!screen->caps.map_unsynchronized_thread_safe ||
!screen->caps.allow_mapped_buffers_during_execution)
return;
if (!util_queue_init(&glthread->queue, "gl", MARSHAL_MAX_BATCHES - 2,

6
src/mesa/main/queryobj.c
View File

@@ -1345,7 +1345,7 @@ _mesa_init_queryobj(struct gl_context *ctx)
_mesa_InitHashTable(&ctx->Query.QueryObjects, ctx->Shared->ReuseGLNames);
ctx->Query.CurrentOcclusionObject = NULL;
if (screen->get_param(screen, PIPE_CAP_OCCLUSION_QUERY))
if (screen->caps.occlusion_query)
ctx->Const.QueryCounterBits.SamplesPassed = 64;
else
ctx->Const.QueryCounterBits.SamplesPassed = 0;
@@ -1355,8 +1355,8 @@ _mesa_init_queryobj(struct gl_context *ctx)
ctx->Const.QueryCounterBits.PrimitivesGenerated = 64;
ctx->Const.QueryCounterBits.PrimitivesWritten = 64;
if (screen->get_param(screen, PIPE_CAP_QUERY_PIPELINE_STATISTICS) ||
screen->get_param(screen, PIPE_CAP_QUERY_PIPELINE_STATISTICS_SINGLE)) {
if (screen->caps.query_pipeline_statistics ||
screen->caps.query_pipeline_statistics_single) {
ctx->Const.QueryCounterBits.VerticesSubmitted = 64;
ctx->Const.QueryCounterBits.PrimitivesSubmitted = 64;
ctx->Const.QueryCounterBits.VsInvocations = 64;

2
src/mesa/state_tracker/st_cb_bitmap.c
View File

@@ -319,7 +319,7 @@ draw_bitmap_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z,
* it up into chunks.
*/
ASSERTED GLuint maxSize =
st->screen->get_param(st->screen, PIPE_CAP_MAX_TEXTURE_2D_SIZE);
st->screen->caps.max_texture_2d_size;
assert(width <= (GLsizei) maxSize);
assert(height <= (GLsizei) maxSize);
}

4
src/mesa/state_tracker/st_cb_clear.c
View File

@@ -162,7 +162,7 @@ set_vertex_shader_layered(struct st_context *st)
{
struct pipe_context *pipe = st->pipe;
if (!st->screen->get_param(st->screen, PIPE_CAP_VS_INSTANCEID)) {
if (!st->screen->caps.vs_instanceid) {
assert(!"Got layered clear, but VS instancing is unsupported");
set_vertex_shader(st);
return;
@@ -170,7 +170,7 @@ set_vertex_shader_layered(struct st_context *st)
if (!st->clear.vs_layered) {
bool vs_layer =
st->screen->get_param(st->screen, PIPE_CAP_VS_LAYER_VIEWPORT);
st->screen->caps.vs_layer_viewport;
if (vs_layer) {
st->clear.vs_layered = make_nir_clear_vertex_shader(st, true);
} else {

6
src/mesa/state_tracker/st_cb_drawpixels.c
View File

@@ -730,8 +730,7 @@ draw_textured_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z,
/* XXX if DrawPixels image is larger than max texture size, break
* it up into chunks.
*/
maxSize = st->screen->get_param(st->screen,
PIPE_CAP_MAX_TEXTURE_2D_SIZE);
maxSize = st->screen->caps.max_texture_2d_size;
assert(width <= maxSize);
assert(height <= maxSize);
@@ -1165,8 +1164,7 @@ static void
clamp_size(struct st_context *st, GLsizei *width, GLsizei *height,
struct gl_pixelstore_attrib *unpack)
{
const int maxSize = st->screen->get_param(st->screen,
PIPE_CAP_MAX_TEXTURE_2D_SIZE);
const int maxSize = st->screen->caps.max_texture_2d_size;
if (*width > maxSize) {
if (unpack->RowLength == 0)

2
src/mesa/state_tracker/st_cb_flush.c
View File

@@ -183,6 +183,6 @@ void
st_init_flush_functions(struct pipe_screen *screen,
struct dd_function_table *functions)
{
if (screen->get_param(screen, PIPE_CAP_DEVICE_RESET_STATUS_QUERY))
if (screen->caps.device_reset_status_query)
functions->GetGraphicsResetStatus = st_get_graphics_reset_status;
}

2
src/mesa/state_tracker/st_cb_readpixels.c
View File

@@ -285,7 +285,7 @@ blit_to_staging(struct st_context *st, struct gl_renderbuffer *rb,
/* We are creating a texture of the size of the region being read back.
* Need to check for NPOT texture support. */
if (!screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES) &&
if (!screen->caps.npot_textures &&
(!util_is_power_of_two_or_zero(width) ||
!util_is_power_of_two_or_zero(height)))
return NULL;

4
src/mesa/state_tracker/st_cb_texture.c
View File

@@ -2283,7 +2283,7 @@ st_TexSubImage(struct gl_context *ctx, GLuint dims,
&src_templ.depth0, &src_templ.array_size);
/* Check for NPOT texture support. */
if (!screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES) &&
if (!screen->caps.npot_textures &&
(!util_is_power_of_two_or_zero(src_templ.width0) ||
!util_is_power_of_two_or_zero(src_templ.height0) ||
!util_is_power_of_two_or_zero(src_templ.depth0))) {
@@ -2490,7 +2490,7 @@ st_CompressedTexSubImage(struct gl_context *ctx, GLuint dims,
}
if (!st->pbo.upload_enabled ||
!screen->get_param(screen, PIPE_CAP_SURFACE_REINTERPRET_BLOCKS)) {
!screen->caps.surface_reinterpret_blocks) {
goto fallback;
}

93
src/mesa/state_tracker/st_context.c
View File

@@ -447,7 +447,7 @@ st_create_context_priv(struct gl_context *ctx, struct pipe_context *pipe,
st->pipe = pipe;
st->can_bind_const_buffer_as_vertex =
screen->get_param(screen, PIPE_CAP_CAN_BIND_CONST_BUFFER_AS_VERTEX);
screen->caps.can_bind_const_buffer_as_vertex;
/* st/mesa always uploads zero-stride vertex attribs, and other user
* vertex buffers are only possible with a compatibility profile.
@@ -480,14 +480,14 @@ st_create_context_priv(struct gl_context *ctx, struct pipe_context *pipe,
st_init_clear(st);
{
enum pipe_texture_transfer_mode val = screen->get_param(screen, PIPE_CAP_TEXTURE_TRANSFER_MODES);
enum pipe_texture_transfer_mode val = screen->caps.texture_transfer_modes;
st->prefer_blit_based_texture_transfer = (val & PIPE_TEXTURE_TRANSFER_BLIT) != 0;
st->allow_compute_based_texture_transfer = (val & PIPE_TEXTURE_TRANSFER_COMPUTE) != 0;
}
st_init_pbo_helpers(st);
/* Choose texture target for glDrawPixels, glBitmap, renderbuffers */
if (screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES))
if (screen->caps.npot_textures)
st->internal_target = PIPE_TEXTURE_2D;
else
st->internal_target = PIPE_TEXTURE_RECT;
@@ -513,7 +513,7 @@ st_create_context_priv(struct gl_context *ctx, struct pipe_context *pipe,
}
ctx->Const.PackedDriverUniformStorage =
screen->get_param(screen, PIPE_CAP_PACKED_UNIFORMS);
screen->caps.packed_uniforms;
ctx->Const.BitmapUsesRed =
screen->is_format_supported(screen, PIPE_FORMAT_R8_UNORM,
@@ -521,10 +521,10 @@ st_create_context_priv(struct gl_context *ctx, struct pipe_context *pipe,
PIPE_BIND_SAMPLER_VIEW);
ctx->Const.QueryCounterBits.Timestamp =
screen->get_param(screen, PIPE_CAP_QUERY_TIMESTAMP_BITS);
screen->caps.query_timestamp_bits;
st->has_stencil_export =
screen->get_param(screen, PIPE_CAP_SHADER_STENCIL_EXPORT);
screen->caps.shader_stencil_export;
st->has_etc1 = screen->is_format_supported(screen, PIPE_FORMAT_ETC1_RGB8,
PIPE_TEXTURE_2D, 0, 0,
PIPE_BIND_SAMPLER_VIEW);
@@ -549,7 +549,7 @@ st_create_context_priv(struct gl_context *ctx, struct pipe_context *pipe,
screen->is_format_supported(screen, PIPE_FORMAT_ASTC_5x5_SRGB,
PIPE_TEXTURE_2D, 0, 0, PIPE_BIND_SAMPLER_VIEW);
st->astc_void_extents_need_denorm_flush =
screen->get_param(screen, PIPE_CAP_ASTC_VOID_EXTENTS_NEED_DENORM_FLUSH);
screen->caps.astc_void_extents_need_denorm_flush;
st->has_s3tc = screen->is_format_supported(screen, PIPE_FORMAT_DXT5_RGBA,
PIPE_TEXTURE_2D, 0, 0,
@@ -564,49 +564,48 @@ st_create_context_priv(struct gl_context *ctx, struct pipe_context *pipe,
PIPE_TEXTURE_2D, 0, 0,
PIPE_BIND_SAMPLER_VIEW);
st->force_persample_in_shader =
screen->get_param(screen, PIPE_CAP_SAMPLE_SHADING) &&
!screen->get_param(screen, PIPE_CAP_FORCE_PERSAMPLE_INTERP);
st->has_shareable_shaders = screen->get_param(screen,
PIPE_CAP_SHAREABLE_SHADERS);
screen->caps.sample_shading &&
!screen->caps.force_persample_interp;
st->has_shareable_shaders = screen->caps.shareable_shaders;
st->needs_texcoord_semantic =
screen->get_param(screen, PIPE_CAP_TGSI_TEXCOORD);
screen->caps.tgsi_texcoord;
st->apply_texture_swizzle_to_border_color =
!!(screen->get_param(screen, PIPE_CAP_TEXTURE_BORDER_COLOR_QUIRK) &
!!(screen->caps.texture_border_color_quirk &
(PIPE_QUIRK_TEXTURE_BORDER_COLOR_SWIZZLE_NV50 |
PIPE_QUIRK_TEXTURE_BORDER_COLOR_SWIZZLE_R600));
st->use_format_with_border_color =
!!(screen->get_param(screen, PIPE_CAP_TEXTURE_BORDER_COLOR_QUIRK) &
!!(screen->caps.texture_border_color_quirk &
PIPE_QUIRK_TEXTURE_BORDER_COLOR_SWIZZLE_FREEDRENO);
st->alpha_border_color_is_not_w =
!!(screen->get_param(screen, PIPE_CAP_TEXTURE_BORDER_COLOR_QUIRK) &
!!(screen->caps.texture_border_color_quirk &
PIPE_QUIRK_TEXTURE_BORDER_COLOR_SWIZZLE_ALPHA_NOT_W);
st->emulate_gl_clamp =
!screen->get_param(screen, PIPE_CAP_GL_CLAMP);
!screen->caps.gl_clamp;
st->has_time_elapsed =
screen->get_param(screen, PIPE_CAP_QUERY_TIME_ELAPSED);
screen->caps.query_time_elapsed;
ctx->Const.GLSLHasHalfFloatPacking =
screen->get_param(screen, PIPE_CAP_SHADER_PACK_HALF_FLOAT);
screen->caps.shader_pack_half_float;
st->has_multi_draw_indirect =
screen->get_param(screen, PIPE_CAP_MULTI_DRAW_INDIRECT);
screen->caps.multi_draw_indirect;
st->has_indirect_partial_stride =
screen->get_param(screen, PIPE_CAP_MULTI_DRAW_INDIRECT_PARTIAL_STRIDE);
screen->caps.multi_draw_indirect_partial_stride;
st->has_occlusion_query =
screen->get_param(screen, PIPE_CAP_OCCLUSION_QUERY);
screen->caps.occlusion_query;
st->has_single_pipe_stat =
screen->get_param(screen, PIPE_CAP_QUERY_PIPELINE_STATISTICS_SINGLE);
screen->caps.query_pipeline_statistics_single;
st->has_pipeline_stat =
screen->get_param(screen, PIPE_CAP_QUERY_PIPELINE_STATISTICS);
screen->caps.query_pipeline_statistics;
st->has_indep_blend_enable =
screen->get_param(screen, PIPE_CAP_INDEP_BLEND_ENABLE);
screen->caps.indep_blend_enable;
st->has_indep_blend_func =
screen->get_param(screen, PIPE_CAP_INDEP_BLEND_FUNC);
screen->caps.indep_blend_func;
st->can_dither =
screen->get_param(screen, PIPE_CAP_DITHERING);
screen->caps.dithering;
st->lower_flatshade =
!screen->get_param(screen, PIPE_CAP_FLATSHADE);
!screen->caps.flatshade;
st->lower_alpha_test =
!screen->get_param(screen, PIPE_CAP_ALPHA_TEST);
switch (screen->get_param(screen, PIPE_CAP_POINT_SIZE_FIXED)) {
!screen->caps.alpha_test;
switch (screen->caps.point_size_fixed) {
case PIPE_POINT_SIZE_LOWER_ALWAYS:
st->lower_point_size = true;
st->add_point_size = true;
@@ -617,17 +616,17 @@ st_create_context_priv(struct gl_context *ctx, struct pipe_context *pipe,
default: break;
}
st->lower_two_sided_color =
!screen->get_param(screen, PIPE_CAP_TWO_SIDED_COLOR);
!screen->caps.two_sided_color;
st->lower_ucp =
!screen->get_param(screen, PIPE_CAP_CLIP_PLANES);
!screen->caps.clip_planes;
st->prefer_real_buffer_in_constbuf0 =
screen->get_param(screen, PIPE_CAP_PREFER_REAL_BUFFER_IN_CONSTBUF0);
screen->caps.prefer_real_buffer_in_constbuf0;
st->has_conditional_render =
screen->get_param(screen, PIPE_CAP_CONDITIONAL_RENDER);
screen->caps.conditional_render;
st->lower_rect_tex =
!screen->get_param(screen, PIPE_CAP_TEXRECT);
!screen->caps.texrect;
st->allow_st_finalize_nir_twice =
screen->get_param(screen, PIPE_CAP_CALL_FINALIZE_NIR_IN_LINKER);
screen->caps.call_finalize_nir_in_linker;
st->has_hw_atomics =
screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
@@ -635,15 +634,14 @@ st_create_context_priv(struct gl_context *ctx, struct pipe_context *pipe,
? true : false;
st->validate_all_dirty_states =
screen->get_param(screen, PIPE_CAP_VALIDATE_ALL_DIRTY_STATES)
screen->caps.validate_all_dirty_states
? true : false;
st->can_null_texture =
screen->get_param(screen, PIPE_CAP_NULL_TEXTURES)
screen->caps.null_textures
? true : false;
util_throttle_init(&st->throttle,
screen->get_param(screen,
PIPE_CAP_MAX_TEXTURE_UPLOAD_MEMORY_BUDGET));
screen->caps.max_texture_upload_memory_budget);
/* GL limits and extensions */
st_init_limits(screen, &ctx->Const, &ctx->Extensions, ctx->API);
@@ -655,12 +653,12 @@ st_create_context_priv(struct gl_context *ctx, struct pipe_context *pipe,
}
/* Enable shader-based fallbacks for ARB_color_buffer_float if needed. */
if (screen->get_param(screen, PIPE_CAP_VERTEX_COLOR_UNCLAMPED)) {
if (!screen->get_param(screen, PIPE_CAP_VERTEX_COLOR_CLAMPED)) {
if (screen->caps.vertex_color_unclamped) {
if (!screen->caps.vertex_color_clamped) {
st->clamp_vert_color_in_shader = GL_TRUE;
}
if (!screen->get_param(screen, PIPE_CAP_FRAGMENT_COLOR_CLAMPED)) {
if (!screen->caps.fragment_color_clamped) {
st->clamp_frag_color_in_shader = GL_TRUE;
}
@@ -681,11 +679,10 @@ st_create_context_priv(struct gl_context *ctx, struct pipe_context *pipe,
ctx->Point.MaxSize = MAX2(ctx->Const.MaxPointSize,
ctx->Const.MaxPointSizeAA);
ctx->Const.NoClippingOnCopyTex = screen->get_param(screen,
PIPE_CAP_NO_CLIP_ON_COPY_TEX);
ctx->Const.NoClippingOnCopyTex = screen->caps.no_clip_on_copy_tex;
ctx->Const.ForceFloat32TexNearest =
!screen->get_param(screen, PIPE_CAP_TEXTURE_FLOAT_LINEAR);
!screen->caps.texture_float_linear;
ctx->Const.ShaderCompilerOptions[MESA_SHADER_VERTEX].PositionAlwaysInvariant = options->vs_position_always_invariant;
@@ -764,7 +761,7 @@ st_create_context_priv(struct gl_context *ctx, struct pipe_context *pipe,
list_inithead(&st->zombie_shaders.list.node);
simple_mtx_init(&st->zombie_shaders.mutex, mtx_plain);
ctx->Const.DriverSupportedPrimMask = screen->get_param(screen, PIPE_CAP_SUPPORTED_PRIM_MODES) |
ctx->Const.DriverSupportedPrimMask = screen->caps.supported_prim_modes |
/* patches is always supported */
BITFIELD_BIT(MESA_PRIM_PATCHES);
st->active_states = _mesa_get_active_states(ctx);
@@ -843,10 +840,10 @@ st_create_context(gl_api api, struct pipe_context *pipe,
if (debug_get_option_mesa_mvp_dp4())
ctx->Const.ShaderCompilerOptions[MESA_SHADER_VERTEX].OptimizeForAOS = GL_TRUE;
if (pipe->screen->get_param(pipe->screen, PIPE_CAP_INVALIDATE_BUFFER))
if (pipe->screen->caps.invalidate_buffer)
ctx->has_invalidate_buffer = true;
if (pipe->screen->get_param(pipe->screen, PIPE_CAP_STRING_MARKER))
if (pipe->screen->caps.string_marker)
ctx->has_string_marker = true;
st = st_create_context_priv(ctx, pipe, options);

223
src/mesa/state_tracker/st_extensions.c
View File

@@ -115,24 +115,24 @@ void st_init_limits(struct pipe_screen *screen,
bool can_ubo = true;
int temp;
c->MaxTextureSize = screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_2D_SIZE);
c->MaxTextureSize = screen->caps.max_texture_2d_size;
c->MaxTextureSize = MIN2(c->MaxTextureSize, 1 << (MAX_TEXTURE_LEVELS - 1));
c->MaxTextureMbytes = MAX2(c->MaxTextureMbytes,
screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_MB));
screen->caps.max_texture_mb);
c->Max3DTextureLevels
= _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_3D_LEVELS),
= _min(screen->caps.max_texture_3d_levels,
MAX_TEXTURE_LEVELS);
extensions->OES_texture_3D = c->Max3DTextureLevels != 0;
c->MaxCubeTextureLevels
= _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS),
= _min(screen->caps.max_texture_cube_levels,
MAX_TEXTURE_LEVELS);
c->MaxTextureRectSize = _min(c->MaxTextureSize, MAX_TEXTURE_RECT_SIZE);
c->MaxArrayTextureLayers
= screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS);
= screen->caps.max_texture_array_layers;
/* Define max viewport size and max renderbuffer size in terms of
* max texture size (note: max tex RECT size = max tex 2D size).
@@ -143,17 +143,16 @@ void st_init_limits(struct pipe_screen *screen,
c->MaxRenderbufferSize = c->MaxTextureRectSize;
c->SubPixelBits =
screen->get_param(screen, PIPE_CAP_RASTERIZER_SUBPIXEL_BITS);
screen->caps.rasterizer_subpixel_bits;
c->ViewportSubpixelBits =
screen->get_param(screen, PIPE_CAP_VIEWPORT_SUBPIXEL_BITS);
screen->caps.viewport_subpixel_bits;
c->MaxDrawBuffers = c->MaxColorAttachments =
_clamp(screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS),
_clamp(screen->caps.max_render_targets,
1, MAX_DRAW_BUFFERS);
c->MaxDualSourceDrawBuffers =
_clamp(screen->get_param(screen,
PIPE_CAP_MAX_DUAL_SOURCE_RENDER_TARGETS),
_clamp(screen->caps.max_dual_source_render_targets,
0, MAX_DRAW_BUFFERS);
c->MaxLineWidth =
@@ -182,11 +181,10 @@ void st_init_limits(struct pipe_screen *screen,
_minf(31.0f, screen->get_paramf(screen, PIPE_CAPF_MAX_TEXTURE_LOD_BIAS));
c->QuadsFollowProvokingVertexConvention =
screen->get_param(screen,
PIPE_CAP_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION);
screen->caps.quads_follow_provoking_vertex_convention;
c->MaxUniformBlockSize =
screen->get_param(screen, PIPE_CAP_MAX_CONSTANT_BUFFER_SIZE_UINT);
screen->caps.max_constant_buffer_size_uint;
if (c->MaxUniformBlockSize < 16384) {
can_ubo = false;
@@ -197,9 +195,9 @@ void st_init_limits(struct pipe_screen *screen,
*/
c->MaxUniformBlockSize &= ~3;
c->HasFBFetch = screen->get_param(screen, PIPE_CAP_FBFETCH);
c->HasFBFetch = screen->caps.fbfetch;
c->PointSizeFixed = screen->get_param(screen, PIPE_CAP_POINT_SIZE_FIXED) != PIPE_POINT_SIZE_LOWER_ALWAYS;
c->PointSizeFixed = screen->caps.point_size_fixed != PIPE_POINT_SIZE_LOWER_ALWAYS;
for (sh = 0; sh < PIPE_SHADER_TYPES; ++sh) {
const gl_shader_stage stage = tgsi_processor_to_shader_stage(sh);
@@ -216,7 +214,7 @@ void st_init_limits(struct pipe_screen *screen,
}
if (sh == PIPE_SHADER_COMPUTE) {
if (!screen->get_param(screen, PIPE_CAP_COMPUTE))
if (!screen->caps.compute)
continue;
}
@@ -250,13 +248,13 @@ void st_init_limits(struct pipe_screen *screen,
sh == PIPE_SHADER_TESS_EVAL ||
sh == PIPE_SHADER_GEOMETRY) {
if (!screen->get_param(screen, PIPE_CAP_CLIP_PLANES))
if (!screen->caps.clip_planes)
pc->MaxUniformComponents -= 4 * MAX_CLIP_PLANES;
if (!screen->get_param(screen, PIPE_CAP_POINT_SIZE_FIXED))
if (!screen->caps.point_size_fixed)
pc->MaxUniformComponents -= 4;
} else if (sh == PIPE_SHADER_FRAGMENT) {
if (!screen->get_param(screen, PIPE_CAP_ALPHA_TEST))
if (!screen->caps.alpha_test)
pc->MaxUniformComponents -= 4;
}
@@ -364,9 +362,9 @@ void st_init_limits(struct pipe_screen *screen,
}
if (sh == PIPE_SHADER_VERTEX || sh == PIPE_SHADER_GEOMETRY) {
if (screen->get_param(screen, PIPE_CAP_VIEWPORT_TRANSFORM_LOWERED))
if (screen->caps.viewport_transform_lowered)
options->LowerBuiltinVariablesXfb |= VARYING_BIT_POS;
if (screen->get_param(screen, PIPE_CAP_PSIZ_CLAMPED))
if (screen->caps.psiz_clamped)
options->LowerBuiltinVariablesXfb |= VARYING_BIT_PSIZ;
}
@@ -390,9 +388,9 @@ void st_init_limits(struct pipe_screen *screen,
c->Program[MESA_SHADER_FRAGMENT].MaxUniformComponents;
c->GLSLLowerConstArrays =
screen->get_param(screen, PIPE_CAP_PREFER_IMM_ARRAYS_AS_CONSTBUF);
screen->caps.prefer_imm_arrays_as_constbuf;
c->GLSLTessLevelsAsInputs =
screen->get_param(screen, PIPE_CAP_GLSL_TESS_LEVELS_AS_INPUTS);
screen->caps.glsl_tess_levels_as_inputs;
c->PrimitiveRestartForPatches = false;
c->MaxCombinedTextureImageUnits =
@@ -416,59 +414,58 @@ void st_init_limits(struct pipe_screen *screen,
c->Program[MESA_SHADER_VERTEX].MaxAttribs =
MIN2(c->Program[MESA_SHADER_VERTEX].MaxAttribs, 16);
c->MaxVarying = screen->get_param(screen, PIPE_CAP_MAX_VARYINGS);
c->MaxVarying = screen->caps.max_varyings;
c->MaxVarying = MIN2(c->MaxVarying, MAX_VARYING);
c->MaxGeometryOutputVertices =
screen->get_param(screen, PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES);
screen->caps.max_geometry_output_vertices;
c->MaxGeometryTotalOutputComponents =
screen->get_param(screen, PIPE_CAP_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS);
screen->caps.max_geometry_total_output_components;
c->MaxGeometryShaderInvocations =
screen->get_param(screen, PIPE_CAP_MAX_GS_INVOCATIONS);
screen->caps.max_gs_invocations;
c->MaxTessPatchComponents =
MIN2(screen->get_param(screen, PIPE_CAP_MAX_SHADER_PATCH_VARYINGS),
MIN2(screen->caps.max_shader_patch_varyings,
MAX_VARYING) * 4;
c->MinProgramTexelOffset =
screen->get_param(screen, PIPE_CAP_MIN_TEXEL_OFFSET);
screen->caps.min_texel_offset;
c->MaxProgramTexelOffset =
screen->get_param(screen, PIPE_CAP_MAX_TEXEL_OFFSET);
screen->caps.max_texel_offset;
c->MaxProgramTextureGatherComponents =
screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_GATHER_COMPONENTS);
screen->caps.max_texture_gather_components;
c->MinProgramTextureGatherOffset =
screen->get_param(screen, PIPE_CAP_MIN_TEXTURE_GATHER_OFFSET);
screen->caps.min_texture_gather_offset;
c->MaxProgramTextureGatherOffset =
screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_GATHER_OFFSET);
screen->caps.max_texture_gather_offset;
c->MaxTransformFeedbackBuffers =
screen->get_param(screen, PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS);
screen->caps.max_stream_output_buffers;
c->MaxTransformFeedbackBuffers = MIN2(c->MaxTransformFeedbackBuffers,
MAX_FEEDBACK_BUFFERS);
c->MaxTransformFeedbackSeparateComponents =
screen->get_param(screen, PIPE_CAP_MAX_STREAM_OUTPUT_SEPARATE_COMPONENTS);
screen->caps.max_stream_output_separate_components;
c->MaxTransformFeedbackInterleavedComponents =
screen->get_param(screen,
PIPE_CAP_MAX_STREAM_OUTPUT_INTERLEAVED_COMPONENTS);
screen->caps.max_stream_output_interleaved_components;
c->MaxVertexStreams =
MAX2(1, screen->get_param(screen, PIPE_CAP_MAX_VERTEX_STREAMS));
MAX2(1, screen->caps.max_vertex_streams);
/* The vertex stream must fit into pipe_stream_output_info::stream */
assert(c->MaxVertexStreams <= 4);
c->MaxVertexAttribStride
= screen->get_param(screen, PIPE_CAP_MAX_VERTEX_ATTRIB_STRIDE);
= screen->caps.max_vertex_attrib_stride;
/* The value cannot be larger than that since pipe_vertex_buffer::src_offset
* is only 16 bits.
*/
temp = screen->get_param(screen, PIPE_CAP_MAX_VERTEX_ELEMENT_SRC_OFFSET);
temp = screen->caps.max_vertex_element_src_offset;
c->MaxVertexAttribRelativeOffset = MIN2(0xffff, temp);
c->GLSLSkipStrictMaxUniformLimitCheck =
screen->get_param(screen, PIPE_CAP_TGSI_CAN_COMPACT_CONSTANTS);
screen->caps.tgsi_can_compact_constants;
c->UniformBufferOffsetAlignment =
screen->get_param(screen, PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT);
screen->caps.constant_buffer_offset_alignment;
if (can_ubo) {
extensions->ARB_uniform_buffer_object = GL_TRUE;
@@ -483,17 +480,17 @@ void st_init_limits(struct pipe_screen *screen,
}
c->GLSLFragCoordIsSysVal =
screen->get_param(screen, PIPE_CAP_FS_POSITION_IS_SYSVAL);
screen->caps.fs_position_is_sysval;
c->GLSLPointCoordIsSysVal =
screen->get_param(screen, PIPE_CAP_FS_POINT_IS_SYSVAL);
screen->caps.fs_point_is_sysval;
c->GLSLFrontFacingIsSysVal =
screen->get_param(screen, PIPE_CAP_FS_FACE_IS_INTEGER_SYSVAL);
screen->caps.fs_face_is_integer_sysval;
/* GL_ARB_get_program_binary */
if (screen->get_disk_shader_cache && screen->get_disk_shader_cache(screen))
c->NumProgramBinaryFormats = 1;
/* GL_ARB_gl_spirv */
if (screen->get_param(screen, PIPE_CAP_GL_SPIRV) &&
if (screen->caps.gl_spirv &&
(api == API_OPENGL_CORE || api == API_OPENGL_COMPAT))
c->NumShaderBinaryFormats = 1;
@@ -505,8 +502,7 @@ void st_init_limits(struct pipe_screen *screen,
c->Program[MESA_SHADER_COMPUTE].MaxAtomicCounters);
c->MaxCombinedAtomicBuffers =
MIN2(screen->get_param(screen,
PIPE_CAP_MAX_COMBINED_HW_ATOMIC_COUNTER_BUFFERS),
MIN2(screen->caps.max_combined_hw_atomic_counter_buffers,
MAX_COMBINED_ATOMIC_BUFFERS);
if (!c->MaxCombinedAtomicBuffers) {
c->MaxCombinedAtomicBuffers = MAX2(
@@ -520,7 +516,7 @@ void st_init_limits(struct pipe_screen *screen,
}
c->MaxCombinedAtomicCounters =
screen->get_param(screen, PIPE_CAP_MAX_COMBINED_HW_ATOMIC_COUNTERS);
screen->caps.max_combined_hw_atomic_counters;
if (!c->MaxCombinedAtomicCounters)
c->MaxCombinedAtomicCounters = MAX_ATOMIC_COUNTERS;
@@ -531,10 +527,10 @@ void st_init_limits(struct pipe_screen *screen,
c->MaxCombinedShaderOutputResources = c->MaxDrawBuffers;
c->ShaderStorageBufferOffsetAlignment =
screen->get_param(screen, PIPE_CAP_SHADER_BUFFER_OFFSET_ALIGNMENT);
screen->caps.shader_buffer_offset_alignment;
if (c->ShaderStorageBufferOffsetAlignment) {
c->MaxCombinedShaderStorageBlocks =
MIN2(screen->get_param(screen, PIPE_CAP_MAX_COMBINED_SHADER_BUFFERS),
MIN2(screen->caps.max_combined_shader_buffers,
MAX_COMBINED_SHADER_STORAGE_BUFFERS);
if (!c->MaxCombinedShaderStorageBlocks) {
c->MaxCombinedShaderStorageBlocks = MAX2(
@@ -551,7 +547,7 @@ void st_init_limits(struct pipe_screen *screen,
c->MaxCombinedShaderOutputResources +=
c->MaxCombinedShaderStorageBlocks;
c->MaxShaderStorageBlockSize =
screen->get_param(screen, PIPE_CAP_MAX_SHADER_BUFFER_SIZE_UINT);
screen->caps.max_shader_buffer_size_uint;
if (c->Program[MESA_SHADER_FRAGMENT].MaxShaderStorageBlocks)
extensions->ARB_shader_storage_buffer_object = GL_TRUE;
}
@@ -566,7 +562,7 @@ void st_init_limits(struct pipe_screen *screen,
c->MaxCombinedShaderOutputResources += c->MaxCombinedImageUniforms;
c->MaxImageUnits = MAX_IMAGE_UNITS;
if (c->Program[MESA_SHADER_FRAGMENT].MaxImageUniforms &&
screen->get_param(screen, PIPE_CAP_IMAGE_STORE_FORMATTED)) {
screen->caps.image_store_formatted) {
extensions->ARB_shader_image_load_store = GL_TRUE;
extensions->ARB_shader_image_size = GL_TRUE;
}
@@ -581,22 +577,22 @@ void st_init_limits(struct pipe_screen *screen,
* in practicality.
*/
c->MaxFramebufferLayers =
screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS);
screen->caps.max_texture_array_layers;
c->MaxWindowRectangles =
screen->get_param(screen, PIPE_CAP_MAX_WINDOW_RECTANGLES);
screen->caps.max_window_rectangles;
c->SparseBufferPageSize =
screen->get_param(screen, PIPE_CAP_SPARSE_BUFFER_PAGE_SIZE);
screen->caps.sparse_buffer_page_size;
c->AllowMappedBuffersDuringExecution =
screen->get_param(screen, PIPE_CAP_ALLOW_MAPPED_BUFFERS_DURING_EXECUTION);
screen->caps.allow_mapped_buffers_during_execution;
c->UseSTD430AsDefaultPacking =
screen->get_param(screen, PIPE_CAP_LOAD_CONSTBUF);
screen->caps.load_constbuf;
c->MaxSubpixelPrecisionBiasBits =
screen->get_param(screen, PIPE_CAP_MAX_CONSERVATIVE_RASTER_SUBPIXEL_PRECISION_BIAS);
screen->caps.max_conservative_raster_subpixel_precision_bias;
c->ConservativeRasterDilateRange[0] =
screen->get_paramf(screen, PIPE_CAPF_MIN_CONSERVATIVE_RASTER_DILATE);
@@ -606,45 +602,45 @@ void st_init_limits(struct pipe_screen *screen,
screen->get_paramf(screen, PIPE_CAPF_CONSERVATIVE_RASTER_DILATE_GRANULARITY);
/* limit the max combined shader output resources to a driver limit */
temp = screen->get_param(screen, PIPE_CAP_MAX_COMBINED_SHADER_OUTPUT_RESOURCES);
temp = screen->caps.max_combined_shader_output_resources;
if (temp > 0 && c->MaxCombinedShaderOutputResources > temp)
c->MaxCombinedShaderOutputResources = temp;
c->VertexBufferOffsetIsInt32 =
screen->get_param(screen, PIPE_CAP_SIGNED_VERTEX_BUFFER_OFFSET);
screen->caps.signed_vertex_buffer_offset;
c->UseVAOFastPath =
screen->get_param(screen, PIPE_CAP_ALLOW_DYNAMIC_VAO_FASTPATH);
screen->caps.allow_dynamic_vao_fastpath;
c->glBeginEndBufferSize =
screen->get_param(screen, PIPE_CAP_GL_BEGIN_END_BUFFER_SIZE);
screen->caps.gl_begin_end_buffer_size;
c->MaxSparseTextureSize =
screen->get_param(screen, PIPE_CAP_MAX_SPARSE_TEXTURE_SIZE);
screen->caps.max_sparse_texture_size;
c->MaxSparse3DTextureSize =
screen->get_param(screen, PIPE_CAP_MAX_SPARSE_3D_TEXTURE_SIZE);
screen->caps.max_sparse_3d_texture_size;
c->MaxSparseArrayTextureLayers =
screen->get_param(screen, PIPE_CAP_MAX_SPARSE_ARRAY_TEXTURE_LAYERS);
screen->caps.max_sparse_array_texture_layers;
c->SparseTextureFullArrayCubeMipmaps =
screen->get_param(screen, PIPE_CAP_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS);
screen->caps.sparse_texture_full_array_cube_mipmaps;
c->HardwareAcceleratedSelect =
screen->get_param(screen, PIPE_CAP_HARDWARE_GL_SELECT);
screen->caps.hardware_gl_select;
c->AllowGLThreadBufferSubDataOpt =
screen->get_param(screen, PIPE_CAP_ALLOW_GLTHREAD_BUFFER_SUBDATA_OPT);
screen->caps.allow_glthread_buffer_subdata_opt;
c->HasDrawVertexState =
screen->get_param(screen, PIPE_CAP_DRAW_VERTEX_STATE);
screen->caps.draw_vertex_state;
c->ShaderSubgroupSize =
screen->get_param(screen, PIPE_CAP_SHADER_SUBGROUP_SIZE);
screen->caps.shader_subgroup_size;
c->ShaderSubgroupSupportedStages =
mesa_to_gl_stages(screen->get_param(screen, PIPE_CAP_SHADER_SUBGROUP_SUPPORTED_STAGES));
mesa_to_gl_stages(screen->caps.shader_subgroup_supported_stages);
c->ShaderSubgroupSupportedFeatures =
screen->get_param(screen, PIPE_CAP_SHADER_SUBGROUP_SUPPORTED_FEATURES);
screen->caps.shader_subgroup_supported_features;
c->ShaderSubgroupQuadAllStages =
screen->get_param(screen, PIPE_CAP_SHADER_SUBGROUP_QUAD_ALL_STAGES);
screen->caps.shader_subgroup_quad_all_stages;
}
@@ -1174,12 +1170,12 @@ void st_init_extensions(struct pipe_screen *screen,
PIPE_BIND_VERTEX_BUFFER);
/* Figure out GLSL support and set GLSLVersion to it. */
consts->GLSLVersion = screen->get_param(screen, PIPE_CAP_GLSL_FEATURE_LEVEL);
consts->GLSLVersion = screen->caps.glsl_feature_level;
consts->GLSLVersionCompat =
screen->get_param(screen, PIPE_CAP_GLSL_FEATURE_LEVEL_COMPATIBILITY);
screen->caps.glsl_feature_level_compatibility;
const unsigned ESSLVersion =
screen->get_param(screen, PIPE_CAP_ESSL_FEATURE_LEVEL);
screen->caps.essl_feature_level;
const unsigned GLSLVersion =
api == API_OPENGL_COMPAT ? consts->GLSLVersionCompat :
consts->GLSLVersion;
@@ -1213,7 +1209,7 @@ void st_init_extensions(struct pipe_screen *screen,
consts->ForceMapBufferSynchronized = options->force_gl_map_buffer_synchronized;
consts->PrimitiveRestartFixedIndex =
screen->get_param(screen, PIPE_CAP_PRIMITIVE_RESTART_FIXED_INDEX);
screen->caps.primitive_restart_fixed_index;
/* Technically we are turning on the EXT_gpu_shader5 extension,
* ARB_gpu_shader5 does not exist in GLES, but this flag is what
@@ -1230,7 +1226,7 @@ void st_init_extensions(struct pipe_screen *screen,
/* This extension needs full OpenGL 3.2, but we don't know if that's
* supported at this point. Only check the GLSL version. */
if (GLSLVersion >= 150 &&
screen->get_param(screen, PIPE_CAP_VS_LAYER_VIEWPORT)) {
screen->caps.vs_layer_viewport) {
extensions->AMD_vertex_shader_layer = GL_TRUE;
}
@@ -1244,7 +1240,7 @@ void st_init_extensions(struct pipe_screen *screen,
extensions->EXT_texture_buffer_object = GL_TRUE;
if (consts->MaxTransformFeedbackBuffers &&
screen->get_param(screen, PIPE_CAP_SHADER_ARRAY_COMPONENTS))
screen->caps.shader_array_components)
extensions->ARB_enhanced_layouts = GL_TRUE;
}
@@ -1252,7 +1248,7 @@ void st_init_extensions(struct pipe_screen *screen,
consts->NativeIntegers = GL_TRUE;
consts->MaxClipPlanes = 8;
uint32_t drv_clip_planes = screen->get_param(screen, PIPE_CAP_CLIP_PLANES);
uint32_t drv_clip_planes = screen->caps.clip_planes;
/* only override for > 1 - 0 if none, 1 is MAX, >2 overrides MAX */
if (drv_clip_planes > 1)
consts->MaxClipPlanes = drv_clip_planes;
@@ -1270,7 +1266,7 @@ void st_init_extensions(struct pipe_screen *screen,
extensions->ARB_arrays_of_arrays = GL_TRUE;
extensions->MESA_shader_integer_functions = GL_TRUE;
switch (screen->get_param(screen, PIPE_CAP_MULTIVIEW)) {
switch (screen->caps.multiview) {
case 1:
extensions->OVR_multiview = GL_TRUE;
break;
@@ -1283,8 +1279,8 @@ void st_init_extensions(struct pipe_screen *screen,
extensions->OVR_multiview_multisampled_render_to_texture = extensions->EXT_multisampled_render_to_texture &&
extensions->OVR_multiview;
if (screen->get_param(screen, PIPE_CAP_OPENCL_INTEGER_FUNCTIONS) &&
screen->get_param(screen, PIPE_CAP_INTEGER_MULTIPLY_32X16)) {
if (screen->caps.opencl_integer_functions &&
screen->caps.integer_multiply_32x16) {
extensions->INTEL_shader_integer_functions2 = GL_TRUE;
}
} else {
@@ -1306,7 +1302,7 @@ void st_init_extensions(struct pipe_screen *screen,
if (options->glsl_zero_init) {
consts->GLSLZeroInit = 1;
} else {
consts->GLSLZeroInit = screen->get_param(screen, PIPE_CAP_GLSL_ZERO_INIT);
consts->GLSLZeroInit = screen->caps.glsl_zero_init;
}
consts->ForceIntegerTexNearest = options->force_integer_tex_nearest;
@@ -1476,7 +1472,7 @@ void st_init_extensions(struct pipe_screen *screen,
extensions->EXT_framebuffer_multisample_blit_scaled = GL_TRUE;
}
else if (consts->MaxSamples > 0 &&
screen->get_param(screen, PIPE_CAP_FAKE_SW_MSAA)) {
screen->caps.fake_sw_msaa) {
/* fake MSAA support */
consts->FakeSWMSAA = GL_TRUE;
extensions->EXT_framebuffer_multisample = GL_TRUE;
@@ -1488,7 +1484,7 @@ void st_init_extensions(struct pipe_screen *screen,
!options->disable_blend_func_extended)
extensions->ARB_blend_func_extended = GL_TRUE;
if (screen->get_param(screen, PIPE_CAP_QUERY_TIME_ELAPSED) ||
if (screen->caps.query_time_elapsed ||
extensions->ARB_timer_query) {
extensions->EXT_timer_query = GL_TRUE;
}
@@ -1524,18 +1520,18 @@ void st_init_extensions(struct pipe_screen *screen,
consts->AllowGLSLRelaxedES = GL_TRUE;
consts->MinMapBufferAlignment =
screen->get_param(screen, PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT);
screen->caps.min_map_buffer_alignment;
/* The OpenGL Compatibility profile requires arbitrary buffer swizzling. */
if (api == API_OPENGL_COMPAT &&
screen->get_param(screen, PIPE_CAP_BUFFER_SAMPLER_VIEW_RGBA_ONLY))
screen->caps.buffer_sampler_view_rgba_only)
extensions->ARB_texture_buffer_object = GL_FALSE;
if (extensions->ARB_texture_buffer_object) {
consts->MaxTextureBufferSize =
screen->get_param(screen, PIPE_CAP_MAX_TEXEL_BUFFER_ELEMENTS_UINT);
screen->caps.max_texel_buffer_elements_uint;
consts->TextureBufferOffsetAlignment =
screen->get_param(screen, PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT);
screen->caps.texture_buffer_offset_alignment;
if (consts->TextureBufferOffsetAlignment)
extensions->ARB_texture_buffer_range = GL_TRUE;
@@ -1552,7 +1548,7 @@ void st_init_extensions(struct pipe_screen *screen,
extensions->ARB_texture_buffer_object_rgb32;
extensions->EXT_framebuffer_sRGB =
screen->get_param(screen, PIPE_CAP_DEST_SURFACE_SRGB_CONTROL) &&
screen->caps.dest_surface_srgb_control &&
extensions->EXT_sRGB;
/* Unpacking a varying in the fragment shader costs 1 texture indirection.
@@ -1569,17 +1565,16 @@ void st_init_extensions(struct pipe_screen *screen,
consts->DisableVaryingPacking = GL_TRUE;
}
if (!screen->get_param(screen, PIPE_CAP_PACKED_STREAM_OUTPUT))
if (!screen->caps.packed_stream_output)
consts->DisableTransformFeedbackPacking = GL_TRUE;
if (screen->get_param(screen, PIPE_CAP_PREFER_POT_ALIGNED_VARYINGS))
if (screen->caps.prefer_pot_aligned_varyings)
consts->PreferPOTAlignedVaryings = 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);
unsigned max_fb_fetch_rts = screen->caps.fbfetch;
bool coherent_fb_fetch = screen->caps.fbfetch_coherent;
if (screen->get_param(screen, PIPE_CAP_BLEND_EQUATION_ADVANCED))
if (screen->caps.blend_equation_advanced)
extensions->KHR_blend_equation_advanced = true;
if (max_fb_fetch_rts > 0) {
@@ -1587,13 +1582,13 @@ void st_init_extensions(struct pipe_screen *screen,
extensions->KHR_blend_equation_advanced_coherent = coherent_fb_fetch;
if (max_fb_fetch_rts >=
screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS)) {
screen->caps.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);
consts->MaxViewports = screen->caps.max_viewports;
if (consts->MaxViewports >= 16) {
if (GLSLVersion >= 400) {
consts->ViewportBounds.Min = -32768.0;
@@ -1610,11 +1605,11 @@ void st_init_extensions(struct pipe_screen *screen,
if (extensions->AMD_vertex_shader_layer &&
extensions->AMD_vertex_shader_viewport_index &&
screen->get_param(screen, PIPE_CAP_TES_LAYER_VIEWPORT))
screen->caps.tes_layer_viewport)
extensions->ARB_shader_viewport_layer_array = GL_TRUE;
/* ARB_framebuffer_no_attachments */
if (screen->get_param(screen, PIPE_CAP_FRAMEBUFFER_NO_ATTACHMENT) &&
if (screen->caps.framebuffer_no_attachment &&
((consts->MaxSamples >= 4 && consts->MaxFramebufferLayers >= 2048) ||
(consts->MaxFramebufferSamples >= consts->MaxSamples &&
consts->MaxFramebufferLayers >= consts->MaxArrayTextureLayers)))
@@ -1660,16 +1655,16 @@ void st_init_extensions(struct pipe_screen *screen,
}
#endif
if (screen->get_param(screen, PIPE_CAP_DOUBLES)) {
if (screen->caps.doubles) {
extensions->ARB_gpu_shader_fp64 = GL_TRUE;
extensions->ARB_vertex_attrib_64bit = GL_TRUE;
}
if ((ST_DEBUG & DEBUG_GREMEDY) &&
screen->get_param(screen, PIPE_CAP_STRING_MARKER))
screen->caps.string_marker)
extensions->GREMEDY_string_marker = GL_TRUE;
if (screen->get_param(screen, PIPE_CAP_COMPUTE)) {
if (screen->caps.compute) {
uint64_t grid_size[3], block_size[3];
uint64_t max_local_size, max_threads_per_block;
@@ -1810,21 +1805,21 @@ void st_init_extensions(struct pipe_screen *screen,
extensions->ARB_texture_stencil8 &&
extensions->ARB_texture_multisample;
if (screen->get_param(screen, PIPE_CAP_CONSERVATIVE_RASTER_POST_SNAP_TRIANGLES) &&
screen->get_param(screen, PIPE_CAP_CONSERVATIVE_RASTER_POST_SNAP_POINTS_LINES) &&
screen->get_param(screen, PIPE_CAP_CONSERVATIVE_RASTER_POST_DEPTH_COVERAGE)) {
if (screen->caps.conservative_raster_post_snap_triangles &&
screen->caps.conservative_raster_post_snap_points_lines &&
screen->caps.conservative_raster_post_depth_coverage) {
float max_dilate;
bool pre_snap_triangles, pre_snap_points_lines;
max_dilate = screen->get_paramf(screen, PIPE_CAPF_MAX_CONSERVATIVE_RASTER_DILATE);
pre_snap_triangles =
screen->get_param(screen, PIPE_CAP_CONSERVATIVE_RASTER_PRE_SNAP_TRIANGLES);
screen->caps.conservative_raster_pre_snap_triangles;
pre_snap_points_lines =
screen->get_param(screen, PIPE_CAP_CONSERVATIVE_RASTER_PRE_SNAP_POINTS_LINES);
screen->caps.conservative_raster_pre_snap_points_lines;
extensions->NV_conservative_raster =
screen->get_param(screen, PIPE_CAP_MAX_CONSERVATIVE_RASTER_SUBPIXEL_PRECISION_BIAS) > 1;
screen->caps.max_conservative_raster_subpixel_precision_bias > 1;
if (extensions->NV_conservative_raster) {
extensions->NV_conservative_raster_dilate = max_dilate >= 0.75;
@@ -1840,7 +1835,7 @@ void st_init_extensions(struct pipe_screen *screen,
extensions->ARB_shader_draw_parameters;
consts->SpirVExtensions->supported[SPV_KHR_storage_buffer_storage_class] = true;
consts->SpirVExtensions->supported[SPV_KHR_variable_pointers] =
screen->get_param(screen, PIPE_CAP_GL_SPIRV_VARIABLE_POINTERS);
screen->caps.gl_spirv_variable_pointers;
consts->SpirVExtensions->supported[SPV_KHR_shader_ballot] =
extensions->ARB_shader_ballot;
consts->SpirVExtensions->supported[SPV_KHR_subgroup_vote] =
@@ -1850,7 +1845,7 @@ void st_init_extensions(struct pipe_screen *screen,
consts->AllowDrawOutOfOrder =
api == API_OPENGL_COMPAT &&
options->allow_draw_out_of_order &&
screen->get_param(screen, PIPE_CAP_ALLOW_DRAW_OUT_OF_ORDER);
screen->caps.allow_draw_out_of_order;
consts->GLThreadNopCheckFramebufferStatus = options->glthread_nop_check_framebuffer_status;
const struct nir_shader_compiler_options *nir_options =
@@ -1858,7 +1853,7 @@ void st_init_extensions(struct pipe_screen *screen,
if (screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_INTEGERS) &&
extensions->ARB_stencil_texturing &&
screen->get_param(screen, PIPE_CAP_DOUBLES) &&
screen->caps.doubles &&
!(nir_options->lower_doubles_options & nir_lower_fp64_full_software))
extensions->NV_copy_depth_to_color = true;
}

3
src/mesa/state_tracker/st_gen_mipmap.c
View File

@@ -141,8 +141,7 @@ st_generate_mipmap(struct gl_context *ctx, GLenum target,
* if not then generate the mipmap by rendering/texturing.
* If that fails, use the software fallback.
*/
if (!st->screen->get_param(st->screen,
PIPE_CAP_GENERATE_MIPMAP) ||
if (!st->screen->caps.generate_mipmap ||
!st->pipe->generate_mipmap(st->pipe, pt, format, baseLevel,
lastLevel, first_layer, last_layer)) {

22
src/mesa/state_tracker/st_glsl_to_nir.cpp
View File

@@ -323,7 +323,7 @@ st_glsl_to_nir_post_opts(struct st_context *st, struct gl_program *prog,
!st->ctx->Const.PackedDriverUniformStorage)
NIR_PASS(_, nir, st_nir_lower_builtin);
if (!screen->get_param(screen, PIPE_CAP_NIR_ATOMICS_AS_DEREF))
if (!screen->caps.nir_atomics_as_deref)
NIR_PASS(_, nir, gl_nir_lower_atomics, shader_program, true);
NIR_PASS(_, nir, nir_opt_intrinsics);
@@ -367,7 +367,7 @@ st_glsl_to_nir_post_opts(struct st_context *st, struct gl_program *prog,
nir_var_shader_in | nir_var_shader_out | nir_var_function_temp;
nir_remove_dead_variables(nir, mask, NULL);
if (!st->has_hw_atomics && !screen->get_param(screen, PIPE_CAP_NIR_ATOMICS_AS_DEREF)) {
if (!st->has_hw_atomics && !screen->caps.nir_atomics_as_deref) {
unsigned align_offset_state = 0;
if (st->ctx->Const.ShaderStorageBufferOffsetAlignment > 4) {
struct gl_program_parameter_list *params = prog->Parameters;
@@ -466,17 +466,13 @@ st_nir_lower_wpos_ytransform(struct nir_shader *nir,
memcpy(wpos_options.state_tokens, wposTransformState,
sizeof(wpos_options.state_tokens));
wpos_options.fs_coord_origin_upper_left =
pscreen->get_param(pscreen,
PIPE_CAP_FS_COORD_ORIGIN_UPPER_LEFT);
pscreen->caps.fs_coord_origin_upper_left;
wpos_options.fs_coord_origin_lower_left =
pscreen->get_param(pscreen,
PIPE_CAP_FS_COORD_ORIGIN_LOWER_LEFT);
pscreen->caps.fs_coord_origin_lower_left;
wpos_options.fs_coord_pixel_center_integer =
pscreen->get_param(pscreen,
PIPE_CAP_FS_COORD_PIXEL_CENTER_INTEGER);
pscreen->caps.fs_coord_pixel_center_integer;
wpos_options.fs_coord_pixel_center_half_integer =
pscreen->get_param(pscreen,
PIPE_CAP_FS_COORD_PIXEL_CENTER_HALF_INTEGER);
pscreen->caps.fs_coord_pixel_center_half_integer;
if (nir_lower_wpos_ytransform(nir, &wpos_options)) {
_mesa_add_state_reference(prog->Parameters, wposTransformState);
@@ -831,7 +827,7 @@ st_nir_lower_samplers(struct pipe_screen *screen, nir_shader *nir,
struct gl_shader_program *shader_program,
struct gl_program *prog)
{
if (screen->get_param(screen, PIPE_CAP_NIR_SAMPLERS_AS_DEREF))
if (screen->caps.nir_samplers_as_deref)
NIR_PASS(_, nir, gl_nir_lower_samplers_as_deref, shader_program);
else
NIR_PASS(_, nir, gl_nir_lower_samplers, shader_program);
@@ -893,7 +889,7 @@ st_finalize_nir(struct st_context *st, struct gl_program *prog,
NIR_PASS(_, nir, nir_lower_var_copies);
const bool lower_tg4_offsets =
!is_draw_shader && !st->screen->get_param(screen, PIPE_CAP_TEXTURE_GATHER_OFFSETS);
!is_draw_shader && !st->screen->caps.texture_gather_offsets;
if (!is_draw_shader && (st->lower_rect_tex || lower_tg4_offsets)) {
struct nir_lower_tex_options opts = {0};
@@ -920,7 +916,7 @@ st_finalize_nir(struct st_context *st, struct gl_program *prog,
}
st_nir_lower_samplers(screen, nir, shader_program, prog);
if (!is_draw_shader && !screen->get_param(screen, PIPE_CAP_NIR_IMAGES_AS_DEREF))
if (!is_draw_shader && !screen->caps.nir_images_as_deref)
NIR_PASS(_, nir, gl_nir_lower_images, false);
}

12
src/mesa/state_tracker/st_interop.c
View File

@@ -48,14 +48,14 @@ st_interop_query_device_info(struct st_context *st,
/* PCI values are obsolete on version >= 4 of the interface */
if (out->version < 4) {
out->pci_segment_group = screen->get_param(screen, PIPE_CAP_PCI_GROUP);
out->pci_bus = screen->get_param(screen, PIPE_CAP_PCI_BUS);
out->pci_device = screen->get_param(screen, PIPE_CAP_PCI_DEVICE);
out->pci_function = screen->get_param(screen, PIPE_CAP_PCI_FUNCTION);
out->pci_segment_group = screen->caps.pci_group;
out->pci_bus = screen->caps.pci_bus;
out->pci_device = screen->caps.pci_device;
out->pci_function = screen->caps.pci_function;
}
out->vendor_id = screen->get_param(screen, PIPE_CAP_VENDOR_ID);
out->device_id = screen->get_param(screen, PIPE_CAP_DEVICE_ID);
out->vendor_id = screen->caps.vendor_id;
out->device_id = screen->caps.device_id;
if (out->version > 1 && screen->interop_query_device_info)
out->driver_data_size = screen->interop_query_device_info(screen,

4
src/mesa/state_tracker/st_manager.c
View File

@@ -1037,7 +1037,7 @@ st_api_create_context(struct pipe_frontend_screen *fscreen,
}
}
st->can_scissor_clear = !!st->screen->get_param(st->screen, PIPE_CAP_CLEAR_SCISSORED);
st->can_scissor_clear = !!st->screen->caps.clear_scissored;
st->ctx->invalidate_on_gl_viewport =
fscreen->get_param(fscreen, ST_MANAGER_BROKEN_INVALIDATE);
@@ -1045,7 +1045,7 @@ st_api_create_context(struct pipe_frontend_screen *fscreen,
st->frontend_screen = fscreen;
if (st->ctx->IntelBlackholeRender &&
st->screen->get_param(st->screen, PIPE_CAP_FRONTEND_NOOP))
st->screen->caps.frontend_noop)
st->pipe->set_frontend_noop(st->pipe, st->ctx->IntelBlackholeRender);
*error = ST_CONTEXT_SUCCESS;

2
src/mesa/state_tracker/st_nir_builtins.c
View File

@@ -71,7 +71,7 @@ st_nir_finish_builtin_nir(struct st_context *st, nir_shader *nir)
st_nir_lower_samplers(screen, nir, NULL, NULL);
st_nir_lower_uniforms(st, nir);
if (!screen->get_param(screen, PIPE_CAP_NIR_IMAGES_AS_DEREF))
if (!screen->caps.nir_images_as_deref)
NIR_PASS(_, nir, gl_nir_lower_images, false);
if (nir->info.io_lowered &&

20
src/mesa/state_tracker/st_pbo.c
View File

@@ -614,7 +614,7 @@ st_pbo_get_download_fs(struct st_context *st, enum pipe_texture_target target,
struct pipe_screen *screen = st->screen;
enum st_pbo_conversion conversion = get_pbo_conversion(src_format, dst_format);
bool formatless_store = screen->get_param(screen, PIPE_CAP_IMAGE_STORE_FORMATTED);
bool formatless_store = screen->caps.image_store_formatted;
/* For drivers not supporting formatless storing, download FS is stored in an
* indirect dynamically allocated array of storing formats.
@@ -640,26 +640,26 @@ st_init_pbo_helpers(struct st_context *st)
struct pipe_screen *screen = st->screen;
st->pbo.upload_enabled =
screen->get_param(screen, PIPE_CAP_TEXTURE_BUFFER_OBJECTS) &&
screen->get_param(screen, PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT) >= 1 &&
screen->caps.texture_buffer_objects &&
screen->caps.texture_buffer_offset_alignment >= 1 &&
screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_INTEGERS);
if (!st->pbo.upload_enabled)
return;
st->pbo.download_enabled =
st->pbo.upload_enabled &&
screen->get_param(screen, PIPE_CAP_SAMPLER_VIEW_TARGET) &&
screen->get_param(screen, PIPE_CAP_FRAMEBUFFER_NO_ATTACHMENT) &&
screen->caps.sampler_view_target &&
screen->caps.framebuffer_no_attachment &&
screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
PIPE_SHADER_CAP_MAX_SHADER_IMAGES) >= 1;
st->pbo.rgba_only =
screen->get_param(screen, PIPE_CAP_BUFFER_SAMPLER_VIEW_RGBA_ONLY);
screen->caps.buffer_sampler_view_rgba_only;
if (screen->get_param(screen, PIPE_CAP_VS_INSTANCEID)) {
if (screen->get_param(screen, PIPE_CAP_VS_LAYER_VIEWPORT)) {
if (screen->caps.vs_instanceid) {
if (screen->caps.vs_layer_viewport) {
st->pbo.layers = true;
} else if (screen->get_param(screen, PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES) >= 3) {
} else if (screen->caps.max_geometry_output_vertices >= 3) {
st->pbo.layers = true;
st->pbo.use_gs = true;
}
@@ -687,7 +687,7 @@ void
st_destroy_pbo_helpers(struct st_context *st)
{
struct pipe_screen *screen = st->screen;
bool formatless_store = screen->get_param(screen, PIPE_CAP_IMAGE_STORE_FORMATTED);
bool formatless_store = screen->caps.image_store_formatted;
unsigned i;
for (i = 0; i < ARRAY_SIZE(st->pbo.upload_fs); ++i) {

4
src/mesa/state_tracker/st_vdpau.c
View File

@@ -216,8 +216,8 @@ st_vdpau_map_surface(struct gl_context *ctx, GLenum target, GLenum access,
struct winsys_handle whandle = { .type = WINSYS_HANDLE_TYPE_FD };
unsigned usage = PIPE_HANDLE_USAGE_FRAMEBUFFER_WRITE;
if (screen->get_param(screen, PIPE_CAP_DMABUF) &&
res->screen->get_param(res->screen, PIPE_CAP_DMABUF) &&
if (screen->caps.dmabuf &&
res->screen->caps.dmabuf &&
res->screen->resource_get_handle(res->screen, NULL, res, &whandle,
usage)) {
whandle.modifier = DRM_FORMAT_MOD_INVALID;