eden-emu/Vulkan-Utility-Libraries
14
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Utility-Libraries.git synced 2025-05-15 09:18:49 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

layer: Improve API consistency

Browse source
This commit is contained in:
Christophe 2023-08-08 17:09:13 +02:00 • committed by Christophe
parent 430013c64e
commit 87b77bc639
14 changed files with 274 additions and 314 deletions
Download patch file Download diff file Expand all files Collapse all files

6
include/vulkan/layer/vk_layer_settings.hpp
View file

@ -62,10 +62,10 @@ void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet,
const char *pSettingName, std::vector<std::string> &settingValues); const char *pSettingName, std::vector<std::string> &settingValues);
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet,
const char *pSettingName, VkFrameset &settingValue); const char *pSettingName, VkFramesetEXT &settingValue);
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName,
const char *pSettingName, std::vector<VkFrameset> &settingValues); std::vector<VkFramesetEXT> &settingValues);
// Required by vk_safe_struct // Required by vk_safe_struct
typedef std::pair<uint32_t, uint32_t> VlCustomSTypeInfo; typedef std::pair<uint32_t, uint32_t> VlCustomSTypeInfo;

65
include/vulkan/layer/vk_layer_settings_ext.h
View file

@ -37,37 +37,19 @@ extern "C" {
// Mark Lobodzinski // Mark Lobodzinski
// //
// Description // Description
// This extension provides the VkLayerSettingsEXT struct that can be included in the pNext chain of the // This extension provides a mechanism for configuring programmatically through
// VkInstanceCreateInfo structure passed as the pCreateInfo parameter of vkCreateInstance // the Vulkan API the behavior of layers.
// The structure contains an array of VkLayerSettingValueEXT structures that define layer specific settings //
// The extension also provides the vkEnumerateInstanceLayerSettingsEXT and vkEnumerateInstanceLayerSettingOptionEXT // This extension provides the [VkLayerSettingsCreateInfoEXT] struct that can be
// commands, useful for enumerating all layer settings and their possible values, respectively. // included in the [pNext] chain of the [VkInstanceCreateInfo]
// structure passed as the [pCreateInfo] parameter of [vkCreateInstance].
//
// The structure contains an array of [VkLayerSettingEXT] structure
// values that configure specific features of layers.
// //
// Note // Note
// The VK_EXT_layer_settings extension subsumes all the functionality provided in the [VK_EXT_validation_flags] extension // The [VK_EXT_layer_settings] extension subsumes all the functionality provided in the [VK_EXT_validation_flags] extension
// and the [VK_EXT_validation_features] extension. // and the [VK_EXT_validation_features] extension.
//
// New Commands
// vkEnumerateInstanceLayerSettingsEXT
// vkEnumerateInstanceLayerSettingOptionEXT
//
// New Structures
// array_int32
// array_int64
// array_float
// array_bool
// array_char
// VkLayerSettingValueEXT
// VkLayerSettingDescriptionEXT
// VkLayerSettingOptionEXT
// Extending VkInstanceCreateInfo :
// VkLayerSettingsEXT
//
// New Unions
// VkLayerSettingValueDataEXT
//
// New Enums
// VkLayerSettingValueTypeEXT
#define VK_EXT_layer_settings 1 #define VK_EXT_layer_settings 1
#define VK_EXT_LAYER_SETTINGS_SPEC_VERSION 1 #define VK_EXT_LAYER_SETTINGS_SPEC_VERSION 1
@ -82,40 +64,29 @@ extern "C" {
#define VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT ((VkStructureType)(VK_STRUCTURE_TYPE_MAX_ENUM - 43)) #define VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT ((VkStructureType)(VK_STRUCTURE_TYPE_MAX_ENUM - 43))
typedef enum VkLayerSettingTypeEXT { typedef enum VkLayerSettingTypeEXT {
VK_LAYER_SETTING_TYPE_BOOL_EXT = 0, VK_LAYER_SETTING_TYPE_BOOL32_EXT = 0,
VK_LAYER_SETTING_TYPE_INT32_EXT, VK_LAYER_SETTING_TYPE_INT32_EXT,
VK_LAYER_SETTING_TYPE_INT64_EXT, VK_LAYER_SETTING_TYPE_INT64_EXT,
VK_LAYER_SETTING_TYPE_UINT32_EXT, VK_LAYER_SETTING_TYPE_UINT32_EXT,
VK_LAYER_SETTING_TYPE_UINT64_EXT, VK_LAYER_SETTING_TYPE_UINT64_EXT,
VK_LAYER_SETTING_TYPE_FLOAT_EXT, VK_LAYER_SETTING_TYPE_FLOAT32_EXT,
VK_LAYER_SETTING_TYPE_DOUBLE_EXT, VK_LAYER_SETTING_TYPE_FLOAT64_EXT,
VK_LAYER_SETTING_TYPE_FRAMESET_EXT, VK_LAYER_SETTING_TYPE_STRING_EXT,
VK_LAYER_SETTING_TYPE_STRING_EXT VK_LAYER_SETTING_TYPE_FRAMESET_EXT
} VkLayerSettingTypeEXT; } VkLayerSettingTypeEXT;
typedef struct VkFrameset { typedef struct VkFramesetEXT {
uint32_t first; uint32_t first;
uint32_t count; uint32_t count;
uint32_t step; uint32_t step;
} VkFrameset; } VkFramesetEXT;
typedef struct VkLayerSettingEXT { typedef struct VkLayerSettingEXT {
const char *pLayerName; const char *pLayerName;
const char *pSettingName; const char *pSettingName;
VkLayerSettingTypeEXT type; VkLayerSettingTypeEXT type;
uint32_t count; uint32_t count;
union { const void *pValues;
const void *value;
const VkBool32 *asBool32;
const int32_t *asInt32;
const int64_t *asInt64;
const uint32_t *asUint32;
const uint64_t *asUint64;
const float *asFloat;
const double *asDouble;
const VkFrameset *asFrameset;
const char **asString;
};
} VkLayerSettingEXT; } VkLayerSettingEXT;
typedef struct VkLayerSettingsCreateInfoEXT { typedef struct VkLayerSettingsCreateInfoEXT {

14
src/layer/layer_settings_manager.cpp
View file

@ -148,11 +148,11 @@ std::string LayerSettings::FindSettingsFile() {
LSTATUS err = RegOpenKeyEx(hives[hive_index], "Software\\Khronos\\Vulkan\\Settings", 0, KEY_READ, &key); LSTATUS err = RegOpenKeyEx(hives[hive_index], "Software\\Khronos\\Vulkan\\Settings", 0, KEY_READ, &key);
if (err == ERROR_SUCCESS) { if (err == ERROR_SUCCESS) {
char name[2048]; char name[2048];
DWORD i = 0, name_size, type, value, value_size; DWORD i = 0, name_size, type, pValues, value_size;
while (ERROR_SUCCESS == RegEnumValue(key, i++, name, &(name_size = sizeof(name)), nullptr, &type, while (ERROR_SUCCESS == RegEnumValue(key, i++, name, &(name_size = sizeof(name)), nullptr, &type,
reinterpret_cast<LPBYTE>(&value), &(value_size = sizeof(value)))) { reinterpret_cast<LPBYTE>(&pValues), &(value_size = sizeof(pValues)))) {
// Check if the registry entry is a dword with a value of zero // Check if the registry entry is a dword with a value of zero
if (type != REG_DWORD || value != 0) { if (type != REG_DWORD || pValues != 0) {
continue; continue;
} }
@ -315,16 +315,16 @@ std::string LayerSettings::GetFileSetting(const char *pSettingName) {
} }
} }
void LayerSettings::SetFileSetting(const char *pSettingName, const std::string &value) { void LayerSettings::SetFileSetting(const char *pSettingName, const std::string &pValues) {
assert(pSettingName != nullptr); assert(pSettingName != nullptr);
this->setting_file_values.insert({pSettingName, value}); this->setting_file_values.insert({pSettingName, pValues});
} }
const LayerSetting *LayerSettings::GetAPISetting(const char *pSettingName) { const VkLayerSettingEXT *LayerSettings::GetAPISetting(const char *pSettingName) {
assert(pSettingName != nullptr); assert(pSettingName != nullptr);
return reinterpret_cast<const LayerSetting *>(this->FindLayerSettingValue(pSettingName)); return reinterpret_cast<const VkLayerSettingEXT *>(this->FindLayerSettingValue(pSettingName));
} }
} // namespace vl } // namespace vl

22
src/layer/layer_settings_manager.hpp
View file

@ -15,24 +15,6 @@
#include <map> #include <map>
namespace vl { namespace vl {
struct LayerSetting {
const char *pLayerName;
const char *pSettingName;
VkLayerSettingTypeEXT type;
uint32_t count;
union {
const VkBool32 *asBool32;
const int32_t *asInt32;
const int64_t *asInt64;
const uint32_t *asUint32;
const uint64_t *asUint64;
const float *asFloat;
const double *asDouble;
const VkFrameset *asFrameset;
const char **asString;
};
};
class LayerSettings { class LayerSettings {
public: public:
LayerSettings(const char *pLayerName, const VkLayerSettingsCreateInfoEXT *pCreateInfo, LayerSettings(const char *pLayerName, const VkLayerSettingsCreateInfoEXT *pCreateInfo,
@ -49,9 +31,9 @@ namespace vl {
std::string GetFileSetting(const char *pSettingName); std::string GetFileSetting(const char *pSettingName);
void SetFileSetting(const char *pSettingName, const std::string& value); void SetFileSetting(const char *pSettingName, const std::string& pValues);
const LayerSetting *GetAPISetting(const char *pSettingName); const VkLayerSettingEXT *GetAPISetting(const char *pSettingName);
void Log(const char *pSettingName, const char *pMessage); void Log(const char *pSettingName, const char *pMessage);

12
src/layer/layer_settings_util.cpp
View file

@ -16,10 +16,10 @@
namespace vl { namespace vl {
std::vector<std::string> Split(const std::string &value, char delimiter) { std::vector<std::string> Split(const std::string &pValues, char delimiter) {
std::vector<std::string> result; std::vector<std::string> result;
std::string parse = value; std::string parse = pValues;
std::size_t start = 0; std::size_t start = 0;
std::size_t end = parse.find(delimiter); std::size_t end = parse.find(delimiter);
@ -198,10 +198,10 @@ int64_t ToInt64(const std::string &token) {
return int_id; return int_id;
} }
VkFrameset ToFrameSet(const std::string &s) { VkFramesetEXT ToFrameSet(const std::string &s) {
assert(IsFrameSets(s)); assert(IsFrameSets(s));
VkFrameset frameset{0, 1, 1}; VkFramesetEXT frameset{0, 1, 1};
const std::vector<std::string> &frameset_split = vl::Split(s, '-'); const std::vector<std::string> &frameset_split = vl::Split(s, '-');
if (frameset_split.size() >= 1) { if (frameset_split.size() >= 1) {
@ -217,10 +217,10 @@ VkFrameset ToFrameSet(const std::string &s) {
return frameset; return frameset;
} }
std::vector<VkFrameset> ToFrameSets(const std::string &s) { std::vector<VkFramesetEXT> ToFrameSets(const std::string &s) {
std::vector<std::string> tokens = Split(s, FindDelimiter(s)); std::vector<std::string> tokens = Split(s, FindDelimiter(s));
std::vector<VkFrameset> results; std::vector<VkFramesetEXT> results;
results.resize(tokens.size()); results.resize(tokens.size());
for (std::size_t i = 0, n = tokens.size(); i < n; ++i) { for (std::size_t i = 0, n = tokens.size(); i < n; ++i) {
results[i] = ToFrameSet(tokens[i]); results[i] = ToFrameSet(tokens[i]);

6
src/layer/layer_settings_util.hpp
View file

@ -20,7 +20,7 @@ namespace vl {
const void *next); const void *next);
std::vector<std::string> Split( std::vector<std::string> Split(
const std::string &value, char delimiter); const std::string &pValues, char delimiter);
enum TrimMode { enum TrimMode {
TRIM_NONE, TRIM_NONE,
@ -62,9 +62,9 @@ namespace vl {
bool IsFrameSets(const std::string &s); bool IsFrameSets(const std::string &s);
VkFrameset ToFrameSet(const std::string &s); VkFramesetEXT ToFrameSet(const std::string &s);
std::vector<VkFrameset> ToFrameSets(const std::string &s); std::vector<VkFramesetEXT> ToFrameSets(const std::string &s);
bool IsInteger(const std::string &s); bool IsInteger(const std::string &s);

65
src/layer/vk_layer_settings.cpp
View file

@ -87,7 +87,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
const std::string &file_setting_list = layer_setting_set->GetFileSetting(pSettingName); const std::string &file_setting_list = layer_setting_set->GetFileSetting(pSettingName);
// Third: search from VK_EXT_layer_settings usage // Third: search from VK_EXT_layer_settings usage
const vl::LayerSetting *api_setting = layer_setting_set->GetAPISetting(pSettingName); const VkLayerSettingEXT *api_setting = layer_setting_set->GetAPISetting(pSettingName);
// Environment variables overrides the values set by vk_layer_settings // Environment variables overrides the values set by vk_layer_settings
const std::string setting_list = env_setting_list.empty() ? file_setting_list : env_setting_list; const std::string setting_list = env_setting_list.empty() ? file_setting_list : env_setting_list;
@ -107,7 +107,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
layer_setting_set->Log(pSettingName, message.c_str()); layer_setting_set->Log(pSettingName, message.c_str());
return VK_ERROR_UNKNOWN; return VK_ERROR_UNKNOWN;
} }
case VK_LAYER_SETTING_TYPE_BOOL_EXT: { case VK_LAYER_SETTING_TYPE_BOOL32_EXT: {
std::vector<VkBool32> values; std::vector<VkBool32> values;
VkResult result = VK_SUCCESS; VkResult result = VK_SUCCESS;
@ -141,7 +141,8 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
result = VK_INCOMPLETE; result = VK_INCOMPLETE;
} }
const std::uint32_t size = std::min(*pValueCount, api_setting->count); const std::uint32_t size = std::min(*pValueCount, api_setting->count);
values.assign(api_setting->asBool32, api_setting->asBool32 + size); const VkBool32 *data = static_cast<const VkBool32 *>(api_setting->pValues);
values.assign(data, data + size);
} else { } else {
*pValueCount = api_setting->count; *pValueCount = api_setting->count;
} }
@ -185,7 +186,8 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
result = VK_INCOMPLETE; result = VK_INCOMPLETE;
} }
const std::uint32_t size = std::min(*pValueCount, api_setting->count); const std::uint32_t size = std::min(*pValueCount, api_setting->count);
values.assign(api_setting->asInt32, api_setting->asInt32 + size); const int32_t *data = static_cast<const int32_t *>(api_setting->pValues);
values.assign(data, data + size);
} else { } else {
*pValueCount = api_setting->count; *pValueCount = api_setting->count;
} }
@ -229,7 +231,8 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
result = VK_INCOMPLETE; result = VK_INCOMPLETE;
} }
const std::uint32_t size = std::min(*pValueCount, api_setting->count); const std::uint32_t size = std::min(*pValueCount, api_setting->count);
values.assign(api_setting->asInt64, api_setting->asInt64 + size); const int64_t *data = static_cast<const int64_t *>(api_setting->pValues);
values.assign(data, data + size);
} else { } else {
*pValueCount = api_setting->count; *pValueCount = api_setting->count;
} }
@ -273,7 +276,8 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
result = VK_INCOMPLETE; result = VK_INCOMPLETE;
} }
const uint32_t size = std::min(*pValueCount, api_setting->count); const uint32_t size = std::min(*pValueCount, api_setting->count);
values.assign(api_setting->asUint32, api_setting->asUint32 + size); const uint32_t *data = static_cast<const uint32_t *>(api_setting->pValues);
values.assign(data, data + size);
} else { } else {
*pValueCount = api_setting->count; *pValueCount = api_setting->count;
} }
@ -317,7 +321,8 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
result = VK_INCOMPLETE; result = VK_INCOMPLETE;
} }
const std::uint32_t size = std::min(*pValueCount, api_setting->count); const std::uint32_t size = std::min(*pValueCount, api_setting->count);
values.assign(api_setting->asUint64, api_setting->asUint64 + size); const uint64_t *data = static_cast<const uint64_t *>(api_setting->pValues);
values.assign(data, data + size);
} else { } else {
*pValueCount = api_setting->count; *pValueCount = api_setting->count;
} }
@ -329,7 +334,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
return result; return result;
} }
case VK_LAYER_SETTING_TYPE_FLOAT_EXT: { case VK_LAYER_SETTING_TYPE_FLOAT32_EXT: {
std::vector<float> values; std::vector<float> values;
VkResult result = VK_SUCCESS; VkResult result = VK_SUCCESS;
@ -361,7 +366,8 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
result = VK_INCOMPLETE; result = VK_INCOMPLETE;
} }
const std::uint32_t size = std::min(*pValueCount, api_setting->count); const std::uint32_t size = std::min(*pValueCount, api_setting->count);
values.assign(api_setting->asFloat, api_setting->asFloat + size); const float *data = static_cast<const float *>(api_setting->pValues);
values.assign(data, data + size);
} else { } else {
*pValueCount = api_setting->count; *pValueCount = api_setting->count;
} }
@ -373,7 +379,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
return result; return result;
} }
case VK_LAYER_SETTING_TYPE_DOUBLE_EXT: { case VK_LAYER_SETTING_TYPE_FLOAT64_EXT: {
std::vector<double> values; std::vector<double> values;
VkResult result = VK_SUCCESS; VkResult result = VK_SUCCESS;
@ -405,7 +411,8 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
result = VK_INCOMPLETE; result = VK_INCOMPLETE;
} }
const std::uint32_t size = std::min(*pValueCount, api_setting->count); const std::uint32_t size = std::min(*pValueCount, api_setting->count);
values.assign(api_setting->asDouble, api_setting->asDouble + size); const double *data = static_cast<const double *>(api_setting->pValues);
values.assign(data, data + size);
} else { } else {
*pValueCount = api_setting->count; *pValueCount = api_setting->count;
} }
@ -418,7 +425,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
return result; return result;
} }
case VK_LAYER_SETTING_TYPE_FRAMESET_EXT: { case VK_LAYER_SETTING_TYPE_FRAMESET_EXT: {
std::vector<VkFrameset> values; std::vector<VkFramesetEXT> values;
VkResult result = VK_SUCCESS; VkResult result = VK_SUCCESS;
if (!settings.empty()) { // From env variable or setting file if (!settings.empty()) { // From env variable or setting file
@ -449,14 +456,15 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
result = VK_INCOMPLETE; result = VK_INCOMPLETE;
} }
const std::uint32_t size = std::min(*pValueCount, api_setting->count); const std::uint32_t size = std::min(*pValueCount, api_setting->count);
values.assign(api_setting->asFrameset, api_setting->asFrameset + size); const VkFramesetEXT *data = static_cast<const VkFramesetEXT *>(api_setting->pValues);
values.assign(data, data + size);
} else { } else {
*pValueCount = api_setting->count; *pValueCount = api_setting->count;
} }
} }
if (copy_values) { if (copy_values) {
std::copy(values.begin(), values.end(), reinterpret_cast<VkFrameset *>(pValues)); std::copy(values.begin(), values.end(), reinterpret_cast<VkFramesetEXT *>(pValues));
} }
return result; return result;
@ -487,50 +495,49 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
switch (api_setting->type) { switch (api_setting->type) {
case VK_LAYER_SETTING_TYPE_STRING_EXT: case VK_LAYER_SETTING_TYPE_STRING_EXT:
for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) { for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) {
settings_cache[i] = api_setting->asString[i]; settings_cache[i] = reinterpret_cast<const char * const *>(api_setting->pValues)[i];
} }
break; break;
case VK_LAYER_SETTING_TYPE_BOOL_EXT: case VK_LAYER_SETTING_TYPE_BOOL32_EXT:
for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) { for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) {
settings_cache[i] = api_setting->asBool32[i] == VK_TRUE ? "true" : "false"; settings_cache[i] =
static_cast<const VkBool32 *>(api_setting->pValues)[i] == VK_TRUE ? "true" : "false";
} }
break; break;
case VK_LAYER_SETTING_TYPE_INT32_EXT: case VK_LAYER_SETTING_TYPE_INT32_EXT:
for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) { for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) {
settings_cache[i] = vl::Format("%d", api_setting->asInt32[i]); settings_cache[i] = vl::Format("%d", static_cast<const int32_t *>(api_setting->pValues)[i]);
} }
break; break;
case VK_LAYER_SETTING_TYPE_INT64_EXT: case VK_LAYER_SETTING_TYPE_INT64_EXT:
for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) { for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) {
settings_cache[i] = vl::Format("%lld", api_setting->asInt64[i]); settings_cache[i] = vl::Format("%lld", static_cast<const int64_t *>(api_setting->pValues)[i]);
} }
break; break;
case VK_LAYER_SETTING_TYPE_UINT32_EXT: case VK_LAYER_SETTING_TYPE_UINT32_EXT:
for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) { for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) {
settings_cache[i] = vl::Format("%u", api_setting->asUint32[i]); settings_cache[i] = vl::Format("%u", static_cast<const uint32_t *>(api_setting->pValues)[i]);
} }
break; break;
case VK_LAYER_SETTING_TYPE_UINT64_EXT: case VK_LAYER_SETTING_TYPE_UINT64_EXT:
for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) { for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) {
settings_cache[i] = vl::Format("%llu", api_setting->asUint64[i]); settings_cache[i] = vl::Format("%llu", static_cast<const uint64_t *>(api_setting->pValues)[i]);
} }
break; break;
case VK_LAYER_SETTING_TYPE_FLOAT_EXT: case VK_LAYER_SETTING_TYPE_FLOAT32_EXT:
for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) { for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) {
settings_cache[i] = vl::Format("%f", api_setting->asFloat[i]); settings_cache[i] = vl::Format("%f", static_cast<const float *>(api_setting->pValues)[i]);
} }
break; break;
case VK_LAYER_SETTING_TYPE_DOUBLE_EXT: case VK_LAYER_SETTING_TYPE_FLOAT64_EXT:
for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) { for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) {
settings_cache[i] = vl::Format("%f", api_setting->asDouble[i]); settings_cache[i] = vl::Format("%f", static_cast<const double *>(api_setting->pValues)[i]);
} }
break; break;
case VK_LAYER_SETTING_TYPE_FRAMESET_EXT: case VK_LAYER_SETTING_TYPE_FRAMESET_EXT:
for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) { for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) {
settings_cache[i] = vl::Format("%d-%d-%d", const VkFramesetEXT* asFramesets = static_cast<const VkFramesetEXT*>(api_setting->pValues);
api_setting->asFrameset[i].first, settings_cache[i] = vl::Format("%d-%d-%d", asFramesets[i].first, asFramesets[i].count, asFramesets[i].step);
api_setting->asFrameset[i].count,
api_setting->asFrameset[i].step);
} }
break; break;
default: default:

26
src/layer/vk_layer_settings_helper.cpp
View file

@ -23,17 +23,17 @@ static std::string Merge(const std::vector<std::string> &strings) {
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, bool &settingValue) { void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, bool &settingValue) {
uint32_t value_count = 1; uint32_t value_count = 1;
VkBool32 value; VkBool32 pValues;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, &value); vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_BOOL32_EXT, &value_count, &pValues);
settingValue = value == VK_TRUE; settingValue = pValues == VK_TRUE;
} }
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<bool> &settingValues) { void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<bool> &settingValues) {
uint32_t value_count = 0; uint32_t value_count = 0;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, nullptr); vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_BOOL32_EXT, &value_count, nullptr);
if (value_count > 0) { if (value_count > 0) {
std::vector<VkBool32> values(value_count); std::vector<VkBool32> values(value_count);
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, &values[0]); vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_BOOL32_EXT, &value_count, &values[0]);
for (std::size_t i = 0, n = values.size(); i < n; ++i) { for (std::size_t i = 0, n = values.size(); i < n; ++i) {
settingValues.push_back(values[i] == VK_TRUE); settingValues.push_back(values[i] == VK_TRUE);
} }
@ -98,29 +98,29 @@ void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSet
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, float &settingValue) { void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, float &settingValue) {
uint32_t value_count = 1; uint32_t value_count = 1;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &settingValue); vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FLOAT32_EXT, &value_count, &settingValue);
} }
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<float> &settingValues) { void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<float> &settingValues) {
uint32_t value_count = 1; uint32_t value_count = 1;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, nullptr); vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FLOAT32_EXT, &value_count, nullptr);
if (value_count > 0) { if (value_count > 0) {
settingValues.resize(static_cast<std::size_t>(value_count)); settingValues.resize(static_cast<std::size_t>(value_count));
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &settingValues[0]); vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FLOAT32_EXT, &value_count, &settingValues[0]);
} }
} }
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, double &settingValue) { void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, double &settingValue) {
uint32_t value_count = 1; uint32_t value_count = 1;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, &settingValue); vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FLOAT64_EXT, &value_count, &settingValue);
} }
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<double> &settingValues) { void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<double> &settingValues) {
uint32_t value_count = 1; uint32_t value_count = 1;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, nullptr); vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FLOAT64_EXT, &value_count, nullptr);
if (value_count > 0) { if (value_count > 0) {
settingValues.resize(static_cast<std::size_t>(value_count)); settingValues.resize(static_cast<std::size_t>(value_count));
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, &settingValues[0]); vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FLOAT64_EXT, &value_count, &settingValues[0]);
} }
} }
@ -140,12 +140,12 @@ void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSet
} }
} }
void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char* pSettingName, VkFrameset& settingValue) { void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char* pSettingName, VkFramesetEXT& settingValue) {
uint32_t value_count = 1; uint32_t value_count = 1;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FRAMESET_EXT, &value_count, &settingValue); vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FRAMESET_EXT, &value_count, &settingValue);
} }
void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char* pSettingName, std::vector<VkFrameset>& settingValues) { void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<VkFramesetEXT> &settingValues) {
uint32_t value_count = 0; uint32_t value_count = 0;
vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FRAMESET_EXT, &value_count, nullptr); vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FRAMESET_EXT, &value_count, nullptr);
if (value_count > 0) { if (value_count > 0) {

68
tests/layer/test_setting_api.cpp
View file

@ -22,14 +22,14 @@ TEST(test_layer_setting_api, vlHasLayerSetting_NotFound) {
} }
TEST(test_layer_setting_api, vlHasLayerSetting_Found) { TEST(test_layer_setting_api, vlHasLayerSetting_Found) {
std::int32_t value = 76; std::int32_t pValues = 76;
VkLayerSettingEXT my_setting; VkLayerSettingEXT my_setting;
my_setting.pLayerName = "VK_LAYER_LUNARG_test"; my_setting.pLayerName = "VK_LAYER_LUNARG_test";
my_setting.pSettingName = "my_setting"; my_setting.pSettingName = "my_setting";
my_setting.type = VK_LAYER_SETTING_TYPE_INT32_EXT; my_setting.type = VK_LAYER_SETTING_TYPE_INT32_EXT;
my_setting.count = 1; my_setting.count = 1;
my_setting.asInt32 = &value; my_setting.pValues = &pValues;
std::vector<VkLayerSettingEXT> settings; std::vector<VkLayerSettingEXT> settings;
settings.push_back(my_setting); settings.push_back(my_setting);
@ -53,8 +53,8 @@ TEST(test_layer_setting_api, vlHasLayerSetting) {
VkLayerSettingEXT setting_bool_value{}; VkLayerSettingEXT setting_bool_value{};
setting_bool_value.pLayerName = "VK_LAYER_LUNARG_test"; setting_bool_value.pLayerName = "VK_LAYER_LUNARG_test";
setting_bool_value.pSettingName = "bool_value"; setting_bool_value.pSettingName = "bool_value";
setting_bool_value.type = VK_LAYER_SETTING_TYPE_BOOL_EXT; setting_bool_value.type = VK_LAYER_SETTING_TYPE_BOOL32_EXT;
setting_bool_value.asBool32 = &value_bool; setting_bool_value.pValues = &value_bool;
setting_bool_value.count = 1; setting_bool_value.count = 1;
settings.push_back(setting_bool_value); settings.push_back(setting_bool_value);
@ -63,7 +63,7 @@ TEST(test_layer_setting_api, vlHasLayerSetting) {
setting_int32_value.pLayerName = "VK_LAYER_LUNARG_test"; setting_int32_value.pLayerName = "VK_LAYER_LUNARG_test";
setting_int32_value.pSettingName = "int32_value"; setting_int32_value.pSettingName = "int32_value";
setting_int32_value.type = VK_LAYER_SETTING_TYPE_INT32_EXT; setting_int32_value.type = VK_LAYER_SETTING_TYPE_INT32_EXT;
setting_int32_value.asInt32 = &value_int32; setting_int32_value.pValues = &value_int32;
setting_int32_value.count = 1; setting_int32_value.count = 1;
settings.push_back(setting_int32_value); settings.push_back(setting_int32_value);
@ -72,7 +72,7 @@ TEST(test_layer_setting_api, vlHasLayerSetting) {
setting_int64_value.pLayerName = "VK_LAYER_LUNARG_test"; setting_int64_value.pLayerName = "VK_LAYER_LUNARG_test";
setting_int64_value.pSettingName = "int64_value"; setting_int64_value.pSettingName = "int64_value";
setting_int64_value.type = VK_LAYER_SETTING_TYPE_INT64_EXT; setting_int64_value.type = VK_LAYER_SETTING_TYPE_INT64_EXT;
setting_int64_value.asInt64 = &value_int64; setting_int64_value.pValues = &value_int64;
setting_int64_value.count = 1; setting_int64_value.count = 1;
settings.push_back(setting_int64_value); settings.push_back(setting_int64_value);
@ -81,7 +81,7 @@ TEST(test_layer_setting_api, vlHasLayerSetting) {
setting_uint32_value.pLayerName = "VK_LAYER_LUNARG_test"; setting_uint32_value.pLayerName = "VK_LAYER_LUNARG_test";
setting_uint32_value.pSettingName = "uint32_value"; setting_uint32_value.pSettingName = "uint32_value";
setting_uint32_value.type = VK_LAYER_SETTING_TYPE_UINT32_EXT; setting_uint32_value.type = VK_LAYER_SETTING_TYPE_UINT32_EXT;
setting_uint32_value.asUint32 = &value_uint32; setting_uint32_value.pValues = &value_uint32;
setting_uint32_value.count = 1; setting_uint32_value.count = 1;
settings.push_back(setting_uint32_value); settings.push_back(setting_uint32_value);
@ -90,7 +90,7 @@ TEST(test_layer_setting_api, vlHasLayerSetting) {
setting_uint64_value.pLayerName = "VK_LAYER_LUNARG_test"; setting_uint64_value.pLayerName = "VK_LAYER_LUNARG_test";
setting_uint64_value.pSettingName = "uint64_value"; setting_uint64_value.pSettingName = "uint64_value";
setting_uint64_value.type = VK_LAYER_SETTING_TYPE_UINT64_EXT; setting_uint64_value.type = VK_LAYER_SETTING_TYPE_UINT64_EXT;
setting_uint64_value.asUint64 = &value_uint64; setting_uint64_value.pValues = &value_uint64;
setting_uint64_value.count = 1; setting_uint64_value.count = 1;
settings.push_back(setting_uint64_value); settings.push_back(setting_uint64_value);
@ -98,8 +98,8 @@ TEST(test_layer_setting_api, vlHasLayerSetting) {
VkLayerSettingEXT setting_float_value{}; VkLayerSettingEXT setting_float_value{};
setting_float_value.pLayerName = "VK_LAYER_LUNARG_test"; setting_float_value.pLayerName = "VK_LAYER_LUNARG_test";
setting_float_value.pSettingName = "float_value"; setting_float_value.pSettingName = "float_value";
setting_float_value.type = VK_LAYER_SETTING_TYPE_FLOAT_EXT; setting_float_value.type = VK_LAYER_SETTING_TYPE_FLOAT32_EXT;
setting_float_value.asFloat = &value_float; setting_float_value.pValues = &value_float;
setting_float_value.count = 1; setting_float_value.count = 1;
settings.push_back(setting_float_value); settings.push_back(setting_float_value);
@ -107,17 +107,17 @@ TEST(test_layer_setting_api, vlHasLayerSetting) {
VkLayerSettingEXT setting_double_value{}; VkLayerSettingEXT setting_double_value{};
setting_double_value.pLayerName = "VK_LAYER_LUNARG_test"; setting_double_value.pLayerName = "VK_LAYER_LUNARG_test";
setting_double_value.pSettingName = "double_value"; setting_double_value.pSettingName = "double_value";
setting_double_value.type = VK_LAYER_SETTING_TYPE_DOUBLE_EXT; setting_double_value.type = VK_LAYER_SETTING_TYPE_FLOAT64_EXT;
setting_double_value.asDouble = &value_double; setting_double_value.pValues = &value_double;
setting_double_value.count = 1; setting_double_value.count = 1;
settings.push_back(setting_double_value); settings.push_back(setting_double_value);
VkFrameset value_frameset{76, 100, 10}; VkFramesetEXT value_frameset{76, 100, 10};
VkLayerSettingEXT setting_frameset_value{}; VkLayerSettingEXT setting_frameset_value{};
setting_frameset_value.pLayerName = "VK_LAYER_LUNARG_test"; setting_frameset_value.pLayerName = "VK_LAYER_LUNARG_test";
setting_frameset_value.pSettingName = "frameset_value"; setting_frameset_value.pSettingName = "frameset_value";
setting_frameset_value.type = VK_LAYER_SETTING_TYPE_FRAMESET_EXT; setting_frameset_value.type = VK_LAYER_SETTING_TYPE_FRAMESET_EXT;
setting_frameset_value.asFrameset = &value_frameset; setting_frameset_value.pValues = &value_frameset;
setting_frameset_value.count = 1; setting_frameset_value.count = 1;
settings.push_back(setting_frameset_value); settings.push_back(setting_frameset_value);
@ -148,7 +148,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Bool) {
std::vector<VkBool32> input_values{VK_TRUE, VK_FALSE}; std::vector<VkBool32> input_values{VK_TRUE, VK_FALSE};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}}; {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}};
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
@ -160,7 +160,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Bool) {
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, nullptr); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
@ -168,7 +168,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Bool) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, &values[0]); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete); EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_EQ(VK_TRUE, values[0]); EXPECT_EQ(VK_TRUE, values[0]);
EXPECT_EQ(VK_FALSE, values[1]); EXPECT_EQ(VK_FALSE, values[1]);
@ -176,7 +176,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Bool) {
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, &values[0]); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_EQ(VK_TRUE, values[0]); EXPECT_EQ(VK_TRUE, values[0]);
EXPECT_EQ(VK_FALSE, values[1]); EXPECT_EQ(VK_FALSE, values[1]);
@ -189,7 +189,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Int32) {
std::vector<std::int32_t> input_values{76, -82}; std::vector<std::int32_t> input_values{76, -82};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
VkLayerSettingEXT{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}}; VkLayerSettingEXT{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}};
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
@ -230,7 +230,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Int64) {
std::vector<std::int64_t> input_values{76, -82}; std::vector<std::int64_t> input_values{76, -82};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}}; {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}};
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
@ -271,7 +271,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint32) {
std::vector<std::uint32_t> input_values{76, 82}; std::vector<std::uint32_t> input_values{76, 82};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}} {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}
}; };
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
@ -313,7 +313,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint64) {
std::vector<std::uint64_t> input_values{76, 82}; std::vector<std::uint64_t> input_values{76, 82};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT64_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}} {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT64_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}
}; };
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
@ -355,7 +355,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Float) {
std::vector<float> input_values{76.1f, -82.5f}; std::vector<float> input_values{76.1f, -82.5f};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}} {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}
}; };
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
@ -368,7 +368,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Float) {
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, nullptr); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
@ -376,14 +376,14 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Float) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &values[0]); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete); EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f); EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
EXPECT_EQ(1, value_count); EXPECT_EQ(1, value_count);
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &values[0]); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f); EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f); EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f);
@ -396,7 +396,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Double) {
std::vector<double> input_values{76.1, -82.5}; std::vector<double> input_values{76.1, -82.5};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}} {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}
}; };
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
@ -409,7 +409,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Double) {
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, nullptr); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
@ -417,14 +417,14 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Double) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, &values[0]); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete); EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001); EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
EXPECT_EQ(1, value_count); EXPECT_EQ(1, value_count);
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, &values[0]); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001); EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001); EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001);
@ -434,12 +434,12 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Double) {
} }
TEST(test_layer_setting_api, vlGetLayerSettingValues_Frameset) { TEST(test_layer_setting_api, vlGetLayerSettingValues_Frameset) {
std::vector<VkFrameset> input_values{ std::vector<VkFramesetEXT> input_values{
{76, 100, 10}, {1, 100, 1} {76, 100, 10}, {1, 100, 1}
}; };
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}} {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}
}; };
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
@ -456,7 +456,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Frameset) {
EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
std::vector<VkFrameset> values(static_cast<uint32_t>(value_count)); std::vector<VkFramesetEXT> values(static_cast<uint32_t>(value_count));
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
@ -485,7 +485,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Frameset) {
TEST(test_layer_setting_api, vlGetLayerSettingValues_String) { TEST(test_layer_setting_api, vlGetLayerSettingValues_String) {
std::vector<const char*> input_values{"VALUE_A", "VALUE_B"}; std::vector<const char*> input_values{"VALUE_A", "VALUE_B"};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}} {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}
}; };
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{

28
tests/layer/test_setting_cast.cpp
View file

@ -16,7 +16,7 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Bool) {
std::vector<VkBool32> input_values{VK_TRUE, VK_FALSE}; std::vector<VkBool32> input_values{VK_TRUE, VK_FALSE};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}}; {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}};
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
@ -30,7 +30,7 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Bool) {
uint32_t value_count = 2; uint32_t value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, &values[0]); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
EXPECT_EQ(VK_TRUE, values[0]); EXPECT_EQ(VK_TRUE, values[0]);
@ -52,7 +52,7 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Int32) {
std::vector<std::int32_t> input_values{76, -82}; std::vector<std::int32_t> input_values{76, -82};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
VkLayerSettingEXT{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}}; VkLayerSettingEXT{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}};
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
@ -88,7 +88,7 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Int64) {
std::vector<std::int64_t> input_values{76, -82}; std::vector<std::int64_t> input_values{76, -82};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}}}; {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}};
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]}; VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
@ -124,7 +124,7 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Uint32) {
std::vector<std::uint32_t> input_values{76, 82}; std::vector<std::uint32_t> input_values{76, 82};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}} {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}
}; };
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
@ -161,7 +161,7 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Uint64) {
std::vector<std::uint64_t> input_values{76, 82}; std::vector<std::uint64_t> input_values{76, 82};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT64_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}} {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT64_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}
}; };
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
@ -198,7 +198,7 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Float) {
std::vector<float> input_values{76.1f, -82.5f}; std::vector<float> input_values{76.1f, -82.5f};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}} {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}
}; };
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
@ -213,7 +213,7 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Float) {
uint32_t value_count = 2; uint32_t value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &values[0]); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f); EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
@ -235,7 +235,7 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Double) {
std::vector<double> input_values{76.1, -82.5}; std::vector<double> input_values{76.1, -82.5};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}} {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}
}; };
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
@ -250,7 +250,7 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Double) {
uint32_t value_count = 2; uint32_t value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, &values[0]); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001); EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001); EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001);
@ -269,12 +269,12 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Double) {
} }
TEST(test_layer_setting_cast, vlGetLayerSettingValues_Frameset) { TEST(test_layer_setting_cast, vlGetLayerSettingValues_Frameset) {
std::vector<VkFrameset> input_values{ std::vector<VkFramesetEXT> input_values{
{76, 100, 10}, {1, 100, 1} {76, 100, 10}, {1, 100, 1}
}; };
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}} {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}
}; };
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{
@ -285,7 +285,7 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Frameset) {
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
std::vector<VkFrameset> values(input_values.size()); std::vector<VkFramesetEXT> values(input_values.size());
uint32_t value_count = 2; uint32_t value_count = 2;
VkResult result_complete = VkResult result_complete =
@ -314,7 +314,7 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Frameset) {
TEST(test_layer_setting_cast, vlGetLayerSettingValues_String) { TEST(test_layer_setting_cast, vlGetLayerSettingValues_String) {
std::vector<const char*> input_values{"VALUE_A", "VALUE_B"}; std::vector<const char*> input_values{"VALUE_A", "VALUE_B"};
std::vector<VkLayerSettingEXT> settings{ std::vector<VkLayerSettingEXT> settings{
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast<uint32_t>(input_values.size()), {&input_values[0]}} {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}
}; };
VkLayerSettingsCreateInfoEXT layer_settings_create_info{ VkLayerSettingsCreateInfoEXT layer_settings_create_info{

110
tests/layer/test_setting_cpp.cpp
View file

@ -15,7 +15,7 @@
TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Bool) { TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Bool) {
const VkBool32 value_data{VK_TRUE}; const VkBool32 value_data{VK_TRUE};
const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, 1, {&value_data}}; const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, 1, &value_data};
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, 1, &setting}; const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, 1, &setting};
@ -24,10 +24,10 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Bool) {
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
bool value = true; bool pValues = true;
vlGetLayerSettingValue(layerSettingSet, "my_setting", value); vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_EQ(true, value); EXPECT_EQ(true, pValues);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vlDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
@ -37,7 +37,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Bool) {
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data)); const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
const VkLayerSettingEXT settings[] = { const VkLayerSettingEXT settings[] = {
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, value_count, {values_data}} {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, value_count, values_data}
}; };
const uint32_t settings_size = static_cast<uint32_t>(std::size(settings)); const uint32_t settings_size = static_cast<uint32_t>(std::size(settings));
@ -61,7 +61,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Bool) {
TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Int32) { TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Int32) {
const std::int32_t value_data{76}; const std::int32_t value_data{76};
const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, 1, {&value_data}}; const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, 1, &value_data};
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, 1, &setting}; const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, 1, &setting};
@ -70,10 +70,10 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Int32) {
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
std::int32_t value; std::int32_t pValues;
vlGetLayerSettingValue(layerSettingSet, "my_setting", value); vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_EQ(76, value); EXPECT_EQ(76, pValues);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vlDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
@ -83,7 +83,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Int32) {
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data)); const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
const VkLayerSettingEXT settings[] = { const VkLayerSettingEXT settings[] = {
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, value_count, {values_data}} {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, value_count, values_data}
}; };
const uint32_t settings_size = static_cast<uint32_t>(std::size(settings)); const uint32_t settings_size = static_cast<uint32_t>(std::size(settings));
@ -107,7 +107,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Int32) {
TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Uint32) { TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Uint32) {
const std::uint32_t value_data{76}; const std::uint32_t value_data{76};
const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, 1, {&value_data}}; const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, 1, &value_data};
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, 1, &setting}; const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, 1, &setting};
@ -116,10 +116,10 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Uint32) {
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
std::uint32_t value; std::uint32_t pValues;
vlGetLayerSettingValue(layerSettingSet, "my_setting", value); vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_EQ(76, value); EXPECT_EQ(76, pValues);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vlDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
@ -129,7 +129,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Uint32) {
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data)); const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
const VkLayerSettingEXT settings[] = { const VkLayerSettingEXT settings[] = {
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, value_count, {values_data}} {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, value_count, values_data}
}; };
const uint32_t settings_size = static_cast<uint32_t>(std::size(settings)); const uint32_t settings_size = static_cast<uint32_t>(std::size(settings));
@ -153,7 +153,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Uint32) {
TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Int64) { TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Int64) {
const std::int64_t value_data{76}; const std::int64_t value_data{76};
const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, 1, {&value_data}}; const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, 1, &value_data};
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, 1, &setting}; const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, 1, &setting};
@ -162,10 +162,10 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Int64) {
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
std::int64_t value; std::int64_t pValues;
vlGetLayerSettingValue(layerSettingSet, "my_setting", value); vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_EQ(76, value); EXPECT_EQ(76, pValues);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vlDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
@ -175,7 +175,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Int64) {
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data)); const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
const VkLayerSettingEXT settings[] = { const VkLayerSettingEXT settings[] = {
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, value_count, {values_data}} {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, value_count, values_data}
}; };
const uint32_t settings_size = static_cast<uint32_t>(std::size(settings)); const uint32_t settings_size = static_cast<uint32_t>(std::size(settings));
@ -199,7 +199,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Int64) {
TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Uint64) { TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Uint64) {
const std::uint64_t value_data{76}; const std::uint64_t value_data{76};
const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT64_EXT, 1, {&value_data}}; const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT64_EXT, 1, &value_data};
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, 1, &setting}; const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, 1, &setting};
@ -208,10 +208,10 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Uint64) {
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
std::uint64_t value; std::uint64_t pValues;
vlGetLayerSettingValue(layerSettingSet, "my_setting", value); vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_EQ(76, value); EXPECT_EQ(76, pValues);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vlDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
@ -221,7 +221,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Uint64) {
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data)); const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
const VkLayerSettingEXT settings[] = { const VkLayerSettingEXT settings[] = {
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT64_EXT, value_count, {values_data}} {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT64_EXT, value_count, values_data}
}; };
const uint32_t settings_size = static_cast<uint32_t>(std::size(settings)); const uint32_t settings_size = static_cast<uint32_t>(std::size(settings));
@ -245,7 +245,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Uint64) {
TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Float) { TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Float) {
const float value_data{-82.5f}; const float value_data{-82.5f};
const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, 1, {&value_data}}; const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, 1, &value_data};
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, 1, &setting}; const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, 1, &setting};
@ -254,10 +254,10 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Float) {
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
float value; float pValues;
vlGetLayerSettingValue(layerSettingSet, "my_setting", value); vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_TRUE(std::abs(value - -82.5f) <= 0.0001f); EXPECT_TRUE(std::abs(pValues - -82.5f) <= 0.0001f);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vlDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
@ -267,7 +267,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Float) {
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data)); const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
const VkLayerSettingEXT settings[] = { const VkLayerSettingEXT settings[] = {
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, value_count, {values_data}} {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, value_count, values_data}
}; };
const uint32_t settings_size = static_cast<uint32_t>(std::size(settings)); const uint32_t settings_size = static_cast<uint32_t>(std::size(settings));
@ -291,7 +291,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Float) {
TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Double) { TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Double) {
const double value_data{-82.5}; const double value_data{-82.5};
const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, 1, {&value_data}}; const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, 1, &value_data};
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, 1, &setting}; const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, 1, &setting};
@ -300,10 +300,10 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Double) {
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
double value; double pValues;
vlGetLayerSettingValue(layerSettingSet, "my_setting", value); vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_TRUE(std::abs(value - -82.5) <= 0.0001); EXPECT_TRUE(std::abs(pValues - -82.5) <= 0.0001);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vlDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
@ -313,7 +313,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Double) {
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data)); const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
const VkLayerSettingEXT settings[] = { const VkLayerSettingEXT settings[] = {
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, value_count, {values_data}} {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, value_count, values_data}
}; };
const uint32_t settings_size = static_cast<uint32_t>(std::size(settings)); const uint32_t settings_size = static_cast<uint32_t>(std::size(settings));
@ -337,16 +337,16 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Double) {
TEST(test_layer_setting_cpp, vlGetLayerSettingValue_String) { TEST(test_layer_setting_cpp, vlGetLayerSettingValue_String) {
const char* value_data[] = {"VALUE_A"}; const char* value_data[] = {"VALUE_A"};
const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, 1, {value_data}}; const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, 1, value_data};
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, 1, &setting}; const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, 1, &setting};
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
std::string value; std::string pValues;
vlGetLayerSettingValue(layerSettingSet, "my_setting", value); vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_STREQ("VALUE_A", value.c_str()); EXPECT_STREQ("VALUE_A", pValues.c_str());
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vlDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
@ -356,7 +356,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Strings) {
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data)); const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
const VkLayerSettingEXT settings[] = { const VkLayerSettingEXT settings[] = {
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, value_count, {values_data}} {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, value_count, values_data}
}; };
const uint32_t settings_size = static_cast<uint32_t>(std::size(settings)); const uint32_t settings_size = static_cast<uint32_t>(std::size(settings));
@ -365,9 +365,9 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Strings) {
VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
std::string value; std::string pValues;
vlGetLayerSettingValue(layerSettingSet, "my_setting", value); vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_STREQ("VALUE_A,VALUE_B", value.c_str()); EXPECT_STREQ("VALUE_A,VALUE_B", pValues.c_str());
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vlDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
@ -377,7 +377,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_String) {
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data)); const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
const VkLayerSettingEXT settings[] = { const VkLayerSettingEXT settings[] = {
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, value_count, {values_data}} {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, value_count, values_data}
}; };
const uint32_t settings_size = static_cast<uint32_t>(std::size(settings)); const uint32_t settings_size = static_cast<uint32_t>(std::size(settings));
@ -398,9 +398,9 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_String) {
} }
TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Frameset) { TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Frameset) {
const VkFrameset value_data{76, 100, 10}; const VkFramesetEXT value_data{76, 100, 10};
const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, 1, {&value_data}}; const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, 1, &value_data};
const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, 1, &setting}; const VkLayerSettingsCreateInfoEXT layer_settings_create_info{VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, 1, &setting};
@ -409,24 +409,24 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Frameset) {
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
VkFrameset value; VkFramesetEXT pValues;
vlGetLayerSettingValue(layerSettingSet, "my_setting", value); vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
EXPECT_EQ(76, value.first); EXPECT_EQ(76, pValues.first);
EXPECT_EQ(100, value.count); EXPECT_EQ(100, pValues.count);
EXPECT_EQ(10, value.step); EXPECT_EQ(10, pValues.step);
vlDestroyLayerSettingSet(layerSettingSet, nullptr); vlDestroyLayerSettingSet(layerSettingSet, nullptr);
} }
TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Frameset) { TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Frameset) {
const VkFrameset values_data[] = { const VkFramesetEXT values_data[] = {
{76, 100, 10}, {1, 100, 1} {76, 100, 10}, {1, 100, 1}
}; };
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data)); const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
const VkLayerSettingEXT settings[] = { const VkLayerSettingEXT settings[] = {
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, value_count, {values_data}} {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, value_count, values_data}
}; };
const uint32_t settings_size = static_cast<uint32_t>(std::size(settings)); const uint32_t settings_size = static_cast<uint32_t>(std::size(settings));
@ -437,7 +437,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Frameset) {
EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
std::vector<VkFrameset> values; std::vector<VkFramesetEXT> values;
vlGetLayerSettingValues(layerSettingSet, "my_setting", values); vlGetLayerSettingValues(layerSettingSet, "my_setting", values);
EXPECT_EQ(76, values[0].first); EXPECT_EQ(76, values[0].first);
@ -456,7 +456,7 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_VlCustomSTypeInfo) {
const uint32_t value_count = static_cast<uint32_t>(std::size(values_data)); const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
const VkLayerSettingEXT settings[] = { const VkLayerSettingEXT settings[] = {
{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, value_count, {values_data}} {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, value_count, values_data}
}; };
const uint32_t settings_size = static_cast<uint32_t>(std::size(settings)); const uint32_t settings_size = static_cast<uint32_t>(std::size(settings));

20
tests/layer/test_setting_env.cpp
View file

@ -22,7 +22,7 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Bool) {
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, nullptr); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
@ -30,7 +30,7 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Bool) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, &values[0]); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete); EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_EQ(VK_TRUE, values[0]); EXPECT_EQ(VK_TRUE, values[0]);
EXPECT_EQ(VK_FALSE, values[1]); EXPECT_EQ(VK_FALSE, values[1]);
@ -38,7 +38,7 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Bool) {
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, &values[0]); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_EQ(VK_TRUE, values[0]); EXPECT_EQ(VK_TRUE, values[0]);
EXPECT_EQ(VK_FALSE, values[1]); EXPECT_EQ(VK_FALSE, values[1]);
@ -197,7 +197,7 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Float) {
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, nullptr); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
@ -205,14 +205,14 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Float) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &values[0]); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete); EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f); EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
EXPECT_EQ(1, value_count); EXPECT_EQ(1, value_count);
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &values[0]); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f); EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f); EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f);
@ -231,7 +231,7 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Double) {
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, nullptr); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
@ -239,14 +239,14 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Double) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, &values[0]); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete); EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001); EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
EXPECT_EQ(1, value_count); EXPECT_EQ(1, value_count);
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, &values[0]); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001); EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001); EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001);
@ -269,7 +269,7 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Frameset) {
EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
std::vector<VkFrameset> values(static_cast<uint32_t>(value_count)); std::vector<VkFramesetEXT> values(static_cast<uint32_t>(value_count));
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =

20
tests/layer/test_setting_file.cpp
View file

@ -23,7 +23,7 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Bool) {
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, nullptr); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
@ -31,7 +31,7 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Bool) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, &values[0]); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete); EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_EQ(VK_TRUE, values[0]); EXPECT_EQ(VK_TRUE, values[0]);
EXPECT_EQ(VK_FALSE, values[1]); EXPECT_EQ(VK_FALSE, values[1]);
@ -39,7 +39,7 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Bool) {
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, &values[0]); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_EQ(VK_TRUE, values[0]); EXPECT_EQ(VK_TRUE, values[0]);
EXPECT_EQ(VK_FALSE, values[1]); EXPECT_EQ(VK_FALSE, values[1]);
@ -198,7 +198,7 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Float) {
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, nullptr); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
@ -206,14 +206,14 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Float) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &values[0]); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete); EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f); EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
EXPECT_EQ(1, value_count); EXPECT_EQ(1, value_count);
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &values[0]); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f); EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f); EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f);
@ -232,7 +232,7 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Double) {
uint32_t value_count = 0; uint32_t value_count = 0;
VkResult result_count = VkResult result_count =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, nullptr); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, &value_count, nullptr);
EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
@ -240,14 +240,14 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Double) {
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, &values[0]); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_INCOMPLETE, result_incomplete); EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001); EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
EXPECT_EQ(1, value_count); EXPECT_EQ(1, value_count);
value_count = 2; value_count = 2;
VkResult result_complete = VkResult result_complete =
vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, &values[0]); vlGetLayerSettingValues(layerSettingSet, "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, &value_count, &values[0]);
EXPECT_EQ(VK_SUCCESS, result_complete); EXPECT_EQ(VK_SUCCESS, result_complete);
EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001); EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001); EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001);
@ -270,7 +270,7 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Frameset) {
EXPECT_EQ(VK_SUCCESS, result_count); EXPECT_EQ(VK_SUCCESS, result_count);
EXPECT_EQ(2, value_count); EXPECT_EQ(2, value_count);
std::vector<VkFrameset> values(static_cast<uint32_t>(value_count)); std::vector<VkFramesetEXT> values(static_cast<uint32_t>(value_count));
value_count = 1; value_count = 1;
VkResult result_incomplete = VkResult result_incomplete =

126
tests/layer/test_setting_util.cpp
View file

@ -72,24 +72,24 @@ TEST(test_layer_settings_util, FindDelimiter) {
} }
TEST(test_layer_settings_util, Split_1Value) { TEST(test_layer_settings_util, Split_1Value) {
std::string value("VALUE_A"); std::string pValues("VALUE_A");
std::vector<std::string> reault = vl::Split(value, ','); std::vector<std::string> reault = vl::Split(pValues, ',');
EXPECT_EQ(1, reault.size()); EXPECT_EQ(1, reault.size());
EXPECT_STREQ("VALUE_A", reault[0].c_str()); EXPECT_STREQ("VALUE_A", reault[0].c_str());
} }
TEST(test_layer_settings_util, Split_1Value_ExtraComma) { TEST(test_layer_settings_util, Split_1Value_ExtraComma) {
std::string value("VALUE_A,"); std::string pValues("VALUE_A,");
std::vector<std::string> reault = vl::Split(value, ','); std::vector<std::string> reault = vl::Split(pValues, ',');
EXPECT_EQ(1, reault.size()); EXPECT_EQ(1, reault.size());
EXPECT_STREQ("VALUE_A", reault[0].c_str()); EXPECT_STREQ("VALUE_A", reault[0].c_str());
} }
TEST(test_layer_settings_util, Split_2Values) { TEST(test_layer_settings_util, Split_2Values) {
std::string value("VALUE_A,VALUE_B"); std::string pValues("VALUE_A,VALUE_B");
std::vector<std::string> reault = vl::Split(value, ','); std::vector<std::string> reault = vl::Split(pValues, ',');
EXPECT_EQ(2, reault.size()); EXPECT_EQ(2, reault.size());
EXPECT_STREQ("VALUE_A", reault[0].c_str()); EXPECT_STREQ("VALUE_A", reault[0].c_str());
@ -97,8 +97,8 @@ TEST(test_layer_settings_util, Split_2Values) {
} }
TEST(test_layer_settings_util, Split_2Values_ExtraComma) { TEST(test_layer_settings_util, Split_2Values_ExtraComma) {
std::string value("VALUE_A,VALUE_B,"); std::string pValues("VALUE_A,VALUE_B,");
std::vector<std::string> reault = vl::Split(value, ','); std::vector<std::string> reault = vl::Split(pValues, ',');
EXPECT_EQ(2, reault.size()); EXPECT_EQ(2, reault.size());
EXPECT_STREQ("VALUE_A", reault[0].c_str()); EXPECT_STREQ("VALUE_A", reault[0].c_str());
@ -106,59 +106,59 @@ TEST(test_layer_settings_util, Split_2Values_ExtraComma) {
} }
TEST(test_layer_settings_util, Split_2Values_WrongSeparator) { TEST(test_layer_settings_util, Split_2Values_WrongSeparator) {
std::string value("VALUE_A,VALUE_B"); std::string pValues("VALUE_A,VALUE_B");
std::vector<std::string> reault = vl::Split(value, ';'); std::vector<std::string> reault = vl::Split(pValues, ';');
EXPECT_EQ(1, reault.size()); EXPECT_EQ(1, reault.size());
EXPECT_STREQ("VALUE_A,VALUE_B", reault[0].c_str()); EXPECT_STREQ("VALUE_A,VALUE_B", reault[0].c_str());
} }
TEST(test_layer_settings_util, Split_0Value) { TEST(test_layer_settings_util, Split_0Value) {
std::string value(""); std::string pValues("");
std::vector<std::string> result = vl::Split(value, ','); std::vector<std::string> result = vl::Split(pValues, ',');
EXPECT_EQ(0, result.size()); EXPECT_EQ(0, result.size());
} }
TEST(test_layer_settings_util, TrimWhitespace_NoWhitespace) { TEST(test_layer_settings_util, TrimWhitespace_NoWhitespace) {
std::string value("VALUE_A-VALUE_B"); std::string pValues("VALUE_A-VALUE_B");
std::string result = vl::TrimWhitespace(value); std::string result = vl::TrimWhitespace(pValues);
EXPECT_STREQ("VALUE_A-VALUE_B", result.c_str()); EXPECT_STREQ("VALUE_A-VALUE_B", result.c_str());
} }
TEST(test_layer_settings_util, TrimWhitespace_space) { TEST(test_layer_settings_util, TrimWhitespace_space) {
{ {
const std::string value("VALUE_A "); const std::string pValues("VALUE_A ");
const std::string result = vl::TrimWhitespace(value); const std::string result = vl::TrimWhitespace(pValues);
EXPECT_STREQ("VALUE_A", result.c_str()); EXPECT_STREQ("VALUE_A", result.c_str());
} }
{ {
const std::string value(" VALUE_A"); const std::string pValues(" VALUE_A");
const std::string result = vl::TrimWhitespace(value); const std::string result = vl::TrimWhitespace(pValues);
EXPECT_STREQ("VALUE_A", result.c_str()); EXPECT_STREQ("VALUE_A", result.c_str());
} }
{ {
const std::string value(" VALUE_A "); const std::string pValues(" VALUE_A ");
const std::string result = vl::TrimWhitespace(value); const std::string result = vl::TrimWhitespace(pValues);
EXPECT_STREQ("VALUE_A", result.c_str()); EXPECT_STREQ("VALUE_A", result.c_str());
} }
{ {
const std::string value("VALUE A"); const std::string pValues("VALUE A");
const std::string result = vl::TrimWhitespace(value); const std::string result = vl::TrimWhitespace(pValues);
EXPECT_STREQ("VALUE A", result.c_str()); EXPECT_STREQ("VALUE A", result.c_str());
} }
{ {
const std::string value(" VALUE A "); const std::string pValues(" VALUE A ");
const std::string result = vl::TrimWhitespace(value); const std::string result = vl::TrimWhitespace(pValues);
EXPECT_STREQ("VALUE A", result.c_str()); EXPECT_STREQ("VALUE A", result.c_str());
} }
@ -166,36 +166,36 @@ TEST(test_layer_settings_util, TrimWhitespace_space) {
TEST(test_layer_settings_util, TrimWhitespace_Whitespace) { TEST(test_layer_settings_util, TrimWhitespace_Whitespace) {
{ {
const std::string value("VALUE_A\n"); const std::string pValues("VALUE_A\n");
const std::string result = vl::TrimWhitespace(value); const std::string result = vl::TrimWhitespace(pValues);
EXPECT_STREQ("VALUE_A", result.c_str()); EXPECT_STREQ("VALUE_A", result.c_str());
} }
{ {
const std::string value("\f\tVALUE_A"); const std::string pValues("\f\tVALUE_A");
const std::string result = vl::TrimWhitespace(value); const std::string result = vl::TrimWhitespace(pValues);
EXPECT_STREQ("VALUE_A", result.c_str()); EXPECT_STREQ("VALUE_A", result.c_str());
} }
{ {
const std::string value("\t\vVALUE_A\n\r"); const std::string pValues("\t\vVALUE_A\n\r");
const std::string result = vl::TrimWhitespace(value); const std::string result = vl::TrimWhitespace(pValues);
EXPECT_STREQ("VALUE_A", result.c_str()); EXPECT_STREQ("VALUE_A", result.c_str());
} }
{ {
const std::string value("VALUE\tA\f"); const std::string pValues("VALUE\tA\f");
const std::string result = vl::TrimWhitespace(value); const std::string result = vl::TrimWhitespace(pValues);
EXPECT_STREQ("VALUE\tA", result.c_str()); EXPECT_STREQ("VALUE\tA", result.c_str());
} }
{ {
const std::string value("\f\tVALUE\tA\t\f"); const std::string pValues("\f\tVALUE\tA\t\f");
const std::string result = vl::TrimWhitespace(value); const std::string result = vl::TrimWhitespace(pValues);
EXPECT_STREQ("VALUE\tA", result.c_str()); EXPECT_STREQ("VALUE\tA", result.c_str());
} }
@ -203,29 +203,29 @@ TEST(test_layer_settings_util, TrimWhitespace_Whitespace) {
TEST(test_layer_settings_util, TrimPrefix) { TEST(test_layer_settings_util, TrimPrefix) {
{ {
const std::string value("VK_LAYER_LUNARG_test"); const std::string pValues("VK_LAYER_LUNARG_test");
const std::string result = vl::TrimPrefix(value); const std::string result = vl::TrimPrefix(pValues);
EXPECT_STREQ("LUNARG_test", result.c_str()); EXPECT_STREQ("LUNARG_test", result.c_str());
} }
{ {
const std::string value("VK_LAYER_LUNARG_test_pouet"); const std::string pValues("VK_LAYER_LUNARG_test_pouet");
const std::string result = vl::TrimPrefix(value); const std::string result = vl::TrimPrefix(pValues);
EXPECT_STREQ("LUNARG_test_pouet", result.c_str()); EXPECT_STREQ("LUNARG_test_pouet", result.c_str());
} }
{ {
const std::string value("VK_LAYER_LUNARG_test_POUET"); const std::string pValues("VK_LAYER_LUNARG_test_POUET");
const std::string result = vl::TrimPrefix(value); const std::string result = vl::TrimPrefix(pValues);
EXPECT_STREQ("LUNARG_test_POUET", result.c_str()); EXPECT_STREQ("LUNARG_test_POUET", result.c_str());
} }
{ {
const std::string value("VK_LAYER_lunarg_test_POUET"); const std::string pValues("VK_LAYER_lunarg_test_POUET");
const std::string result = vl::TrimPrefix(value); const std::string result = vl::TrimPrefix(pValues);
EXPECT_STREQ("lunarg_test_POUET", result.c_str()); EXPECT_STREQ("lunarg_test_POUET", result.c_str());
} }
@ -233,29 +233,29 @@ TEST(test_layer_settings_util, TrimPrefix) {
TEST(test_layer_settings_util, TrimVendor) { TEST(test_layer_settings_util, TrimVendor) {
{ {
const std::string value("VK_LAYER_LUNARG_test"); const std::string pValues("VK_LAYER_LUNARG_test");
const std::string result = vl::TrimVendor(value); const std::string result = vl::TrimVendor(pValues);
EXPECT_STREQ("test", result.c_str()); EXPECT_STREQ("test", result.c_str());
} }
{ {
const std::string value("VK_LAYER_LUNARG_test_pouet"); const std::string pValues("VK_LAYER_LUNARG_test_pouet");
const std::string result = vl::TrimVendor(value); const std::string result = vl::TrimVendor(pValues);
EXPECT_STREQ("test_pouet", result.c_str()); EXPECT_STREQ("test_pouet", result.c_str());
} }
{ {
const std::string value("VK_LAYER_LUNARG_test_POUET"); const std::string pValues("VK_LAYER_LUNARG_test_POUET");
const std::string result = vl::TrimVendor(value); const std::string result = vl::TrimVendor(pValues);
EXPECT_STREQ("test_POUET", result.c_str()); EXPECT_STREQ("test_POUET", result.c_str());
} }
{ {
const std::string value("VK_LAYER_lunarg_test_POUET"); const std::string pValues("VK_LAYER_lunarg_test_POUET");
const std::string result = vl::TrimVendor(value); const std::string result = vl::TrimVendor(pValues);
EXPECT_STREQ("test_POUET", result.c_str()); EXPECT_STREQ("test_POUET", result.c_str());
} }
@ -397,7 +397,7 @@ TEST(test_layer_settings_util, is_framesets) {
TEST(test_layer_settings_util, to_framesets) { TEST(test_layer_settings_util, to_framesets) {
{ {
std::vector<VkFrameset> framesets = vl::ToFrameSets("0"); std::vector<VkFramesetEXT> framesets = vl::ToFrameSets("0");
EXPECT_EQ(1, framesets.size()); EXPECT_EQ(1, framesets.size());
EXPECT_EQ(0, framesets[0].first); EXPECT_EQ(0, framesets[0].first);
@ -406,7 +406,7 @@ TEST(test_layer_settings_util, to_framesets) {
} }
{ {
std::vector<VkFrameset> framesets = vl::ToFrameSets("76"); std::vector<VkFramesetEXT> framesets = vl::ToFrameSets("76");
EXPECT_EQ(1, framesets.size()); EXPECT_EQ(1, framesets.size());
EXPECT_EQ(76, framesets[0].first); EXPECT_EQ(76, framesets[0].first);
@ -415,7 +415,7 @@ TEST(test_layer_settings_util, to_framesets) {
} }
{ {
std::vector<VkFrameset> framesets = vl::ToFrameSets("0-2"); std::vector<VkFramesetEXT> framesets = vl::ToFrameSets("0-2");
EXPECT_EQ(1, framesets.size()); EXPECT_EQ(1, framesets.size());
EXPECT_EQ(0, framesets[0].first); EXPECT_EQ(0, framesets[0].first);
@ -424,7 +424,7 @@ TEST(test_layer_settings_util, to_framesets) {
} }
{ {
std::vector<VkFrameset> framesets = vl::ToFrameSets("0-2,6,7"); std::vector<VkFramesetEXT> framesets = vl::ToFrameSets("0-2,6,7");
EXPECT_EQ(3, framesets.size()); EXPECT_EQ(3, framesets.size());
EXPECT_EQ(0, framesets[0].first); EXPECT_EQ(0, framesets[0].first);
@ -441,7 +441,7 @@ TEST(test_layer_settings_util, to_framesets) {
} }
{ {
std::vector<VkFrameset> framesets = vl::ToFrameSets("0-2,6-7"); std::vector<VkFramesetEXT> framesets = vl::ToFrameSets("0-2,6-7");
EXPECT_EQ(2, framesets.size()); EXPECT_EQ(2, framesets.size());
EXPECT_EQ(0, framesets[0].first); EXPECT_EQ(0, framesets[0].first);
@ -454,7 +454,7 @@ TEST(test_layer_settings_util, to_framesets) {
} }
{ {
std::vector<VkFrameset> framesets = vl::ToFrameSets("1-2,60,70"); std::vector<VkFramesetEXT> framesets = vl::ToFrameSets("1-2,60,70");
EXPECT_EQ(3, framesets.size()); EXPECT_EQ(3, framesets.size());
EXPECT_EQ(1, framesets[0].first); EXPECT_EQ(1, framesets[0].first);
@ -471,7 +471,7 @@ TEST(test_layer_settings_util, to_framesets) {
} }
{ {
std::vector<VkFrameset> framesets = vl::ToFrameSets("10-20,60,70"); std::vector<VkFramesetEXT> framesets = vl::ToFrameSets("10-20,60,70");
EXPECT_EQ(3, framesets.size()); EXPECT_EQ(3, framesets.size());
EXPECT_EQ(10, framesets[0].first); EXPECT_EQ(10, framesets[0].first);
@ -488,7 +488,7 @@ TEST(test_layer_settings_util, to_framesets) {
} }
{ {
std::vector<VkFrameset> framesets = vl::ToFrameSets("1-8-2"); std::vector<VkFramesetEXT> framesets = vl::ToFrameSets("1-8-2");
EXPECT_EQ(1, framesets.size()); EXPECT_EQ(1, framesets.size());
EXPECT_EQ(1, framesets[0].first); EXPECT_EQ(1, framesets[0].first);
@ -497,7 +497,7 @@ TEST(test_layer_settings_util, to_framesets) {
} }
{ {
std::vector<VkFrameset> framesets = vl::ToFrameSets("1-8-2,0"); std::vector<VkFramesetEXT> framesets = vl::ToFrameSets("1-8-2,0");
EXPECT_EQ(2, framesets.size()); EXPECT_EQ(2, framesets.size());
EXPECT_EQ(1, framesets[0].first); EXPECT_EQ(1, framesets[0].first);
@ -510,7 +510,7 @@ TEST(test_layer_settings_util, to_framesets) {
} }
{ {
std::vector<VkFrameset> framesets = vl::ToFrameSets("1-8-2,10-20-5"); std::vector<VkFramesetEXT> framesets = vl::ToFrameSets("1-8-2,10-20-5");
EXPECT_EQ(2, framesets.size()); EXPECT_EQ(2, framesets.size());
EXPECT_EQ(1, framesets[0].first); EXPECT_EQ(1, framesets[0].first);
@ -523,7 +523,7 @@ TEST(test_layer_settings_util, to_framesets) {
} }
{ {
std::vector<VkFrameset> framesets = vl::ToFrameSets("1-8,10-20-5"); std::vector<VkFramesetEXT> framesets = vl::ToFrameSets("1-8,10-20-5");
EXPECT_EQ(2, framesets.size()); EXPECT_EQ(2, framesets.size());
EXPECT_EQ(1, framesets[0].first); EXPECT_EQ(1, framesets[0].first);
@ -536,7 +536,7 @@ TEST(test_layer_settings_util, to_framesets) {
} }
{ {
std::vector<VkFrameset> framesets = vl::ToFrameSets("1-8-2,10-20-1"); std::vector<VkFramesetEXT> framesets = vl::ToFrameSets("1-8-2,10-20-1");
EXPECT_EQ(2, framesets.size()); EXPECT_EQ(2, framesets.size());
EXPECT_EQ(1, framesets[0].first); EXPECT_EQ(1, framesets[0].first);
@ -549,7 +549,7 @@ TEST(test_layer_settings_util, to_framesets) {
} }
{ {
std::vector<VkFrameset> framesets = vl::ToFrameSets("1,2,3,4"); std::vector<VkFramesetEXT> framesets = vl::ToFrameSets("1,2,3,4");
EXPECT_EQ(4, framesets.size()); EXPECT_EQ(4, framesets.size());
EXPECT_EQ(1, framesets[0].first); EXPECT_EQ(1, framesets[0].first);