gallium: add PIPE_SHADER_CAP_GLSL_16BIT_TEMPS for LowerPrecisionTemporaries

[mesa.git] / src / gallium / drivers / zink / zink_screen.c

diff --git a/src/gallium/drivers/zink/zink_screen.c b/src/gallium/drivers/zink/zink_screen.c
index 5cb02587526d1441241360f1eb06ab057e6f9c3e..36c89e68324843c5a4cf5b732b466bc060192a77 100644 (file)
--- a/src/gallium/drivers/zink/zink_screen.c
+++ b/src/gallium/drivers/zink/zink_screen.c
@@ -139,6 +139,12 @@ zink_get_param(struct pipe_screen *pscreen, enum pipe_cap param)
    case PIPE_CAP_INDEP_BLEND_FUNC:
       return 1;
 
+   case PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS:
+      return screen->have_EXT_transform_feedback ? screen->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;
 
@@ -165,7 +171,7 @@ zink_get_param(struct pipe_screen *pscreen, enum pipe_cap param)
 
    case PIPE_CAP_GLSL_FEATURE_LEVEL:
    case PIPE_CAP_GLSL_FEATURE_LEVEL_COMPATIBILITY:
-      return 120;
+      return 130;
 
 #if 0 /* TODO: Enable me */
    case PIPE_CAP_COMPUTE:
@@ -270,10 +276,8 @@ zink_get_param(struct pipe_screen *pscreen, enum pipe_cap param)
    case PIPE_CAP_PCI_FUNCTION:
       return 0; /* TODO: figure these out */
 
-#if 0 /* TODO: Enable me */
    case PIPE_CAP_CULL_DISTANCE:
       return screen->feats.shaderCullDistance;
-#endif
 
    case PIPE_CAP_VIEWPORT_SUBPIXEL_BITS:
       return screen->props.limits.viewportSubPixelBits;
@@ -307,6 +311,9 @@ zink_get_param(struct pipe_screen *pscreen, enum pipe_cap param)
    case PIPE_CAP_TGSI_FS_FACE_IS_INTEGER_SYSVAL:
       return 1;
 
+   case PIPE_CAP_VIEWPORT_TRANSFORM_LOWERED:
+      return 1;
+
    case PIPE_CAP_FLATSHADE:
    case PIPE_CAP_ALPHA_TEST:
    case PIPE_CAP_CLIP_PLANES:
@@ -426,6 +433,7 @@ zink_get_shader_param(struct pipe_screen *pscreen,
    case PIPE_SHADER_CAP_FP16:
    case PIPE_SHADER_CAP_FP16_DERIVATIVES:
    case PIPE_SHADER_CAP_INT16:
+   case PIPE_SHADER_CAP_GLSL_16BIT_TEMPS:
       return 0; /* not implemented */
 
    case PIPE_SHADER_CAP_PREFERRED_IR:
@@ -727,7 +735,14 @@ load_device_extensions(struct zink_screen *screen)
       if (!screen->vk_##x)                                                  \
          return false;                                                      \
    } while (0)
-
+   if (screen->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->have_KHR_external_memory_fd)
       GET_PROC_ADDR(GetMemoryFdKHR);
 
@@ -745,6 +760,7 @@ static struct pipe_screen *
 zink_internal_create_screen(struct sw_winsys *winsys, int fd)
 {
    struct zink_screen *screen = CALLOC_STRUCT(zink_screen);
+   bool have_tf_ext = false, have_cond_render_ext = false, have_EXT_index_type_uint8 = false;
    if (!screen)
       return NULL;
 
@@ -754,8 +770,6 @@ zink_internal_create_screen(struct sw_winsys *winsys, int fd)
    screen->pdev = choose_pdev(screen->instance);
    screen->gfx_queue = find_gfx_queue(screen->pdev);
 
-   vkGetPhysicalDeviceProperties(screen->pdev, &screen->props);
-   vkGetPhysicalDeviceFeatures(screen->pdev, &screen->feats);
    vkGetPhysicalDeviceMemoryProperties(screen->pdev, &screen->mem_props);
 
    screen->have_X8_D24_UNORM_PACK32 = zink_is_depth_format_supported(screen,
@@ -781,11 +795,57 @@ zink_internal_create_screen(struct sw_winsys *winsys, int fd)
                screen->have_KHR_external_memory_fd = true;
             if (!strcmp(extensions[i].extensionName,
                         VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME))
-               screen->have_EXT_conditional_rendering = true;
+               have_cond_render_ext = true;
+            if (!strcmp(extensions[i].extensionName,
+                        VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME))
+               have_tf_ext = true;
+            if (!strcmp(extensions[i].extensionName,
+                        VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME))
+               have_EXT_index_type_uint8 = true;
+
          }
          FREE(extensions);
       }
    }
+   VkPhysicalDeviceFeatures2 feats = {};
+   VkPhysicalDeviceTransformFeedbackFeaturesEXT tf_feats = {};
+   VkPhysicalDeviceConditionalRenderingFeaturesEXT cond_render_feats = {};
+   VkPhysicalDeviceIndexTypeUint8FeaturesEXT index_uint8_feats = {};
+
+   feats.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+   if (have_tf_ext) {
+      tf_feats.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
+      tf_feats.pNext = feats.pNext;
+      feats.pNext = &tf_feats;
+   }
+   if (have_cond_render_ext) {
+      cond_render_feats.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
+      cond_render_feats.pNext = feats.pNext;
+      feats.pNext = &cond_render_feats;
+   }
+   if (have_EXT_index_type_uint8) {
+      index_uint8_feats.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT;
+      index_uint8_feats.pNext = feats.pNext;
+      feats.pNext = &index_uint8_feats;
+   }
+   vkGetPhysicalDeviceFeatures2(screen->pdev, &feats);
+   memcpy(&screen->feats, &feats.features, sizeof(screen->feats));
+   if (have_tf_ext && tf_feats.transformFeedback)
+      screen->have_EXT_transform_feedback = true;
+   if (have_cond_render_ext && cond_render_feats.conditionalRendering)
+      screen->have_EXT_conditional_rendering = true;
+   if (have_EXT_index_type_uint8 && index_uint8_feats.indexTypeUint8)
+      screen->have_EXT_index_type_uint8 = true;
+
+   VkPhysicalDeviceProperties2 props = {};
+   props.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
+   if (screen->have_EXT_transform_feedback) {
+      screen->tf_props.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
+      screen->tf_props.pNext = NULL;
+      props.pNext = &screen->tf_props;
+   }
+   vkGetPhysicalDeviceProperties2(screen->pdev, &props);
+   memcpy(&screen->props, &props.properties, sizeof(screen->props));
 
    if (!screen->have_KHR_maintenance1) {
       debug_printf("ZINK: VK_KHR_maintenance1 required!\n");
@@ -803,8 +863,11 @@ zink_internal_create_screen(struct sw_winsys *winsys, int fd)
    dci.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
    dci.queueCreateInfoCount = 1;
    dci.pQueueCreateInfos = &qci;
-   dci.pEnabledFeatures = &screen->feats;
-   const char *extensions[4] = {
+   /* extensions don't have bool members in pEnabledFeatures.
+    * this requires us to pass the whole VkPhysicalDeviceFeatures2 struct
+    */
+   dci.pNext = &feats;
+   const char *extensions[6] = {
       VK_KHR_MAINTENANCE1_EXTENSION_NAME,
    };
    num_extensions = 1;
@@ -822,6 +885,11 @@ zink_internal_create_screen(struct sw_winsys *winsys, int fd)
    if (screen->have_EXT_conditional_rendering)
       extensions[num_extensions++] = VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME;
 
+   if (screen->have_EXT_index_type_uint8)
+      extensions[num_extensions++] = VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME;
+
+   if (screen->have_EXT_transform_feedback)
+      extensions[num_extensions++] = VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME;
    assert(num_extensions <= ARRAY_SIZE(extensions));
 
    dci.ppEnabledExtensionNames = extensions;