claude_code/procedural-3d-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Result (exit) codes for fatal terminations

Browse source
This commit is contained in:
saschawillems 2018-01-21 18:28:17 +01:00
parent 90d7e09890
commit df223f5b9b
29 changed files with 56 additions and 52 deletions
Download patch file Download diff file Expand all files Collapse all files

2
base/VulkanModel.hpp
View file

@ -186,7 +186,7 @@ namespace vks
pScene = Importer.ReadFile(filename.c_str(), flags); pScene = Importer.ReadFile(filename.c_str(), flags);
if (!pScene) { if (!pScene) {
std::string error = Importer.GetErrorString(); std::string error = Importer.GetErrorString();
vks::tools::exitFatal(error + "\n\nThe file may be part of the additional asset pack.\n\nRun \"download_assets.py\" in the repository root to download the latest version.", "Error"); vks::tools::exitFatal(error + "\n\nThe file may be part of the additional asset pack.\n\nRun \"download_assets.py\" in the repository root to download the latest version.", -1);
} }
#endif #endif

15
base/VulkanSwapChain.hpp
View file

@ -136,7 +136,7 @@ public:
#endif #endif
if (err != VK_SUCCESS) { if (err != VK_SUCCESS) {
vks::tools::exitFatal("Could not create surface!", "Fatal error"); vks::tools::exitFatal("Could not create surface!", err);
} }
// Get available queue family properties // Get available queue family properties
@ -194,13 +194,13 @@ public:
// Exit if either a graphics or a presenting queue hasn't been found // Exit if either a graphics or a presenting queue hasn't been found
if (graphicsQueueNodeIndex == UINT32_MAX || presentQueueNodeIndex == UINT32_MAX) if (graphicsQueueNodeIndex == UINT32_MAX || presentQueueNodeIndex == UINT32_MAX)
{ {
vks::tools::exitFatal("Could not find a graphics and/or presenting queue!", "Fatal error"); vks::tools::exitFatal("Could not find a graphics and/or presenting queue!", -1);
} }
// todo : Add support for separate graphics and presenting queue // todo : Add support for separate graphics and presenting queue
if (graphicsQueueNodeIndex != presentQueueNodeIndex) if (graphicsQueueNodeIndex != presentQueueNodeIndex)
{ {
vks::tools::exitFatal("Separate graphics and presenting queues are not supported yet!", "Fatal error"); vks::tools::exitFatal("Separate graphics and presenting queues are not supported yet!", -1);
} }
queueNodeIndex = graphicsQueueNodeIndex; queueNodeIndex = graphicsQueueNodeIndex;
@ -563,7 +563,7 @@ public:
if(!foundMode) if(!foundMode)
{ {
vks::tools::exitFatal("Can't find a display and a display mode!", "Fatal error"); vks::tools::exitFatal("Can't find a display and a display mode!", -1);
return; return;
} }
@ -600,7 +600,7 @@ public:
if(bestPlaneIndex == UINT32_MAX) if(bestPlaneIndex == UINT32_MAX)
{ {
vks::tools::exitFatal("Can't find a plane for displaying!", "Fatal error"); vks::tools::exitFatal("Can't find a plane for displaying!", -1);
return; return;
} }
@ -639,9 +639,8 @@ public:
surfaceInfo.imageExtent.height = height; surfaceInfo.imageExtent.height = height;
VkResult result = vkCreateDisplayPlaneSurfaceKHR(instance, &surfaceInfo, NULL, &surface); VkResult result = vkCreateDisplayPlaneSurfaceKHR(instance, &surfaceInfo, NULL, &surface);
if(result !=VK_SUCCESS) if (result !=VK_SUCCESS) {
{ vks::tools::exitFatal("Failed to create surface!", result);
vks::tools::exitFatal("Failed to create surface!", "Fatal error");
} }
delete[] pDisplays; delete[] pDisplays;

12
base/VulkanTexture.hpp
View file

@ -93,7 +93,7 @@ namespace vks
// So they need to be loaded via the asset manager // So they need to be loaded via the asset manager
AAsset* asset = AAssetManager_open(androidApp->activity->assetManager, filename.c_str(), AASSET_MODE_STREAMING); AAsset* asset = AAssetManager_open(androidApp->activity->assetManager, filename.c_str(), AASSET_MODE_STREAMING);
if (!asset) { if (!asset) {
vks::tools::exitFatal("Could not load texture from " + filename + "\n\nThe file may be part of the additional asset pack.\n\nRun \"download_assets.py\" in the repository root to download the latest version.", "Error"); vks::tools::exitFatal("Could not load texture from " + filename + "\n\nThe file may be part of the additional asset pack.\n\nRun \"download_assets.py\" in the repository root to download the latest version.", -1);
} }
size_t size = AAsset_getLength(asset); size_t size = AAsset_getLength(asset);
assert(size > 0); assert(size > 0);
@ -107,7 +107,7 @@ namespace vks
free(textureData); free(textureData);
#else #else
if (!vks::tools::fileExists(filename)) { if (!vks::tools::fileExists(filename)) {
vks::tools::exitFatal("Could not load texture from " + filename + "\n\nThe file may be part of the additional asset pack.\n\nRun \"download_assets.py\" in the repository root to download the latest version.", "Error"); vks::tools::exitFatal("Could not load texture from " + filename + "\n\nThe file may be part of the additional asset pack.\n\nRun \"download_assets.py\" in the repository root to download the latest version.", -1);
} }
gli::texture2d tex2D(gli::load(filename.c_str())); gli::texture2d tex2D(gli::load(filename.c_str()));
#endif #endif
@ -573,7 +573,7 @@ namespace vks
// So they need to be loaded via the asset manager // So they need to be loaded via the asset manager
AAsset* asset = AAssetManager_open(androidApp->activity->assetManager, filename.c_str(), AASSET_MODE_STREAMING); AAsset* asset = AAssetManager_open(androidApp->activity->assetManager, filename.c_str(), AASSET_MODE_STREAMING);
if (!asset) { if (!asset) {
vks::tools::exitFatal("Could not load texture from " + filename + "\n\nThe file may be part of the additional asset pack.\n\nRun \"download_assets.py\" in the repository root to download the latest version.", "Error"); vks::tools::exitFatal("Could not load texture from " + filename + "\n\nThe file may be part of the additional asset pack.\n\nRun \"download_assets.py\" in the repository root to download the latest version.", -1);
} }
size_t size = AAsset_getLength(asset); size_t size = AAsset_getLength(asset);
assert(size > 0); assert(size > 0);
@ -587,7 +587,7 @@ namespace vks
free(textureData); free(textureData);
#else #else
if (!vks::tools::fileExists(filename)) { if (!vks::tools::fileExists(filename)) {
vks::tools::exitFatal("Could not load texture from " + filename + "\n\nThe file may be part of the additional asset pack.\n\nRun \"download_assets.py\" in the repository root to download the latest version.", "Error"); vks::tools::exitFatal("Could not load texture from " + filename + "\n\nThe file may be part of the additional asset pack.\n\nRun \"download_assets.py\" in the repository root to download the latest version.", -1);
} }
gli::texture2d_array tex2DArray(gli::load(filename)); gli::texture2d_array tex2DArray(gli::load(filename));
#endif #endif
@ -785,7 +785,7 @@ namespace vks
// So they need to be loaded via the asset manager // So they need to be loaded via the asset manager
AAsset* asset = AAssetManager_open(androidApp->activity->assetManager, filename.c_str(), AASSET_MODE_STREAMING); AAsset* asset = AAssetManager_open(androidApp->activity->assetManager, filename.c_str(), AASSET_MODE_STREAMING);
if (!asset) { if (!asset) {
vks::tools::exitFatal("Could not load texture from " + filename + "\n\nThe file may be part of the additional asset pack.\n\nRun \"download_assets.py\" in the repository root to download the latest version.", "Error"); vks::tools::exitFatal("Could not load texture from " + filename + "\n\nThe file may be part of the additional asset pack.\n\nRun \"download_assets.py\" in the repository root to download the latest version.", -1);
} }
size_t size = AAsset_getLength(asset); size_t size = AAsset_getLength(asset);
assert(size > 0); assert(size > 0);
@ -799,7 +799,7 @@ namespace vks
free(textureData); free(textureData);
#else #else
if (!vks::tools::fileExists(filename)) { if (!vks::tools::fileExists(filename)) {
vks::tools::exitFatal("Could not load texture from " + filename + "\n\nThe file may be part of the additional asset pack.\n\nRun \"download_assets.py\" in the repository root to download the latest version.", "Error"); vks::tools::exitFatal("Could not load texture from " + filename + "\n\nThe file may be part of the additional asset pack.\n\nRun \"download_assets.py\" in the repository root to download the latest version.", -1);
} }
gli::texture_cube texCube(gli::load(filename)); gli::texture_cube texCube(gli::load(filename));
#endif #endif

11
base/VulkanTools.cpp
View file

@ -262,17 +262,22 @@ namespace vks
1, &imageMemoryBarrier); 1, &imageMemoryBarrier);
} }
void exitFatal(std::string message, std::string caption, bool silent) void exitFatal(std::string message, int32_t exitCode)
{ {
#if defined(_WIN32) #if defined(_WIN32)
if (!errorModeSilent) { if (!errorModeSilent) {
MessageBox(NULL, message.c_str(), caption.c_str(), MB_OK | MB_ICONERROR); MessageBox(NULL, message.c_str(), NULL, MB_OK | MB_ICONERROR);
} }
#elif defined(__ANDROID__) #elif defined(__ANDROID__)
LOGE("Fatal error: %s", message.c_str()); LOGE("Fatal error: %s", message.c_str());
#endif #endif
std::cerr << message << "\n"; std::cerr << message << "\n";
exit(1); exit(exitCode);
}
void exitFatal(std::string message, VkResult resultCode)
{
exitFatal(message, (int32_t)resultCode);
} }
std::string readTextFile(const char *fileName) std::string readTextFile(const char *fileName)

3
base/VulkanTools.h
View file

@ -114,7 +114,8 @@ namespace vks
VkImageSubresourceRange subresourceRange); VkImageSubresourceRange subresourceRange);
// Display error message and exit on fatal error // Display error message and exit on fatal error
void exitFatal(std::string message, std::string caption, bool silent = false); void exitFatal(std::string message, int32_t exitCode);
void exitFatal(std::string message, VkResult resultCode);
// Load a SPIR-V shader (binary) // Load a SPIR-V shader (binary)
#if defined(__ANDROID__) #if defined(__ANDROID__)

6
base/vulkanexamplebase.cpp
View file

@ -831,7 +831,7 @@ void VulkanExampleBase::initVulkan()
// Vulkan instance // Vulkan instance
err = createInstance(settings.validation); err = createInstance(settings.validation);
if (err) { if (err) {
vks::tools::exitFatal("Could not create Vulkan instance : \n" + vks::tools::errorString(err), "Fatal error", !benchmark.active); vks::tools::exitFatal("Could not create Vulkan instance : \n" + vks::tools::errorString(err), err);
} }
#if defined(VK_USE_PLATFORM_ANDROID_KHR) #if defined(VK_USE_PLATFORM_ANDROID_KHR)
@ -857,7 +857,7 @@ void VulkanExampleBase::initVulkan()
std::vector<VkPhysicalDevice> physicalDevices(gpuCount); std::vector<VkPhysicalDevice> physicalDevices(gpuCount);
err = vkEnumeratePhysicalDevices(instance, &gpuCount, physicalDevices.data()); err = vkEnumeratePhysicalDevices(instance, &gpuCount, physicalDevices.data());
if (err) { if (err) {
vks::tools::exitFatal("Could not enumerate physical devices : \n" + vks::tools::errorString(err), "Fatal error", !benchmark.active); vks::tools::exitFatal("Could not enumerate physical devices : \n" + vks::tools::errorString(err), err);
} }
// GPU selection // GPU selection
@ -932,7 +932,7 @@ void VulkanExampleBase::initVulkan()
vulkanDevice = new vks::VulkanDevice(physicalDevice); vulkanDevice = new vks::VulkanDevice(physicalDevice);
VkResult res = vulkanDevice->createLogicalDevice(enabledFeatures, enabledExtensions); VkResult res = vulkanDevice->createLogicalDevice(enabledFeatures, enabledExtensions);
if (res != VK_SUCCESS) { if (res != VK_SUCCESS) {
vks::tools::exitFatal("Could not create Vulkan device: \n" + vks::tools::errorString(res), "Fatal error", benchmark.active); vks::tools::exitFatal("Could not create Vulkan device: \n" + vks::tools::errorString(res), res);
} }
device = vulkanDevice->logicalDevice; device = vulkanDevice->logicalDevice;

2
examples/deferred/deferred.cpp
View file

@ -520,7 +520,7 @@ public:
texFormat = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK; texFormat = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK;
} }
else { else {
vks::tools::exitFatal("Device does not support any compressed texture format!", "Error"); vks::tools::exitFatal("Device does not support any compressed texture format!", VK_ERROR_FEATURE_NOT_PRESENT);
} }
textures.model.colorMap.loadFromFile(getAssetPath() + "models/armor/color" + texFormatSuffix + ".ktx", texFormat, vulkanDevice, queue); textures.model.colorMap.loadFromFile(getAssetPath() + "models/armor/color" + texFormatSuffix + ".ktx", texFormat, vulkanDevice, queue);

2
examples/deferredmultisampling/deferredmultisampling.cpp
View file

@ -600,7 +600,7 @@ public:
texFormat = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK; texFormat = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK;
} }
else { else {
vks::tools::exitFatal("Device does not support any compressed texture format!", "Error"); vks::tools::exitFatal("Device does not support any compressed texture format!", VK_ERROR_FEATURE_NOT_PRESENT);
} }
textures.model.colorMap.loadFromFile(getAssetPath() + "models/armor/color" + texFormatSuffix + ".ktx", texFormat, vulkanDevice, queue); textures.model.colorMap.loadFromFile(getAssetPath() + "models/armor/color" + texFormatSuffix + ".ktx", texFormat, vulkanDevice, queue);

4
examples/deferredshadows/deferredshadows.cpp
View file

@ -238,7 +238,7 @@ public:
enabledFeatures.geometryShader = VK_TRUE; enabledFeatures.geometryShader = VK_TRUE;
} }
else { else {
vks::tools::exitFatal("Selected GPU does not support geometry shaders!", "Feature not supported"); vks::tools::exitFatal("Selected GPU does not support geometry shaders!", VK_ERROR_FEATURE_NOT_PRESENT);
} }
// Enable anisotropic filtering if supported // Enable anisotropic filtering if supported
if (deviceFeatures.samplerAnisotropy) { if (deviceFeatures.samplerAnisotropy) {
@ -458,7 +458,7 @@ public:
texFormat = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK; texFormat = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK;
} }
else { else {
vks::tools::exitFatal("Device does not support any compressed texture format!", "Error"); vks::tools::exitFatal("Device does not support any compressed texture format!", VK_ERROR_FEATURE_NOT_PRESENT);
} }
textures.model.colorMap.loadFromFile(getAssetPath() + "models/armor/color" + texFormatSuffix + ".ktx", texFormat, vulkanDevice, queue); textures.model.colorMap.loadFromFile(getAssetPath() + "models/armor/color" + texFormatSuffix + ".ktx", texFormat, vulkanDevice, queue);

4
examples/displacement/displacement.cpp
View file

@ -113,7 +113,7 @@ public:
enabledFeatures.tessellationShader = VK_TRUE; enabledFeatures.tessellationShader = VK_TRUE;
} }
else { else {
vks::tools::exitFatal("Selected GPU does not support tessellation shaders!", "Feature not supported"); vks::tools::exitFatal("Selected GPU does not support tessellation shaders!", VK_ERROR_FEATURE_NOT_PRESENT);
} }
// Fill mode non solid is required for wireframe display // Fill mode non solid is required for wireframe display
if (deviceFeatures.fillModeNonSolid) { if (deviceFeatures.fillModeNonSolid) {
@ -138,7 +138,7 @@ public:
textures.colorHeightMap.loadFromFile(getAssetPath() + "textures/stonefloor03_color_etc2_unorm.ktx", VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, vulkanDevice, queue); textures.colorHeightMap.loadFromFile(getAssetPath() + "textures/stonefloor03_color_etc2_unorm.ktx", VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, vulkanDevice, queue);
} }
else { else {
vks::tools::exitFatal("Device does not support any compressed texture format!", "Error"); vks::tools::exitFatal("Device does not support any compressed texture format!", VK_ERROR_FEATURE_NOT_PRESENT);
} }
} }

2
examples/geometryshader/geometryshader.cpp
View file

@ -103,7 +103,7 @@ public:
enabledFeatures.geometryShader = VK_TRUE; enabledFeatures.geometryShader = VK_TRUE;
} }
else { else {
vks::tools::exitFatal("Selected GPU does not support geometry shaders!", "Feature not supported"); vks::tools::exitFatal("Selected GPU does not support geometry shaders!", VK_ERROR_FEATURE_NOT_PRESENT);
} }
} }

2
examples/indirectdraw/indirectdraw.cpp
View file

@ -270,7 +270,7 @@ public:
texFormat = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK; texFormat = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK;
} }
else { else {
vks::tools::exitFatal("Device does not support any compressed texture format!", "Error"); vks::tools::exitFatal("Device does not support any compressed texture format!", VK_ERROR_FEATURE_NOT_PRESENT);
} }
textures.plants.loadFromFile(getAssetPath() + "textures/texturearray_plants" + texFormatSuffix + ".ktx", texFormat, vulkanDevice, queue); textures.plants.loadFromFile(getAssetPath() + "textures/texturearray_plants" + texFormatSuffix + ".ktx", texFormat, vulkanDevice, queue);

2
examples/instancing/instancing.cpp
View file

@ -221,7 +221,7 @@ public:
texFormat = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK; texFormat = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK;
} }
else { else {
vks::tools::exitFatal("Device does not support any compressed texture format!", "Error"); vks::tools::exitFatal("Device does not support any compressed texture format!", VK_ERROR_FEATURE_NOT_PRESENT);
} }
textures.rocks.loadFromFile(getAssetPath() + "textures/texturearray_rocks" + texFormatSuffix + ".ktx", texFormat, vulkanDevice, queue); textures.rocks.loadFromFile(getAssetPath() + "textures/texturearray_rocks" + texFormatSuffix + ".ktx", texFormat, vulkanDevice, queue);

2
examples/mesh/mesh.cpp
View file

@ -364,7 +364,7 @@ public:
textures.colorMap.loadFromFile(getAssetPath() + "models/voyager/voyager_etc2_unorm.ktx", VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, vulkanDevice, queue); textures.colorMap.loadFromFile(getAssetPath() + "models/voyager/voyager_etc2_unorm.ktx", VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, vulkanDevice, queue);
} }
else { else {
vks::tools::exitFatal("Device does not support any compressed texture format!", "Error"); vks::tools::exitFatal("Device does not support any compressed texture format!", VK_ERROR_FEATURE_NOT_PRESENT);
} }
} }

2
examples/multisampling/multisampling.cpp
View file

@ -443,7 +443,7 @@ public:
textures.colorMap.loadFromFile(getAssetPath() + "models/voyager/voyager_etc2_unorm.ktx", VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, vulkanDevice, queue); textures.colorMap.loadFromFile(getAssetPath() + "models/voyager/voyager_etc2_unorm.ktx", VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, vulkanDevice, queue);
} }
else { else {
vks::tools::exitFatal("Device does not support any compressed texture format!", "Error"); vks::tools::exitFatal("Device does not support any compressed texture format!", VK_ERROR_FEATURE_NOT_PRESENT);
} }
} }

2
examples/offscreen/offscreen.cpp
View file

@ -483,7 +483,7 @@ public:
textures.colorMap.loadFromFile(getAssetPath() + "textures/darkmetal_etc2_unorm.ktx", VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, vulkanDevice, queue); textures.colorMap.loadFromFile(getAssetPath() + "textures/darkmetal_etc2_unorm.ktx", VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, vulkanDevice, queue);
} }
else { else {
vks::tools::exitFatal("Device does not support any compressed texture format!", "Error"); vks::tools::exitFatal("Device does not support any compressed texture format!", VK_ERROR_FEATURE_NOT_PRESENT);
} }
} }

2
examples/parallaxmapping/parallaxmapping.cpp
View file

@ -132,7 +132,7 @@ public:
textures.colorMap.loadFromFile(getAssetPath() + "textures/rocks_color_etc2_unorm.ktx", VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, vulkanDevice, queue); textures.colorMap.loadFromFile(getAssetPath() + "textures/rocks_color_etc2_unorm.ktx", VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, vulkanDevice, queue);
} }
else { else {
vks::tools::exitFatal("Device does not support any compressed texture format!", "Error"); vks::tools::exitFatal("Device does not support any compressed texture format!", VK_ERROR_FEATURE_NOT_PRESENT);
} }
} }

2
examples/particlefire/particlefire.cpp
View file

@ -347,7 +347,7 @@ public:
texFormat = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK; texFormat = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK;
} }
else { else {
vks::tools::exitFatal("Device does not support any compressed texture format!", "Error"); vks::tools::exitFatal("Device does not support any compressed texture format!", VK_ERROR_FEATURE_NOT_PRESENT);
} }
// Particles // Particles

2
examples/pipelinestatistics/pipelinestatistics.cpp
View file

@ -102,7 +102,7 @@ public:
enabledFeatures.pipelineStatisticsQuery = VK_TRUE; enabledFeatures.pipelineStatisticsQuery = VK_TRUE;
} }
else { else {
vks::tools::exitFatal("Selected GPU does not support pipeline statistics!", "Feature not supported"); vks::tools::exitFatal("Selected GPU does not support pipeline statistics!", VK_ERROR_FEATURE_NOT_PRESENT);
} }
if (deviceFeatures.fillModeNonSolid) { if (deviceFeatures.fillModeNonSolid) {
enabledFeatures.fillModeNonSolid = VK_TRUE; enabledFeatures.fillModeNonSolid = VK_TRUE;

2
examples/scenerendering/scenerendering.cpp
View file

@ -164,7 +164,7 @@ private:
texFormat = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK; texFormat = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK;
} }
else { else {
vks::tools::exitFatal("Device does not support any compressed texture format!", "Error"); vks::tools::exitFatal("Device does not support any compressed texture format!", VK_ERROR_FEATURE_NOT_PRESENT);
} }
aiString texturefile; aiString texturefile;

2
examples/skeletalanimation/skeletalanimation.cpp
View file

@ -683,7 +683,7 @@ public:
texFormat = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK; texFormat = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK;
} }
else { else {
vks::tools::exitFatal("Device does not support any compressed texture format!", "Error"); vks::tools::exitFatal("Device does not support any compressed texture format!", VK_ERROR_FEATURE_NOT_PRESENT);
} }
textures.colorMap.loadFromFile(getAssetPath() + "textures/goblin" + texFormatSuffix + ".ktx", texFormat, vulkanDevice, queue); textures.colorMap.loadFromFile(getAssetPath() + "textures/goblin" + texFormatSuffix + ".ktx", texFormat, vulkanDevice, queue);

2
examples/subpasses/subpasses.cpp
View file

@ -548,7 +548,7 @@ public:
textures.glass.loadFromFile(getAssetPath() + "textures/colored_glass_etc2_unorm.ktx", VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, vulkanDevice, queue); textures.glass.loadFromFile(getAssetPath() + "textures/colored_glass_etc2_unorm.ktx", VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, vulkanDevice, queue);
} }
else { else {
vks::tools::exitFatal("Device does not support any compressed texture format!", "Error"); vks::tools::exitFatal("Device does not support any compressed texture format!", VK_ERROR_FEATURE_NOT_PRESENT);
} }
} }

4
examples/terraintessellation/terraintessellation.cpp
View file

@ -160,7 +160,7 @@ public:
enabledFeatures.tessellationShader = VK_TRUE; enabledFeatures.tessellationShader = VK_TRUE;
} }
else { else {
vks::tools::exitFatal("Selected GPU does not support tessellation shaders!", "Feature not supported"); vks::tools::exitFatal("Selected GPU does not support tessellation shaders!", VK_ERROR_FEATURE_NOT_PRESENT);
} }
// Fill mode non solid is required for wireframe display // Fill mode non solid is required for wireframe display
if (deviceFeatures.fillModeNonSolid) { if (deviceFeatures.fillModeNonSolid) {
@ -255,7 +255,7 @@ public:
texFormat = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK; texFormat = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK;
} }
else { else {
vks::tools::exitFatal("Device does not support any compressed texture format!", "Error"); vks::tools::exitFatal("Device does not support any compressed texture format!", VK_ERROR_FEATURE_NOT_PRESENT);
} }
textures.skySphere.loadFromFile(getAssetPath() + "textures/skysphere" + texFormatSuffix + ".ktx", texFormat, vulkanDevice, queue); textures.skySphere.loadFromFile(getAssetPath() + "textures/skysphere" + texFormatSuffix + ".ktx", texFormat, vulkanDevice, queue);

4
examples/tessellation/tessellation.cpp
View file

@ -122,7 +122,7 @@ public:
enabledFeatures.tessellationShader = VK_TRUE; enabledFeatures.tessellationShader = VK_TRUE;
} }
else { else {
vks::tools::exitFatal("Selected GPU does not support tessellation shaders!", "Feature not supported"); vks::tools::exitFatal("Selected GPU does not support tessellation shaders!", VK_ERROR_FEATURE_NOT_PRESENT);
} }
// Fill mode non solid is required for wireframe display // Fill mode non solid is required for wireframe display
if (deviceFeatures.fillModeNonSolid) { if (deviceFeatures.fillModeNonSolid) {
@ -203,7 +203,7 @@ public:
textures.colorMap.loadFromFile(getAssetPath() + "textures/deer_etc2_unorm.ktx", VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, vulkanDevice, queue); textures.colorMap.loadFromFile(getAssetPath() + "textures/deer_etc2_unorm.ktx", VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, vulkanDevice, queue);
} }
else { else {
vks::tools::exitFatal("Device does not support any compressed texture format!", "Error"); vks::tools::exitFatal("Device does not support any compressed texture format!", VK_ERROR_FEATURE_NOT_PRESENT);
} }
} }

2
examples/textoverlay/textoverlay.cpp
View file

@ -884,7 +884,7 @@ public:
texFormat = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK; texFormat = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK;
} }
else { else {
vks::tools::exitFatal("Device does not support any compressed texture format!", "Error"); vks::tools::exitFatal("Device does not support any compressed texture format!", VK_ERROR_FEATURE_NOT_PRESENT);
} }
textures.background.loadFromFile(getAssetPath() + "textures/skysphere" + texFormatSuffix + ".ktx", texFormat, vulkanDevice, queue); textures.background.loadFromFile(getAssetPath() + "textures/skysphere" + texFormatSuffix + ".ktx", texFormat, vulkanDevice, queue);

2
examples/texturearray/texturearray.cpp
View file

@ -300,7 +300,7 @@ public:
format = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK; format = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK;
} }
else { else {
vks::tools::exitFatal("Device does not support any compressed texture format!", "Error"); vks::tools::exitFatal("Device does not support any compressed texture format!", VK_ERROR_FEATURE_NOT_PRESENT);
} }
loadTextureArray(getAssetPath() + "textures/" + filename, format); loadTextureArray(getAssetPath() + "textures/" + filename, format);
} }

2
examples/texturecubemap/texturecubemap.cpp
View file

@ -318,7 +318,7 @@ public:
format = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK; format = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK;
} }
else { else {
vks::tools::exitFatal("Device does not support any compressed texture format!", "Error"); vks::tools::exitFatal("Device does not support any compressed texture format!", VK_ERROR_FEATURE_NOT_PRESENT);
} }
loadCubemap(getAssetPath() + "textures/" + filename, format, false); loadCubemap(getAssetPath() + "textures/" + filename, format, false);

5
examples/texturesparseresidency/texturesparseresidency.cpp
View file

@ -912,9 +912,8 @@ public:
{ {
VulkanExampleBase::prepare(); VulkanExampleBase::prepare();
// Check if the GPU supports sparse residency for 2D images // Check if the GPU supports sparse residency for 2D images
if (!vulkanDevice->features.sparseResidencyImage2D) if (!vulkanDevice->features.sparseResidencyImage2D) {
{ vks::tools::exitFatal("Device does not support sparse residency for 2D images!", VK_ERROR_FEATURE_NOT_PRESENT);
vks::tools::exitFatal("Device does not support sparse residency for 2D images!", "Feature not supported");
} }
loadAssets(); loadAssets();
generateTerrain(); generateTerrain();

4
examples/viewportarray/viewportarray.cpp
View file

@ -85,14 +85,14 @@ public:
enabledFeatures.geometryShader = VK_TRUE; enabledFeatures.geometryShader = VK_TRUE;
} }
else { else {
vks::tools::exitFatal("Selected GPU does not support geometry shaders!", "Feature not supported"); vks::tools::exitFatal("Selected GPU does not support geometry shaders!", VK_ERROR_FEATURE_NOT_PRESENT);
} }
// Multiple viewports must be supported // Multiple viewports must be supported
if (deviceFeatures.multiViewport) { if (deviceFeatures.multiViewport) {
enabledFeatures.multiViewport = VK_TRUE; enabledFeatures.multiViewport = VK_TRUE;
} }
else { else {
vks::tools::exitFatal("Selected GPU does not support multi viewports!", "Feature not supported"); vks::tools::exitFatal("Selected GPU does not support multi viewports!", VK_ERROR_FEATURE_NOT_PRESENT);
} }
} }