wine/vkd3d
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/vkd3d.git synced 2024-11-21 16:46:41 -08:00
Code Issues Packages Projects Releases Wiki Activity

tests/shader_runner: Store shader caps using an array.

Browse Source
This commit is contained in:
Elizabeth Figura 2024-10-05 07:46:00 -05:00 committed by Henri Verbeet
parent 390a330b8e
commit d39e840c14
Notes: Henri Verbeet 2024-10-28 18:11:45 +01:00 
Approved-by: Henri Verbeet (@hverbeet)
Merge-Request: https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/1216
10 changed files with 120 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
tests/hlsl/wave-ops-float.shader_test
View File

@ -1,6 +1,6 @@
[require] [require]
shader model >= 6.0 shader model >= 6.0
wave ops wave-ops
format r32g32b32a32-float uav-load format r32g32b32a32-float uav-load
format r32g32b32a32-uint uav-load format r32g32b32a32-uint uav-load

2
tests/hlsl/wave-ops-int.shader_test
View File

@ -1,6 +1,6 @@
[require] [require]
shader model >= 6.0 shader model >= 6.0
wave ops wave-ops
format r32g32b32a32-sint uav-load format r32g32b32a32-sint uav-load
[uav 0] [uav 0]

2
tests/hlsl/wave-ops-uint.shader_test
View File

@ -1,6 +1,6 @@
[require] [require]
shader model >= 6.0 shader model >= 6.0
wave ops wave-ops
format r32-uint uav-load format r32-uint uav-load
[uav 0] [uav 0]

141
tests/shader_runner.c
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2020-2021 Zebediah Figura for CodeWeavers * Copyright 2020-2024 Elizabeth Figura for CodeWeavers
* *
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
@ -329,8 +329,34 @@ static DXGI_FORMAT parse_format(const char *line, enum texture_data_type *data_t
fatal_error("Unknown format '%s'.\n", line); fatal_error("Unknown format '%s'.\n", line);
} }
static const char *const shader_cap_strings[] =
{
[SHADER_CAP_CLIP_PLANES] = "clip-planes",
[SHADER_CAP_DEPTH_BOUNDS] = "depth-bounds",
[SHADER_CAP_FLOAT64] = "float64",
[SHADER_CAP_GEOMETRY_SHADER] = "geometry-shader",
[SHADER_CAP_INT64] = "int64",
[SHADER_CAP_POINT_SIZE] = "point-size",
[SHADER_CAP_ROV] = "rov",
[SHADER_CAP_WAVE_OPS] = "wave-ops",
};
static bool match_shader_cap_string(const char *line, enum shader_cap *cap)
{
for (enum shader_cap i = 0; i < SHADER_CAP_COUNT; ++i)
{
if (match_string(line, shader_cap_strings[i], &line))
{
*cap = i;
return true;
}
}
return false;
}
static void parse_require_directive(struct shader_runner *runner, const char *line) static void parse_require_directive(struct shader_runner *runner, const char *line)
{ {
enum shader_cap shader_cap;
bool less_than = false; bool less_than = false;
unsigned int i; unsigned int i;
@ -392,37 +418,9 @@ static void parse_require_directive(struct shader_runner *runner, const char *li
fatal_error("Unknown format cap '%s'.\n", line); fatal_error("Unknown format cap '%s'.\n", line);
} }
} }
else if (match_string(line, "geometry-shader", &line)) else if (match_shader_cap_string(line, &shader_cap))
{ {
runner->require_geometry_shader = true; runner->require_shader_caps[shader_cap] = true;
}
else if (match_string(line, "float64", &line))
{
runner->require_float64 = true;
}
else if (match_string(line, "int64", &line))
{
runner->require_int64 = true;
}
else if (match_string(line, "rov", &line))
{
runner->require_rov = true;
}
else if (match_string(line, "wave ops", &line))
{
runner->require_wave_ops = true;
}
else if (match_string(line, "depth-bounds", &line))
{
runner->require_depth_bounds = true;
}
else if (match_string(line, "clip-planes", &line))
{
runner->require_clip_planes = true;
}
else if (match_string(line, "point-size", &line))
{
runner->require_point_size = true;
} }
else else
{ {
@ -932,7 +930,7 @@ static void parse_test_directive(struct shader_runner *runner, const char *line)
{ {
if (sscanf(line, "%f %f", &runner->depth_min, &runner->depth_max) != 2) if (sscanf(line, "%f %f", &runner->depth_min, &runner->depth_max) != 2)
fatal_error("Malformed depth-bounds arguments '%s'.\n", line); fatal_error("Malformed depth-bounds arguments '%s'.\n", line);
if (!runner->caps->depth_bounds) if (!runner->caps->shader_caps[SHADER_CAP_DEPTH_BOUNDS])
fatal_error("depth-bounds set but runner does not support depth bounds testing."); fatal_error("depth-bounds set but runner does not support depth bounds testing.");
runner->depth_bounds = true; runner->depth_bounds = true;
} }
@ -1591,22 +1589,11 @@ static bool check_capabilities(const struct shader_runner *runner, const struct
{ {
unsigned int i; unsigned int i;
if (runner->require_geometry_shader && !caps->geometry_shader) for (i = 0; i < SHADER_CAP_COUNT; ++i)
return false; {
if (runner->require_float64 && !caps->float64) if (runner->require_shader_caps[i] && !caps->shader_caps[i])
return false;
if (runner->require_int64 && !caps->int64)
return false;
if (runner->require_rov && !caps->rov)
return false;
if (runner->require_wave_ops && !caps->wave_ops)
return false;
if (runner->require_depth_bounds && !caps->depth_bounds)
return false;
if (runner->require_clip_planes && !caps->clip_planes)
return false;
if (runner->require_point_size && !caps->point_size)
return false; return false;
}
for (i = 0; i < ARRAY_SIZE(runner->require_format_caps); ++i) for (i = 0; i < ARRAY_SIZE(runner->require_format_caps); ++i)
{ {
@ -1624,7 +1611,7 @@ static void trace_tags(const struct shader_runner_caps *caps)
p = tags; p = tags;
rem = ARRAY_SIZE(tags); rem = ARRAY_SIZE(tags);
rc = snprintf(p, rem, " tags:"); rc = snprintf(p, rem, "%8s:", "tags");
p += rc; p += rc;
rem -= rc; rem -= rc;
@ -1638,7 +1625,7 @@ static void trace_tags(const struct shader_runner_caps *caps)
p = tags; p = tags;
rem = ARRAY_SIZE(tags); rem = ARRAY_SIZE(tags);
rc = snprintf(p, rem, " "); rc = snprintf(p, rem, "%8s ", "");
--i; --i;
} }
p += rc; p += rc;
@ -1647,6 +1634,40 @@ static void trace_tags(const struct shader_runner_caps *caps)
trace("%s.\n", tags); trace("%s.\n", tags);
} }
static void trace_shader_caps(const bool *caps)
{
char buffer[80], *p;
size_t rem;
int rc;
p = buffer;
rem = ARRAY_SIZE(buffer);
rc = snprintf(p, rem, "%8s:", "caps");
p += rc;
rem -= rc;
for (size_t i = 0; i < SHADER_CAP_COUNT; ++i)
{
if (!caps[i])
continue;
rc = snprintf(p, rem, " %s", shader_cap_strings[i]);
if (!(rc >= 0 && (size_t)rc < rem))
{
*p = 0;
trace("%s\n", buffer);
p = buffer;
rem = ARRAY_SIZE(buffer);
rc = snprintf(p, rem, "%8s ", "");
--i;
}
p += rc;
rem -= rc;
}
trace("%s.\n", buffer);
}
static void trace_format_cap(const struct shader_runner_caps *caps, enum format_cap cap, const char *cap_name) static void trace_format_cap(const struct shader_runner_caps *caps, enum format_cap cap, const char *cap_name)
{ {
bool show_none = true; bool show_none = true;
@ -1656,7 +1677,7 @@ static void trace_format_cap(const struct shader_runner_caps *caps, enum format_
p = buffer; p = buffer;
rem = ARRAY_SIZE(buffer); rem = ARRAY_SIZE(buffer);
rc = snprintf(p, rem, "%15s:", cap_name); rc = snprintf(p, rem, "%8s:", cap_name);
p += rc; p += rc;
rem -= rc; rem -= rc;
@ -1672,7 +1693,7 @@ static void trace_format_cap(const struct shader_runner_caps *caps, enum format_
p = buffer; p = buffer;
rem = ARRAY_SIZE(buffer); rem = ARRAY_SIZE(buffer);
rc = snprintf(p, rem, " "); rc = snprintf(p, rem, "%8s ", "");
--i; --i;
} }
p += rc; p += rc;
@ -1718,14 +1739,7 @@ void run_shader_tests(struct shader_runner *runner, const struct shader_runner_c
dxc_compiler ? "dxcompiler" : HLSL_COMPILER, caps->runner); dxc_compiler ? "dxcompiler" : HLSL_COMPILER, caps->runner);
if (caps->tag_count) if (caps->tag_count)
trace_tags(caps); trace_tags(caps);
trace("geometry-shader: %u.\n", caps->geometry_shader); trace_shader_caps(caps->shader_caps);
trace(" float64: %u.\n", caps->float64);
trace(" int64: %u.\n", caps->int64);
trace(" rov: %u.\n", caps->rov);
trace(" wave-ops: %u.\n", caps->wave_ops);
trace(" depth-bounds: %u.\n", caps->depth_bounds);
trace(" clip-planes: %u.\n", caps->clip_planes);
trace(" point-size: %u.\n", caps->point_size);
trace_format_cap(caps, FORMAT_CAP_UAV_LOAD, "uav-load"); trace_format_cap(caps, FORMAT_CAP_UAV_LOAD, "uav-load");
if (!test_options.filename) if (!test_options.filename)
@ -1987,14 +2001,7 @@ void run_shader_tests(struct shader_runner *runner, const struct shader_runner_c
state = STATE_REQUIRE; state = STATE_REQUIRE;
runner->minimum_shader_model = caps->minimum_shader_model; runner->minimum_shader_model = caps->minimum_shader_model;
runner->maximum_shader_model = caps->maximum_shader_model; runner->maximum_shader_model = caps->maximum_shader_model;
runner->require_geometry_shader = false; memset(runner->require_shader_caps, 0, sizeof(runner->require_shader_caps));
runner->require_float64 = false;
runner->require_int64 = false;
runner->require_rov = false;
runner->require_wave_ops = false;
runner->require_depth_bounds = false;
runner->require_clip_planes = false;
runner->require_point_size = false;
memset(runner->require_format_caps, 0, sizeof(runner->require_format_caps)); memset(runner->require_format_caps, 0, sizeof(runner->require_format_caps));
runner->compile_options = 0; runner->compile_options = 0;
test_action = TEST_ACTION_RUN; test_action = TEST_ACTION_RUN;

37
tests/shader_runner.h
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2021 Zebediah Figura for CodeWeavers * Copyright 2021-2024 Elizabeth Figura for CodeWeavers
* *
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
@ -135,6 +135,19 @@ enum format_cap
FORMAT_CAP_UAV_LOAD = 0x00000001, FORMAT_CAP_UAV_LOAD = 0x00000001,
}; };
enum shader_cap
{
SHADER_CAP_CLIP_PLANES,
SHADER_CAP_DEPTH_BOUNDS,
SHADER_CAP_FLOAT64,
SHADER_CAP_GEOMETRY_SHADER,
SHADER_CAP_INT64,
SHADER_CAP_POINT_SIZE,
SHADER_CAP_ROV,
SHADER_CAP_WAVE_OPS,
SHADER_CAP_COUNT,
};
struct shader_runner_caps struct shader_runner_caps
{ {
const char *runner; const char *runner;
@ -142,14 +155,7 @@ struct shader_runner_caps
size_t tag_count; size_t tag_count;
enum shader_model minimum_shader_model; enum shader_model minimum_shader_model;
enum shader_model maximum_shader_model; enum shader_model maximum_shader_model;
bool geometry_shader; bool shader_caps[SHADER_CAP_COUNT];
bool float64;
bool int64;
bool rov;
bool wave_ops;
bool depth_bounds;
bool clip_planes;
bool point_size;
uint32_t format_caps[DXGI_FORMAT_COUNT]; uint32_t format_caps[DXGI_FORMAT_COUNT];
}; };
@ -158,9 +164,9 @@ static inline unsigned int shader_runner_caps_get_feature_flags(const struct sha
{ {
unsigned int flags = 0; unsigned int flags = 0;
if (caps->int64) if (caps->shader_caps[SHADER_CAP_INT64])
flags |= VKD3D_SHADER_COMPILE_OPTION_FEATURE_INT64; flags |= VKD3D_SHADER_COMPILE_OPTION_FEATURE_INT64;
if (caps->float64) if (caps->shader_caps[SHADER_CAP_FLOAT64])
flags |= VKD3D_SHADER_COMPILE_OPTION_FEATURE_FLOAT64; flags |= VKD3D_SHADER_COMPILE_OPTION_FEATURE_FLOAT64;
return flags; return flags;
@ -182,14 +188,7 @@ struct shader_runner
char *gs_source; char *gs_source;
enum shader_model minimum_shader_model; enum shader_model minimum_shader_model;
enum shader_model maximum_shader_model; enum shader_model maximum_shader_model;
bool require_geometry_shader; bool require_shader_caps[SHADER_CAP_COUNT];
bool require_float64;
bool require_int64;
bool require_rov;
bool require_wave_ops;
bool require_depth_bounds;
bool require_clip_planes;
bool require_point_size;
uint32_t require_format_caps[DXGI_FORMAT_COUNT]; uint32_t require_format_caps[DXGI_FORMAT_COUNT];
bool last_render_failed; bool last_render_failed;

4
tests/shader_runner_d3d11.c
View File

@ -316,13 +316,13 @@ static BOOL init_test_context(struct d3d11_shader_runner *runner)
hr = ID3D11Device_CheckFeatureSupport(runner->device, D3D11_FEATURE_DOUBLES, hr = ID3D11Device_CheckFeatureSupport(runner->device, D3D11_FEATURE_DOUBLES,
&doubles, sizeof(doubles)); &doubles, sizeof(doubles));
ok(hr == S_OK, "Failed to check double precision feature support, hr %#lx.\n", hr); ok(hr == S_OK, "Failed to check double precision feature support, hr %#lx.\n", hr);
runner->caps.float64 = doubles.DoublePrecisionFloatShaderOps; runner->caps.shader_caps[SHADER_CAP_FLOAT64] = doubles.DoublePrecisionFloatShaderOps;
hr = ID3D11Device_CheckFeatureSupport(runner->device, hr = ID3D11Device_CheckFeatureSupport(runner->device,
D3D11_FEATURE_D3D11_OPTIONS2, &options2, sizeof(options2)); D3D11_FEATURE_D3D11_OPTIONS2, &options2, sizeof(options2));
ok(hr == S_OK, "Failed to check feature options2 support, hr %#lx.\n", hr); ok(hr == S_OK, "Failed to check feature options2 support, hr %#lx.\n", hr);
runner->caps.rov = options2.ROVsSupported; runner->caps.shader_caps[SHADER_CAP_ROV] = options2.ROVsSupported;
for (unsigned int i = 0; i < ARRAY_SIZE(formats); ++i) for (unsigned int i = 0; i < ARRAY_SIZE(formats); ++i)
{ {
runner->caps.format_caps[formats[i]] = get_format_support(runner->device, formats[i]); runner->caps.format_caps[formats[i]] = get_format_support(runner->device, formats[i]);

12
tests/shader_runner_d3d12.c
View File

@ -1028,12 +1028,12 @@ static void d3d12_runner_init_caps(struct d3d12_shader_runner *runner,
#endif #endif
runner->caps.minimum_shader_model = minimum_shader_model; runner->caps.minimum_shader_model = minimum_shader_model;
runner->caps.maximum_shader_model = maximum_shader_model; runner->caps.maximum_shader_model = maximum_shader_model;
runner->caps.geometry_shader = true; runner->caps.shader_caps[SHADER_CAP_DEPTH_BOUNDS] = options2.DepthBoundsTestSupported;
runner->caps.float64 = options.DoublePrecisionFloatShaderOps; runner->caps.shader_caps[SHADER_CAP_FLOAT64] = options.DoublePrecisionFloatShaderOps;
runner->caps.int64 = options1.Int64ShaderOps; runner->caps.shader_caps[SHADER_CAP_GEOMETRY_SHADER] = true;
runner->caps.rov = options.ROVsSupported; runner->caps.shader_caps[SHADER_CAP_INT64] = options1.Int64ShaderOps;
runner->caps.wave_ops = options1.WaveOps; runner->caps.shader_caps[SHADER_CAP_ROV] = options.ROVsSupported;
runner->caps.depth_bounds = options2.DepthBoundsTestSupported; runner->caps.shader_caps[SHADER_CAP_WAVE_OPS] = options1.WaveOps;
if (is_mvk_device(device)) if (is_mvk_device(device))
{ {

4
tests/shader_runner_d3d9.c
View File

@ -152,8 +152,8 @@ static bool init_test_context(struct d3d9_shader_runner *runner)
runner->caps.runner = "d3d9.dll"; runner->caps.runner = "d3d9.dll";
runner->caps.minimum_shader_model = SHADER_MODEL_2_0; runner->caps.minimum_shader_model = SHADER_MODEL_2_0;
runner->caps.maximum_shader_model = SHADER_MODEL_3_0; runner->caps.maximum_shader_model = SHADER_MODEL_3_0;
runner->caps.clip_planes = true; runner->caps.shader_caps[SHADER_CAP_CLIP_PLANES] = true;
runner->caps.point_size = true; runner->caps.shader_caps[SHADER_CAP_POINT_SIZE] = true;
return true; return true;
} }

8
tests/shader_runner_gl.c
View File

@ -131,11 +131,11 @@ static bool check_gl_extensions(struct gl_runner *runner)
} }
if (check_gl_extension("GL_ARB_gpu_shader_fp64", count)) if (check_gl_extension("GL_ARB_gpu_shader_fp64", count))
runner->caps.float64 = true; runner->caps.shader_caps[SHADER_CAP_FLOAT64] = true;
if (check_gl_extension("GL_ARB_gpu_shader_int64", count)) if (check_gl_extension("GL_ARB_gpu_shader_int64", count))
runner->caps.int64 = true; runner->caps.shader_caps[SHADER_CAP_INT64] = true;
if (check_gl_extension("GL_EXT_depth_bounds_test", count)) if (check_gl_extension("GL_EXT_depth_bounds_test", count))
runner->caps.depth_bounds = true; runner->caps.shader_caps[SHADER_CAP_DEPTH_BOUNDS] = true;
return true; return true;
} }
@ -346,7 +346,7 @@ static bool gl_runner_init(struct gl_runner *runner, enum shading_language langu
runner->caps.tag_count = runner->language == GLSL; runner->caps.tag_count = runner->language == GLSL;
runner->caps.minimum_shader_model = SHADER_MODEL_4_0; runner->caps.minimum_shader_model = SHADER_MODEL_4_0;
runner->caps.maximum_shader_model = SHADER_MODEL_5_1; runner->caps.maximum_shader_model = SHADER_MODEL_5_1;
runner->caps.geometry_shader = true; runner->caps.shader_caps[SHADER_CAP_GEOMETRY_SHADER] = true;
glGetIntegerv(GL_NUM_EXTENSIONS, &extension_count); glGetIntegerv(GL_NUM_EXTENSIONS, &extension_count);
if (check_gl_extension("GL_ARB_internalformat_query2", extension_count)) if (check_gl_extension("GL_ARB_internalformat_query2", extension_count))

20
tests/shader_runner_vulkan.c
View File

@ -365,7 +365,7 @@ static bool compile_shader(struct vulkan_shader_runner *runner, const char *sour
spirv_info.extensions = spirv_extensions; spirv_info.extensions = spirv_extensions;
spirv_info.extension_count = 0; spirv_info.extension_count = 0;
if (runner->caps.rov) if (runner->caps.shader_caps[SHADER_CAP_ROV])
spirv_extensions[spirv_info.extension_count++] = VKD3D_SHADER_SPIRV_EXTENSION_EXT_FRAGMENT_SHADER_INTERLOCK; spirv_extensions[spirv_info.extension_count++] = VKD3D_SHADER_SPIRV_EXTENSION_EXT_FRAGMENT_SHADER_INTERLOCK;
if (runner->demote_to_helper_invocation) if (runner->demote_to_helper_invocation)
spirv_extensions[spirv_info.extension_count++] = VKD3D_SHADER_SPIRV_EXTENSION_EXT_DEMOTE_TO_HELPER_INVOCATION; spirv_extensions[spirv_info.extension_count++] = VKD3D_SHADER_SPIRV_EXTENSION_EXT_DEMOTE_TO_HELPER_INVOCATION;
@ -1433,7 +1433,7 @@ static bool check_device_extensions(struct vulkan_shader_runner *runner,
{ {
enabled_extensions->names[enabled_extensions->count++] = name; enabled_extensions->names[enabled_extensions->count++] = name;
if (!strcmp(name, VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME)) if (!strcmp(name, VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME))
runner->caps.rov = true; runner->caps.shader_caps[SHADER_CAP_ROV] = true;
if (!strcmp(name, VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME)) if (!strcmp(name, VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME))
runner->demote_to_helper_invocation = true; runner->demote_to_helper_invocation = true;
if (!strcmp(name, VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME)) if (!strcmp(name, VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME))
@ -1460,7 +1460,7 @@ static void get_physical_device_info(struct vulkan_shader_runner *runner, struct
memset(info, 0, sizeof(*info)); memset(info, 0, sizeof(*info));
info->features2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; info->features2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
if (runner->caps.rov) if (runner->caps.shader_caps[SHADER_CAP_ROV])
{ {
info->features2.pNext = &info->interlock_features; info->features2.pNext = &info->interlock_features;
info->interlock_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT; info->interlock_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
@ -1602,8 +1602,8 @@ static bool init_vulkan_runner(struct vulkan_shader_runner *runner)
runner->caps.tag_count = ARRAY_SIZE(tags); runner->caps.tag_count = ARRAY_SIZE(tags);
} }
runner->caps.clip_planes = true; runner->caps.shader_caps[SHADER_CAP_CLIP_PLANES] = true;
runner->caps.point_size = true; runner->caps.shader_caps[SHADER_CAP_POINT_SIZE] = true;
device_desc.pEnabledFeatures = &features; device_desc.pEnabledFeatures = &features;
memset(&features, 0, sizeof(features)); memset(&features, 0, sizeof(features));
@ -1626,25 +1626,25 @@ static bool init_vulkan_runner(struct vulkan_shader_runner *runner)
if (ret_features->geometryShader) if (ret_features->geometryShader)
{ {
features.geometryShader = VK_TRUE; features.geometryShader = VK_TRUE;
runner->caps.geometry_shader = true; runner->caps.shader_caps[SHADER_CAP_GEOMETRY_SHADER] = true;
} }
if (ret_features->shaderFloat64) if (ret_features->shaderFloat64)
{ {
features.shaderFloat64 = VK_TRUE; features.shaderFloat64 = VK_TRUE;
runner->caps.float64 = true; runner->caps.shader_caps[SHADER_CAP_FLOAT64] = true;
} }
if (ret_features->shaderInt64) if (ret_features->shaderInt64)
{ {
features.shaderInt64 = VK_TRUE; features.shaderInt64 = VK_TRUE;
runner->caps.int64 = true; runner->caps.shader_caps[SHADER_CAP_INT64] = true;
} }
if (ret_features->depthBounds) if (ret_features->depthBounds)
{ {
features.depthBounds = VK_TRUE; features.depthBounds = VK_TRUE;
runner->caps.depth_bounds = true; runner->caps.shader_caps[SHADER_CAP_DEPTH_BOUNDS] = true;
} }
if (device_info.interlock_features.fragmentShaderSampleInterlock if (device_info.interlock_features.fragmentShaderSampleInterlock
@ -1659,7 +1659,7 @@ static bool init_vulkan_runner(struct vulkan_shader_runner *runner)
} }
else else
{ {
runner->caps.rov = false; runner->caps.shader_caps[SHADER_CAP_ROV] = false;
} }
if (device_info.demote_to_helper_invocation_features.shaderDemoteToHelperInvocation) if (device_info.demote_to_helper_invocation_features.shaderDemoteToHelperInvocation)