fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2025-12-23 11:10:10 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

zink: use the dispatch tables

Browse source 
- removed all usage of GET_PROC_ADDR
- find-and-replaced all instances of `screen->vk_` to `screen->vk.`

Reviewed-By: Mike Blumenkrantz <michael.blumenkrantz@gmail.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/11036>
This commit is contained in:
Hoe Hao Cheng 2021-05-28 03:45:38 +08:00 • committed by Marge Bot
parent 039078fe97
commit 5574868103
11 changed files with 58 additions and 232 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/gallium/drivers/zink/zink_context.c
View file

@ -3331,7 +3331,7 @@ zink_emit_string_marker(struct pipe_context *pctx,
string, string,
{ 0 } { 0 }
}; };
screen->vk_CmdInsertDebugUtilsLabelEXT(batch->state->cmdbuf, &label); screen->vk.CmdInsertDebugUtilsLabelEXT(batch->state->cmdbuf, &label);
free(temp); free(temp);
} }

4
src/gallium/drivers/zink/zink_descriptors.c
View file

@ -296,8 +296,8 @@ descriptor_layout_create(struct zink_screen *screen, enum zink_descriptor_type t
supp.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT; supp.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT;
supp.pNext = NULL; supp.pNext = NULL;
supp.supported = VK_FALSE; supp.supported = VK_FALSE;
if (screen->vk_GetDescriptorSetLayoutSupport) { if (screen->vk.GetDescriptorSetLayoutSupport) {
screen->vk_GetDescriptorSetLayoutSupport(screen->dev, &dcslci, &supp); screen->vk.GetDescriptorSetLayoutSupport(screen->dev, &dcslci, &supp);
if (supp.supported == VK_FALSE) { if (supp.supported == VK_FALSE) {
debug_printf("vkGetDescriptorSetLayoutSupport claims layout is unsupported\n"); debug_printf("vkGetDescriptorSetLayoutSupport claims layout is unsupported\n");
return VK_NULL_HANDLE; return VK_NULL_HANDLE;

10
src/gallium/drivers/zink/zink_descriptors_lazy.c
View file

@ -254,7 +254,7 @@ zink_descriptor_program_init_lazy(struct zink_context *ctx, struct zink_program
template[i].pipelineBindPoint = pg->is_compute ? VK_PIPELINE_BIND_POINT_COMPUTE : VK_PIPELINE_BIND_POINT_GRAPHICS; template[i].pipelineBindPoint = pg->is_compute ? VK_PIPELINE_BIND_POINT_COMPUTE : VK_PIPELINE_BIND_POINT_GRAPHICS;
template[i].pipelineLayout = pg->layout; template[i].pipelineLayout = pg->layout;
template[i].set = i; template[i].set = i;
if (screen->vk_CreateDescriptorUpdateTemplate(screen->dev, &template[i], NULL, &pg->dd->templates[i]) != VK_SUCCESS) if (screen->vk.CreateDescriptorUpdateTemplate(screen->dev, &template[i], NULL, &pg->dd->templates[i]) != VK_SUCCESS)
return false; return false;
} }
return true; return true;
@ -267,7 +267,7 @@ zink_descriptor_program_deinit_lazy(struct zink_screen *screen, struct zink_prog
return; return;
for (unsigned i = 0; i < 1 + !!pg->dd->push_usage; i++) { for (unsigned i = 0; i < 1 + !!pg->dd->push_usage; i++) {
if (pg->dd->templates[i]) if (pg->dd->templates[i])
screen->vk_DestroyDescriptorUpdateTemplate(screen->dev, pg->dd->templates[i], NULL); screen->vk.DestroyDescriptorUpdateTemplate(screen->dev, pg->dd->templates[i], NULL);
} }
ralloc_free(pg->dd); ralloc_free(pg->dd);
} }
@ -355,7 +355,7 @@ zink_descriptors_update_lazy(struct zink_context *ctx, bool is_compute)
batch_changed |= bs->dd->pg[is_compute] != pg; batch_changed |= bs->dd->pg[is_compute] != pg;
assert(pg->dd->layout_key->num_descriptors); assert(pg->dd->layout_key->num_descriptors);
screen->vk_UpdateDescriptorSetWithTemplate(screen->dev, desc_set, pg->dd->templates[0], ctx); screen->vk.UpdateDescriptorSetWithTemplate(screen->dev, desc_set, pg->dd->templates[0], ctx);
if (pg->dd->layout_key) if (pg->dd->layout_key)
vkCmdBindDescriptorSets(batch->state->cmdbuf, vkCmdBindDescriptorSets(batch->state->cmdbuf,
is_compute ? VK_PIPELINE_BIND_POINT_COMPUTE : VK_PIPELINE_BIND_POINT_GRAPHICS, is_compute ? VK_PIPELINE_BIND_POINT_COMPUTE : VK_PIPELINE_BIND_POINT_GRAPHICS,
@ -372,13 +372,13 @@ zink_descriptors_update_lazy(struct zink_context *ctx, bool is_compute)
0, NULL); 0, NULL);
} }
if (screen->info.have_KHR_push_descriptor) if (screen->info.have_KHR_push_descriptor)
screen->vk_CmdPushDescriptorSetWithTemplateKHR(batch->state->cmdbuf, pg->dd->templates[1], screen->vk.CmdPushDescriptorSetWithTemplateKHR(batch->state->cmdbuf, pg->dd->templates[1],
pg->layout, 1, ctx); pg->layout, 1, ctx);
else { else {
struct zink_descriptor_pool *pool = bs->dd->push_pool[is_compute]; struct zink_descriptor_pool *pool = bs->dd->push_pool[is_compute];
VkDescriptorSet desc_set = get_descriptor_set_lazy(ctx, NULL, pool, is_compute); VkDescriptorSet desc_set = get_descriptor_set_lazy(ctx, NULL, pool, is_compute);
bs = ctx->batch.state; bs = ctx->batch.state;
screen->vk_UpdateDescriptorSetWithTemplate(screen->dev, desc_set, pg->dd->templates[1], ctx); screen->vk.UpdateDescriptorSetWithTemplate(screen->dev, desc_set, pg->dd->templates[1], ctx);
vkCmdBindDescriptorSets(batch->state->cmdbuf, vkCmdBindDescriptorSets(batch->state->cmdbuf,
is_compute ? VK_PIPELINE_BIND_POINT_COMPUTE : VK_PIPELINE_BIND_POINT_GRAPHICS, is_compute ? VK_PIPELINE_BIND_POINT_COMPUTE : VK_PIPELINE_BIND_POINT_GRAPHICS,
pg->layout, 1, 1, &desc_set, pg->layout, 1, 1, &desc_set,

10
src/gallium/drivers/zink/zink_device_info.py
View file

@ -341,7 +341,7 @@ zink_get_physical_device_info(struct zink_screen *screen)
} }
// get device features // get device features
if (screen->vk_GetPhysicalDeviceFeatures2) { if (screen->vk.GetPhysicalDeviceFeatures2) {
// check for device extension features // check for device extension features
info->feats.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; info->feats.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
@ -366,13 +366,13 @@ zink_get_physical_device_info(struct zink_screen *screen)
%endif %endif
%endfor %endfor
screen->vk_GetPhysicalDeviceFeatures2(screen->pdev, &info->feats); screen->vk.GetPhysicalDeviceFeatures2(screen->pdev, &info->feats);
} else { } else {
vkGetPhysicalDeviceFeatures(screen->pdev, &info->feats.features); vkGetPhysicalDeviceFeatures(screen->pdev, &info->feats.features);
} }
// check for device properties // check for device properties
if (screen->vk_GetPhysicalDeviceProperties2) { if (screen->vk.GetPhysicalDeviceProperties2) {
VkPhysicalDeviceProperties2 props = {}; VkPhysicalDeviceProperties2 props = {};
props.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2; props.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
@ -397,11 +397,11 @@ zink_get_physical_device_info(struct zink_screen *screen)
%endfor %endfor
// note: setting up local VkPhysicalDeviceProperties2. // note: setting up local VkPhysicalDeviceProperties2.
screen->vk_GetPhysicalDeviceProperties2(screen->pdev, &props); screen->vk.GetPhysicalDeviceProperties2(screen->pdev, &props);
} }
// enable the extensions if they match the conditions given by ext.enable_conds // enable the extensions if they match the conditions given by ext.enable_conds
if (screen->vk_GetPhysicalDeviceProperties2) { if (screen->vk.GetPhysicalDeviceProperties2) {
%for ext in extensions: %for ext in extensions:
<%helpers:guard ext="${ext}"> <%helpers:guard ext="${ext}">
<% <%

36
src/gallium/drivers/zink/zink_draw.c
View file

@ -95,7 +95,7 @@ zink_emit_stream_output_targets(struct pipe_context *pctx)
t->base.buffer_offset + t->base.buffer_size); t->base.buffer_offset + t->base.buffer_size);
} }
screen->vk_CmdBindTransformFeedbackBuffersEXT(batch->state->cmdbuf, 0, ctx->num_so_targets, screen->vk.CmdBindTransformFeedbackBuffersEXT(batch->state->cmdbuf, 0, ctx->num_so_targets,
buffers, buffer_offsets, buffers, buffer_offsets,
buffer_sizes); buffer_sizes);
ctx->dirty_so_targets = false; ctx->dirty_so_targets = false;
@ -151,7 +151,7 @@ zink_bind_vertex_buffers(struct zink_batch *batch, struct zink_context *ctx)
} }
if (screen->info.have_EXT_extended_dynamic_state) if (screen->info.have_EXT_extended_dynamic_state)
screen->vk_CmdBindVertexBuffers2EXT(batch->state->cmdbuf, 0, screen->vk.CmdBindVertexBuffers2EXT(batch->state->cmdbuf, 0,
elems->hw_state.num_bindings, elems->hw_state.num_bindings,
buffers, buffer_offsets, NULL, buffer_strides); buffers, buffer_offsets, NULL, buffer_strides);
else else
@ -559,7 +559,7 @@ zink_draw_vbo(struct pipe_context *pctx,
viewports[i] = viewport; viewports[i] = viewport;
} }
if (screen->info.have_EXT_extended_dynamic_state) if (screen->info.have_EXT_extended_dynamic_state)
screen->vk_CmdSetViewportWithCountEXT(batch->state->cmdbuf, ctx->vp_state.num_viewports, viewports); screen->vk.CmdSetViewportWithCountEXT(batch->state->cmdbuf, ctx->vp_state.num_viewports, viewports);
else else
vkCmdSetViewport(batch->state->cmdbuf, 0, ctx->vp_state.num_viewports, viewports); vkCmdSetViewport(batch->state->cmdbuf, 0, ctx->vp_state.num_viewports, viewports);
} }
@ -581,7 +581,7 @@ zink_draw_vbo(struct pipe_context *pctx,
} }
} }
if (screen->info.have_EXT_extended_dynamic_state) if (screen->info.have_EXT_extended_dynamic_state)
screen->vk_CmdSetScissorWithCountEXT(batch->state->cmdbuf, ctx->vp_state.num_viewports, scissors); screen->vk.CmdSetScissorWithCountEXT(batch->state->cmdbuf, ctx->vp_state.num_viewports, scissors);
else else
vkCmdSetScissor(batch->state->cmdbuf, 0, ctx->vp_state.num_viewports, scissors); vkCmdSetScissor(batch->state->cmdbuf, 0, ctx->vp_state.num_viewports, scissors);
} }
@ -608,23 +608,23 @@ zink_draw_vbo(struct pipe_context *pctx,
} }
if (screen->info.have_EXT_extended_dynamic_state) { if (screen->info.have_EXT_extended_dynamic_state) {
screen->vk_CmdSetDepthBoundsTestEnableEXT(batch->state->cmdbuf, dsa_state->hw_state.depth_bounds_test); screen->vk.CmdSetDepthBoundsTestEnableEXT(batch->state->cmdbuf, dsa_state->hw_state.depth_bounds_test);
if (dsa_state->hw_state.depth_bounds_test) if (dsa_state->hw_state.depth_bounds_test)
vkCmdSetDepthBounds(batch->state->cmdbuf, vkCmdSetDepthBounds(batch->state->cmdbuf,
dsa_state->hw_state.min_depth_bounds, dsa_state->hw_state.min_depth_bounds,
dsa_state->hw_state.max_depth_bounds); dsa_state->hw_state.max_depth_bounds);
screen->vk_CmdSetDepthTestEnableEXT(batch->state->cmdbuf, dsa_state->hw_state.depth_test); screen->vk.CmdSetDepthTestEnableEXT(batch->state->cmdbuf, dsa_state->hw_state.depth_test);
if (dsa_state->hw_state.depth_test) if (dsa_state->hw_state.depth_test)
screen->vk_CmdSetDepthCompareOpEXT(batch->state->cmdbuf, dsa_state->hw_state.depth_compare_op); screen->vk.CmdSetDepthCompareOpEXT(batch->state->cmdbuf, dsa_state->hw_state.depth_compare_op);
screen->vk_CmdSetDepthWriteEnableEXT(batch->state->cmdbuf, dsa_state->hw_state.depth_write); screen->vk.CmdSetDepthWriteEnableEXT(batch->state->cmdbuf, dsa_state->hw_state.depth_write);
screen->vk_CmdSetStencilTestEnableEXT(batch->state->cmdbuf, dsa_state->hw_state.stencil_test); screen->vk.CmdSetStencilTestEnableEXT(batch->state->cmdbuf, dsa_state->hw_state.stencil_test);
if (dsa_state->hw_state.stencil_test) { if (dsa_state->hw_state.stencil_test) {
screen->vk_CmdSetStencilOpEXT(batch->state->cmdbuf, VK_STENCIL_FACE_FRONT_BIT, screen->vk.CmdSetStencilOpEXT(batch->state->cmdbuf, VK_STENCIL_FACE_FRONT_BIT,
dsa_state->hw_state.stencil_front.failOp, dsa_state->hw_state.stencil_front.failOp,
dsa_state->hw_state.stencil_front.passOp, dsa_state->hw_state.stencil_front.passOp,
dsa_state->hw_state.stencil_front.depthFailOp, dsa_state->hw_state.stencil_front.depthFailOp,
dsa_state->hw_state.stencil_front.compareOp); dsa_state->hw_state.stencil_front.compareOp);
screen->vk_CmdSetStencilOpEXT(batch->state->cmdbuf, VK_STENCIL_FACE_BACK_BIT, screen->vk.CmdSetStencilOpEXT(batch->state->cmdbuf, VK_STENCIL_FACE_BACK_BIT,
dsa_state->hw_state.stencil_back.failOp, dsa_state->hw_state.stencil_back.failOp,
dsa_state->hw_state.stencil_back.passOp, dsa_state->hw_state.stencil_back.passOp,
dsa_state->hw_state.stencil_back.depthFailOp, dsa_state->hw_state.stencil_back.depthFailOp,
@ -641,12 +641,12 @@ zink_draw_vbo(struct pipe_context *pctx,
vkCmdSetStencilCompareMask(batch->state->cmdbuf, VK_STENCIL_FACE_FRONT_AND_BACK, dsa_state->hw_state.stencil_front.compareMask); vkCmdSetStencilCompareMask(batch->state->cmdbuf, VK_STENCIL_FACE_FRONT_AND_BACK, dsa_state->hw_state.stencil_front.compareMask);
} }
} }
screen->vk_CmdSetFrontFaceEXT(batch->state->cmdbuf, ctx->gfx_pipeline_state.front_face); screen->vk.CmdSetFrontFaceEXT(batch->state->cmdbuf, ctx->gfx_pipeline_state.front_face);
if (ctx->sample_locations_changed) { if (ctx->sample_locations_changed) {
VkSampleLocationsInfoEXT loc; VkSampleLocationsInfoEXT loc;
zink_init_vk_sample_locations(ctx, &loc); zink_init_vk_sample_locations(ctx, &loc);
screen->vk_CmdSetSampleLocationsEXT(batch->state->cmdbuf, &loc); screen->vk.CmdSetSampleLocationsEXT(batch->state->cmdbuf, &loc);
} }
ctx->sample_locations_changed = false; ctx->sample_locations_changed = false;
} }
@ -688,7 +688,7 @@ zink_draw_vbo(struct pipe_context *pctx,
} }
} }
} }
screen->vk_CmdBeginTransformFeedbackEXT(batch->state->cmdbuf, 0, ctx->num_so_targets, counter_buffers, counter_buffer_offsets); screen->vk.CmdBeginTransformFeedbackEXT(batch->state->cmdbuf, 0, ctx->num_so_targets, counter_buffers, counter_buffer_offsets);
} }
ctx->pipeline_changed[0] = false; ctx->pipeline_changed[0] = false;
@ -728,7 +728,7 @@ zink_draw_vbo(struct pipe_context *pctx,
if (dindirect->indirect_draw_count) { if (dindirect->indirect_draw_count) {
struct zink_resource *indirect_draw_count = zink_resource(dindirect->indirect_draw_count); struct zink_resource *indirect_draw_count = zink_resource(dindirect->indirect_draw_count);
zink_batch_reference_resource_rw(batch, indirect_draw_count, false); zink_batch_reference_resource_rw(batch, indirect_draw_count, false);
screen->vk_CmdDrawIndexedIndirectCount(batch->state->cmdbuf, indirect->obj->buffer, dindirect->offset, screen->vk.CmdDrawIndexedIndirectCount(batch->state->cmdbuf, indirect->obj->buffer, dindirect->offset,
indirect_draw_count->obj->buffer, dindirect->indirect_draw_count_offset, indirect_draw_count->obj->buffer, dindirect->indirect_draw_count_offset,
dindirect->draw_count, dindirect->stride); dindirect->draw_count, dindirect->stride);
} else } else
@ -745,7 +745,7 @@ zink_draw_vbo(struct pipe_context *pctx,
update_drawid(ctx, draw_id); update_drawid(ctx, draw_id);
zink_batch_reference_resource_rw(batch, zink_resource(so_target->base.buffer), false); zink_batch_reference_resource_rw(batch, zink_resource(so_target->base.buffer), false);
zink_batch_reference_resource_rw(batch, zink_resource(so_target->counter_buffer), true); zink_batch_reference_resource_rw(batch, zink_resource(so_target->counter_buffer), true);
screen->vk_CmdDrawIndirectByteCountEXT(batch->state->cmdbuf, dinfo->instance_count, dinfo->start_instance, screen->vk.CmdDrawIndirectByteCountEXT(batch->state->cmdbuf, dinfo->instance_count, dinfo->start_instance,
zink_resource(so_target->counter_buffer)->obj->buffer, so_target->counter_buffer_offset, 0, zink_resource(so_target->counter_buffer)->obj->buffer, so_target->counter_buffer_offset, 0,
MIN2(so_target->stride, screen->info.tf_props.maxTransformFeedbackBufferDataStride)); MIN2(so_target->stride, screen->info.tf_props.maxTransformFeedbackBufferDataStride));
} else if (dindirect && dindirect->buffer) { } else if (dindirect && dindirect->buffer) {
@ -757,7 +757,7 @@ zink_draw_vbo(struct pipe_context *pctx,
if (dindirect->indirect_draw_count) { if (dindirect->indirect_draw_count) {
struct zink_resource *indirect_draw_count = zink_resource(dindirect->indirect_draw_count); struct zink_resource *indirect_draw_count = zink_resource(dindirect->indirect_draw_count);
zink_batch_reference_resource_rw(batch, indirect_draw_count, false); zink_batch_reference_resource_rw(batch, indirect_draw_count, false);
screen->vk_CmdDrawIndirectCount(batch->state->cmdbuf, indirect->obj->buffer, dindirect->offset, screen->vk.CmdDrawIndirectCount(batch->state->cmdbuf, indirect->obj->buffer, dindirect->offset,
indirect_draw_count->obj->buffer, dindirect->indirect_draw_count_offset, indirect_draw_count->obj->buffer, dindirect->indirect_draw_count_offset,
dindirect->draw_count, dindirect->stride); dindirect->draw_count, dindirect->stride);
} else } else
@ -779,7 +779,7 @@ zink_draw_vbo(struct pipe_context *pctx,
t->counter_buffer_valid = true; t->counter_buffer_valid = true;
} }
} }
screen->vk_CmdEndTransformFeedbackEXT(batch->state->cmdbuf, 0, ctx->num_so_targets, counter_buffers, counter_buffer_offsets); screen->vk.CmdEndTransformFeedbackEXT(batch->state->cmdbuf, 0, ctx->num_so_targets, counter_buffers, counter_buffer_offsets);
} }
batch->has_work = true; batch->has_work = true;
/* check memory usage and flush/stall as needed to avoid oom */ /* check memory usage and flush/stall as needed to avoid oom */

1
src/gallium/drivers/zink/zink_extensions.py
View file

@ -151,7 +151,6 @@ class ExtensionRegistryEntry:
# the version in which the extension is promoted to core VK # the version in which the extension is promoted to core VK
promoted_in : Version = None promoted_in : Version = None
# functions added by the extension are referred to as "commands" in the registry # functions added by the extension are referred to as "commands" in the registry
commands : List[str] = None
device_commands : List[str] = None device_commands : List[str] = None
pdevice_commands : List[str] = None pdevice_commands : List[str] = None
instance_commands : List[str] = None instance_commands : List[str] = None

38
src/gallium/drivers/zink/zink_instance.py
View file

@ -95,9 +95,6 @@ struct zink_instance_info {
VkInstance VkInstance
zink_create_instance(struct zink_instance_info *instance_info); zink_create_instance(struct zink_instance_info *instance_info);
bool
zink_load_instance_extensions(struct zink_screen *screen);
bool bool
zink_verify_instance_extensions(struct zink_screen *screen); zink_verify_instance_extensions(struct zink_screen *screen);
@ -220,41 +217,6 @@ zink_create_instance(struct zink_instance_info *instance_info)
return instance; return instance;
} }
bool
zink_load_instance_extensions(struct zink_screen *screen)
{
if (zink_debug & ZINK_DEBUG_VALIDATION) {
printf("zink: Loader %d.%d.%d \\n", VK_VERSION_MAJOR(screen->instance_info.loader_version), VK_VERSION_MINOR(screen->instance_info.loader_version), VK_VERSION_PATCH(screen->instance_info.loader_version));
}
%for ext in extensions:
%if bool(ext.instance_funcs) and not ext.core_since:
if (screen->instance_info.have_${ext.name_with_vendor()}) {
%for func in ext.instance_funcs:
GET_PROC_ADDR_INSTANCE_LOCAL(screen->instance, ${func}${ext.vendor()});
screen->vk_${func} = vk_${func}${ext.vendor()};
%endfor
}
%elif bool(ext.instance_funcs):
if (screen->instance_info.have_${ext.name_with_vendor()}) {
if (screen->vk_version < ${ext.core_since.version()}) {
%for func in ext.instance_funcs:
GET_PROC_ADDR_INSTANCE_LOCAL(screen->instance, ${func}${ext.vendor()});
screen->vk_${func} = vk_${func}${ext.vendor()};
if (!screen->vk_${func}) return false;
%endfor
} else {
%for func in ext.instance_funcs:
GET_PROC_ADDR_INSTANCE(${func});
%endfor
}
}
%endif
%endfor
return true;
}
bool bool
zink_verify_instance_extensions(struct zink_screen *screen) zink_verify_instance_extensions(struct zink_screen *screen)
{ {

18
src/gallium/drivers/zink/zink_query.c
View file

@ -659,20 +659,20 @@ begin_query(struct zink_context *ctx, struct zink_batch *batch, struct zink_quer
if (q->type == PIPE_QUERY_PRIMITIVES_EMITTED || if (q->type == PIPE_QUERY_PRIMITIVES_EMITTED ||
q->type == PIPE_QUERY_PRIMITIVES_GENERATED || q->type == PIPE_QUERY_PRIMITIVES_GENERATED ||
q->type == PIPE_QUERY_SO_OVERFLOW_PREDICATE) { q->type == PIPE_QUERY_SO_OVERFLOW_PREDICATE) {
zink_screen(ctx->base.screen)->vk_CmdBeginQueryIndexedEXT(batch->state->cmdbuf, zink_screen(ctx->base.screen)->vk.CmdBeginQueryIndexedEXT(batch->state->cmdbuf,
q->xfb_query_pool[0] ? q->xfb_query_pool[0] : q->query_pool, q->xfb_query_pool[0] ? q->xfb_query_pool[0] : q->query_pool,
q->curr_query, q->curr_query,
flags, flags,
q->index); q->index);
q->xfb_running = true; q->xfb_running = true;
} else if (q->type == PIPE_QUERY_SO_OVERFLOW_ANY_PREDICATE) { } else if (q->type == PIPE_QUERY_SO_OVERFLOW_ANY_PREDICATE) {
zink_screen(ctx->base.screen)->vk_CmdBeginQueryIndexedEXT(batch->state->cmdbuf, zink_screen(ctx->base.screen)->vk.CmdBeginQueryIndexedEXT(batch->state->cmdbuf,
q->query_pool, q->query_pool,
q->curr_query, q->curr_query,
flags, flags,
0); 0);
for (unsigned i = 0; i < ARRAY_SIZE(q->xfb_query_pool); i++) for (unsigned i = 0; i < ARRAY_SIZE(q->xfb_query_pool); i++)
zink_screen(ctx->base.screen)->vk_CmdBeginQueryIndexedEXT(batch->state->cmdbuf, zink_screen(ctx->base.screen)->vk.CmdBeginQueryIndexedEXT(batch->state->cmdbuf,
q->xfb_query_pool[i], q->xfb_query_pool[i],
q->curr_query, q->curr_query,
flags, flags,
@ -722,15 +722,15 @@ end_query(struct zink_context *ctx, struct zink_batch *batch, struct zink_query
} else if (q->type == PIPE_QUERY_PRIMITIVES_EMITTED || } else if (q->type == PIPE_QUERY_PRIMITIVES_EMITTED ||
q->type == PIPE_QUERY_PRIMITIVES_GENERATED || q->type == PIPE_QUERY_PRIMITIVES_GENERATED ||
q->type == PIPE_QUERY_SO_OVERFLOW_PREDICATE) { q->type == PIPE_QUERY_SO_OVERFLOW_PREDICATE) {
screen->vk_CmdEndQueryIndexedEXT(batch->state->cmdbuf, q->xfb_query_pool[0] ? q->xfb_query_pool[0] : screen->vk.CmdEndQueryIndexedEXT(batch->state->cmdbuf, q->xfb_query_pool[0] ? q->xfb_query_pool[0] :
q->query_pool, q->query_pool,
q->curr_query, q->index); q->curr_query, q->index);
} }
else if (q->type == PIPE_QUERY_SO_OVERFLOW_ANY_PREDICATE) { else if (q->type == PIPE_QUERY_SO_OVERFLOW_ANY_PREDICATE) {
screen->vk_CmdEndQueryIndexedEXT(batch->state->cmdbuf, q->query_pool, q->curr_query, 0); screen->vk.CmdEndQueryIndexedEXT(batch->state->cmdbuf, q->query_pool, q->curr_query, 0);
for (unsigned i = 0; i < ARRAY_SIZE(q->xfb_query_pool); i++) { for (unsigned i = 0; i < ARRAY_SIZE(q->xfb_query_pool); i++) {
screen->vk_CmdEndQueryIndexedEXT(batch->state->cmdbuf, q->xfb_query_pool[i], q->curr_query, i + 1); screen->vk.CmdEndQueryIndexedEXT(batch->state->cmdbuf, q->xfb_query_pool[i], q->curr_query, i + 1);
} }
} }
if (q->vkqtype != VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT && !is_time_query(q)) if (q->vkqtype != VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT && !is_time_query(q))
@ -857,7 +857,7 @@ zink_start_conditional_render(struct zink_context *ctx)
begin_info.sType = VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT; begin_info.sType = VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT;
begin_info.buffer = ctx->render_condition.query->predicate->obj->buffer; begin_info.buffer = ctx->render_condition.query->predicate->obj->buffer;
begin_info.flags = begin_flags; begin_info.flags = begin_flags;
screen->vk_CmdBeginConditionalRenderingEXT(batch->state->cmdbuf, &begin_info); screen->vk.CmdBeginConditionalRenderingEXT(batch->state->cmdbuf, &begin_info);
zink_batch_reference_resource_rw(batch, ctx->render_condition.query->predicate, false); zink_batch_reference_resource_rw(batch, ctx->render_condition.query->predicate, false);
} }
@ -867,7 +867,7 @@ zink_stop_conditional_render(struct zink_context *ctx)
struct zink_batch *batch = &ctx->batch; struct zink_batch *batch = &ctx->batch;
struct zink_screen *screen = zink_screen(ctx->base.screen); struct zink_screen *screen = zink_screen(ctx->base.screen);
zink_clear_apply_conditionals(ctx); zink_clear_apply_conditionals(ctx);
screen->vk_CmdEndConditionalRenderingEXT(batch->state->cmdbuf); screen->vk.CmdEndConditionalRenderingEXT(batch->state->cmdbuf);
} }
static void static void
@ -1005,7 +1005,7 @@ zink_get_timestamp(struct pipe_context *pctx)
VkCalibratedTimestampInfoEXT cti = {}; VkCalibratedTimestampInfoEXT cti = {};
cti.sType = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT; cti.sType = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT;
cti.timeDomain = VK_TIME_DOMAIN_DEVICE_EXT; cti.timeDomain = VK_TIME_DOMAIN_DEVICE_EXT;
screen->vk_GetCalibratedTimestampsEXT(screen->dev, 1, &cti, &timestamp, &deviation); screen->vk.GetCalibratedTimestampsEXT(screen->dev, 1, &cti, &timestamp, &deviation);
timestamp_to_nanoseconds(screen, &timestamp); timestamp_to_nanoseconds(screen, &timestamp);
return timestamp; return timestamp;
} }

6
src/gallium/drivers/zink/zink_resource.c
View file

@ -301,7 +301,7 @@ check_ici(struct zink_screen *screen, VkImageCreateInfo *ici)
{ {
VkImageFormatProperties image_props; VkImageFormatProperties image_props;
VkResult ret; VkResult ret;
if (screen->vk_GetPhysicalDeviceImageFormatProperties2) { if (screen->vk.GetPhysicalDeviceImageFormatProperties2) {
VkImageFormatProperties2 props2 = {}; VkImageFormatProperties2 props2 = {};
props2.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2; props2.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2;
VkPhysicalDeviceImageFormatInfo2 info = {}; VkPhysicalDeviceImageFormatInfo2 info = {};
@ -311,7 +311,7 @@ check_ici(struct zink_screen *screen, VkImageCreateInfo *ici)
info.tiling = ici->tiling; info.tiling = ici->tiling;
info.usage = ici->usage; info.usage = ici->usage;
info.flags = ici->flags; info.flags = ici->flags;
ret = screen->vk_GetPhysicalDeviceImageFormatProperties2(screen->pdev, &info, &props2); ret = screen->vk.GetPhysicalDeviceImageFormatProperties2(screen->pdev, &info, &props2);
image_props = props2.imageFormatProperties; image_props = props2.imageFormatProperties;
} else } else
ret = vkGetPhysicalDeviceImageFormatProperties(screen->pdev, ici->format, ici->imageType, ret = vkGetPhysicalDeviceImageFormatProperties(screen->pdev, ici->format, ici->imageType,
@ -691,7 +691,7 @@ zink_resource_get_handle(struct pipe_screen *pscreen,
//TODO: remove for wsi //TODO: remove for wsi
fd_info.memory = obj->mem; fd_info.memory = obj->mem;
fd_info.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT; fd_info.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
VkResult result = (*screen->vk_GetMemoryFdKHR)(screen->dev, &fd_info, &fd); VkResult result = (*screen->vk.GetMemoryFdKHR)(screen->dev, &fd_info, &fd);
if (result != VK_SUCCESS) if (result != VK_SUCCESS)
return false; return false;
whandle->handle = fd; whandle->handle = fd;

114
src/gallium/drivers/zink/zink_screen.c
View file

@ -962,7 +962,7 @@ zink_destroy_screen(struct pipe_screen *pscreen)
struct zink_screen *screen = zink_screen(pscreen); struct zink_screen *screen = zink_screen(pscreen);
if (VK_NULL_HANDLE != screen->debugUtilsCallbackHandle) { if (VK_NULL_HANDLE != screen->debugUtilsCallbackHandle) {
screen->vk_DestroyDebugUtilsMessengerEXT(screen->instance, screen->debugUtilsCallbackHandle, NULL); screen->vk.DestroyDebugUtilsMessengerEXT(screen->instance, screen->debugUtilsCallbackHandle, NULL);
} }
hash_table_foreach(&screen->surface_cache, entry) { hash_table_foreach(&screen->surface_cache, entry) {
@ -1225,11 +1225,11 @@ static bool
check_have_device_time(struct zink_screen *screen) check_have_device_time(struct zink_screen *screen)
{ {
uint32_t num_domains = 0; uint32_t num_domains = 0;
screen->vk_GetPhysicalDeviceCalibrateableTimeDomainsEXT(screen->pdev, &num_domains, NULL); screen->vk.GetPhysicalDeviceCalibrateableTimeDomainsEXT(screen->pdev, &num_domains, NULL);
assert(num_domains > 0); assert(num_domains > 0);
VkTimeDomainEXT *domains = malloc(sizeof(VkTimeDomainEXT) * num_domains); VkTimeDomainEXT *domains = malloc(sizeof(VkTimeDomainEXT) * num_domains);
screen->vk_GetPhysicalDeviceCalibrateableTimeDomainsEXT(screen->pdev, &num_domains, domains); screen->vk.GetPhysicalDeviceCalibrateableTimeDomainsEXT(screen->pdev, &num_domains, domains);
/* VK_TIME_DOMAIN_DEVICE_EXT is used for the ctx->get_timestamp hook and is the only one we really need */ /* VK_TIME_DOMAIN_DEVICE_EXT is used for the ctx->get_timestamp hook and is the only one we really need */
for (unsigned i = 0; i < num_domains; i++) { for (unsigned i = 0; i < num_domains; i++) {
@ -1242,80 +1242,6 @@ check_have_device_time(struct zink_screen *screen)
return false; return false;
} }
static bool
load_device_extensions(struct zink_screen *screen)
{
if (screen->info.have_EXT_transform_feedback) {
GET_PROC_ADDR(CmdBindTransformFeedbackBuffersEXT);
GET_PROC_ADDR(CmdBeginTransformFeedbackEXT);
GET_PROC_ADDR(CmdEndTransformFeedbackEXT);
GET_PROC_ADDR(CmdBeginQueryIndexedEXT);
GET_PROC_ADDR(CmdEndQueryIndexedEXT);
GET_PROC_ADDR(CmdDrawIndirectByteCountEXT);
}
if (screen->info.have_KHR_external_memory_fd)
GET_PROC_ADDR(GetMemoryFdKHR);
if (screen->info.have_EXT_conditional_rendering) {
GET_PROC_ADDR(CmdBeginConditionalRenderingEXT);
GET_PROC_ADDR(CmdEndConditionalRenderingEXT);
}
if (screen->info.have_KHR_draw_indirect_count) {
GET_PROC_ADDR_KHR(CmdDrawIndexedIndirectCount);
GET_PROC_ADDR_KHR(CmdDrawIndirectCount);
}
if (screen->info.have_EXT_calibrated_timestamps) {
GET_PROC_ADDR_INSTANCE(GetPhysicalDeviceCalibrateableTimeDomainsEXT);
GET_PROC_ADDR(GetCalibratedTimestampsEXT);
}
if (screen->info.have_EXT_extended_dynamic_state) {
GET_PROC_ADDR(CmdSetViewportWithCountEXT);
GET_PROC_ADDR(CmdSetScissorWithCountEXT);
GET_PROC_ADDR(CmdSetDepthBoundsTestEnableEXT);
GET_PROC_ADDR(CmdSetDepthCompareOpEXT);
GET_PROC_ADDR(CmdSetDepthTestEnableEXT);
GET_PROC_ADDR(CmdSetDepthWriteEnableEXT);
GET_PROC_ADDR(CmdSetStencilOpEXT);
GET_PROC_ADDR(CmdSetStencilTestEnableEXT);
GET_PROC_ADDR(CmdBindVertexBuffers2EXT);
GET_PROC_ADDR(CmdSetFrontFaceEXT);
}
if (screen->info.have_EXT_image_drm_format_modifier)
GET_PROC_ADDR(GetImageDrmFormatModifierPropertiesEXT);
if (screen->info.have_KHR_timeline_semaphore)
GET_PROC_ADDR_KHR(WaitSemaphores);
if (screen->info.have_KHR_maintenance3)
GET_PROC_ADDR_KHR(GetDescriptorSetLayoutSupport);
if (screen->info.have_KHR_push_descriptor) {
GET_PROC_ADDR(CmdPushDescriptorSetKHR);
GET_PROC_ADDR(CmdPushDescriptorSetWithTemplateKHR);
}
if (screen->info.have_KHR_descriptor_update_template) {
GET_PROC_ADDR_KHR(CreateDescriptorUpdateTemplate);
GET_PROC_ADDR_KHR(DestroyDescriptorUpdateTemplate);
GET_PROC_ADDR_KHR(UpdateDescriptorSetWithTemplate);
}
if (screen->info.have_KHR_swapchain) {
GET_PROC_ADDR(CreateSwapchainKHR);
GET_PROC_ADDR(DestroySwapchainKHR);
}
if (screen->info.have_EXT_sample_locations) {
GET_PROC_ADDR(CmdSetSampleLocationsEXT);
GET_PROC_ADDR_INSTANCE(GetPhysicalDeviceMultisamplePropertiesEXT);
}
return true;
}
static VKAPI_ATTR VkBool32 VKAPI_CALL static VKAPI_ATTR VkBool32 VKAPI_CALL
zink_debug_util_callback( zink_debug_util_callback(
VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
@ -1342,10 +1268,6 @@ zink_debug_util_callback(
static bool static bool
create_debug(struct zink_screen *screen) create_debug(struct zink_screen *screen)
{ {
GET_PROC_ADDR_INSTANCE(CreateDebugUtilsMessengerEXT);
GET_PROC_ADDR_INSTANCE(DestroyDebugUtilsMessengerEXT);
GET_PROC_ADDR_INSTANCE(CmdInsertDebugUtilsLabelEXT);
VkDebugUtilsMessengerCreateInfoEXT vkDebugUtilsMessengerCreateInfoEXT = { VkDebugUtilsMessengerCreateInfoEXT vkDebugUtilsMessengerCreateInfoEXT = {
VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
NULL, NULL,
@ -1363,7 +1285,7 @@ create_debug(struct zink_screen *screen)
VkDebugUtilsMessengerEXT vkDebugUtilsCallbackEXT = VK_NULL_HANDLE; VkDebugUtilsMessengerEXT vkDebugUtilsCallbackEXT = VK_NULL_HANDLE;
screen->vk_CreateDebugUtilsMessengerEXT( screen->vk.CreateDebugUtilsMessengerEXT(
screen->instance, screen->instance,
&vkDebugUtilsMessengerCreateInfoEXT, &vkDebugUtilsMessengerCreateInfoEXT,
NULL, NULL,
@ -1390,25 +1312,25 @@ zink_internal_setup_moltenvk(struct zink_screen *screen)
GET_PROC_ADDR_INSTANCE(UseIOSurfaceMVK); GET_PROC_ADDR_INSTANCE(UseIOSurfaceMVK);
GET_PROC_ADDR_INSTANCE(GetIOSurfaceMVK); GET_PROC_ADDR_INSTANCE(GetIOSurfaceMVK);
if (screen->vk_GetVersionStringsMVK) { if (screen->vk.GetVersionStringsMVK) {
char molten_version[64] = {0}; char molten_version[64] = {0};
char vulkan_version[64] = {0}; char vulkan_version[64] = {0};
(*screen->vk_GetVersionStringsMVK)(molten_version, sizeof(molten_version) - 1, vulkan_version, sizeof(vulkan_version) - 1); (*screen->vk.GetVersionStringsMVK)(molten_version, sizeof(molten_version) - 1, vulkan_version, sizeof(vulkan_version) - 1);
printf("zink: MoltenVK %s Vulkan %s \n", molten_version, vulkan_version); printf("zink: MoltenVK %s Vulkan %s \n", molten_version, vulkan_version);
} }
if (screen->vk_GetMoltenVKConfigurationMVK && screen->vk_SetMoltenVKConfigurationMVK) { if (screen->vk.GetMoltenVKConfigurationMVK && screen->vk.SetMoltenVKConfigurationMVK) {
MVKConfiguration molten_config = {0}; MVKConfiguration molten_config = {0};
size_t molten_config_size = sizeof(molten_config); size_t molten_config_size = sizeof(molten_config);
VkResult res = (*screen->vk_GetMoltenVKConfigurationMVK)(screen->instance, &molten_config, &molten_config_size); VkResult res = (*screen->vk.GetMoltenVKConfigurationMVK)(screen->instance, &molten_config, &molten_config_size);
if (res == VK_SUCCESS || res == VK_INCOMPLETE) { if (res == VK_SUCCESS || res == VK_INCOMPLETE) {
// Needed to allow MoltenVK to accept VkImageView swizzles. // Needed to allow MoltenVK to accept VkImageView swizzles.
// Encountered when using VK_FORMAT_R8G8_UNORM // Encountered when using VK_FORMAT_R8G8_UNORM
molten_config.fullImageViewSwizzle = VK_TRUE; molten_config.fullImageViewSwizzle = VK_TRUE;
(*screen->vk_SetMoltenVKConfigurationMVK)(screen->instance, &molten_config, &molten_config_size); (*screen->vk.SetMoltenVKConfigurationMVK)(screen->instance, &molten_config, &molten_config_size);
} }
} }
#endif // MVK_VERSION #endif // MVK_VERSION
@ -1439,10 +1361,10 @@ populate_format_props(struct zink_screen *screen)
VkFormat format = zink_get_format(screen, i); VkFormat format = zink_get_format(screen, i);
if (!format) if (!format)
continue; continue;
if (screen->vk_GetPhysicalDeviceFormatProperties2) { if (screen->vk.GetPhysicalDeviceFormatProperties2) {
VkFormatProperties2 props = {}; VkFormatProperties2 props = {};
props.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2; props.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2;
screen->vk_GetPhysicalDeviceFormatProperties2(screen->pdev, format, &props); screen->vk.GetPhysicalDeviceFormatProperties2(screen->pdev, format, &props);
screen->format_props[i] = props.formatProperties; screen->format_props[i] = props.formatProperties;
} else } else
vkGetPhysicalDeviceFormatProperties(screen->pdev, format, &screen->format_props[i]); vkGetPhysicalDeviceFormatProperties(screen->pdev, format, &screen->format_props[i]);
@ -1487,7 +1409,7 @@ zink_screen_timeline_wait(struct zink_screen *screen, uint32_t batch_id, uint64_
bool success = false; bool success = false;
if (screen->device_lost) if (screen->device_lost)
return true; return true;
VkResult ret = screen->vk_WaitSemaphores(screen->dev, &wi, timeout); VkResult ret = screen->vk.WaitSemaphores(screen->dev, &wi, timeout);
success = zink_screen_handle_vkresult(screen, ret); success = zink_screen_handle_vkresult(screen, ret);
if (success) if (success)
@ -1519,14 +1441,14 @@ zink_query_memory_info(struct pipe_screen *pscreen, struct pipe_memory_info *inf
{ {
struct zink_screen *screen = zink_screen(pscreen); struct zink_screen *screen = zink_screen(pscreen);
memset(info, 0, sizeof(struct pipe_memory_info)); memset(info, 0, sizeof(struct pipe_memory_info));
if (screen->info.have_EXT_memory_budget && screen->vk_GetPhysicalDeviceMemoryProperties2) { if (screen->info.have_EXT_memory_budget && screen->vk.GetPhysicalDeviceMemoryProperties2) {
VkPhysicalDeviceMemoryProperties2 mem = {}; VkPhysicalDeviceMemoryProperties2 mem = {};
mem.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2; mem.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
VkPhysicalDeviceMemoryBudgetPropertiesEXT budget = {}; VkPhysicalDeviceMemoryBudgetPropertiesEXT budget = {};
budget.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT; budget.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
mem.pNext = &budget; mem.pNext = &budget;
screen->vk_GetPhysicalDeviceMemoryProperties2(screen->pdev, &mem); screen->vk.GetPhysicalDeviceMemoryProperties2(screen->pdev, &mem);
for (unsigned i = 0; i < mem.memoryProperties.memoryHeapCount; i++) { for (unsigned i = 0; i < mem.memoryProperties.memoryHeapCount; i++) {
if (mem.memoryProperties.memoryHeaps[i].flags == VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) { if (mem.memoryProperties.memoryHeaps[i].flags == VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) {
@ -1663,9 +1585,6 @@ zink_internal_create_screen(const struct pipe_screen_config *config)
vk_instance_dispatch_table_load(&screen->vk.instance, &vkGetInstanceProcAddr, screen->instance); vk_instance_dispatch_table_load(&screen->vk.instance, &vkGetInstanceProcAddr, screen->instance);
vk_physical_device_dispatch_table_load(&screen->vk.physical_device, &vkGetInstanceProcAddr, screen->instance); vk_physical_device_dispatch_table_load(&screen->vk.physical_device, &vkGetInstanceProcAddr, screen->instance);
if (!zink_load_instance_extensions(screen))
goto fail;
if (!zink_verify_instance_extensions(screen)) if (!zink_verify_instance_extensions(screen))
goto fail; goto fail;
@ -1706,9 +1625,6 @@ zink_internal_create_screen(const struct pipe_screen_config *config)
/* this has bad perf on AMD */ /* this has bad perf on AMD */
screen->info.have_KHR_push_descriptor = false; screen->info.have_KHR_push_descriptor = false;
if (!load_device_extensions(screen))
goto fail;
vk_device_dispatch_table_load(&screen->vk.device, &vkGetDeviceProcAddr, screen->dev); vk_device_dispatch_table_load(&screen->vk.device, &vkGetDeviceProcAddr, screen->dev);
if (!zink_verify_device_extensions(screen)) if (!zink_verify_device_extensions(screen))
@ -1748,7 +1664,7 @@ zink_internal_create_screen(const struct pipe_screen_config *config)
prop.pNext = NULL; prop.pNext = NULL;
for (unsigned i = 0; i < ARRAY_SIZE(screen->maxSampleLocationGridSize); i++) { for (unsigned i = 0; i < ARRAY_SIZE(screen->maxSampleLocationGridSize); i++) {
if (screen->info.sample_locations_props.sampleLocationSampleCounts & (1 << i)) { if (screen->info.sample_locations_props.sampleLocationSampleCounts & (1 << i)) {
screen->vk_GetPhysicalDeviceMultisamplePropertiesEXT(screen->pdev, 1 << i, &prop); screen->vk.GetPhysicalDeviceMultisamplePropertiesEXT(screen->pdev, 1 << i, &prop);
screen->maxSampleLocationGridSize[i] = prop.maxSampleLocationGridSize; screen->maxSampleLocationGridSize[i] = prop.maxSampleLocationGridSize;
} }
} }

51
src/gallium/drivers/zink/zink_screen.h
View file

@ -117,23 +117,6 @@ struct zink_screen {
struct vk_dispatch_table vk; struct vk_dispatch_table vk;
PFN_vkGetPhysicalDeviceFeatures2 vk_GetPhysicalDeviceFeatures2;
PFN_vkGetPhysicalDeviceProperties2 vk_GetPhysicalDeviceProperties2;
PFN_vkGetPhysicalDeviceFormatProperties2 vk_GetPhysicalDeviceFormatProperties2;
PFN_vkGetPhysicalDeviceImageFormatProperties2 vk_GetPhysicalDeviceImageFormatProperties2;
PFN_vkGetPhysicalDeviceMemoryProperties2 vk_GetPhysicalDeviceMemoryProperties2;
PFN_vkCmdDrawIndirectCount vk_CmdDrawIndirectCount;
PFN_vkCmdDrawIndexedIndirectCount vk_CmdDrawIndexedIndirectCount;
PFN_vkWaitSemaphores vk_WaitSemaphores;
PFN_vkGetDescriptorSetLayoutSupport vk_GetDescriptorSetLayoutSupport;
PFN_vkCmdPushDescriptorSetKHR vk_CmdPushDescriptorSetKHR;
PFN_vkCreateDescriptorUpdateTemplate vk_CreateDescriptorUpdateTemplate;
PFN_vkDestroyDescriptorUpdateTemplate vk_DestroyDescriptorUpdateTemplate;
PFN_vkUpdateDescriptorSetWithTemplate vk_UpdateDescriptorSetWithTemplate;
PFN_vkCmdPushDescriptorSetWithTemplateKHR vk_CmdPushDescriptorSetWithTemplateKHR;
bool (*descriptor_program_init)(struct zink_context *ctx, struct zink_program *pg); bool (*descriptor_program_init)(struct zink_context *ctx, struct zink_program *pg);
void (*descriptor_program_deinit)(struct zink_screen *screen, struct zink_program *pg); void (*descriptor_program_deinit)(struct zink_screen *screen, struct zink_program *pg);
void (*descriptors_update)(struct zink_context *ctx, bool is_compute); void (*descriptors_update)(struct zink_context *ctx, bool is_compute);
@ -148,35 +131,6 @@ struct zink_screen {
void (*descriptors_deinit)(struct zink_context *ctx); void (*descriptors_deinit)(struct zink_context *ctx);
bool lazy_descriptors; bool lazy_descriptors;
PFN_vkGetMemoryFdKHR vk_GetMemoryFdKHR;
PFN_vkCmdBeginConditionalRenderingEXT vk_CmdBeginConditionalRenderingEXT;
PFN_vkCmdEndConditionalRenderingEXT vk_CmdEndConditionalRenderingEXT;
PFN_vkCmdBindTransformFeedbackBuffersEXT vk_CmdBindTransformFeedbackBuffersEXT;
PFN_vkCmdBeginTransformFeedbackEXT vk_CmdBeginTransformFeedbackEXT;
PFN_vkCmdEndTransformFeedbackEXT vk_CmdEndTransformFeedbackEXT;
PFN_vkCmdBeginQueryIndexedEXT vk_CmdBeginQueryIndexedEXT;
PFN_vkCmdEndQueryIndexedEXT vk_CmdEndQueryIndexedEXT;
PFN_vkCmdDrawIndirectByteCountEXT vk_CmdDrawIndirectByteCountEXT;
PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vk_GetPhysicalDeviceCalibrateableTimeDomainsEXT;
PFN_vkGetCalibratedTimestampsEXT vk_GetCalibratedTimestampsEXT;
PFN_vkCmdSetViewportWithCountEXT vk_CmdSetViewportWithCountEXT;
PFN_vkCmdSetScissorWithCountEXT vk_CmdSetScissorWithCountEXT;
PFN_vkCmdSetDepthBoundsTestEnableEXT vk_CmdSetDepthBoundsTestEnableEXT;
PFN_vkCmdSetDepthCompareOpEXT vk_CmdSetDepthCompareOpEXT;
PFN_vkCmdSetDepthTestEnableEXT vk_CmdSetDepthTestEnableEXT;
PFN_vkCmdSetDepthWriteEnableEXT vk_CmdSetDepthWriteEnableEXT;
PFN_vkCmdSetStencilTestEnableEXT vk_CmdSetStencilTestEnableEXT;
PFN_vkCmdSetStencilOpEXT vk_CmdSetStencilOpEXT;
PFN_vkCmdBindVertexBuffers2EXT vk_CmdBindVertexBuffers2EXT;
PFN_vkCmdSetFrontFaceEXT vk_CmdSetFrontFaceEXT;
PFN_vkCreateDebugUtilsMessengerEXT vk_CreateDebugUtilsMessengerEXT;
PFN_vkDestroyDebugUtilsMessengerEXT vk_DestroyDebugUtilsMessengerEXT;
PFN_vkCmdInsertDebugUtilsLabelEXT vk_CmdInsertDebugUtilsLabelEXT;
#if defined(MVK_VERSION) #if defined(MVK_VERSION)
PFN_vkGetMoltenVKConfigurationMVK vk_GetMoltenVKConfigurationMVK; PFN_vkGetMoltenVKConfigurationMVK vk_GetMoltenVKConfigurationMVK;
PFN_vkSetMoltenVKConfigurationMVK vk_SetMoltenVKConfigurationMVK; PFN_vkSetMoltenVKConfigurationMVK vk_SetMoltenVKConfigurationMVK;
@ -187,16 +141,11 @@ struct zink_screen {
PFN_vkGetIOSurfaceMVK vk_GetIOSurfaceMVK; PFN_vkGetIOSurfaceMVK vk_GetIOSurfaceMVK;
#endif #endif
PFN_vkCreateSwapchainKHR vk_CreateSwapchainKHR;
PFN_vkDestroySwapchainKHR vk_DestroySwapchainKHR;
struct { struct {
bool dual_color_blend_by_location; bool dual_color_blend_by_location;
bool inline_uniforms; bool inline_uniforms;
} driconf; } driconf;
PFN_vkGetImageDrmFormatModifierPropertiesEXT vk_GetImageDrmFormatModifierPropertiesEXT;
VkFormatProperties format_props[PIPE_FORMAT_COUNT]; VkFormatProperties format_props[PIPE_FORMAT_COUNT];
struct { struct {
uint32_t image_view; uint32_t image_view;