Skip to content

Commit 60481ed

Browse files
asuessenbachasuessenbach
committed
Adjust hello_triangle samples to warn instead of throw when there's no validation layer
1 parent 87849d4 commit 60481ed

File tree

8 files changed

+58
-184
lines changed

8 files changed

+58
-184
lines changed

‎samples/api/hello_triangle/hello_triangle.cpp‎

Lines changed: 14 additions & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -83,38 +83,6 @@ bool HelloTriangle::validate_extensions(const std::vector<const char *>
8383
return true;
8484
}
8585

86-
/**
87-
* @brief Validates a list of required layers, comparing it with the available ones.
88-
*
89-
* @param required A vector containing required layer names.
90-
* @param available A VkLayerProperties object containing available layers.
91-
* @return true if all required extensions are available
92-
* @return false otherwise
93-
*/
94-
bool HelloTriangle::validate_layers(const std::vector<const char *> &required,
95-
const std::vector<VkLayerProperties> &available)
96-
{
97-
for (auto extension : required)
98-
{
99-
bool found = false;
100-
for (auto &available_extension : available)
101-
{
102-
if (strcmp(available_extension.layerName, extension) == 0)
103-
{
104-
found = true;
105-
break;
106-
}
107-
}
108-
109-
if (!found)
110-
{
111-
return false;
112-
}
113-
}
114-
115-
return true;
116-
}
117-
11886
/**
11987
* @brief Find the vulkan shader stage for a given a string.
12088
*
@@ -226,30 +194,27 @@ void HelloTriangle::init_instance()
226194
throw std::runtime_error("Required instance extensions are missing.");
227195
}
228196

229-
uint32_t instance_layer_count;
230-
VK_CHECK(vkEnumerateInstanceLayerProperties(&instance_layer_count, nullptr));
197+
std::vector<const char *> requested_instance_layers{};
231198

232-
std::vector<VkLayerProperties> supported_validation_layers(instance_layer_count);
233-
VK_CHECK(vkEnumerateInstanceLayerProperties(&instance_layer_count, supported_validation_layers.data()));
199+
#if defined(VKB_DEBUG) || defined(VKB_VALIDATION_LAYERS)
200+
char const *validationLayer = "VK_LAYER_KHRONOS_validation";
234201

235-
std::vector<const char *> requested_validation_layers{};
202+
uint32_t instance_layer_count;
203+
VK_CHECK(vkEnumerateInstanceLayerProperties(&instance_layer_count, nullptr));
236204

237-
#if defined(VKB_DEBUG) || defined(VKB_VALIDATION_LAYERS)
238-
requested_validation_layers.push_back("VK_LAYER_KHRONOS_validation");
239-
#endif
205+
std::vector<VkLayerProperties> supported_instance_layers(instance_layer_count);
206+
VK_CHECK(vkEnumerateInstanceLayerProperties(&instance_layer_count, supported_instance_layers.data()));
240207

241-
if (validate_layers(requested_validation_layers, supported_validation_layers))
208+
if (std::any_of(supported_instance_layers.begin(), supported_instance_layers.end(), [&validationLayer](auto const &lp) { return strcmp(lp.layerName, validationLayer) == 0; }))
242209
{
243-
LOGI("Enabled Validation Layers:")
244-
for (const auto &layer : requested_validation_layers)
245-
{
246-
LOGI(" \t{}", layer);
247-
}
210+
requested_instance_layers.push_back(validationLayer);
211+
LOGI("Enabled Validation Layer {}", validationLayer);
248212
}
249213
else
250214
{
251-
throw std::runtime_error("Required validation layers are missing.");
215+
LOGW("Validation Layer {} is not available", validationLayer);
252216
}
217+
#endif
253218

254219
VkApplicationInfo app{VK_STRUCTURE_TYPE_APPLICATION_INFO};
255220
app.pApplicationName = "Hello Triangle";
@@ -260,8 +225,8 @@ void HelloTriangle::init_instance()
260225
instance_info.pApplicationInfo = &app;
261226
instance_info.enabledExtensionCount = vkb::to_u32(required_instance_extensions.size());
262227
instance_info.ppEnabledExtensionNames = required_instance_extensions.data();
263-
instance_info.enabledLayerCount = vkb::to_u32(requested_validation_layers.size());
264-
instance_info.ppEnabledLayerNames = requested_validation_layers.data();
228+
instance_info.enabledLayerCount = vkb::to_u32(requested_instance_layers.size());
229+
instance_info.ppEnabledLayerNames = requested_instance_layers.data();
265230

266231
#if defined(VKB_DEBUG) || defined(VKB_VALIDATION_LAYERS)
267232
// Validation layers help finding wrong api usage, we enable them when explicitly requested or in debug builds

‎samples/api/hello_triangle/hello_triangle.h‎

Lines changed: 1 addition & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
/* Copyright (c) 2018-2024, Arm Limited and Contributors
1+
/* Copyright (c) 2018-2025, Arm Limited and Contributors
22
*
33
* SPDX-License-Identifier: Apache-2.0
44
*
@@ -125,9 +125,6 @@ class HelloTriangle : public vkb::Application
125125
bool validate_extensions(const std::vector<const char *> &required,
126126
const std::vector<VkExtensionProperties> &available);
127127

128-
bool validate_layers(const std::vector<const char *> &required,
129-
const std::vector<VkLayerProperties> &available);
130-
131128
VkShaderStageFlagBits find_shader_stage(const std::string &ext);
132129

133130
void init_instance();

‎samples/api/hello_triangle_1_3/hello_triangle_1_3.cpp‎

Lines changed: 14 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -90,41 +90,6 @@ bool HelloTriangleV13::validate_extensions(const std::vector<const char *>
9090
return all_found;
9191
}
9292

93-
/**
94-
* @brief Validates a list of required layers, comparing it with the available ones.
95-
*
96-
* @param required A vector containing required layer names.
97-
* @param available A VkLayerProperties object containing available layers.
98-
* @return true if all required extensions are available
99-
* @return false otherwise
100-
*/
101-
bool HelloTriangleV13::validate_layers(const std::vector<const char *> &required,
102-
const std::vector<VkLayerProperties> &available)
103-
{
104-
bool all_found = true;
105-
106-
for (const auto *layer_name : required)
107-
{
108-
bool found = false;
109-
for (const auto &available_layer : available)
110-
{
111-
if (strcmp(available_layer.layerName, layer_name) == 0)
112-
{
113-
found = true;
114-
break;
115-
}
116-
}
117-
118-
if (!found)
119-
{
120-
LOGE("Error: Required layer not found: {}", layer_name);
121-
all_found = false;
122-
}
123-
}
124-
125-
return all_found;
126-
}
127-
12893
/**
12994
* @brief Initializes the Vulkan instance.
13095
*/
@@ -188,30 +153,27 @@ void HelloTriangleV13::init_instance()
188153
throw std::runtime_error("Required instance extensions are missing.");
189154
}
190155

191-
uint32_t instance_layer_count;
192-
VK_CHECK(vkEnumerateInstanceLayerProperties(&instance_layer_count, nullptr));
156+
std::vector<const char *> requested_instance_layers{};
193157

194-
std::vector<VkLayerProperties> supported_validation_layers(instance_layer_count);
195-
VK_CHECK(vkEnumerateInstanceLayerProperties(&instance_layer_count, supported_validation_layers.data()));
158+
#if defined(VKB_DEBUG) || defined(VKB_VALIDATION_LAYERS)
159+
char const *validationLayer = "VK_LAYER_KHRONOS_validation";
196160

197-
std::vector<const char *> requested_validation_layers{};
161+
uint32_t instance_layer_count;
162+
VK_CHECK(vkEnumerateInstanceLayerProperties(&instance_layer_count, nullptr));
198163

199-
#if defined(VKB_DEBUG) || defined(VKB_VALIDATION_LAYERS)
200-
requested_validation_layers.push_back("VK_LAYER_KHRONOS_validation");
201-
#endif
164+
std::vector<VkLayerProperties> supported_instance_layers(instance_layer_count);
165+
VK_CHECK(vkEnumerateInstanceLayerProperties(&instance_layer_count, supported_instance_layers.data()));
202166

203-
if (validate_layers(requested_validation_layers, supported_validation_layers))
167+
if (std::any_of(supported_instance_layers.begin(), supported_instance_layers.end(), [&validationLayer](auto const &lp) { return strcmp(lp.layerName, validationLayer) == 0; }))
204168
{
205-
LOGI("Enabled Validation Layers:");
206-
for (const auto &layer : requested_validation_layers)
207-
{
208-
LOGI(" \t{}", layer);
209-
}
169+
requested_instance_layers.push_back(validationLayer);
170+
LOGI("Enabled Validation Layer {}", validationLayer);
210171
}
211172
else
212173
{
213-
throw std::runtime_error("Required validation layers are missing.");
174+
LOGW("Validation Layer {} is not available", validationLayer);
214175
}
176+
#endif
215177

216178
VkApplicationInfo app{
217179
.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
@@ -222,8 +184,8 @@ void HelloTriangleV13::init_instance()
222184
VkInstanceCreateInfo instance_info{
223185
.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
224186
.pApplicationInfo = &app,
225-
.enabledLayerCount = vkb::to_u32(requested_validation_layers.size()),
226-
.ppEnabledLayerNames = requested_validation_layers.data(),
187+
.enabledLayerCount = vkb::to_u32(requested_instance_layers.size()),
188+
.ppEnabledLayerNames = requested_instance_layers.data(),
227189
.enabledExtensionCount = vkb::to_u32(required_instance_extensions.size()),
228190
.ppEnabledExtensionNames = required_instance_extensions.data()};
229191

‎samples/api/hello_triangle_1_3/hello_triangle_1_3.h‎

Lines changed: 1 addition & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
/* Copyright (c) 2024, Huawei Technologies Co., Ltd.
1+
/* Copyright (c) 2024-2025, Huawei Technologies Co., Ltd.
22
*
33
* SPDX-License-Identifier: Apache-2.0
44
*
@@ -142,9 +142,6 @@ class HelloTriangleV13 : public vkb::Application
142142
bool validate_extensions(const std::vector<const char *> &required,
143143
const std::vector<VkExtensionProperties> &available);
144144

145-
bool validate_layers(const std::vector<const char *> &required,
146-
const std::vector<VkLayerProperties> &available);
147-
148145
void init_instance();
149146

150147
void init_device();

‎samples/api/hpp_hello_triangle/hpp_hello_triangle.cpp‎

Lines changed: 10 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -71,27 +71,6 @@ bool validate_extensions(const std::vector<const char *> &required,
7171
}) == required.end();
7272
}
7373

74-
bool validate_layers(const std::vector<const char *> &required,
75-
const std::vector<vk::LayerProperties> &available)
76-
{
77-
// inner find_if returns true if the layer was not found
78-
// outer find_if returns iterator to the not found layer, if any
79-
auto requiredButNotFoundIt = std::find_if(required.begin(),
80-
required.end(),
81-
[&available](auto layer) {
82-
return std::find_if(available.begin(),
83-
available.end(),
84-
[&layer](auto const &lp) {
85-
return strcmp(lp.layerName, layer) == 0;
86-
}) == available.end();
87-
});
88-
if (requiredButNotFoundIt != required.end())
89-
{
90-
LOGE("Validation Layer {} not found", *requiredButNotFoundIt);
91-
}
92-
return (requiredButNotFoundIt == required.end());
93-
}
94-
9574
HPPHelloTriangle::HPPHelloTriangle()
9675
{
9776
}
@@ -441,30 +420,27 @@ vk::Instance HPPHelloTriangle::create_instance(std::vector<const char *> const &
441420
throw std::runtime_error("Required instance extensions are missing.");
442421
}
443422

444-
std::vector<vk::LayerProperties> supported_validation_layers = vk::enumerateInstanceLayerProperties();
423+
std::vector<const char *> requested_instance_layers(required_validation_layers);
445424

446-
std::vector<const char *> requested_validation_layers(required_validation_layers);
425+
#if defined(VKB_DEBUG) || defined(VKB_VALIDATION_LAYERS)
426+
char const *validationLayer = "VK_LAYER_KHRONOS_validation";
447427

448-
#ifdef VKB_VALIDATION_LAYERS
449-
requested_validation_layers.push_back("VK_LAYER_KHRONOS_validation");
450-
#endif
428+
std::vector<vk::LayerProperties> supported_instance_layers = vk::enumerateInstanceLayerProperties();
451429

452-
if (validate_layers(requested_validation_layers, supported_validation_layers))
430+
if (std::any_of(supported_instance_layers.begin(), supported_instance_layers.end(), [&validationLayer](auto const &lp) { return strcmp(lp.layerName, validationLayer) == 0; }))
453431
{
454-
LOGI("Enabled Validation Layers:")
455-
for (const auto &layer : requested_validation_layers)
456-
{
457-
LOGI(" \t{}", layer);
458-
}
432+
requested_instance_layers.push_back(validationLayer);
433+
LOGI("Enabled Validation Layer {}", validationLayer);
459434
}
460435
else
461436
{
462-
throw std::runtime_error("Required validation layers are missing.");
437+
LOGW("Validation Layer {} is not available", validationLayer);
463438
}
439+
#endif
464440

465441
vk::ApplicationInfo app("HPP Hello Triangle", {}, "Vulkan Samples", {}, VK_MAKE_VERSION(1, 0, 0));
466442

467-
vk::InstanceCreateInfo instance_info({}, &app, requested_validation_layers, active_instance_extensions);
443+
vk::InstanceCreateInfo instance_info({}, &app, requested_instance_layers, active_instance_extensions);
468444

469445
#if defined(VKB_DEBUG) || defined(VKB_VALIDATION_LAYERS)
470446
debug_utils_create_info =

‎samples/extensions/full_screen_exclusive/full_screen_exclusive.cpp‎

Lines changed: 15 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -70,30 +70,6 @@ bool FullScreenExclusive::validate_extensions(const std::vector<const char *> &r
7070
return true;
7171
}
7272

73-
bool FullScreenExclusive::validate_layers(const std::vector<const char *> &required, const std::vector<VkLayerProperties> &available)
74-
{
75-
for (auto extension : required)
76-
{
77-
bool found = false;
78-
79-
for (auto &available_extension : available)
80-
{
81-
if (strcmp(available_extension.layerName, extension) == 0)
82-
{
83-
found = true;
84-
break;
85-
}
86-
}
87-
88-
if (!found)
89-
{
90-
return false;
91-
}
92-
}
93-
94-
return true;
95-
}
96-
9773
VkShaderStageFlagBits FullScreenExclusive::find_shader_stage(const std::string &ext)
9874
{
9975
if (ext == "vert")
@@ -161,28 +137,28 @@ void FullScreenExclusive::init_instance(const std::vector<const char *> &require
161137
{
162138
throw std::runtime_error("Required instance extensions are missing.");
163139
}
140+
141+
std::vector<const char *> requested_instance_layers(required_validation_layers);
142+
143+
#if defined(VKB_DEBUG) || defined(VKB_VALIDATION_LAYERS)
144+
char const *validationLayer = "VK_LAYER_KHRONOS_validation";
145+
164146
uint32_t instance_layer_count;
165147
VK_CHECK(vkEnumerateInstanceLayerProperties(&instance_layer_count, nullptr));
166-
std::vector<VkLayerProperties> supported_validation_layers(instance_layer_count);
167-
VK_CHECK(vkEnumerateInstanceLayerProperties(&instance_layer_count, supported_validation_layers.data()));
168-
std::vector<const char *> requested_validation_layers(required_validation_layers);
169148

170-
#if defined(VKB_DEBUG) || defined(VKB_VALIDATION_LAYERS)
171-
requested_validation_layers.push_back("VK_LAYER_KHRONOS_validation");
172-
#endif
149+
std::vector<VkLayerProperties> supported_instance_layers(instance_layer_count);
150+
VK_CHECK(vkEnumerateInstanceLayerProperties(&instance_layer_count, supported_instance_layers.data()));
173151

174-
if (validate_layers(requested_validation_layers, supported_validation_layers))
152+
if (std::any_of(supported_instance_layers.begin(), supported_instance_layers.end(), [&validationLayer](auto const &lp) { return strcmp(lp.layerName, validationLayer) == 0; }))
175153
{
176-
LOGI("Enabled Validation Layers:")
177-
for (const auto &layer : requested_validation_layers)
178-
{
179-
LOGI(" \t{}", layer)
180-
}
154+
requested_instance_layers.push_back(validationLayer);
155+
LOGI("Enabled Validation Layer {}", validationLayer);
181156
}
182157
else
183158
{
184-
throw std::runtime_error("Required validation layers are missing.");
159+
LOGW("Validation Layer {} is not available", validationLayer);
185160
}
161+
#endif
186162

187163
VkApplicationInfo app{VK_STRUCTURE_TYPE_APPLICATION_INFO};
188164
app.pApplicationName = "Full Screen Exclusive";
@@ -193,8 +169,8 @@ void FullScreenExclusive::init_instance(const std::vector<const char *> &require
193169
instance_info.pApplicationInfo = &app;
194170
instance_info.enabledExtensionCount = vkb::to_u32(active_instance_extensions.size());
195171
instance_info.ppEnabledExtensionNames = active_instance_extensions.data();
196-
instance_info.enabledLayerCount = vkb::to_u32(requested_validation_layers.size());
197-
instance_info.ppEnabledLayerNames = requested_validation_layers.data();
172+
instance_info.enabledLayerCount = vkb::to_u32(requested_instance_layers.size());
173+
instance_info.ppEnabledLayerNames = requested_instance_layers.data();
198174

199175
#if defined(VKB_DEBUG) || defined(VKB_VALIDATION_LAYERS)
200176
VkDebugUtilsMessengerCreateInfoEXT debug_utils_create_info = {VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT};

‎samples/extensions/full_screen_exclusive/full_screen_exclusive.h‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
/* Copyright (c) 2023, Holochip Corporation
1+
/* Copyright (c) 2023-2025, Holochip Corporation
22
*
33
* SPDX-License-Identifier: Apache-2.0
44
*
@@ -103,7 +103,6 @@ class FullScreenExclusive : public vkb::Application
103103
void update(float delta_time) override;
104104
bool resize(uint32_t width, uint32_t height) override;
105105
static bool validate_extensions(const std::vector<const char *> &required, const std::vector<VkExtensionProperties> &available);
106-
static bool validate_layers(const std::vector<const char *> &required, const std::vector<VkLayerProperties> &available);
107106
static VkShaderStageFlagBits find_shader_stage(const std::string &ext);
108107
void init_instance(const std::vector<const char *> &required_instance_extensions, const std::vector<const char *> &required_validation_layers);
109108
void init_device(const std::vector<const char *> &required_device_extensions);

‎samples/extensions/shader_debugprintf/shader_debugprintf.cpp‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -49,6 +49,8 @@ ShaderDebugPrintf::ShaderDebugPrintf()
4949
// If layer settings available, use it to configure validation layer for debugPrintfEXT
5050
add_instance_extension(VK_EXT_LAYER_SETTINGS_EXTENSION_NAME, /*optional*/ true);
5151

52+
add_instance_layer("VK_LAYER_KHRONOS_shader_object");
53+
5254
VkLayerSettingEXT layerSetting;
5355
layerSetting.pLayerName = "VK_LAYER_KHRONOS_validation";
5456
layerSetting.pSettingName = "enables";

0 commit comments

Comments
 (0)