zink: use the new, generated extension infrastructure

this is just a find-and-replace from screen->... to screen->info.

Reviewed-by: Erik Faye-Lund <erik.faye-lund@collabora.com>
Reviewed-by: Mike Blumenkrantz <michael.blumenkrantz@gmail.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/6789>

src/gallium/drivers/zink/zink_context.c

@@ -385,7 +385,7 @@ zink_set_constant_buffer(struct pipe_context *pctx,
       if (cb->user_buffer) {
          struct zink_screen *screen = zink_screen(pctx->screen);
          u_upload_data(ctx->base.const_uploader, 0, cb->buffer_size,
-                       screen->props.limits.minUniformBufferOffsetAlignment,
+                       screen->info.props.limits.minUniformBufferOffsetAlignment,
                        cb->user_buffer, &offset, &buffer);
       }
 
@@ -875,7 +875,7 @@ zink_flush(struct pipe_context *pctx,
    struct zink_batch *batch = zink_curr_batch(ctx);
    flush_batch(ctx);
 
-   if (zink_screen(pctx->screen)->have_EXT_transform_feedback && ctx->num_so_targets)
+   if (zink_screen(pctx->screen)->info.have_EXT_transform_feedback && ctx->num_so_targets)
       ctx->dirty_so_targets = true;
 
    if (pfence)

src/gallium/drivers/zink/zink_draw.c

@@ -268,7 +268,7 @@ zink_draw_vbo(struct pipe_context *pctx,
    if (dinfo->index_size > 0) {
        uint32_t restart_index = util_prim_restart_index_from_size(dinfo->index_size);
        if ((dinfo->primitive_restart && (dinfo->restart_index != restart_index)) ||
-           (!screen->have_EXT_index_type_uint8 && dinfo->index_size == 8)) {
+           (!screen->info.have_EXT_index_type_uint8 && dinfo->index_size == 8)) {
           util_translate_prim_restart_ib(pctx, dinfo, &index_buffer);
           need_index_buffer_unref = true;
        } else {
@@ -306,7 +306,7 @@ zink_draw_vbo(struct pipe_context *pctx,
          int index = shader->bindings[j].index;
          if (shader->bindings[j].type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) {
             assert(ctx->ubos[i][index].buffer_size > 0);
-            assert(ctx->ubos[i][index].buffer_size <= screen->props.limits.maxUniformBufferRange);
+            assert(ctx->ubos[i][index].buffer_size <= screen->info.props.limits.maxUniformBufferRange);
             assert(ctx->ubos[i][index].buffer);
             struct zink_resource *res = zink_resource(ctx->ubos[i][index].buffer);
             buffer_infos[num_buffer_info].buffer = res->buffer;
@@ -408,7 +408,7 @@ zink_draw_vbo(struct pipe_context *pctx,
    }
 
    if (line_width_needed(reduced_prim, rast_state->hw_state.polygon_mode)) {
-      if (screen->feats.wideLines || ctx->line_width == 1.0f)
+      if (screen->info.feats.features.wideLines || ctx->line_width == 1.0f)
          vkCmdSetLineWidth(batch->cmdbuf, ctx->line_width);
       else
          debug_printf("BUG: wide lines not supported, needs fallback!");
@@ -467,7 +467,7 @@ zink_draw_vbo(struct pipe_context *pctx,
          index_size = MAX2(index_size, 2);
       switch (index_size) {
       case 1:
-         assert(screen->have_EXT_index_type_uint8);
+         assert(screen->info.have_EXT_index_type_uint8);
          index_type = VK_INDEX_TYPE_UINT8_EXT;
          break;
       case 2:
@@ -486,11 +486,11 @@ zink_draw_vbo(struct pipe_context *pctx,
          dinfo->count, dinfo->instance_count,
          need_index_buffer_unref ? 0 : dinfo->start, dinfo->index_bias, dinfo->start_instance);
    } else {
-      if (so_target && screen->tf_props.transformFeedbackDraw) {
+      if (so_target && screen->info.tf_props.transformFeedbackDraw) {
          zink_batch_reference_resoure(batch, zink_resource(so_target->counter_buffer));
          screen->vk_CmdDrawIndirectByteCountEXT(batch->cmdbuf, dinfo->instance_count, dinfo->start_instance,
                                        zink_resource(so_target->counter_buffer)->buffer, so_target->counter_buffer_offset, 0,
-                                       MIN2(so_target->stride, screen->tf_props.maxTransformFeedbackBufferDataStride));
+                                       MIN2(so_target->stride, screen->info.tf_props.maxTransformFeedbackBufferDataStride));
       }
       else
          vkCmdDraw(batch->cmdbuf, dinfo->count, dinfo->instance_count, dinfo->start, dinfo->start_instance);

src/gallium/drivers/zink/zink_resource.c

@@ -58,7 +58,7 @@ get_memory_type_index(struct zink_screen *screen,
 {
    for (uint32_t i = 0u; i < VK_MAX_MEMORY_TYPES; i++) {
       if (((reqs->memoryTypeBits >> i) & 1) == 1) {
-         if ((screen->mem_props.memoryTypes[i].propertyFlags & props) == props) {
+         if ((screen->info.mem_props.memoryTypes[i].propertyFlags & props) == props) {
             return i;
             break;
          }
@@ -642,7 +642,7 @@ zink_screen_resource_init(struct pipe_screen *pscreen)
    pscreen->resource_destroy = zink_resource_destroy;
    pscreen->transfer_helper = u_transfer_helper_create(&transfer_vtbl, true, true, false, false);
 
-   if (zink_screen(pscreen)->have_KHR_external_memory_fd) {
+   if (zink_screen(pscreen)->info.have_KHR_external_memory_fd) {
       pscreen->resource_get_handle = zink_resource_get_handle;
       pscreen->resource_from_handle = zink_resource_from_handle;
    }

src/gallium/drivers/zink/zink_screen.c

@@ -64,7 +64,7 @@ zink_get_device_vendor(struct pipe_screen *pscreen)
 {
    struct zink_screen *screen = zink_screen(pscreen);
    static char buf[1000];
-   snprintf(buf, sizeof(buf), "Unknown (vendor-id: 0x%04x)", screen->props.vendorID);
+   snprintf(buf, sizeof(buf), "Unknown (vendor-id: 0x%04x)", screen->info.props.vendorID);
    return buf;
 }
 
@@ -73,7 +73,7 @@ zink_get_name(struct pipe_screen *pscreen)
 {
    struct zink_screen *screen = zink_screen(pscreen);
    static char buf[1000];
-   snprintf(buf, sizeof(buf), "zink (%s)", screen->props.deviceName);
+   snprintf(buf, sizeof(buf), "zink (%s)", screen->info.props.deviceName);
    return buf;
 }
 
@@ -81,10 +81,10 @@ static int
 get_video_mem(struct zink_screen *screen)
 {
    VkDeviceSize size = 0;
-   for (uint32_t i = 0; i < screen->mem_props.memoryHeapCount; ++i) {
-      if (screen->mem_props.memoryHeaps[i].flags &
+   for (uint32_t i = 0; i < screen->info.mem_props.memoryHeapCount; ++i) {
+      if (screen->info.mem_props.memoryHeaps[i].flags &
           VK_MEMORY_HEAP_DEVICE_LOCAL_BIT)
-         size += screen->mem_props.memoryHeaps[i].size;
+         size += screen->info.mem_props.memoryHeaps[i].size;
    }
    return (int)(size >> 20);
 }
@@ -100,18 +100,18 @@ zink_get_param(struct pipe_screen *pscreen, enum pipe_cap param)
       return 1;
 
    case PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR:
-      return screen->have_EXT_vertex_attribute_divisor;
+      return screen->info.have_EXT_vertex_attribute_divisor;
 
    case PIPE_CAP_MAX_DUAL_SOURCE_RENDER_TARGETS:
-      if (!screen->feats.dualSrcBlend)
+      if (!screen->info.feats.features.dualSrcBlend)
          return 0;
-      return screen->props.limits.maxFragmentDualSrcAttachments;
+      return screen->info.props.limits.maxFragmentDualSrcAttachments;
 
    case PIPE_CAP_POINT_SPRITE:
       return 1;
 
    case PIPE_CAP_MAX_RENDER_TARGETS:
-      return screen->props.limits.maxColorAttachments;
+      return screen->info.props.limits.maxColorAttachments;
 
    case PIPE_CAP_OCCLUSION_QUERY:
       return 1;
@@ -128,11 +128,11 @@ zink_get_param(struct pipe_screen *pscreen, enum pipe_cap param)
       return 1;
 
    case PIPE_CAP_MAX_TEXTURE_2D_SIZE:
-      return screen->props.limits.maxImageDimension2D;
+      return screen->info.props.limits.maxImageDimension2D;
    case PIPE_CAP_MAX_TEXTURE_3D_LEVELS:
-      return 1 + util_logbase2(screen->props.limits.maxImageDimension3D);
+      return 1 + util_logbase2(screen->info.props.limits.maxImageDimension3D);
    case PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS:
-      return 1 + util_logbase2(screen->props.limits.maxImageDimensionCube);
+      return 1 + util_logbase2(screen->info.props.limits.maxImageDimensionCube);
 
    case PIPE_CAP_BLEND_EQUATION_SEPARATE:
    case PIPE_CAP_FRAGMENT_SHADER_TEXTURE_LOD:
@@ -145,16 +145,16 @@ zink_get_param(struct pipe_screen *pscreen, enum pipe_cap param)
       return 1;
 
    case PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS:
-      return screen->have_EXT_transform_feedback ? screen->tf_props.maxTransformFeedbackBuffers : 0;
+      return screen->info.have_EXT_transform_feedback ? screen->info.tf_props.maxTransformFeedbackBuffers : 0;
    case PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME:
    case PIPE_CAP_STREAM_OUTPUT_INTERLEAVE_BUFFERS:
       return 1;
 
    case PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS:
-      return screen->props.limits.maxImageArrayLayers;
+      return screen->info.props.limits.maxImageArrayLayers;
 
    case PIPE_CAP_DEPTH_CLIP_DISABLE:
-      return screen->feats.depthClamp;
+      return screen->info.feats.features.depthClamp;
 
    case PIPE_CAP_TGSI_INSTANCEID:
    case PIPE_CAP_MIXED_COLORBUFFER_FORMATS:
@@ -162,15 +162,15 @@ zink_get_param(struct pipe_screen *pscreen, enum pipe_cap param)
       return 1;
 
    case PIPE_CAP_MIN_TEXEL_OFFSET:
-      return screen->props.limits.minTexelOffset;
+      return screen->info.props.limits.minTexelOffset;
    case PIPE_CAP_MAX_TEXEL_OFFSET:
-      return screen->props.limits.maxTexelOffset;
+      return screen->info.props.limits.maxTexelOffset;
 
    case PIPE_CAP_VERTEX_COLOR_UNCLAMPED:
       return 1;
 
    case PIPE_CAP_CONDITIONAL_RENDER:
-     return screen->have_EXT_conditional_rendering;
+     return screen->info.have_EXT_conditional_rendering;
 
    case PIPE_CAP_GLSL_FEATURE_LEVEL:
    case PIPE_CAP_GLSL_FEATURE_LEVEL_COMPATIBILITY:
@@ -182,7 +182,7 @@ zink_get_param(struct pipe_screen *pscreen, enum pipe_cap param)
 #endif
 
    case PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT:
-      return screen->props.limits.minUniformBufferOffsetAlignment;
+      return screen->info.props.limits.minUniformBufferOffsetAlignment;
 
 #if 0 /* TODO: Enable me */
    case PIPE_CAP_QUERY_TIMESTAMP:
@@ -190,37 +190,37 @@ zink_get_param(struct pipe_screen *pscreen, enum pipe_cap param)
 #endif
 
    case PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT:
-      return screen->props.limits.minMemoryMapAlignment;
+      return screen->info.props.limits.minMemoryMapAlignment;
 
    case PIPE_CAP_CUBE_MAP_ARRAY:
-      return screen->feats.imageCubeArray;
+      return screen->info.feats.features.imageCubeArray;
 
    case PIPE_CAP_TEXTURE_BUFFER_OBJECTS:
    case PIPE_CAP_PRIMITIVE_RESTART:
       return 1;
 
    case PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT:
-      return screen->props.limits.minTexelBufferOffsetAlignment;
+      return screen->info.props.limits.minTexelBufferOffsetAlignment;
 
    case PIPE_CAP_PREFER_BLIT_BASED_TEXTURE_TRANSFER:
       return 0; /* unsure */
 
    case PIPE_CAP_MAX_TEXTURE_BUFFER_SIZE:
-      return screen->props.limits.maxTexelBufferElements;
+      return screen->info.props.limits.maxTexelBufferElements;
 
    case PIPE_CAP_ENDIANNESS:
       return PIPE_ENDIAN_NATIVE; /* unsure */
 
    case PIPE_CAP_MAX_VIEWPORTS:
-      return 1; /* TODO: When GS is supported, use screen->props.limits.maxViewports */
+      return 1; /* TODO: When GS is supported, use screen->info.props.limits.maxViewports */
 
    case PIPE_CAP_MIXED_FRAMEBUFFER_SIZES:
       return 1;
 
    case PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES:
-      return screen->props.limits.maxGeometryOutputVertices;
+      return screen->info.props.limits.maxGeometryOutputVertices;
    case PIPE_CAP_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS:
-      return screen->props.limits.maxGeometryOutputComponents;
+      return screen->info.props.limits.maxGeometryOutputComponents;
 
 #if 0 /* TODO: Enable me. Enables ARB_texture_gather */
    case PIPE_CAP_MAX_TEXTURE_GATHER_COMPONENTS:
@@ -228,27 +228,27 @@ zink_get_param(struct pipe_screen *pscreen, enum pipe_cap param)
 #endif
 
    case PIPE_CAP_MIN_TEXTURE_GATHER_OFFSET:
-      return screen->props.limits.minTexelGatherOffset;
+      return screen->info.props.limits.minTexelGatherOffset;
    case PIPE_CAP_MAX_TEXTURE_GATHER_OFFSET:
-      return screen->props.limits.maxTexelGatherOffset;
+      return screen->info.props.limits.maxTexelGatherOffset;
 
    case PIPE_CAP_TGSI_FS_FINE_DERIVATIVE:
       return 1;
 
    case PIPE_CAP_VENDOR_ID:
-      return screen->props.vendorID;
+      return screen->info.props.vendorID;
    case PIPE_CAP_DEVICE_ID:
-      return screen->props.deviceID;
+      return screen->info.props.deviceID;
 
    case PIPE_CAP_ACCELERATED:
       return 1;
    case PIPE_CAP_VIDEO_MEMORY:
       return get_video_mem(screen);
    case PIPE_CAP_UMA:
-      return screen->props.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
+      return screen->info.props.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
 
    case PIPE_CAP_MAX_VERTEX_ATTRIB_STRIDE:
-      return screen->props.limits.maxVertexInputBindingStride;
+      return screen->info.props.limits.maxVertexInputBindingStride;
 
 #if 0 /* TODO: Enable me */
    case PIPE_CAP_SAMPLER_VIEW_TARGET:
@@ -271,7 +271,7 @@ zink_get_param(struct pipe_screen *pscreen, enum pipe_cap param)
 
 #if 0 /* TODO: Enable me. Enables GL_ARB_shader_storage_buffer_object */
    case PIPE_CAP_SHADER_BUFFER_OFFSET_ALIGNMENT:
-      return screen->props.limits.minStorageBufferOffsetAlignment;
+      return screen->info.props.limits.minStorageBufferOffsetAlignment;
 #endif
 
    case PIPE_CAP_PCI_GROUP:
@@ -281,10 +281,10 @@ zink_get_param(struct pipe_screen *pscreen, enum pipe_cap param)
       return 0; /* TODO: figure these out */
 
    case PIPE_CAP_CULL_DISTANCE:
-      return screen->feats.shaderCullDistance;
+      return screen->info.feats.features.shaderCullDistance;
 
    case PIPE_CAP_VIEWPORT_SUBPIXEL_BITS:
-      return screen->props.limits.viewportSubPixelBits;
+      return screen->info.props.limits.viewportSubPixelBits;
 
    case PIPE_CAP_GLSL_OPTIMIZE_CONSERVATIVELY:
       return 0; /* not sure */
@@ -293,10 +293,10 @@ zink_get_param(struct pipe_screen *pscreen, enum pipe_cap param)
       return 0; /* not implemented */
 
    case PIPE_CAP_MAX_COMBINED_SHADER_BUFFERS:
-      return screen->props.limits.maxDescriptorSetStorageBuffers;
+      return screen->info.props.limits.maxDescriptorSetStorageBuffers;
 
    case PIPE_CAP_MAX_SHADER_BUFFER_SIZE:
-      return screen->props.limits.maxStorageBufferRange; /* unsure */
+      return screen->info.props.limits.maxStorageBufferRange; /* unsure */
 
    case PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT:
    case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER:
@@ -326,7 +326,7 @@ zink_get_param(struct pipe_screen *pscreen, enum pipe_cap param)
       return 0;
 
    case PIPE_CAP_DMABUF:
-      return screen->have_KHR_external_memory_fd;
+      return screen->info.have_KHR_external_memory_fd;
 
    default:
       return u_pipe_screen_get_param_defaults(pscreen, param);
@@ -341,17 +341,17 @@ zink_get_paramf(struct pipe_screen *pscreen, enum pipe_capf param)
    switch (param) {
    case PIPE_CAPF_MAX_LINE_WIDTH:
    case PIPE_CAPF_MAX_LINE_WIDTH_AA:
-      return screen->props.limits.lineWidthRange[1];
+      return screen->info.props.limits.lineWidthRange[1];
 
    case PIPE_CAPF_MAX_POINT_WIDTH:
    case PIPE_CAPF_MAX_POINT_WIDTH_AA:
-      return screen->props.limits.pointSizeRange[1];
+      return screen->info.props.limits.pointSizeRange[1];
 
    case PIPE_CAPF_MAX_TEXTURE_ANISOTROPY:
-      return screen->props.limits.maxSamplerAnisotropy;
+      return screen->info.props.limits.maxSamplerAnisotropy;
 
    case PIPE_CAPF_MAX_TEXTURE_LOD_BIAS:
-      return screen->props.limits.maxSamplerLodBias;
+      return screen->info.props.limits.maxSamplerLodBias;
 
    case PIPE_CAPF_MIN_CONSERVATIVE_RASTER_DILATE:
    case PIPE_CAPF_MAX_CONSERVATIVE_RASTER_DILATE:
@@ -384,10 +384,10 @@ zink_get_shader_param(struct pipe_screen *pscreen,
    case PIPE_SHADER_CAP_MAX_INPUTS:
       switch (shader) {
       case PIPE_SHADER_VERTEX:
-         return MIN2(screen->props.limits.maxVertexInputAttributes,
+         return MIN2(screen->info.props.limits.maxVertexInputAttributes,
                      PIPE_MAX_SHADER_INPUTS);
       case PIPE_SHADER_FRAGMENT:
-         return MIN2(screen->props.limits.maxFragmentInputComponents / 4,
+         return MIN2(screen->info.props.limits.maxFragmentInputComponents / 4,
                      PIPE_MAX_SHADER_INPUTS);
       default:
          return 0; /* unsupported stage */
@@ -396,10 +396,10 @@ zink_get_shader_param(struct pipe_screen *pscreen,
    case PIPE_SHADER_CAP_MAX_OUTPUTS:
       switch (shader) {
       case PIPE_SHADER_VERTEX:
-         return MIN2(screen->props.limits.maxVertexOutputComponents / 4,
+         return MIN2(screen->info.props.limits.maxVertexOutputComponents / 4,
                      PIPE_MAX_SHADER_OUTPUTS);
       case PIPE_SHADER_FRAGMENT:
-         return MIN2(screen->props.limits.maxColorAttachments,
+         return MIN2(screen->info.props.limits.maxColorAttachments,
                 PIPE_MAX_SHADER_OUTPUTS);
       default:
          return 0; /* unsupported stage */
@@ -410,17 +410,17 @@ zink_get_shader_param(struct pipe_screen *pscreen,
       case PIPE_SHADER_VERTEX:
       case PIPE_SHADER_FRAGMENT:
          /* this might be a bit simplistic... */
-         return MIN2(screen->props.limits.maxPerStageDescriptorSamplers,
+         return MIN2(screen->info.props.limits.maxPerStageDescriptorSamplers,
                      PIPE_MAX_SAMPLERS);
       default:
          return 0; /* unsupported stage */
       }
 
    case PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE:
-      return MIN2(screen->props.limits.maxUniformBufferRange, INT_MAX);
+      return MIN2(screen->info.props.limits.maxUniformBufferRange, INT_MAX);
 
    case PIPE_SHADER_CAP_MAX_CONST_BUFFERS:
-      return screen->props.limits.maxPerStageDescriptorUniformBuffers;
+      return screen->info.props.limits.maxPerStageDescriptorUniformBuffers;
 
    case PIPE_SHADER_CAP_MAX_TEMPS:
       return INT_MAX;
@@ -447,7 +447,7 @@ zink_get_shader_param(struct pipe_screen *pscreen,
       return 0; /* not implemented */
 
    case PIPE_SHADER_CAP_MAX_SAMPLER_VIEWS:
-      return MIN2(screen->props.limits.maxPerStageDescriptorSampledImages,
+      return MIN2(screen->info.props.limits.maxPerStageDescriptorSampledImages,
                   PIPE_MAX_SHADER_SAMPLER_VIEWS);
 
    case PIPE_SHADER_CAP_TGSI_DROUND_SUPPORTED:
@@ -463,14 +463,14 @@ zink_get_shader_param(struct pipe_screen *pscreen,
 
    case PIPE_SHADER_CAP_MAX_SHADER_BUFFERS:
       /* TODO: this limitation is dumb, and will need some fixes in mesa */
-      return MIN2(screen->props.limits.maxPerStageDescriptorStorageBuffers, PIPE_MAX_SHADER_BUFFERS);
+      return MIN2(screen->info.props.limits.maxPerStageDescriptorStorageBuffers, PIPE_MAX_SHADER_BUFFERS);
 
    case PIPE_SHADER_CAP_SUPPORTED_IRS:
       return (1 << PIPE_SHADER_IR_NIR) | (1 << PIPE_SHADER_IR_TGSI);
 
    case PIPE_SHADER_CAP_MAX_SHADER_IMAGES:
 #if 0 /* TODO: needs compiler support */
-      return MIN2(screen->props.limits.maxPerStageDescriptorStorageImages,
+      return MIN2(screen->info.props.limits.maxPerStageDescriptorStorageImages,
                   PIPE_MAX_SHADER_IMAGES);
 #else
       return 0;
@@ -518,7 +518,7 @@ zink_is_format_supported(struct pipe_screen *pscreen,
    struct zink_screen *screen = zink_screen(pscreen);
 
    if (format == PIPE_FORMAT_NONE)
-      return screen->props.limits.framebufferNoAttachmentsSampleCounts &
+      return screen->info.props.limits.framebufferNoAttachmentsSampleCounts &
              vk_sample_count_flags(sample_count);
 
    VkFormat vkformat = zink_get_format(screen, format);
@@ -533,33 +533,33 @@ zink_is_format_supported(struct pipe_screen *pscreen,
       if (util_format_is_depth_or_stencil(format)) {
          if (util_format_has_depth(desc)) {
             if (bind & PIPE_BIND_DEPTH_STENCIL &&
-                (screen->props.limits.framebufferDepthSampleCounts & sample_mask) != sample_mask)
+                (screen->info.props.limits.framebufferDepthSampleCounts & sample_mask) != sample_mask)
                return false;
             if (bind & PIPE_BIND_SAMPLER_VIEW &&
-                (screen->props.limits.sampledImageDepthSampleCounts & sample_mask) != sample_mask)
+                (screen->info.props.limits.sampledImageDepthSampleCounts & sample_mask) != sample_mask)
                return false;
          }
          if (util_format_has_stencil(desc)) {
             if (bind & PIPE_BIND_DEPTH_STENCIL &&
-                (screen->props.limits.framebufferStencilSampleCounts & sample_mask) != sample_mask)
+                (screen->info.props.limits.framebufferStencilSampleCounts & sample_mask) != sample_mask)
                return false;
             if (bind & PIPE_BIND_SAMPLER_VIEW &&
-                (screen->props.limits.sampledImageStencilSampleCounts & sample_mask) != sample_mask)
+                (screen->info.props.limits.sampledImageStencilSampleCounts & sample_mask) != sample_mask)
                return false;
          }
       } else if (util_format_is_pure_integer(format)) {
          if (bind & PIPE_BIND_RENDER_TARGET &&
-             !(screen->props.limits.framebufferColorSampleCounts & sample_mask))
+             !(screen->info.props.limits.framebufferColorSampleCounts & sample_mask))
             return false;
          if (bind & PIPE_BIND_SAMPLER_VIEW &&
-             !(screen->props.limits.sampledImageIntegerSampleCounts & sample_mask))
+             !(screen->info.props.limits.sampledImageIntegerSampleCounts & sample_mask))
             return false;
       } else {
          if (bind & PIPE_BIND_RENDER_TARGET &&
-             !(screen->props.limits.framebufferColorSampleCounts & sample_mask))
+             !(screen->info.props.limits.framebufferColorSampleCounts & sample_mask))
             return false;
          if (bind & PIPE_BIND_SAMPLER_VIEW &&
-             !(screen->props.limits.sampledImageColorSampleCounts & sample_mask))
+             !(screen->info.props.limits.sampledImageColorSampleCounts & sample_mask))
             return false;
       }
    }
@@ -593,7 +593,7 @@ zink_is_format_supported(struct pipe_screen *pscreen,
    if (util_format_is_compressed(format)) {
       const struct util_format_description *desc = util_format_description(format);
       if (desc->layout == UTIL_FORMAT_LAYOUT_BPTC &&
-          !screen->feats.textureCompressionBC)
+          !screen->info.feats.features.textureCompressionBC)
          return false;
    }
 
@@ -750,7 +750,7 @@ load_device_extensions(struct zink_screen *screen)
          return false;                                                      \
       } \
    } while (0)
-   if (screen->have_EXT_transform_feedback) {
+   if (screen->info.have_EXT_transform_feedback) {
       GET_PROC_ADDR(CmdBindTransformFeedbackBuffersEXT);
       GET_PROC_ADDR(CmdBeginTransformFeedbackEXT);
       GET_PROC_ADDR(CmdEndTransformFeedbackEXT);
@@ -758,15 +758,15 @@ load_device_extensions(struct zink_screen *screen)
       GET_PROC_ADDR(CmdEndQueryIndexedEXT);
       GET_PROC_ADDR(CmdDrawIndirectByteCountEXT);
    }
-   if (screen->have_KHR_external_memory_fd)
+   if (screen->info.have_KHR_external_memory_fd)
       GET_PROC_ADDR(GetMemoryFdKHR);
 
-   if (screen->have_EXT_conditional_rendering) {
+   if (screen->info.have_EXT_conditional_rendering) {
       GET_PROC_ADDR(CmdBeginConditionalRenderingEXT);
       GET_PROC_ADDR(CmdEndConditionalRenderingEXT);
    }
 
-   if (screen->have_EXT_calibrated_timestamps) {
+   if (screen->info.have_EXT_calibrated_timestamps) {
       GET_PROC_ADDR_INSTANCE(GetPhysicalDeviceCalibrateableTimeDomainsEXT);
       GET_PROC_ADDR(GetCalibratedTimestampsEXT);
 

src/gallium/drivers/zink/zink_state.c

@@ -60,9 +60,9 @@ zink_create_vertex_elements_state(struct pipe_context *pctx,
       ves->bindings[binding].binding = binding;
       ves->bindings[binding].inputRate = elem->instance_divisor ? VK_VERTEX_INPUT_RATE_INSTANCE : VK_VERTEX_INPUT_RATE_VERTEX;
 
-      assert(!elem->instance_divisor || zink_screen(pctx->screen)->have_EXT_vertex_attribute_divisor);
+      assert(!elem->instance_divisor || zink_screen(pctx->screen)->info.have_EXT_vertex_attribute_divisor);
       ves->divisor[binding] = elem->instance_divisor;
-      assert(elem->instance_divisor <= screen->max_vertex_attrib_divisor);
+      assert(elem->instance_divisor <= screen->info.vdiv_props.maxVertexAttribDivisor);
 
       ves->hw_state.attribs[i].binding = binding;
       ves->hw_state.attribs[i].location = i; // TODO: unsure
@@ -437,8 +437,8 @@ zink_create_rasterizer_state(struct pipe_context *pctx,
    state->offset_scale = rs_state->offset_scale;
 
    state->line_width = line_width(rs_state->line_width,
-                                  screen->props.limits.lineWidthGranularity,
-                                  screen->props.limits.lineWidthRange);
+                                  screen->info.props.limits.lineWidthGranularity,
+                                  screen->info.props.limits.lineWidthRange);
 
    return state;
 }