diff --git a/include/vulkan/layer/vk_layer_settings.hpp b/include/vulkan/layer/vk_layer_settings.hpp new file mode 100644 index 0000000..7dae424 --- /dev/null +++ b/include/vulkan/layer/vk_layer_settings.hpp @@ -0,0 +1,87 @@ +/* + * Copyright (c) 2023 The Khronos Group Inc. + * Copyright (c) 2023 Valve Corporation + * Copyright (c) 2023 LunarG, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * Authors: + * - Christophe Riccio + */ + +#pragma once + +#include "vk_layer_settings.h" +#include +#include + +void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, + const char *pSettingName, bool &settingValue); + +void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, + const char *pSettingName, std::vector &settingValues); + +void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, + const char *pSettingName, int32_t &settingValue); + +void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, + const char *pSettingName, std::vector &settingValues); + +void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, + const char *pSettingName, int64_t &settingValue); + +void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, + const char *pSettingName, std::vector &settingValues); + +void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, + const char *pSettingName, uint32_t &settingValue); + +void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, + const char *pSettingName, std::vector &settingValues); + +void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, + const char *pSettingName, uint64_t &settingValue); + +void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, + const char *pSettingName, std::vector &settingValues); + +void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, + const char *pSettingName, float &settingValue); + +void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, + const char *pSettingName, std::vector &settingValues); + +void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, + const char *pSettingName, double &settingValue); + +void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, + const char *pSettingName, std::vector &settingValues); + +void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, + const char *pSettingName, std::string &settingValue); + +void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, + const char *pSettingName, std::vector &settingValues); + +void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, + const char *pSettingName, VkFrameset &settingValue); + +void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, + const char *pSettingName, std::vector &settingValues); + +// Required by vk_safe_struct +typedef std::pair VlCustomSTypeInfo; + +void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, + const char *pSettingName, + std::vector &settingValues); diff --git a/src/layer/CMakeLists.txt b/src/layer/CMakeLists.txt index c6c17cc..cbfd814 100644 --- a/src/layer/CMakeLists.txt +++ b/src/layer/CMakeLists.txt @@ -22,6 +22,7 @@ target_compile_features(VulkanLayerSettings PRIVATE cxx_std_17) target_sources(VulkanLayerSettings PRIVATE vk_layer_settings.cpp + vk_layer_settings_helper.cpp layer_settings_manager.cpp layer_settings_manager.hpp layer_settings_util.cpp diff --git a/src/layer/vk_layer_settings_helper.cpp b/src/layer/vk_layer_settings_helper.cpp new file mode 100644 index 0000000..2385150 --- /dev/null +++ b/src/layer/vk_layer_settings_helper.cpp @@ -0,0 +1,197 @@ +/* + * Copyright (c) 2023 The Khronos Group Inc. + * Copyright (c) 2023 Valve Corporation + * Copyright (c) 2023 LunarG, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * Authors: + * - Christophe Riccio + */ + +#include "vulkan/layer/vk_layer_settings.hpp" + +void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, bool &settingValue) { + uint32_t value_count = 1; + VkBool32 value; + vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, &value); + settingValue = value == VK_TRUE; +} + +void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector &settingValues) { + uint32_t value_count = 0; + vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, nullptr); + if (value_count > 0) { + std::vector values(value_count); + vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_BOOL_EXT, &value_count, &values[0]); + for (std::size_t i = 0, n = values.size(); i < n; ++i) { + settingValues.push_back(values[i] == VK_TRUE); + } + } +} + +void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, int32_t &settingValue) { + uint32_t value_count = 1; + vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_INT32_EXT, &value_count, &settingValue); +} + +void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector &settingValues) { + uint32_t value_count = 1; + vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_INT32_EXT, &value_count, nullptr); + if (value_count > 0) { + settingValues.resize(static_cast(value_count)); + vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_INT32_EXT, &value_count, &settingValues[0]); + } +} + +void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, int64_t &settingValue) { + uint32_t value_count = 1; + vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_INT64_EXT, &value_count, &settingValue); +} + +void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector &settingValues) { + uint32_t value_count = 1; + vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_INT64_EXT, &value_count, nullptr); + if (value_count > 0) { + settingValues.resize(static_cast(value_count)); + vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_INT64_EXT, &value_count, &settingValues[0]); + } +} + +void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, uint32_t &settingValue) { + uint32_t value_count = 1; + vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_UINT32_EXT, &value_count, &settingValue); +} + +void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector &settingValues) { + uint32_t value_count = 1; + vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_UINT32_EXT, &value_count, nullptr); + if (value_count > 0) { + settingValues.resize(static_cast(value_count)); + vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_UINT32_EXT, &value_count, &settingValues[0]); + } +} + +void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, uint64_t &settingValue) { + uint32_t value_count = 1; + vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_UINT64_EXT, &value_count, &settingValue); +} + +void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector &settingValues) { + uint32_t value_count = 1; + vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_UINT64_EXT, &value_count, nullptr); + if (value_count > 0) { + settingValues.resize(static_cast(value_count)); + vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_UINT64_EXT, &value_count, &settingValues[0]); + } +} + +void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, float &settingValue) { + uint32_t value_count = 1; + vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &settingValue); +} + +void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector &settingValues) { + uint32_t value_count = 1; + vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, nullptr); + if (value_count > 0) { + settingValues.resize(static_cast(value_count)); + vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FLOAT_EXT, &value_count, &settingValues[0]); + } +} + +void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, double &settingValue) { + uint32_t value_count = 1; + vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, &settingValue); +} + +void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector &settingValues) { + uint32_t value_count = 1; + vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, nullptr); + if (value_count > 0) { + settingValues.resize(static_cast(value_count)); + vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_DOUBLE_EXT, &value_count, &settingValues[0]); + } +} + +void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::string &settingValue) { + std::vector settingValues; + vlGetLayerSettingValues(layerSettingSet, pSettingName, settingValues); + if (!settingValues.empty()) { + settingValue = settingValues[0]; + } +} + +void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector &settingValues) { + uint32_t value_count = 0; + vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_STRING_EXT, &value_count, nullptr); + if (value_count > 0) { + std::vector values(value_count); + vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_STRING_EXT, &value_count, &values[0]); + settingValues.assign(values.begin(), values.end()); + } +} + +void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char* pSettingName, VkFrameset& settingValue) { + uint32_t value_count = 1; + vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FRAMESET_EXT, &value_count, &settingValue); +} + +void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char* pSettingName, std::vector& settingValues) { + uint32_t value_count = 0; + vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FRAMESET_EXT, &value_count, nullptr); + if (value_count > 0) { + settingValues.resize(static_cast(value_count)); + vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_FRAMESET_EXT, &value_count, &settingValues[0]); + } +} + +static uint32_t TokenToUint(const std::string &token) { + uint32_t int_id = 0; + if ((token.find("0x") == 0) || token.find("0X") == 0) { // Handle hex format + int_id = static_cast(std::strtoul(token.c_str(), nullptr, 16)); + } else { + int_id = static_cast(std::strtoul(token.c_str(), nullptr, 10)); // Decimal format + } + return int_id; +} + +static void SetCustomStypeInfo(std::vector raw_id_list, std::vector& custom_stype_info) { + // List format is a list of integer pairs + for (std::size_t i = 0, n = raw_id_list.size(); i < n; i += 2) { + uint32_t stype_id = TokenToUint(raw_id_list[i + 0]); + uint32_t struct_size_in_bytes = TokenToUint(raw_id_list[i + 1]); + + bool found = false; + // Prevent duplicate entries + for (auto item : custom_stype_info) { + if (item.first == stype_id) { + found = true; + break; + } + } + if (!found) { + custom_stype_info.push_back(std::make_pair(stype_id, struct_size_in_bytes)); + } + } +} + +void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector &settingValues) { + uint32_t value_count = 0; + vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_STRING_EXT, &value_count, nullptr); + if (value_count > 0) { + std::vector values(value_count); + vlGetLayerSettingValues(layerSettingSet, pSettingName, VK_LAYER_SETTING_TYPE_STRING_EXT, &value_count, &values[0]); + SetCustomStypeInfo(values, settingValues); + } +} diff --git a/tests/layer/CMakeLists.txt b/tests/layer/CMakeLists.txt index a25e9ff..d6de626 100644 --- a/tests/layer/CMakeLists.txt +++ b/tests/layer/CMakeLists.txt @@ -58,6 +58,26 @@ target_link_libraries(test_layer_settings_api PRIVATE gtest_discover_tests(test_layer_settings_api) +# test_layer_setting_cpp +add_executable(test_layer_settings_cpp) + +target_include_directories(test_layer_settings_cpp PRIVATE + ${CMAKE_SOURCE_DIR}/src/layer +) + +target_sources(test_layer_settings_cpp PRIVATE + test_setting_cpp.cpp +) + +target_link_libraries(test_layer_settings_cpp PRIVATE + GTest::gtest + GTest::gtest_main + Vulkan::Headers + Vulkan::LayerSettings +) + +gtest_discover_tests(test_layer_settings_cpp) + # test_layer_setting_env add_executable(test_layer_settings_env) diff --git a/tests/layer/test_setting_cpp.cpp b/tests/layer/test_setting_cpp.cpp new file mode 100644 index 0000000..c0b8593 --- /dev/null +++ b/tests/layer/test_setting_cpp.cpp @@ -0,0 +1,486 @@ +/* + * Copyright (c) 2023-2023 Valve Corporation + * Copyright (c) 2023-2023 LunarG, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * Authors: + * - Christophe Riccio + */ + +#include + +#include "vulkan/layer/vk_layer_settings.hpp" +#include + +TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Bool) { + VkBool32 input_values{VK_TRUE}; + + std::vector settings{ + {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, 1, {&input_values}} + }; + + VkLayerSettingsCreateInfoEXT layer_settings_create_info{ + VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast(settings.size()), &settings[0]}; + + VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + + EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); + + bool value = true; + vlGetLayerSettingValue(layerSettingSet, "my_setting", value); + + EXPECT_EQ(true, value); + + vlDestroyLayerSettingSet(layerSettingSet, nullptr); +} + +TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Bool) { + std::vector input_values{VK_TRUE, VK_FALSE}; + + std::vector settings{ + {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_BOOL_EXT, static_cast(input_values.size()), {&input_values[0]}} + }; + + VkLayerSettingsCreateInfoEXT layer_settings_create_info{ + VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast(settings.size()), &settings[0]}; + + VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + + EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); + + std::vector values; + vlGetLayerSettingValues(layerSettingSet, "my_setting", values); + + EXPECT_EQ(true, values[0]); + EXPECT_EQ(false, values[1]); + EXPECT_EQ(2, values.size()); + + vlDestroyLayerSettingSet(layerSettingSet, nullptr); +} + +TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Int32) { + std::vector input_values{76}; + + std::vector settings{ + {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, static_cast(input_values.size()), {&input_values[0]}} + }; + + VkLayerSettingsCreateInfoEXT layer_settings_create_info{ + VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast(settings.size()), &settings[0]}; + + VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + + EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); + + std::int32_t value; + vlGetLayerSettingValue(layerSettingSet, "my_setting", value); + + EXPECT_EQ(76, value); + + vlDestroyLayerSettingSet(layerSettingSet, nullptr); +} + +TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Int32) { + std::vector input_values{76, 82}; + + std::vector settings{ + {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, static_cast(input_values.size()), {&input_values[0]}} + }; + + VkLayerSettingsCreateInfoEXT layer_settings_create_info{ + VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast(settings.size()), &settings[0]}; + + VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + + EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); + + std::vector values; + vlGetLayerSettingValues(layerSettingSet, "my_setting", values); + + EXPECT_EQ(76, values[0]); + EXPECT_EQ(82, values[1]); + EXPECT_EQ(2, values.size()); + + vlDestroyLayerSettingSet(layerSettingSet, nullptr); +} + +TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Uint32) { + std::vector input_values{76, 82}; + + std::vector settings{ + {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, static_cast(input_values.size()), {&input_values[0]}} + }; + + VkLayerSettingsCreateInfoEXT layer_settings_create_info{ + VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast(settings.size()), &settings[0]}; + + VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + + EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); + + std::uint32_t value; + vlGetLayerSettingValue(layerSettingSet, "my_setting", value); + + EXPECT_EQ(76, value); + + vlDestroyLayerSettingSet(layerSettingSet, nullptr); +} + +TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Uint32) { + std::vector input_values{76, 82}; + + std::vector settings{ + {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, static_cast(input_values.size()), {&input_values[0]}} + }; + + VkLayerSettingsCreateInfoEXT layer_settings_create_info{ + VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast(settings.size()), &settings[0]}; + + VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + + EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); + + std::vector values; + vlGetLayerSettingValues(layerSettingSet, "my_setting", values); + + EXPECT_EQ(76, values[0]); + EXPECT_EQ(82, values[1]); + EXPECT_EQ(2, values.size()); + + vlDestroyLayerSettingSet(layerSettingSet, nullptr); +} + +TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Int64) { + std::vector input_values{76}; + + std::vector settings{ + {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, static_cast(input_values.size()), {&input_values[0]}} + }; + + VkLayerSettingsCreateInfoEXT layer_settings_create_info{ + VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast(settings.size()), &settings[0]}; + + VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + + EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); + + std::int64_t value; + vlGetLayerSettingValue(layerSettingSet, "my_setting", value); + + EXPECT_EQ(76, value); + + vlDestroyLayerSettingSet(layerSettingSet, nullptr); +} + +TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Int64) { + std::vector input_values{76, 82}; + + std::vector settings{ + {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, static_cast(input_values.size()), {&input_values[0]}} + }; + + VkLayerSettingsCreateInfoEXT layer_settings_create_info{ + VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast(settings.size()), &settings[0]}; + + VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + + EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); + + std::vector values; + vlGetLayerSettingValues(layerSettingSet, "my_setting", values); + + EXPECT_EQ(76, values[0]); + EXPECT_EQ(82, values[1]); + EXPECT_EQ(2, values.size()); + + vlDestroyLayerSettingSet(layerSettingSet, nullptr); +} + +TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Uint64) { + std::vector input_values{76}; + + std::vector settings{ + {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT64_EXT, static_cast(input_values.size()), {&input_values[0]}} + }; + + VkLayerSettingsCreateInfoEXT layer_settings_create_info{ + VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast(settings.size()), &settings[0]}; + + VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + + EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); + + std::uint64_t value; + vlGetLayerSettingValue(layerSettingSet, "my_setting", value); + + EXPECT_EQ(76, value); + + vlDestroyLayerSettingSet(layerSettingSet, nullptr); +} + +TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Uint64) { + std::vector input_values{76, 82}; + + std::vector settings{ + {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT64_EXT, static_cast(input_values.size()), {&input_values[0]}} + }; + + VkLayerSettingsCreateInfoEXT layer_settings_create_info{ + VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast(settings.size()), &settings[0]}; + + VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + + EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); + + std::vector values; + vlGetLayerSettingValues(layerSettingSet, "my_setting", values); + + EXPECT_EQ(76, values[0]); + EXPECT_EQ(82, values[1]); + EXPECT_EQ(2, values.size()); + + vlDestroyLayerSettingSet(layerSettingSet, nullptr); +} + +TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Float) { + std::vector input_values{-82.5f}; + + std::vector settings{ + {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, static_cast(input_values.size()), {&input_values[0]}} + }; + + VkLayerSettingsCreateInfoEXT layer_settings_create_info{ + VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast(settings.size()), &settings[0]}; + + VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + + EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); + + float value; + vlGetLayerSettingValue(layerSettingSet, "my_setting", value); + + EXPECT_TRUE(std::abs(value - -82.5f) <= 0.0001f); + + vlDestroyLayerSettingSet(layerSettingSet, nullptr); +} + +TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Float) { + std::vector input_values{76.1f, -82.5f}; + + std::vector settings{ + {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT_EXT, static_cast(input_values.size()), {&input_values[0]}} + }; + + VkLayerSettingsCreateInfoEXT layer_settings_create_info{ + VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast(settings.size()), &settings[0]}; + + VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + + EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); + + std::vector values; + vlGetLayerSettingValues(layerSettingSet, "my_setting", values); + + EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f); + EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f); + EXPECT_EQ(2, values.size()); + + vlDestroyLayerSettingSet(layerSettingSet, nullptr); +} + +TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Double) { + std::vector input_values{-82.5}; + + std::vector settings{ + {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, static_cast(input_values.size()), {&input_values[0]}} + }; + + VkLayerSettingsCreateInfoEXT layer_settings_create_info{ + VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast(settings.size()), &settings[0]}; + + VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + + EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); + + double value; + vlGetLayerSettingValue(layerSettingSet, "my_setting", value); + + EXPECT_TRUE(std::abs(value - -82.5) <= 0.0001); + + vlDestroyLayerSettingSet(layerSettingSet, nullptr); +} + +TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Double) { + std::vector input_values{76.1, -82.5}; + + std::vector settings{ + {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_DOUBLE_EXT, static_cast(input_values.size()), {&input_values[0]}} + }; + + VkLayerSettingsCreateInfoEXT layer_settings_create_info{ + VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast(settings.size()), &settings[0]}; + + VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + + EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); + + std::vector values; + vlGetLayerSettingValues(layerSettingSet, "my_setting", values); + + EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001); + EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001); + EXPECT_EQ(2, values.size()); + + vlDestroyLayerSettingSet(layerSettingSet, nullptr); +} + + +TEST(test_layer_setting_cpp, vlGetLayerSettingValue_String) { + std::vector input_values{"VALUE_A"}; + + std::vector settings{ + {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, 1, {&input_values[0]}} + }; + + VkLayerSettingsCreateInfoEXT layer_settings_create_info{ + VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast(settings.size()), &settings[0]}; + + VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + + std::string value; + vlGetLayerSettingValue(layerSettingSet, "my_setting", value); + EXPECT_STREQ("VALUE_A", value.c_str()); + + vlDestroyLayerSettingSet(layerSettingSet, nullptr); +} + +TEST(test_layer_setting_cpp, vlGetLayerSettingValues_String) { + std::vector input_values{"VALUE_A", "VALUE_B"}; + + std::vector settings{ + {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast(input_values.size()), {&input_values[0]}} + }; + + VkLayerSettingsCreateInfoEXT layer_settings_create_info{ + VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast(settings.size()), &settings[0]}; + + VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + + EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); + + std::vector values; + vlGetLayerSettingValues(layerSettingSet, "my_setting", values); + EXPECT_STREQ("VALUE_A", values[0].c_str()); + EXPECT_STREQ("VALUE_B", values[1].c_str()); + EXPECT_EQ(2, values.size()); + + vlDestroyLayerSettingSet(layerSettingSet, nullptr); +} + +TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Frameset) { + std::vector input_values{{76, 100, 10}}; + + std::vector settings{ + {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, static_cast(input_values.size()), {&input_values[0]}} + }; + + VkLayerSettingsCreateInfoEXT layer_settings_create_info{ + VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast(settings.size()), &settings[0]}; + + VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + + EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); + + VkFrameset value; + vlGetLayerSettingValue(layerSettingSet, "my_setting", value); + + EXPECT_EQ(76, value.first); + EXPECT_EQ(100, value.count); + EXPECT_EQ(10, value.step); + + vlDestroyLayerSettingSet(layerSettingSet, nullptr); +} + +TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Frameset) { + std::vector input_values{ + {76, 100, 10}, {1, 100, 1} + }; + + std::vector settings{ + {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FRAMESET_EXT, static_cast(input_values.size()), {&input_values[0]}} + }; + + VkLayerSettingsCreateInfoEXT layer_settings_create_info{ + VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast(settings.size()), &settings[0]}; + + VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + + EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); + + std::vector values; + vlGetLayerSettingValues(layerSettingSet, "my_setting", values); + + EXPECT_EQ(76, values[0].first); + EXPECT_EQ(100, values[0].count); + EXPECT_EQ(10, values[0].step); + EXPECT_EQ(1, values[1].first); + EXPECT_EQ(100, values[1].count); + EXPECT_EQ(1, values[1].step); + EXPECT_EQ(2, values.size()); + + vlDestroyLayerSettingSet(layerSettingSet, nullptr); +} + +TEST(test_layer_setting_cpp, vlGetLayerSettingValues_VlCustomSTypeInfo) { + std::vector input_values{"0x76", "0X82", "76", "82"}; + + std::vector settings{ + {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast(input_values.size()), {&input_values[0]}} + }; + + VkLayerSettingsCreateInfoEXT layer_settings_create_info{ + VK_STRUCTURE_TYPE_LAYER_SETTINGS_EXT, nullptr, static_cast(settings.size()), &settings[0]}; + + VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + + EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting")); + + std::vector values; + vlGetLayerSettingValues(layerSettingSet, "my_setting", values); + EXPECT_EQ(0x76, values[0].first); + EXPECT_EQ(0x82, values[0].second); + EXPECT_EQ(76, values[1].first); + EXPECT_EQ(82, values[1].second); + + vlDestroyLayerSettingSet(layerSettingSet, nullptr); +}