Google Git
Sign in
chromium/external/github.com/KhronosGroup/Vulkan-ValidationLayers/HEAD/./layers/vulkan/generated/device_features.cpp
blob: 7c9350ef81e9f8f8bcab230eb6de84bd4a61884c [file]
// *** THIS FILE IS GENERATED - DO NOT EDIT ***
// See device_features_generator.py for modifications
/***************************************************************************
*
* Copyright (c) 2023-2026 Google Inc.
* Copyright (c) 2023-2026 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.
****************************************************************************/
// NOLINTBEGIN
#include "generated/device_features.h"
#include "generated/vk_api_version.h"
#include "generated/vk_extension_helper.h"
#include <vulkan/utility/vk_struct_helper.hpp>
void GetEnabledDeviceFeatures(const VkDeviceCreateInfo* pCreateInfo, DeviceFeatures* features, const APIVersion& api_version) {
// Initialize all to false
*features = {};
// handle VkPhysicalDeviceFeatures specially as it is not part of the pNext chain,
// and when it is (through VkPhysicalDeviceFeatures2), it requires an extra indirection.
const VkPhysicalDeviceFeatures* core_features = pCreateInfo->pEnabledFeatures;
if (core_features == nullptr) {
const VkPhysicalDeviceFeatures2* features2 = vku::FindStructInPNextChain<VkPhysicalDeviceFeatures2>(pCreateInfo->pNext);
if (features2 != nullptr) {
core_features = &features2->features;
}
}
if (core_features != nullptr) {
features->robustBufferAccess = core_features->robustBufferAccess == VK_TRUE;
features->fullDrawIndexUint32 = core_features->fullDrawIndexUint32 == VK_TRUE;
features->imageCubeArray = core_features->imageCubeArray == VK_TRUE;
features->independentBlend = core_features->independentBlend == VK_TRUE;
features->geometryShader = core_features->geometryShader == VK_TRUE;
features->tessellationShader = core_features->tessellationShader == VK_TRUE;
features->sampleRateShading = core_features->sampleRateShading == VK_TRUE;
features->dualSrcBlend = core_features->dualSrcBlend == VK_TRUE;
features->logicOp = core_features->logicOp == VK_TRUE;
features->multiDrawIndirect = core_features->multiDrawIndirect == VK_TRUE;
features->drawIndirectFirstInstance = core_features->drawIndirectFirstInstance == VK_TRUE;
features->depthClamp = core_features->depthClamp == VK_TRUE;
features->depthBiasClamp = core_features->depthBiasClamp == VK_TRUE;
features->fillModeNonSolid = core_features->fillModeNonSolid == VK_TRUE;
features->depthBounds = core_features->depthBounds == VK_TRUE;
features->wideLines = core_features->wideLines == VK_TRUE;
features->largePoints = core_features->largePoints == VK_TRUE;
features->alphaToOne = core_features->alphaToOne == VK_TRUE;
features->multiViewport = core_features->multiViewport == VK_TRUE;
features->samplerAnisotropy = core_features->samplerAnisotropy == VK_TRUE;
features->textureCompressionETC2 = core_features->textureCompressionETC2 == VK_TRUE;
features->textureCompressionASTC_LDR = core_features->textureCompressionASTC_LDR == VK_TRUE;
features->textureCompressionBC = core_features->textureCompressionBC == VK_TRUE;
features->occlusionQueryPrecise = core_features->occlusionQueryPrecise == VK_TRUE;
features->pipelineStatisticsQuery = core_features->pipelineStatisticsQuery == VK_TRUE;
features->vertexPipelineStoresAndAtomics = core_features->vertexPipelineStoresAndAtomics == VK_TRUE;
features->fragmentStoresAndAtomics = core_features->fragmentStoresAndAtomics == VK_TRUE;
features->shaderTessellationAndGeometryPointSize = core_features->shaderTessellationAndGeometryPointSize == VK_TRUE;
features->shaderImageGatherExtended = core_features->shaderImageGatherExtended == VK_TRUE;
features->shaderStorageImageExtendedFormats = core_features->shaderStorageImageExtendedFormats == VK_TRUE;
features->shaderStorageImageMultisample = core_features->shaderStorageImageMultisample == VK_TRUE;
features->shaderStorageImageReadWithoutFormat = core_features->shaderStorageImageReadWithoutFormat == VK_TRUE;
features->shaderStorageImageWriteWithoutFormat = core_features->shaderStorageImageWriteWithoutFormat == VK_TRUE;
features->shaderUniformBufferArrayDynamicIndexing = core_features->shaderUniformBufferArrayDynamicIndexing == VK_TRUE;
features->shaderSampledImageArrayDynamicIndexing = core_features->shaderSampledImageArrayDynamicIndexing == VK_TRUE;
features->shaderStorageBufferArrayDynamicIndexing = core_features->shaderStorageBufferArrayDynamicIndexing == VK_TRUE;
features->shaderStorageImageArrayDynamicIndexing = core_features->shaderStorageImageArrayDynamicIndexing == VK_TRUE;
features->shaderClipDistance = core_features->shaderClipDistance == VK_TRUE;
features->shaderCullDistance = core_features->shaderCullDistance == VK_TRUE;
features->shaderFloat64 = core_features->shaderFloat64 == VK_TRUE;
features->shaderInt64 = core_features->shaderInt64 == VK_TRUE;
features->shaderInt16 = core_features->shaderInt16 == VK_TRUE;
features->shaderResourceResidency = core_features->shaderResourceResidency == VK_TRUE;
features->shaderResourceMinLod = core_features->shaderResourceMinLod == VK_TRUE;
features->sparseBinding = core_features->sparseBinding == VK_TRUE;
features->sparseResidencyBuffer = core_features->sparseResidencyBuffer == VK_TRUE;
features->sparseResidencyImage2D = core_features->sparseResidencyImage2D == VK_TRUE;
features->sparseResidencyImage3D = core_features->sparseResidencyImage3D == VK_TRUE;
features->sparseResidency2Samples = core_features->sparseResidency2Samples == VK_TRUE;
features->sparseResidency4Samples = core_features->sparseResidency4Samples == VK_TRUE;
features->sparseResidency8Samples = core_features->sparseResidency8Samples == VK_TRUE;
features->sparseResidency16Samples = core_features->sparseResidency16Samples == VK_TRUE;
features->sparseResidencyAliased = core_features->sparseResidencyAliased == VK_TRUE;
features->variableMultisampleRate = core_features->variableMultisampleRate == VK_TRUE;
features->inheritedQueries = core_features->inheritedQueries == VK_TRUE;
}
for (const VkBaseInStructure* pNext = reinterpret_cast<const VkBaseInStructure*>(pCreateInfo->pNext); pNext != nullptr;
pNext = pNext->pNext) {
switch (pNext->sType) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: {
const VkPhysicalDeviceProtectedMemoryFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(pNext);
features->protectedMemory |= enabled->protectedMemory == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: {
const VkPhysicalDevice16BitStorageFeatures* enabled =
reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(pNext);
features->storageBuffer16BitAccess |= enabled->storageBuffer16BitAccess == VK_TRUE;
features->uniformAndStorageBuffer16BitAccess |= enabled->uniformAndStorageBuffer16BitAccess == VK_TRUE;
features->storagePushConstant16 |= enabled->storagePushConstant16 == VK_TRUE;
features->storageInputOutput16 |= enabled->storageInputOutput16 == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: {
const VkPhysicalDeviceVariablePointersFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>(pNext);
features->variablePointersStorageBuffer |= enabled->variablePointersStorageBuffer == VK_TRUE;
features->variablePointers |= enabled->variablePointers == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: {
const VkPhysicalDeviceSamplerYcbcrConversionFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(pNext);
features->samplerYcbcrConversion |= enabled->samplerYcbcrConversion == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: {
const VkPhysicalDeviceMultiviewFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(pNext);
features->multiview |= enabled->multiview == VK_TRUE;
features->multiviewGeometryShader |= enabled->multiviewGeometryShader == VK_TRUE;
features->multiviewTessellationShader |= enabled->multiviewTessellationShader == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: {
const VkPhysicalDeviceShaderDrawParametersFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures*>(pNext);
features->shaderDrawParameters |= enabled->shaderDrawParameters == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: {
const VkPhysicalDeviceVulkan11Features* enabled = reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>(pNext);
features->storageBuffer16BitAccess |= enabled->storageBuffer16BitAccess == VK_TRUE;
features->uniformAndStorageBuffer16BitAccess |= enabled->uniformAndStorageBuffer16BitAccess == VK_TRUE;
features->storagePushConstant16 |= enabled->storagePushConstant16 == VK_TRUE;
features->storageInputOutput16 |= enabled->storageInputOutput16 == VK_TRUE;
features->multiview |= enabled->multiview == VK_TRUE;
features->multiviewGeometryShader |= enabled->multiviewGeometryShader == VK_TRUE;
features->multiviewTessellationShader |= enabled->multiviewTessellationShader == VK_TRUE;
features->variablePointersStorageBuffer |= enabled->variablePointersStorageBuffer == VK_TRUE;
features->variablePointers |= enabled->variablePointers == VK_TRUE;
features->protectedMemory |= enabled->protectedMemory == VK_TRUE;
features->samplerYcbcrConversion |= enabled->samplerYcbcrConversion == VK_TRUE;
features->shaderDrawParameters |= enabled->shaderDrawParameters == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: {
const VkPhysicalDeviceVulkan12Features* enabled = reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>(pNext);
features->samplerMirrorClampToEdge |= enabled->samplerMirrorClampToEdge == VK_TRUE;
features->drawIndirectCount |= enabled->drawIndirectCount == VK_TRUE;
features->storageBuffer8BitAccess |= enabled->storageBuffer8BitAccess == VK_TRUE;
features->uniformAndStorageBuffer8BitAccess |= enabled->uniformAndStorageBuffer8BitAccess == VK_TRUE;
features->storagePushConstant8 |= enabled->storagePushConstant8 == VK_TRUE;
features->shaderBufferInt64Atomics |= enabled->shaderBufferInt64Atomics == VK_TRUE;
features->shaderSharedInt64Atomics |= enabled->shaderSharedInt64Atomics == VK_TRUE;
features->shaderFloat16 |= enabled->shaderFloat16 == VK_TRUE;
features->shaderInt8 |= enabled->shaderInt8 == VK_TRUE;
features->descriptorIndexing |= enabled->descriptorIndexing == VK_TRUE;
features->shaderInputAttachmentArrayDynamicIndexing |=
enabled->shaderInputAttachmentArrayDynamicIndexing == VK_TRUE;
features->shaderUniformTexelBufferArrayDynamicIndexing |=
enabled->shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE;
features->shaderStorageTexelBufferArrayDynamicIndexing |=
enabled->shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE;
features->shaderUniformBufferArrayNonUniformIndexing |=
enabled->shaderUniformBufferArrayNonUniformIndexing == VK_TRUE;
features->shaderSampledImageArrayNonUniformIndexing |=
enabled->shaderSampledImageArrayNonUniformIndexing == VK_TRUE;
features->shaderStorageBufferArrayNonUniformIndexing |=
enabled->shaderStorageBufferArrayNonUniformIndexing == VK_TRUE;
features->shaderStorageImageArrayNonUniformIndexing |=
enabled->shaderStorageImageArrayNonUniformIndexing == VK_TRUE;
features->shaderInputAttachmentArrayNonUniformIndexing |=
enabled->shaderInputAttachmentArrayNonUniformIndexing == VK_TRUE;
features->shaderUniformTexelBufferArrayNonUniformIndexing |=
enabled->shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE;
features->shaderStorageTexelBufferArrayNonUniformIndexing |=
enabled->shaderStorageTexelBufferArrayNonUniformIndexing == VK_TRUE;
features->descriptorBindingUniformBufferUpdateAfterBind |=
enabled->descriptorBindingUniformBufferUpdateAfterBind == VK_TRUE;
features->descriptorBindingSampledImageUpdateAfterBind |=
enabled->descriptorBindingSampledImageUpdateAfterBind == VK_TRUE;
features->descriptorBindingStorageImageUpdateAfterBind |=
enabled->descriptorBindingStorageImageUpdateAfterBind == VK_TRUE;
features->descriptorBindingStorageBufferUpdateAfterBind |=
enabled->descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE;
features->descriptorBindingUniformTexelBufferUpdateAfterBind |=
enabled->descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE;
features->descriptorBindingStorageTexelBufferUpdateAfterBind |=
enabled->descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE;
features->descriptorBindingUpdateUnusedWhilePending |=
enabled->descriptorBindingUpdateUnusedWhilePending == VK_TRUE;
features->descriptorBindingPartiallyBound |= enabled->descriptorBindingPartiallyBound == VK_TRUE;
features->descriptorBindingVariableDescriptorCount |= enabled->descriptorBindingVariableDescriptorCount == VK_TRUE;
features->runtimeDescriptorArray |= enabled->runtimeDescriptorArray == VK_TRUE;
features->samplerFilterMinmax |= enabled->samplerFilterMinmax == VK_TRUE;
features->scalarBlockLayout |= enabled->scalarBlockLayout == VK_TRUE;
features->imagelessFramebuffer |= enabled->imagelessFramebuffer == VK_TRUE;
features->uniformBufferStandardLayout |= enabled->uniformBufferStandardLayout == VK_TRUE;
features->shaderSubgroupExtendedTypes |= enabled->shaderSubgroupExtendedTypes == VK_TRUE;
features->separateDepthStencilLayouts |= enabled->separateDepthStencilLayouts == VK_TRUE;
features->hostQueryReset |= enabled->hostQueryReset == VK_TRUE;
features->timelineSemaphore |= enabled->timelineSemaphore == VK_TRUE;
features->bufferDeviceAddress |= enabled->bufferDeviceAddress == VK_TRUE;
features->bufferDeviceAddressCaptureReplay |= enabled->bufferDeviceAddressCaptureReplay == VK_TRUE;
features->bufferDeviceAddressMultiDevice |= enabled->bufferDeviceAddressMultiDevice == VK_TRUE;
features->vulkanMemoryModel |= enabled->vulkanMemoryModel == VK_TRUE;
features->vulkanMemoryModelDeviceScope |= enabled->vulkanMemoryModelDeviceScope == VK_TRUE;
features->vulkanMemoryModelAvailabilityVisibilityChains |=
enabled->vulkanMemoryModelAvailabilityVisibilityChains == VK_TRUE;
features->shaderOutputViewportIndex |= enabled->shaderOutputViewportIndex == VK_TRUE;
features->shaderOutputLayer |= enabled->shaderOutputLayer == VK_TRUE;
features->subgroupBroadcastDynamicId |= enabled->subgroupBroadcastDynamicId == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: {
const VkPhysicalDeviceVulkanMemoryModelFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>(pNext);
features->vulkanMemoryModel |= enabled->vulkanMemoryModel == VK_TRUE;
features->vulkanMemoryModelDeviceScope |= enabled->vulkanMemoryModelDeviceScope == VK_TRUE;
features->vulkanMemoryModelAvailabilityVisibilityChains |=
enabled->vulkanMemoryModelAvailabilityVisibilityChains == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: {
const VkPhysicalDeviceHostQueryResetFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>(pNext);
features->hostQueryReset |= enabled->hostQueryReset == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: {
const VkPhysicalDeviceTimelineSemaphoreFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>(pNext);
features->timelineSemaphore |= enabled->timelineSemaphore == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: {
const VkPhysicalDeviceBufferDeviceAddressFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>(pNext);
features->bufferDeviceAddress |= enabled->bufferDeviceAddress == VK_TRUE;
features->bufferDeviceAddressCaptureReplay |= enabled->bufferDeviceAddressCaptureReplay == VK_TRUE;
features->bufferDeviceAddressMultiDevice |= enabled->bufferDeviceAddressMultiDevice == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: {
const VkPhysicalDevice8BitStorageFeatures* enabled =
reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>(pNext);
features->storageBuffer8BitAccess |= enabled->storageBuffer8BitAccess == VK_TRUE;
features->uniformAndStorageBuffer8BitAccess |= enabled->uniformAndStorageBuffer8BitAccess == VK_TRUE;
features->storagePushConstant8 |= enabled->storagePushConstant8 == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: {
const VkPhysicalDeviceShaderAtomicInt64Features* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>(pNext);
features->shaderBufferInt64Atomics |= enabled->shaderBufferInt64Atomics == VK_TRUE;
features->shaderSharedInt64Atomics |= enabled->shaderSharedInt64Atomics == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: {
const VkPhysicalDeviceShaderFloat16Int8Features* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(pNext);
features->shaderFloat16 |= enabled->shaderFloat16 == VK_TRUE;
features->shaderInt8 |= enabled->shaderInt8 == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: {
const VkPhysicalDeviceDescriptorIndexingFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>(pNext);
features->shaderInputAttachmentArrayDynamicIndexing |=
enabled->shaderInputAttachmentArrayDynamicIndexing == VK_TRUE;
features->shaderUniformTexelBufferArrayDynamicIndexing |=
enabled->shaderUniformTexelBufferArrayDynamicIndexing == VK_TRUE;
features->shaderStorageTexelBufferArrayDynamicIndexing |=
enabled->shaderStorageTexelBufferArrayDynamicIndexing == VK_TRUE;
features->shaderUniformBufferArrayNonUniformIndexing |=
enabled->shaderUniformBufferArrayNonUniformIndexing == VK_TRUE;
features->shaderSampledImageArrayNonUniformIndexing |=
enabled->shaderSampledImageArrayNonUniformIndexing == VK_TRUE;
features->shaderStorageBufferArrayNonUniformIndexing |=
enabled->shaderStorageBufferArrayNonUniformIndexing == VK_TRUE;
features->shaderStorageImageArrayNonUniformIndexing |=
enabled->shaderStorageImageArrayNonUniformIndexing == VK_TRUE;
features->shaderInputAttachmentArrayNonUniformIndexing |=
enabled->shaderInputAttachmentArrayNonUniformIndexing == VK_TRUE;
features->shaderUniformTexelBufferArrayNonUniformIndexing |=
enabled->shaderUniformTexelBufferArrayNonUniformIndexing == VK_TRUE;
features->shaderStorageTexelBufferArrayNonUniformIndexing |=
enabled->shaderStorageTexelBufferArrayNonUniformIndexing == VK_TRUE;
features->descriptorBindingUniformBufferUpdateAfterBind |=
enabled->descriptorBindingUniformBufferUpdateAfterBind == VK_TRUE;
features->descriptorBindingSampledImageUpdateAfterBind |=
enabled->descriptorBindingSampledImageUpdateAfterBind == VK_TRUE;
features->descriptorBindingStorageImageUpdateAfterBind |=
enabled->descriptorBindingStorageImageUpdateAfterBind == VK_TRUE;
features->descriptorBindingStorageBufferUpdateAfterBind |=
enabled->descriptorBindingStorageBufferUpdateAfterBind == VK_TRUE;
features->descriptorBindingUniformTexelBufferUpdateAfterBind |=
enabled->descriptorBindingUniformTexelBufferUpdateAfterBind == VK_TRUE;
features->descriptorBindingStorageTexelBufferUpdateAfterBind |=
enabled->descriptorBindingStorageTexelBufferUpdateAfterBind == VK_TRUE;
features->descriptorBindingUpdateUnusedWhilePending |=
enabled->descriptorBindingUpdateUnusedWhilePending == VK_TRUE;
features->descriptorBindingPartiallyBound |= enabled->descriptorBindingPartiallyBound == VK_TRUE;
features->descriptorBindingVariableDescriptorCount |= enabled->descriptorBindingVariableDescriptorCount == VK_TRUE;
features->runtimeDescriptorArray |= enabled->runtimeDescriptorArray == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: {
const VkPhysicalDeviceScalarBlockLayoutFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>(pNext);
features->scalarBlockLayout |= enabled->scalarBlockLayout == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: {
const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(pNext);
features->uniformBufferStandardLayout |= enabled->uniformBufferStandardLayout == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: {
const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(pNext);
features->shaderSubgroupExtendedTypes |= enabled->shaderSubgroupExtendedTypes == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: {
const VkPhysicalDeviceImagelessFramebufferFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>(pNext);
features->imagelessFramebuffer |= enabled->imagelessFramebuffer == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: {
const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(pNext);
features->separateDepthStencilLayouts |= enabled->separateDepthStencilLayouts == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: {
const VkPhysicalDeviceVulkan13Features* enabled = reinterpret_cast<const VkPhysicalDeviceVulkan13Features*>(pNext);
features->robustImageAccess |= enabled->robustImageAccess == VK_TRUE;
features->inlineUniformBlock |= enabled->inlineUniformBlock == VK_TRUE;
features->descriptorBindingInlineUniformBlockUpdateAfterBind |=
enabled->descriptorBindingInlineUniformBlockUpdateAfterBind == VK_TRUE;
features->pipelineCreationCacheControl |= enabled->pipelineCreationCacheControl == VK_TRUE;
features->privateData |= enabled->privateData == VK_TRUE;
features->shaderDemoteToHelperInvocation |= enabled->shaderDemoteToHelperInvocation == VK_TRUE;
features->shaderTerminateInvocation |= enabled->shaderTerminateInvocation == VK_TRUE;
features->subgroupSizeControl |= enabled->subgroupSizeControl == VK_TRUE;
features->computeFullSubgroups |= enabled->computeFullSubgroups == VK_TRUE;
features->synchronization2 |= enabled->synchronization2 == VK_TRUE;
features->textureCompressionASTC_HDR |= enabled->textureCompressionASTC_HDR == VK_TRUE;
features->shaderZeroInitializeWorkgroupMemory |= enabled->shaderZeroInitializeWorkgroupMemory == VK_TRUE;
features->dynamicRendering |= enabled->dynamicRendering == VK_TRUE;
features->shaderIntegerDotProduct |= enabled->shaderIntegerDotProduct == VK_TRUE;
features->maintenance4 |= enabled->maintenance4 == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: {
const VkPhysicalDevicePrivateDataFeatures* enabled =
reinterpret_cast<const VkPhysicalDevicePrivateDataFeatures*>(pNext);
features->privateData |= enabled->privateData == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: {
const VkPhysicalDeviceSynchronization2Features* enabled =
reinterpret_cast<const VkPhysicalDeviceSynchronization2Features*>(pNext);
features->synchronization2 |= enabled->synchronization2 == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: {
const VkPhysicalDeviceTextureCompressionASTCHDRFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeatures*>(pNext);
features->textureCompressionASTC_HDR |= enabled->textureCompressionASTC_HDR == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: {
const VkPhysicalDeviceMaintenance4Features* enabled =
reinterpret_cast<const VkPhysicalDeviceMaintenance4Features*>(pNext);
features->maintenance4 |= enabled->maintenance4 == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: {
const VkPhysicalDeviceShaderTerminateInvocationFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeatures*>(pNext);
features->shaderTerminateInvocation |= enabled->shaderTerminateInvocation == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: {
const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*>(pNext);
features->shaderDemoteToHelperInvocation |= enabled->shaderDemoteToHelperInvocation == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: {
const VkPhysicalDevicePipelineCreationCacheControlFeatures* enabled =
reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeatures*>(pNext);
features->pipelineCreationCacheControl |= enabled->pipelineCreationCacheControl == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: {
const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*>(pNext);
features->shaderZeroInitializeWorkgroupMemory |= enabled->shaderZeroInitializeWorkgroupMemory == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: {
const VkPhysicalDeviceImageRobustnessFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeatures*>(pNext);
features->robustImageAccess |= enabled->robustImageAccess == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: {
const VkPhysicalDeviceSubgroupSizeControlFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeatures*>(pNext);
features->subgroupSizeControl |= enabled->subgroupSizeControl == VK_TRUE;
features->computeFullSubgroups |= enabled->computeFullSubgroups == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: {
const VkPhysicalDeviceInlineUniformBlockFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeatures*>(pNext);
features->inlineUniformBlock |= enabled->inlineUniformBlock == VK_TRUE;
features->descriptorBindingInlineUniformBlockUpdateAfterBind |=
enabled->descriptorBindingInlineUniformBlockUpdateAfterBind == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: {
const VkPhysicalDeviceShaderIntegerDotProductFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeatures*>(pNext);
features->shaderIntegerDotProduct |= enabled->shaderIntegerDotProduct == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: {
const VkPhysicalDeviceDynamicRenderingFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeatures*>(pNext);
features->dynamicRendering |= enabled->dynamicRendering == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: {
const VkPhysicalDeviceVulkan14Features* enabled = reinterpret_cast<const VkPhysicalDeviceVulkan14Features*>(pNext);
features->globalPriorityQuery |= enabled->globalPriorityQuery == VK_TRUE;
features->shaderSubgroupRotate |= enabled->shaderSubgroupRotate == VK_TRUE;
features->shaderSubgroupRotateClustered |= enabled->shaderSubgroupRotateClustered == VK_TRUE;
features->shaderFloatControls2 |= enabled->shaderFloatControls2 == VK_TRUE;
features->shaderExpectAssume |= enabled->shaderExpectAssume == VK_TRUE;
features->rectangularLines |= enabled->rectangularLines == VK_TRUE;
features->bresenhamLines |= enabled->bresenhamLines == VK_TRUE;
features->smoothLines |= enabled->smoothLines == VK_TRUE;
features->stippledRectangularLines |= enabled->stippledRectangularLines == VK_TRUE;
features->stippledBresenhamLines |= enabled->stippledBresenhamLines == VK_TRUE;
features->stippledSmoothLines |= enabled->stippledSmoothLines == VK_TRUE;
features->vertexAttributeInstanceRateDivisor |= enabled->vertexAttributeInstanceRateDivisor == VK_TRUE;
features->vertexAttributeInstanceRateZeroDivisor |= enabled->vertexAttributeInstanceRateZeroDivisor == VK_TRUE;
features->indexTypeUint8 |= enabled->indexTypeUint8 == VK_TRUE;
features->dynamicRenderingLocalRead |= enabled->dynamicRenderingLocalRead == VK_TRUE;
features->maintenance5 |= enabled->maintenance5 == VK_TRUE;
features->maintenance6 |= enabled->maintenance6 == VK_TRUE;
features->pipelineProtectedAccess |= enabled->pipelineProtectedAccess == VK_TRUE;
features->pipelineRobustness |= enabled->pipelineRobustness == VK_TRUE;
features->hostImageCopy |= enabled->hostImageCopy == VK_TRUE;
features->pushDescriptor |= enabled->pushDescriptor == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: {
const VkPhysicalDeviceGlobalPriorityQueryFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeatures*>(pNext);
features->globalPriorityQuery |= enabled->globalPriorityQuery == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: {
const VkPhysicalDeviceIndexTypeUint8Features* enabled =
reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8Features*>(pNext);
features->indexTypeUint8 |= enabled->indexTypeUint8 == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: {
const VkPhysicalDeviceMaintenance5Features* enabled =
reinterpret_cast<const VkPhysicalDeviceMaintenance5Features*>(pNext);
features->maintenance5 |= enabled->maintenance5 == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: {
const VkPhysicalDeviceMaintenance6Features* enabled =
reinterpret_cast<const VkPhysicalDeviceMaintenance6Features*>(pNext);
features->maintenance6 |= enabled->maintenance6 == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: {
const VkPhysicalDeviceHostImageCopyFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceHostImageCopyFeatures*>(pNext);
features->hostImageCopy |= enabled->hostImageCopy == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: {
const VkPhysicalDeviceShaderSubgroupRotateFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderSubgroupRotateFeatures*>(pNext);
features->shaderSubgroupRotate |= enabled->shaderSubgroupRotate == VK_TRUE;
features->shaderSubgroupRotateClustered |= enabled->shaderSubgroupRotateClustered == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: {
const VkPhysicalDeviceShaderFloatControls2Features* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderFloatControls2Features*>(pNext);
features->shaderFloatControls2 |= enabled->shaderFloatControls2 == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: {
const VkPhysicalDeviceShaderExpectAssumeFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderExpectAssumeFeatures*>(pNext);
features->shaderExpectAssume |= enabled->shaderExpectAssume == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: {
const VkPhysicalDevicePipelineProtectedAccessFeatures* enabled =
reinterpret_cast<const VkPhysicalDevicePipelineProtectedAccessFeatures*>(pNext);
features->pipelineProtectedAccess |= enabled->pipelineProtectedAccess == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: {
const VkPhysicalDevicePipelineRobustnessFeatures* enabled =
reinterpret_cast<const VkPhysicalDevicePipelineRobustnessFeatures*>(pNext);
features->pipelineRobustness |= enabled->pipelineRobustness == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: {
const VkPhysicalDeviceLineRasterizationFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeatures*>(pNext);
features->rectangularLines |= enabled->rectangularLines == VK_TRUE;
features->bresenhamLines |= enabled->bresenhamLines == VK_TRUE;
features->smoothLines |= enabled->smoothLines == VK_TRUE;
features->stippledRectangularLines |= enabled->stippledRectangularLines == VK_TRUE;
features->stippledBresenhamLines |= enabled->stippledBresenhamLines == VK_TRUE;
features->stippledSmoothLines |= enabled->stippledSmoothLines == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: {
const VkPhysicalDeviceVertexAttributeDivisorFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeatures*>(pNext);
features->vertexAttributeInstanceRateDivisor |= enabled->vertexAttributeInstanceRateDivisor == VK_TRUE;
features->vertexAttributeInstanceRateZeroDivisor |= enabled->vertexAttributeInstanceRateZeroDivisor == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: {
const VkPhysicalDeviceDynamicRenderingLocalReadFeatures* enabled =
reinterpret_cast<const VkPhysicalDeviceDynamicRenderingLocalReadFeatures*>(pNext);
features->dynamicRenderingLocalRead |= enabled->dynamicRenderingLocalRead == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: {
const VkPhysicalDevicePerformanceQueryFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>(pNext);
features->performanceCounterQueryPools |= enabled->performanceCounterQueryPools == VK_TRUE;
features->performanceCounterMultipleQueryPools |= enabled->performanceCounterMultipleQueryPools == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR: {
const VkPhysicalDeviceShaderBfloat16FeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderBfloat16FeaturesKHR*>(pNext);
features->shaderBFloat16Type |= enabled->shaderBFloat16Type == VK_TRUE;
features->shaderBFloat16DotProduct |= enabled->shaderBFloat16DotProduct == VK_TRUE;
features->shaderBFloat16CooperativeMatrix |= enabled->shaderBFloat16CooperativeMatrix == VK_TRUE;
break;
}
#ifdef VK_ENABLE_BETA_EXTENSIONS
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: {
const VkPhysicalDevicePortabilitySubsetFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(pNext);
features->constantAlphaColorBlendFactors |= enabled->constantAlphaColorBlendFactors == VK_TRUE;
features->events |= enabled->events == VK_TRUE;
features->imageViewFormatReinterpretation |= enabled->imageViewFormatReinterpretation == VK_TRUE;
features->imageViewFormatSwizzle |= enabled->imageViewFormatSwizzle == VK_TRUE;
features->imageView2DOn3DImage |= enabled->imageView2DOn3DImage == VK_TRUE;
features->multisampleArrayImage |= enabled->multisampleArrayImage == VK_TRUE;
features->mutableComparisonSamplers |= enabled->mutableComparisonSamplers == VK_TRUE;
features->pointPolygons |= enabled->pointPolygons == VK_TRUE;
features->samplerMipLodBias |= enabled->samplerMipLodBias == VK_TRUE;
features->separateStencilMaskRef |= enabled->separateStencilMaskRef == VK_TRUE;
features->shaderSampleRateInterpolationFunctions |= enabled->shaderSampleRateInterpolationFunctions == VK_TRUE;
features->tessellationIsolines |= enabled->tessellationIsolines == VK_TRUE;
features->tessellationPointMode |= enabled->tessellationPointMode == VK_TRUE;
features->triangleFans |= enabled->triangleFans == VK_TRUE;
features->vertexAttributeAccessBeyondStride |= enabled->vertexAttributeAccessBeyondStride == VK_TRUE;
break;
}
#endif // VK_ENABLE_BETA_EXTENSIONS
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: {
const VkPhysicalDeviceShaderClockFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR*>(pNext);
features->shaderSubgroupClock |= enabled->shaderSubgroupClock == VK_TRUE;
features->shaderDeviceClock |= enabled->shaderDeviceClock == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: {
const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(pNext);
features->pipelineFragmentShadingRate |= enabled->pipelineFragmentShadingRate == VK_TRUE;
features->primitiveFragmentShadingRate |= enabled->primitiveFragmentShadingRate == VK_TRUE;
features->attachmentFragmentShadingRate |= enabled->attachmentFragmentShadingRate == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES_KHR: {
const VkPhysicalDeviceShaderConstantDataFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderConstantDataFeaturesKHR*>(pNext);
features->shaderConstantData |= enabled->shaderConstantData == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_FEATURES_KHR: {
const VkPhysicalDeviceShaderAbortFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderAbortFeaturesKHR*>(pNext);
features->shaderAbort |= enabled->shaderAbort == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: {
const VkPhysicalDeviceShaderQuadControlFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderQuadControlFeaturesKHR*>(pNext);
features->shaderQuadControl |= enabled->shaderQuadControl == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: {
const VkPhysicalDevicePresentWaitFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDevicePresentWaitFeaturesKHR*>(pNext);
features->presentWait |= enabled->presentWait == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: {
const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(pNext);
features->pipelineExecutableInfo |= enabled->pipelineExecutableInfo == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: {
const VkPhysicalDevicePresentIdFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDevicePresentIdFeaturesKHR*>(pNext);
features->presentId |= enabled->presentId == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES_KHR: {
const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR*>(pNext);
features->deviceAddressCommands |= enabled->deviceAddressCommands == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: {
const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*>(pNext);
features->fragmentShaderBarycentric |= enabled->fragmentShaderBarycentric == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: {
const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(pNext);
features->shaderSubgroupUniformControlFlow |= enabled->shaderSubgroupUniformControlFlow == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: {
const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(pNext);
features->workgroupMemoryExplicitLayout |= enabled->workgroupMemoryExplicitLayout == VK_TRUE;
features->workgroupMemoryExplicitLayoutScalarBlockLayout |=
enabled->workgroupMemoryExplicitLayoutScalarBlockLayout == VK_TRUE;
features->workgroupMemoryExplicitLayout8BitAccess |= enabled->workgroupMemoryExplicitLayout8BitAccess == VK_TRUE;
features->workgroupMemoryExplicitLayout16BitAccess |= enabled->workgroupMemoryExplicitLayout16BitAccess == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: {
const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*>(pNext);
features->rayTracingMaintenance1 |= enabled->rayTracingMaintenance1 == VK_TRUE;
features->rayTracingPipelineTraceRaysIndirect2 |= enabled->rayTracingPipelineTraceRaysIndirect2 == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: {
const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR*>(pNext);
features->shaderUntypedPointers |= enabled->shaderUntypedPointers == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: {
const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR*>(pNext);
features->shaderMaximalReconvergence |= enabled->shaderMaximalReconvergence == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR: {
const VkPhysicalDevicePresentId2FeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDevicePresentId2FeaturesKHR*>(pNext);
features->presentId2 |= enabled->presentId2 == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: {
const VkPhysicalDevicePresentWait2FeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDevicePresentWait2FeaturesKHR*>(pNext);
features->presentWait2 |= enabled->presentWait2 == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: {
const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*>(pNext);
features->rayTracingPositionFetch |= enabled->rayTracingPositionFetch == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: {
const VkPhysicalDevicePipelineBinaryFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDevicePipelineBinaryFeaturesKHR*>(pNext);
features->pipelineBinaries |= enabled->pipelineBinaries == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR: {
const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR*>(pNext);
features->swapchainMaintenance1 |= enabled->swapchainMaintenance1 == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR: {
const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR*>(pNext);
features->internallySynchronizedQueues |= enabled->internallySynchronizedQueues == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: {
const VkPhysicalDeviceCooperativeMatrixFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesKHR*>(pNext);
features->cooperativeMatrix |= enabled->cooperativeMatrix == VK_TRUE;
features->cooperativeMatrixRobustBufferAccess |= enabled->cooperativeMatrixRobustBufferAccess == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR: {
const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR*>(pNext);
features->computeDerivativeGroupQuads |= enabled->computeDerivativeGroupQuads == VK_TRUE;
features->computeDerivativeGroupLinear |= enabled->computeDerivativeGroupLinear == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR: {
const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR*>(pNext);
features->videoEncodeAV1 |= enabled->videoEncodeAV1 == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: {
const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR*>(pNext);
features->videoDecodeVP9 |= enabled->videoDecodeVP9 == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: {
const VkPhysicalDeviceVideoMaintenance1FeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceVideoMaintenance1FeaturesKHR*>(pNext);
features->videoMaintenance1 |= enabled->videoMaintenance1 == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: {
const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR*>(pNext);
features->unifiedImageLayouts |= enabled->unifiedImageLayouts == VK_TRUE;
features->unifiedImageLayoutsVideo |= enabled->unifiedImageLayoutsVideo == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR: {
const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR*>(pNext);
features->indirectMemoryCopy |= enabled->indirectMemoryCopy == VK_TRUE;
features->indirectMemoryToImageCopy |= enabled->indirectMemoryToImageCopy == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR: {
const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR*>(pNext);
features->videoEncodeIntraRefresh |= enabled->videoEncodeIntraRefresh == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR: {
const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR*>(pNext);
features->videoEncodeQuantizationMap |= enabled->videoEncodeQuantizationMap == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: {
const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR*>(pNext);
features->shaderRelaxedExtendedInstruction |= enabled->shaderRelaxedExtendedInstruction == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR: {
const VkPhysicalDeviceMaintenance7FeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceMaintenance7FeaturesKHR*>(pNext);
features->maintenance7 |= enabled->maintenance7 == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_KHR: {
const VkPhysicalDeviceFaultFeaturesKHR* enabled = reinterpret_cast<const VkPhysicalDeviceFaultFeaturesKHR*>(pNext);
features->deviceFault |= enabled->deviceFault == VK_TRUE;
features->deviceFaultVendorBinary |= enabled->deviceFaultVendorBinary == VK_TRUE;
features->deviceFaultReportMasked |= enabled->deviceFaultReportMasked == VK_TRUE;
features->deviceFaultDeviceLostOnMasked |= enabled->deviceFaultDeviceLostOnMasked == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR: {
const VkPhysicalDeviceMaintenance8FeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceMaintenance8FeaturesKHR*>(pNext);
features->maintenance8 |= enabled->maintenance8 == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR: {
const VkPhysicalDeviceShaderFmaFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderFmaFeaturesKHR*>(pNext);
features->shaderFmaFloat16 |= enabled->shaderFmaFloat16 == VK_TRUE;
features->shaderFmaFloat32 |= enabled->shaderFmaFloat32 == VK_TRUE;
features->shaderFmaFloat64 |= enabled->shaderFmaFloat64 == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: {
const VkPhysicalDeviceMaintenance9FeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceMaintenance9FeaturesKHR*>(pNext);
features->maintenance9 |= enabled->maintenance9 == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR: {
const VkPhysicalDeviceVideoMaintenance2FeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceVideoMaintenance2FeaturesKHR*>(pNext);
features->videoMaintenance2 |= enabled->videoMaintenance2 == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR: {
const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR*>(pNext);
features->depthClampZeroOne |= enabled->depthClampZeroOne == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR: {
const VkPhysicalDeviceRobustness2FeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesKHR*>(pNext);
features->robustBufferAccess2 |= enabled->robustBufferAccess2 == VK_TRUE;
features->robustImageAccess2 |= enabled->robustImageAccess2 == VK_TRUE;
features->nullDescriptor |= enabled->nullDescriptor == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: {
const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR*>(pNext);
features->presentModeFifoLatestReady |= enabled->presentModeFifoLatestReady == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR: {
const VkPhysicalDeviceOpacityMicromapFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceOpacityMicromapFeaturesKHR*>(pNext);
features->micromap |= enabled->micromap == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR: {
const VkPhysicalDeviceMaintenance10FeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceMaintenance10FeaturesKHR*>(pNext);
features->maintenance10 |= enabled->maintenance10 == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_11_FEATURES_KHR: {
const VkPhysicalDeviceMaintenance11FeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceMaintenance11FeaturesKHR*>(pNext);
features->maintenance11 |= enabled->maintenance11 == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: {
const VkPhysicalDeviceTransformFeedbackFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(pNext);
features->transformFeedback |= enabled->transformFeedback == VK_TRUE;
features->geometryStreams |= enabled->geometryStreams == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: {
const VkPhysicalDeviceCornerSampledImageFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>(pNext);
features->cornerSampledImage |= enabled->cornerSampledImage == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: {
const VkPhysicalDeviceASTCDecodeFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>(pNext);
features->decodeModeSharedExponent |= enabled->decodeModeSharedExponent == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: {
const VkPhysicalDeviceConditionalRenderingFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(pNext);
features->conditionalRendering |= enabled->conditionalRendering == VK_TRUE;
features->inheritedConditionalRendering |= enabled->inheritedConditionalRendering == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
const VkPhysicalDeviceDepthClipEnableFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(pNext);
features->depthClipEnable |= enabled->depthClipEnable == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: {
const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* enabled =
reinterpret_cast<const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG*>(pNext);
features->relaxedLineRasterization |= enabled->relaxedLineRasterization == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD: {
const VkPhysicalDeviceGpaFeaturesAMD* enabled = reinterpret_cast<const VkPhysicalDeviceGpaFeaturesAMD*>(pNext);
features->perfCounters |= enabled->perfCounters == VK_TRUE;
features->streamingPerfCounters |= enabled->streamingPerfCounters == VK_TRUE;
features->sqThreadTracing |= enabled->sqThreadTracing == VK_TRUE;
features->clockModes |= enabled->clockModes == VK_TRUE;
break;
}
#ifdef VK_ENABLE_BETA_EXTENSIONS
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX: {
const VkPhysicalDeviceShaderEnqueueFeaturesAMDX* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderEnqueueFeaturesAMDX*>(pNext);
features->shaderEnqueue |= enabled->shaderEnqueue == VK_TRUE;
features->shaderMeshEnqueue |= enabled->shaderMeshEnqueue == VK_TRUE;
break;
}
#endif // VK_ENABLE_BETA_EXTENSIONS
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT: {
const VkPhysicalDeviceDescriptorHeapFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceDescriptorHeapFeaturesEXT*>(pNext);
features->descriptorHeap |= enabled->descriptorHeap == VK_TRUE;
features->descriptorHeapCaptureReplay |= enabled->descriptorHeapCaptureReplay == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: {
const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(pNext);
features->advancedBlendCoherentOperations |= enabled->advancedBlendCoherentOperations == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: {
const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(pNext);
features->shaderSMBuiltins |= enabled->shaderSMBuiltins == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: {
const VkPhysicalDeviceShadingRateImageFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>(pNext);
features->shadingRateImage |= enabled->shadingRateImage == VK_TRUE;
features->shadingRateCoarseSampleOrder |= enabled->shadingRateCoarseSampleOrder == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: {
const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(pNext);
features->representativeFragmentTest |= enabled->representativeFragmentTest == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM: {
const VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM* enabled =
reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM*>(pNext);
features->cooperativeMatrixConversion |= enabled->cooperativeMatrixConversion == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM: {
const VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM* enabled =
reinterpret_cast<const VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM*>(pNext);
features->elapsedTimerQuery |= enabled->elapsedTimerQuery == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: {
const VkPhysicalDeviceMeshShaderFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(pNext);
features->taskShader |= enabled->taskShader == VK_TRUE;
features->meshShader |= enabled->meshShader == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: {
const VkPhysicalDeviceShaderImageFootprintFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(pNext);
features->imageFootprint |= enabled->imageFootprint == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: {
const VkPhysicalDeviceExclusiveScissorFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>(pNext);
features->exclusiveScissor |= enabled->exclusiveScissor == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT: {
const VkPhysicalDevicePresentTimingFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDevicePresentTimingFeaturesEXT*>(pNext);
features->presentTiming |= enabled->presentTiming == VK_TRUE;
features->presentAtAbsoluteTime |= enabled->presentAtAbsoluteTime == VK_TRUE;
features->presentAtRelativeTime |= enabled->presentAtRelativeTime == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: {
const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(pNext);
features->shaderIntegerFunctions2 |= enabled->shaderIntegerFunctions2 == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: {
const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(pNext);
features->fragmentDensityMap |= enabled->fragmentDensityMap == VK_TRUE;
features->fragmentDensityMapDynamic |= enabled->fragmentDensityMapDynamic == VK_TRUE;
features->fragmentDensityMapNonSubsampledImages |= enabled->fragmentDensityMapNonSubsampledImages == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: {
const VkPhysicalDeviceCoherentMemoryFeaturesAMD* enabled =
reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(pNext);
features->deviceCoherentMemory |= enabled->deviceCoherentMemory == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: {
const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(pNext);
features->shaderImageInt64Atomics |= enabled->shaderImageInt64Atomics == VK_TRUE;
features->sparseImageInt64Atomics |= enabled->sparseImageInt64Atomics == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: {
const VkPhysicalDeviceMemoryPriorityFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(pNext);
features->memoryPriority |= enabled->memoryPriority == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: {
const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(pNext);
features->dedicatedAllocationImageAliasing |= enabled->dedicatedAllocationImageAliasing == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: {
const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(pNext);
features->bufferDeviceAddressEXT |= enabled->bufferDeviceAddress == VK_TRUE;
features->bufferDeviceAddressCaptureReplayEXT |= enabled->bufferDeviceAddressCaptureReplay == VK_TRUE;
features->bufferDeviceAddressMultiDeviceEXT |= enabled->bufferDeviceAddressMultiDevice == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: {
const VkPhysicalDeviceCooperativeMatrixFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(pNext);
features->cooperativeMatrix |= enabled->cooperativeMatrix == VK_TRUE;
features->cooperativeMatrixRobustBufferAccess |= enabled->cooperativeMatrixRobustBufferAccess == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: {
const VkPhysicalDeviceCoverageReductionModeFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(pNext);
features->coverageReductionMode |= enabled->coverageReductionMode == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: {
const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(pNext);
features->fragmentShaderSampleInterlock |= enabled->fragmentShaderSampleInterlock == VK_TRUE;
features->fragmentShaderPixelInterlock |= enabled->fragmentShaderPixelInterlock == VK_TRUE;
features->fragmentShaderShadingRateInterlock |= enabled->fragmentShaderShadingRateInterlock == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: {
const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(pNext);
features->ycbcrImageArrays |= enabled->ycbcrImageArrays == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: {
const VkPhysicalDeviceProvokingVertexFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceProvokingVertexFeaturesEXT*>(pNext);
features->provokingVertexLast |= enabled->provokingVertexLast == VK_TRUE;
features->transformFeedbackPreservesProvokingVertex |=
enabled->transformFeedbackPreservesProvokingVertex == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: {
const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(pNext);
features->shaderBufferFloat32Atomics |= enabled->shaderBufferFloat32Atomics == VK_TRUE;
features->shaderBufferFloat32AtomicAdd |= enabled->shaderBufferFloat32AtomicAdd == VK_TRUE;
features->shaderBufferFloat64Atomics |= enabled->shaderBufferFloat64Atomics == VK_TRUE;
features->shaderBufferFloat64AtomicAdd |= enabled->shaderBufferFloat64AtomicAdd == VK_TRUE;
features->shaderSharedFloat32Atomics |= enabled->shaderSharedFloat32Atomics == VK_TRUE;
features->shaderSharedFloat32AtomicAdd |= enabled->shaderSharedFloat32AtomicAdd == VK_TRUE;
features->shaderSharedFloat64Atomics |= enabled->shaderSharedFloat64Atomics == VK_TRUE;
features->shaderSharedFloat64AtomicAdd |= enabled->shaderSharedFloat64AtomicAdd == VK_TRUE;
features->shaderImageFloat32Atomics |= enabled->shaderImageFloat32Atomics == VK_TRUE;
features->shaderImageFloat32AtomicAdd |= enabled->shaderImageFloat32AtomicAdd == VK_TRUE;
features->sparseImageFloat32Atomics |= enabled->sparseImageFloat32Atomics == VK_TRUE;
features->sparseImageFloat32AtomicAdd |= enabled->sparseImageFloat32AtomicAdd == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: {
const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(pNext);
features->extendedDynamicState |= enabled->extendedDynamicState == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: {
const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT*>(pNext);
features->memoryMapPlaced |= enabled->memoryMapPlaced == VK_TRUE;
features->memoryMapRangePlaced |= enabled->memoryMapRangePlaced == VK_TRUE;
features->memoryUnmapReserve |= enabled->memoryUnmapReserve == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: {
const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(pNext);
features->shaderBufferFloat16Atomics |= enabled->shaderBufferFloat16Atomics == VK_TRUE;
features->shaderBufferFloat16AtomicAdd |= enabled->shaderBufferFloat16AtomicAdd == VK_TRUE;
features->shaderBufferFloat16AtomicMinMax |= enabled->shaderBufferFloat16AtomicMinMax == VK_TRUE;
features->shaderBufferFloat32AtomicMinMax |= enabled->shaderBufferFloat32AtomicMinMax == VK_TRUE;
features->shaderBufferFloat64AtomicMinMax |= enabled->shaderBufferFloat64AtomicMinMax == VK_TRUE;
features->shaderSharedFloat16Atomics |= enabled->shaderSharedFloat16Atomics == VK_TRUE;
features->shaderSharedFloat16AtomicAdd |= enabled->shaderSharedFloat16AtomicAdd == VK_TRUE;
features->shaderSharedFloat16AtomicMinMax |= enabled->shaderSharedFloat16AtomicMinMax == VK_TRUE;
features->shaderSharedFloat32AtomicMinMax |= enabled->shaderSharedFloat32AtomicMinMax == VK_TRUE;
features->shaderSharedFloat64AtomicMinMax |= enabled->shaderSharedFloat64AtomicMinMax == VK_TRUE;
features->shaderImageFloat32AtomicMinMax |= enabled->shaderImageFloat32AtomicMinMax == VK_TRUE;
features->sparseImageFloat32AtomicMinMax |= enabled->sparseImageFloat32AtomicMinMax == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: {
const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(pNext);
features->deviceGeneratedCommandsNV |= enabled->deviceGeneratedCommands == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: {
const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(pNext);
features->inheritedViewportScissor2D |= enabled->inheritedViewportScissor2D == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: {
const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(pNext);
features->texelBufferAlignment |= enabled->texelBufferAlignment == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: {
const VkPhysicalDeviceDepthBiasControlFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceDepthBiasControlFeaturesEXT*>(pNext);
features->depthBiasControl |= enabled->depthBiasControl == VK_TRUE;
features->leastRepresentableValueForceUnormRepresentation |=
enabled->leastRepresentableValueForceUnormRepresentation == VK_TRUE;
features->floatRepresentation |= enabled->floatRepresentation == VK_TRUE;
features->depthBiasExact |= enabled->depthBiasExact == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: {
const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(pNext);
features->deviceMemoryReport |= enabled->deviceMemoryReport == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: {
const VkPhysicalDeviceCustomBorderColorFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(pNext);
features->customBorderColors |= enabled->customBorderColors == VK_TRUE;
features->customBorderColorWithoutFormat |= enabled->customBorderColorWithoutFormat == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT: {
const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT*>(pNext);
features->textureCompressionASTC_3D |= enabled->textureCompressionASTC_3D == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: {
const VkPhysicalDevicePresentBarrierFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDevicePresentBarrierFeaturesNV*>(pNext);
features->presentBarrier |= enabled->presentBarrier == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: {
const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(pNext);
features->diagnosticsConfig |= enabled->diagnosticsConfig == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_FEATURES_QCOM: {
const VkPhysicalDeviceQueuePerfHintFeaturesQCOM* enabled =
reinterpret_cast<const VkPhysicalDeviceQueuePerfHintFeaturesQCOM*>(pNext);
features->queuePerfHint |= enabled->queuePerfHint == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM: {
const VkPhysicalDeviceImageProcessing3FeaturesQCOM* enabled =
reinterpret_cast<const VkPhysicalDeviceImageProcessing3FeaturesQCOM*>(pNext);
features->imageGatherLinear |= enabled->imageGatherLinear == VK_TRUE;
features->imageGatherExtendedModes |= enabled->imageGatherExtendedModes == VK_TRUE;
features->blockMatchExtendedClampToEdge |= enabled->blockMatchExtendedClampToEdge == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM: {
const VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM*>(pNext);
features->shaderMultipleWaitQueues |= enabled->shaderMultipleWaitQueues == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT: {
const VkPhysicalDeviceShaderSplitBarrierFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderSplitBarrierFeaturesEXT*>(pNext);
features->shaderSplitBarrier |= enabled->shaderSplitBarrier == VK_TRUE;
break;
}
#ifdef VK_ENABLE_BETA_EXTENSIONS
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV: {
const VkPhysicalDeviceCudaKernelLaunchFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceCudaKernelLaunchFeaturesNV*>(pNext);
features->cudaKernelLaunchFeatures |= enabled->cudaKernelLaunchFeatures == VK_TRUE;
break;
}
#endif // VK_ENABLE_BETA_EXTENSIONS
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM: {
const VkPhysicalDeviceTileShadingFeaturesQCOM* enabled =
reinterpret_cast<const VkPhysicalDeviceTileShadingFeaturesQCOM*>(pNext);
features->tileShading |= enabled->tileShading == VK_TRUE;
features->tileShadingFragmentStage |= enabled->tileShadingFragmentStage == VK_TRUE;
features->tileShadingColorAttachments |= enabled->tileShadingColorAttachments == VK_TRUE;
features->tileShadingDepthAttachments |= enabled->tileShadingDepthAttachments == VK_TRUE;
features->tileShadingStencilAttachments |= enabled->tileShadingStencilAttachments == VK_TRUE;
features->tileShadingInputAttachments |= enabled->tileShadingInputAttachments == VK_TRUE;
features->tileShadingSampledAttachments |= enabled->tileShadingSampledAttachments == VK_TRUE;
features->tileShadingPerTileDraw |= enabled->tileShadingPerTileDraw == VK_TRUE;
features->tileShadingPerTileDispatch |= enabled->tileShadingPerTileDispatch == VK_TRUE;
features->tileShadingDispatchTile |= enabled->tileShadingDispatchTile == VK_TRUE;
features->tileShadingApron |= enabled->tileShadingApron == VK_TRUE;
features->tileShadingAnisotropicApron |= enabled->tileShadingAnisotropicApron == VK_TRUE;
features->tileShadingAtomicOps |= enabled->tileShadingAtomicOps == VK_TRUE;
features->tileShadingImageProcessing |= enabled->tileShadingImageProcessing == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: {
const VkPhysicalDeviceDescriptorBufferFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceDescriptorBufferFeaturesEXT*>(pNext);
features->descriptorBuffer |= enabled->descriptorBuffer == VK_TRUE;
features->descriptorBufferCaptureReplay |= enabled->descriptorBufferCaptureReplay == VK_TRUE;
features->descriptorBufferImageLayoutIgnored |= enabled->descriptorBufferImageLayoutIgnored == VK_TRUE;
features->descriptorBufferPushDescriptors |= enabled->descriptorBufferPushDescriptors == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: {
const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*>(pNext);
features->graphicsPipelineLibrary |= enabled->graphicsPipelineLibrary == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: {
const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*>(pNext);
features->shaderEarlyAndLateFragmentTests |= enabled->shaderEarlyAndLateFragmentTests == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: {
const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(pNext);
features->fragmentShadingRateEnums |= enabled->fragmentShadingRateEnums == VK_TRUE;
features->supersampleFragmentShadingRates |= enabled->supersampleFragmentShadingRates == VK_TRUE;
features->noInvocationFragmentShadingRates |= enabled->noInvocationFragmentShadingRates == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: {
const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(pNext);
features->rayTracingMotionBlur |= enabled->rayTracingMotionBlur == VK_TRUE;
features->rayTracingMotionBlurPipelineTraceRaysIndirect |=
enabled->rayTracingMotionBlurPipelineTraceRaysIndirect == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: {
const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(pNext);
features->ycbcr2plane444Formats |= enabled->ycbcr2plane444Formats == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: {
const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(pNext);
features->fragmentDensityMapDeferred |= enabled->fragmentDensityMapDeferred == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: {
const VkPhysicalDeviceImageCompressionControlFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceImageCompressionControlFeaturesEXT*>(pNext);
features->imageCompressionControl |= enabled->imageCompressionControl == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: {
const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*>(pNext);
features->attachmentFeedbackLoopLayout |= enabled->attachmentFeedbackLoopLayout == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: {
const VkPhysicalDevice4444FormatsFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT*>(pNext);
features->formatA4R4G4B4 |= enabled->formatA4R4G4B4 == VK_TRUE;
features->formatA4B4G4R4 |= enabled->formatA4B4G4R4 == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: {
const VkPhysicalDeviceFaultFeaturesEXT* enabled = reinterpret_cast<const VkPhysicalDeviceFaultFeaturesEXT*>(pNext);
features->deviceFault |= enabled->deviceFault == VK_TRUE;
features->deviceFaultVendorBinary |= enabled->deviceFaultVendorBinary == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: {
const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*>(pNext);
features->rasterizationOrderColorAttachmentAccess |= enabled->rasterizationOrderColorAttachmentAccess == VK_TRUE;
features->rasterizationOrderDepthAttachmentAccess |= enabled->rasterizationOrderDepthAttachmentAccess == VK_TRUE;
features->rasterizationOrderStencilAttachmentAccess |=
enabled->rasterizationOrderStencilAttachmentAccess == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: {
const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(pNext);
features->formatRgba10x6WithoutYCbCrSampler |= enabled->formatRgba10x6WithoutYCbCrSampler == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: {
const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*>(pNext);
features->mutableDescriptorType |= enabled->mutableDescriptorType == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: {
const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(pNext);
features->vertexInputDynamicState |= enabled->vertexInputDynamicState == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: {
const VkPhysicalDeviceAddressBindingReportFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceAddressBindingReportFeaturesEXT*>(pNext);
features->reportAddressBinding |= enabled->reportAddressBinding == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: {
const VkPhysicalDeviceDepthClipControlFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceDepthClipControlFeaturesEXT*>(pNext);
features->depthClipControl |= enabled->depthClipControl == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: {
const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(pNext);
features->primitiveTopologyListRestart |= enabled->primitiveTopologyListRestart == VK_TRUE;
features->primitiveTopologyPatchListRestart |= enabled->primitiveTopologyPatchListRestart == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: {
const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* enabled =
reinterpret_cast<const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(pNext);
features->subpassShading |= enabled->subpassShading == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: {
const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* enabled =
reinterpret_cast<const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(pNext);
features->invocationMask |= enabled->invocationMask == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: {
const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(pNext);
features->externalMemoryRDMA |= enabled->externalMemoryRDMA == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: {
const VkPhysicalDevicePipelinePropertiesFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDevicePipelinePropertiesFeaturesEXT*>(pNext);
features->pipelinePropertiesIdentifier |= enabled->pipelinePropertiesIdentifier == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: {
const VkPhysicalDeviceFrameBoundaryFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceFrameBoundaryFeaturesEXT*>(pNext);
features->frameBoundary |= enabled->frameBoundary == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: {
const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*>(pNext);
features->multisampledRenderToSingleSampled |= enabled->multisampledRenderToSingleSampled == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: {
const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(pNext);
features->extendedDynamicState2 |= enabled->extendedDynamicState2 == VK_TRUE;
features->extendedDynamicState2LogicOp |= enabled->extendedDynamicState2LogicOp == VK_TRUE;
features->extendedDynamicState2PatchControlPoints |= enabled->extendedDynamicState2PatchControlPoints == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: {
const VkPhysicalDeviceColorWriteEnableFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(pNext);
features->colorWriteEnable |= enabled->colorWriteEnable == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: {
const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(pNext);
features->primitivesGeneratedQuery |= enabled->primitivesGeneratedQuery == VK_TRUE;
features->primitivesGeneratedQueryWithRasterizerDiscard |=
enabled->primitivesGeneratedQueryWithRasterizerDiscard == VK_TRUE;
features->primitivesGeneratedQueryWithNonZeroStreams |=
enabled->primitivesGeneratedQueryWithNonZeroStreams == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE: {
const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE* enabled =
reinterpret_cast<const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE*>(pNext);
features->videoEncodeRgbConversion |= enabled->videoEncodeRgbConversion == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: {
const VkPhysicalDeviceImageViewMinLodFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceImageViewMinLodFeaturesEXT*>(pNext);
features->minLod |= enabled->minLod == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: {
const VkPhysicalDeviceMultiDrawFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceMultiDrawFeaturesEXT*>(pNext);
features->multiDraw |= enabled->multiDraw == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: {
const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*>(pNext);
features->image2DViewOf3D |= enabled->image2DViewOf3D == VK_TRUE;
features->sampler2DViewOf3D |= enabled->sampler2DViewOf3D == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: {
const VkPhysicalDeviceShaderTileImageFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderTileImageFeaturesEXT*>(pNext);
features->shaderTileImageColorReadAccess |= enabled->shaderTileImageColorReadAccess == VK_TRUE;
features->shaderTileImageDepthReadAccess |= enabled->shaderTileImageDepthReadAccess == VK_TRUE;
features->shaderTileImageStencilReadAccess |= enabled->shaderTileImageStencilReadAccess == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: {
const VkPhysicalDeviceOpacityMicromapFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceOpacityMicromapFeaturesEXT*>(pNext);
features->micromap |= enabled->micromap == VK_TRUE;
features->micromapCaptureReplay |= enabled->micromapCaptureReplay == VK_TRUE;
features->micromapHostCommands |= enabled->micromapHostCommands == VK_TRUE;
break;
}
#ifdef VK_ENABLE_BETA_EXTENSIONS
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: {
const VkPhysicalDeviceDisplacementMicromapFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapFeaturesNV*>(pNext);
features->displacementMicromap |= enabled->displacementMicromap == VK_TRUE;
break;
}
#endif // VK_ENABLE_BETA_EXTENSIONS
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: {
const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* enabled =
reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*>(pNext);
features->clustercullingShader |= enabled->clustercullingShader == VK_TRUE;
features->multiviewClusterCullingShader |= enabled->multiviewClusterCullingShader == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI: {
const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* enabled =
reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI*>(pNext);
features->clusterShadingRate |= enabled->clusterShadingRate == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: {
const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(pNext);
features->borderColorSwizzle |= enabled->borderColorSwizzle == VK_TRUE;
features->borderColorSwizzleFromImage |= enabled->borderColorSwizzleFromImage == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: {
const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(pNext);
features->pageableDeviceLocalMemory |= enabled->pageableDeviceLocalMemory == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: {
const VkPhysicalDeviceSchedulingControlsFeaturesARM* enabled =
reinterpret_cast<const VkPhysicalDeviceSchedulingControlsFeaturesARM*>(pNext);
features->schedulingControls |= enabled->schedulingControls == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: {
const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*>(pNext);
features->imageSlicedViewOf3D |= enabled->imageSlicedViewOf3D == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: {
const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* enabled =
reinterpret_cast<const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*>(pNext);
features->descriptorSetHostMapping |= enabled->descriptorSetHostMapping == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: {
const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*>(pNext);
features->nonSeamlessCubeMap |= enabled->nonSeamlessCubeMap == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: {
const VkPhysicalDeviceRenderPassStripedFeaturesARM* enabled =
reinterpret_cast<const VkPhysicalDeviceRenderPassStripedFeaturesARM*>(pNext);
features->renderPassStriped |= enabled->renderPassStriped == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT: {
const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT*>(pNext);
features->fragmentDensityMapOffset |= enabled->fragmentDensityMapOffset == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: {
const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV*>(pNext);
features->indirectCopy |= enabled->indirectCopy == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT: {
const VkPhysicalDeviceMemoryDecompressionFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionFeaturesEXT*>(pNext);
features->memoryDecompression |= enabled->memoryDecompression == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV: {
const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV*>(pNext);
features->deviceGeneratedCompute |= enabled->deviceGeneratedCompute == VK_TRUE;
features->deviceGeneratedComputePipelines |= enabled->deviceGeneratedComputePipelines == VK_TRUE;
features->deviceGeneratedComputeCaptureReplay |= enabled->deviceGeneratedComputeCaptureReplay == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV: {
const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV*>(pNext);
features->spheres |= enabled->spheres == VK_TRUE;
features->linearSweptSpheres |= enabled->linearSweptSpheres == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: {
const VkPhysicalDeviceLinearColorAttachmentFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceLinearColorAttachmentFeaturesNV*>(pNext);
features->linearColorAttachment |= enabled->linearColorAttachment == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: {
const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*>(pNext);
features->imageCompressionControlSwapchain |= enabled->imageCompressionControlSwapchain == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: {
const VkPhysicalDeviceImageProcessingFeaturesQCOM* enabled =
reinterpret_cast<const VkPhysicalDeviceImageProcessingFeaturesQCOM*>(pNext);
features->textureSampleWeighted |= enabled->textureSampleWeighted == VK_TRUE;
features->textureBoxFilter |= enabled->textureBoxFilter == VK_TRUE;
features->textureBlockMatch |= enabled->textureBlockMatch == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT: {
const VkPhysicalDeviceNestedCommandBufferFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceNestedCommandBufferFeaturesEXT*>(pNext);
features->nestedCommandBuffer |= enabled->nestedCommandBuffer == VK_TRUE;
features->nestedCommandBufferRendering |= enabled->nestedCommandBufferRendering == VK_TRUE;
features->nestedCommandBufferSimultaneousUse |= enabled->nestedCommandBufferSimultaneousUse == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: {
const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(pNext);
features->extendedDynamicState3TessellationDomainOrigin |=
enabled->extendedDynamicState3TessellationDomainOrigin == VK_TRUE;
features->extendedDynamicState3DepthClampEnable |= enabled->extendedDynamicState3DepthClampEnable == VK_TRUE;
features->extendedDynamicState3PolygonMode |= enabled->extendedDynamicState3PolygonMode == VK_TRUE;
features->extendedDynamicState3RasterizationSamples |=
enabled->extendedDynamicState3RasterizationSamples == VK_TRUE;
features->extendedDynamicState3SampleMask |= enabled->extendedDynamicState3SampleMask == VK_TRUE;
features->extendedDynamicState3AlphaToCoverageEnable |=
enabled->extendedDynamicState3AlphaToCoverageEnable == VK_TRUE;
features->extendedDynamicState3AlphaToOneEnable |= enabled->extendedDynamicState3AlphaToOneEnable == VK_TRUE;
features->extendedDynamicState3LogicOpEnable |= enabled->extendedDynamicState3LogicOpEnable == VK_TRUE;
features->extendedDynamicState3ColorBlendEnable |= enabled->extendedDynamicState3ColorBlendEnable == VK_TRUE;
features->extendedDynamicState3ColorBlendEquation |= enabled->extendedDynamicState3ColorBlendEquation == VK_TRUE;
features->extendedDynamicState3ColorWriteMask |= enabled->extendedDynamicState3ColorWriteMask == VK_TRUE;
features->extendedDynamicState3RasterizationStream |= enabled->extendedDynamicState3RasterizationStream == VK_TRUE;
features->extendedDynamicState3ConservativeRasterizationMode |=
enabled->extendedDynamicState3ConservativeRasterizationMode == VK_TRUE;
features->extendedDynamicState3ExtraPrimitiveOverestimationSize |=
enabled->extendedDynamicState3ExtraPrimitiveOverestimationSize == VK_TRUE;
features->extendedDynamicState3DepthClipEnable |= enabled->extendedDynamicState3DepthClipEnable == VK_TRUE;
features->extendedDynamicState3SampleLocationsEnable |=
enabled->extendedDynamicState3SampleLocationsEnable == VK_TRUE;
features->extendedDynamicState3ColorBlendAdvanced |= enabled->extendedDynamicState3ColorBlendAdvanced == VK_TRUE;
features->extendedDynamicState3ProvokingVertexMode |= enabled->extendedDynamicState3ProvokingVertexMode == VK_TRUE;
features->extendedDynamicState3LineRasterizationMode |=
enabled->extendedDynamicState3LineRasterizationMode == VK_TRUE;
features->extendedDynamicState3LineStippleEnable |= enabled->extendedDynamicState3LineStippleEnable == VK_TRUE;
features->extendedDynamicState3DepthClipNegativeOneToOne |=
enabled->extendedDynamicState3DepthClipNegativeOneToOne == VK_TRUE;
features->extendedDynamicState3ViewportWScalingEnable |=
enabled->extendedDynamicState3ViewportWScalingEnable == VK_TRUE;
features->extendedDynamicState3ViewportSwizzle |= enabled->extendedDynamicState3ViewportSwizzle == VK_TRUE;
features->extendedDynamicState3CoverageToColorEnable |=
enabled->extendedDynamicState3CoverageToColorEnable == VK_TRUE;
features->extendedDynamicState3CoverageToColorLocation |=
enabled->extendedDynamicState3CoverageToColorLocation == VK_TRUE;
features->extendedDynamicState3CoverageModulationMode |=
enabled->extendedDynamicState3CoverageModulationMode == VK_TRUE;
features->extendedDynamicState3CoverageModulationTableEnable |=
enabled->extendedDynamicState3CoverageModulationTableEnable == VK_TRUE;
features->extendedDynamicState3CoverageModulationTable |=
enabled->extendedDynamicState3CoverageModulationTable == VK_TRUE;
features->extendedDynamicState3CoverageReductionMode |=
enabled->extendedDynamicState3CoverageReductionMode == VK_TRUE;
features->extendedDynamicState3RepresentativeFragmentTestEnable |=
enabled->extendedDynamicState3RepresentativeFragmentTestEnable == VK_TRUE;
features->extendedDynamicState3ShadingRateImageEnable |=
enabled->extendedDynamicState3ShadingRateImageEnable == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: {
const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*>(pNext);
features->subpassMergeFeedback |= enabled->subpassMergeFeedback == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM: {
const VkPhysicalDeviceTensorFeaturesARM* enabled =
reinterpret_cast<const VkPhysicalDeviceTensorFeaturesARM*>(pNext);
features->tensorNonPacked |= enabled->tensorNonPacked == VK_TRUE;
features->shaderTensorAccess |= enabled->shaderTensorAccess == VK_TRUE;
features->shaderStorageTensorArrayDynamicIndexing |= enabled->shaderStorageTensorArrayDynamicIndexing == VK_TRUE;
features->shaderStorageTensorArrayNonUniformIndexing |=
enabled->shaderStorageTensorArrayNonUniformIndexing == VK_TRUE;
features->descriptorBindingStorageTensorUpdateAfterBind |=
enabled->descriptorBindingStorageTensorUpdateAfterBind == VK_TRUE;
features->tensors |= enabled->tensors == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM: {
const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM* enabled =
reinterpret_cast<const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM*>(pNext);
features->descriptorBufferTensorDescriptors |= enabled->descriptorBufferTensorDescriptors == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: {
const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*>(pNext);
features->shaderModuleIdentifier |= enabled->shaderModuleIdentifier == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: {
const VkPhysicalDeviceOpticalFlowFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceOpticalFlowFeaturesNV*>(pNext);
features->opticalFlow |= enabled->opticalFlow == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: {
const VkPhysicalDeviceLegacyDitheringFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceLegacyDitheringFeaturesEXT*>(pNext);
features->legacyDithering |= enabled->legacyDithering == VK_TRUE;
break;
}
#ifdef VK_USE_PLATFORM_ANDROID_KHR
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID: {
const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* enabled =
reinterpret_cast<const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID*>(pNext);
features->externalFormatResolve |= enabled->externalFormatResolve == VK_TRUE;
break;
}
#endif // VK_USE_PLATFORM_ANDROID_KHR
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD: {
const VkPhysicalDeviceAntiLagFeaturesAMD* enabled =
reinterpret_cast<const VkPhysicalDeviceAntiLagFeaturesAMD*>(pNext);
features->antiLag |= enabled->antiLag == VK_TRUE;
break;
}
#ifdef VK_ENABLE_BETA_EXTENSIONS
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX: {
const VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX* enabled =
reinterpret_cast<const VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX*>(pNext);
features->denseGeometryFormat |= enabled->denseGeometryFormat == VK_TRUE;
break;
}
#endif // VK_ENABLE_BETA_EXTENSIONS
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: {
const VkPhysicalDeviceShaderObjectFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderObjectFeaturesEXT*>(pNext);
features->shaderObject |= enabled->shaderObject == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: {
const VkPhysicalDeviceTilePropertiesFeaturesQCOM* enabled =
reinterpret_cast<const VkPhysicalDeviceTilePropertiesFeaturesQCOM*>(pNext);
features->tileProperties |= enabled->tileProperties == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: {
const VkPhysicalDeviceAmigoProfilingFeaturesSEC* enabled =
reinterpret_cast<const VkPhysicalDeviceAmigoProfilingFeaturesSEC*>(pNext);
features->amigoProfiling |= enabled->amigoProfiling == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: {
const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* enabled =
reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM*>(pNext);
features->multiviewPerViewViewports |= enabled->multiviewPerViewViewports == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: {
const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV*>(pNext);
features->rayTracingInvocationReorder |= enabled->rayTracingInvocationReorder == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV: {
const VkPhysicalDeviceCooperativeVectorFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceCooperativeVectorFeaturesNV*>(pNext);
features->cooperativeVector |= enabled->cooperativeVector == VK_TRUE;
features->cooperativeVectorTraining |= enabled->cooperativeVectorTraining == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: {
const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV*>(pNext);
features->extendedSparseAddressSpace |= enabled->extendedSparseAddressSpace == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT: {
const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT*>(pNext);
features->legacyVertexAttributes |= enabled->legacyVertexAttributes == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: {
const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM*>(pNext);
features->shaderCoreBuiltins |= enabled->shaderCoreBuiltins == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: {
const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*>(pNext);
features->pipelineLibraryGroupHandles |= enabled->pipelineLibraryGroupHandles == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: {
const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT*>(pNext);
features->dynamicRenderingUnusedAttachments |= enabled->dynamicRenderingUnusedAttachments == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM: {
const VkPhysicalDeviceDataGraphFeaturesARM* enabled =
reinterpret_cast<const VkPhysicalDeviceDataGraphFeaturesARM*>(pNext);
features->dataGraph |= enabled->dataGraph == VK_TRUE;
features->dataGraphUpdateAfterBind |= enabled->dataGraphUpdateAfterBind == VK_TRUE;
features->dataGraphSpecializationConstants |= enabled->dataGraphSpecializationConstants == VK_TRUE;
features->dataGraphDescriptorBuffer |= enabled->dataGraphDescriptorBuffer == VK_TRUE;
features->dataGraphShaderModule |= enabled->dataGraphShaderModule == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: {
const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* enabled =
reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM*>(pNext);
features->multiviewPerViewRenderAreas |= enabled->multiviewPerViewRenderAreas == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: {
const VkPhysicalDevicePerStageDescriptorSetFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDevicePerStageDescriptorSetFeaturesNV*>(pNext);
features->perStageDescriptorSet |= enabled->perStageDescriptorSet == VK_TRUE;
features->dynamicPipelineLayout |= enabled->dynamicPipelineLayout == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: {
const VkPhysicalDeviceImageProcessing2FeaturesQCOM* enabled =
reinterpret_cast<const VkPhysicalDeviceImageProcessing2FeaturesQCOM*>(pNext);
features->textureBlockMatch2 |= enabled->textureBlockMatch2 == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM: {
const VkPhysicalDeviceCubicWeightsFeaturesQCOM* enabled =
reinterpret_cast<const VkPhysicalDeviceCubicWeightsFeaturesQCOM*>(pNext);
features->selectableCubicWeights |= enabled->selectableCubicWeights == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM: {
const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* enabled =
reinterpret_cast<const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM*>(pNext);
features->ycbcrDegamma |= enabled->ycbcrDegamma == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: {
const VkPhysicalDeviceCubicClampFeaturesQCOM* enabled =
reinterpret_cast<const VkPhysicalDeviceCubicClampFeaturesQCOM*>(pNext);
features->cubicRangeClamp |= enabled->cubicRangeClamp == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: {
const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*>(pNext);
features->attachmentFeedbackLoopDynamicState |= enabled->attachmentFeedbackLoopDynamicState == VK_TRUE;
break;
}
#ifdef VK_USE_PLATFORM_SCREEN_QNX
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX: {
const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX* enabled =
reinterpret_cast<const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX*>(pNext);
features->screenBufferImport |= enabled->screenBufferImport == VK_TRUE;
break;
}
#endif // VK_USE_PLATFORM_SCREEN_QNX
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: {
const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV*>(pNext);
features->descriptorPoolOverallocation |= enabled->descriptorPoolOverallocation == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM: {
const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM* enabled =
reinterpret_cast<const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM*>(pNext);
features->tileMemoryHeap |= enabled->tileMemoryHeap == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: {
const VkPhysicalDeviceRawAccessChainsFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceRawAccessChainsFeaturesNV*>(pNext);
features->shaderRawAccessChains |= enabled->shaderRawAccessChains == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV: {
const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV*>(pNext);
features->commandBufferInheritance |= enabled->commandBufferInheritance == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV: {
const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV*>(pNext);
features->shaderFloat16VectorAtomics |= enabled->shaderFloat16VectorAtomics == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: {
const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT*>(pNext);
features->shaderReplicatedComposites |= enabled->shaderReplicatedComposites == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: {
const VkPhysicalDeviceShaderFloat8FeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderFloat8FeaturesEXT*>(pNext);
features->shaderFloat8 |= enabled->shaderFloat8 == VK_TRUE;
features->shaderFloat8CooperativeMatrix |= enabled->shaderFloat8CooperativeMatrix == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: {
const VkPhysicalDeviceRayTracingValidationFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceRayTracingValidationFeaturesNV*>(pNext);
features->rayTracingValidation |= enabled->rayTracingValidation == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV: {
const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV*>(pNext);
features->clusterAccelerationStructure |= enabled->clusterAccelerationStructure == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV: {
const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV*>(pNext);
features->partitionedAccelerationStructure |= enabled->partitionedAccelerationStructure == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: {
const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT*>(pNext);
features->deviceGeneratedCommands |= enabled->deviceGeneratedCommands == VK_TRUE;
features->dynamicGeneratedPipelineLayout |= enabled->dynamicGeneratedPipelineLayout == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: {
const VkPhysicalDeviceImageAlignmentControlFeaturesMESA* enabled =
reinterpret_cast<const VkPhysicalDeviceImageAlignmentControlFeaturesMESA*>(pNext);
features->imageAlignmentControl |= enabled->imageAlignmentControl == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV: {
const VkPhysicalDevicePushConstantBankFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDevicePushConstantBankFeaturesNV*>(pNext);
features->pushConstantBank |= enabled->pushConstantBank == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT: {
const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT*>(pNext);
features->rayTracingInvocationReorder |= enabled->rayTracingInvocationReorder == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: {
const VkPhysicalDeviceDepthClampControlFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceDepthClampControlFeaturesEXT*>(pNext);
features->depthClampControl |= enabled->depthClampControl == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI: {
const VkPhysicalDeviceHdrVividFeaturesHUAWEI* enabled =
reinterpret_cast<const VkPhysicalDeviceHdrVividFeaturesHUAWEI*>(pNext);
features->hdrVivid |= enabled->hdrVivid == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV: {
const VkPhysicalDeviceCooperativeMatrix2FeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceCooperativeMatrix2FeaturesNV*>(pNext);
features->cooperativeMatrixWorkgroupScope |= enabled->cooperativeMatrixWorkgroupScope == VK_TRUE;
features->cooperativeMatrixFlexibleDimensions |= enabled->cooperativeMatrixFlexibleDimensions == VK_TRUE;
features->cooperativeMatrixReductions |= enabled->cooperativeMatrixReductions == VK_TRUE;
features->cooperativeMatrixConversions |= enabled->cooperativeMatrixConversions == VK_TRUE;
features->cooperativeMatrixPerElementOperations |= enabled->cooperativeMatrixPerElementOperations == VK_TRUE;
features->cooperativeMatrixTensorAddressing |= enabled->cooperativeMatrixTensorAddressing == VK_TRUE;
features->cooperativeMatrixBlockLoads |= enabled->cooperativeMatrixBlockLoads == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM: {
const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM* enabled =
reinterpret_cast<const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM*>(pNext);
features->pipelineOpacityMicromap |= enabled->pipelineOpacityMicromap == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM: {
const VkPhysicalDevicePerformanceCountersByRegionFeaturesARM* enabled =
reinterpret_cast<const VkPhysicalDevicePerformanceCountersByRegionFeaturesARM*>(pNext);
features->performanceCountersByRegion |= enabled->performanceCountersByRegion == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_FEATURES_ARM: {
const VkPhysicalDeviceShaderInstrumentationFeaturesARM* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderInstrumentationFeaturesARM*>(pNext);
features->shaderInstrumentation |= enabled->shaderInstrumentation == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT: {
const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT*>(pNext);
features->vertexAttributeRobustness |= enabled->vertexAttributeRobustness == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM: {
const VkPhysicalDeviceFormatPackFeaturesARM* enabled =
reinterpret_cast<const VkPhysicalDeviceFormatPackFeaturesARM*>(pNext);
features->formatPack |= enabled->formatPack == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE: {
const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE* enabled =
reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE*>(pNext);
features->fragmentDensityMapLayered |= enabled->fragmentDensityMapLayered == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV: {
const VkPhysicalDevicePresentMeteringFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDevicePresentMeteringFeaturesNV*>(pNext);
features->presentMetering |= enabled->presentMetering == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT: {
const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT*>(pNext);
features->zeroInitializeDeviceMemory |= enabled->zeroInitializeDeviceMemory == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT: {
const VkPhysicalDeviceShader64BitIndexingFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceShader64BitIndexingFeaturesEXT*>(pNext);
features->shader64BitIndexing |= enabled->shader64BitIndexing == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT: {
const VkPhysicalDeviceCustomResolveFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceCustomResolveFeaturesEXT*>(pNext);
features->customResolve |= enabled->customResolve == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM: {
const VkPhysicalDeviceDataGraphModelFeaturesQCOM* enabled =
reinterpret_cast<const VkPhysicalDeviceDataGraphModelFeaturesQCOM*>(pNext);
features->dataGraphModel |= enabled->dataGraphModel == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_OPTICAL_FLOW_FEATURES_ARM: {
const VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM* enabled =
reinterpret_cast<const VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM*>(pNext);
features->dataGraphOpticalFlow |= enabled->dataGraphOpticalFlow == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT: {
const VkPhysicalDeviceShaderLongVectorFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderLongVectorFeaturesEXT*>(pNext);
features->longVector |= enabled->longVector == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC: {
const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC* enabled =
reinterpret_cast<const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC*>(pNext);
features->pipelineCacheIncrementalMode |= enabled->pipelineCacheIncrementalMode == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT: {
const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT*>(pNext);
features->shaderUniformBufferUnsizedArray |= enabled->shaderUniformBufferUnsizedArray == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV: {
const VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV*>(pNext);
features->computeOccupancyPriority |= enabled->computeOccupancyPriority == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT: {
const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT*>(pNext);
features->shaderSubgroupPartitioned |= enabled->shaderSubgroupPartitioned == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE: {
const VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE* enabled =
reinterpret_cast<const VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE*>(pNext);
features->shaderMixedFloatDotProductFloat16AccFloat32 |=
enabled->shaderMixedFloatDotProductFloat16AccFloat32 == VK_TRUE;
features->shaderMixedFloatDotProductFloat16AccFloat16 |=
enabled->shaderMixedFloatDotProductFloat16AccFloat16 == VK_TRUE;
features->shaderMixedFloatDotProductBFloat16Acc |= enabled->shaderMixedFloatDotProductBFloat16Acc == VK_TRUE;
features->shaderMixedFloatDotProductFloat8AccFloat32 |=
enabled->shaderMixedFloatDotProductFloat8AccFloat32 == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_THROTTLE_HINT_FEATURES_SEC: {
const VkPhysicalDeviceThrottleHintFeaturesSEC* enabled =
reinterpret_cast<const VkPhysicalDeviceThrottleHintFeaturesSEC*>(pNext);
features->throttleHint |= enabled->throttleHint == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_NEURAL_ACCELERATOR_STATISTICS_FEATURES_ARM: {
const VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM* enabled =
reinterpret_cast<const VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM*>(pNext);
features->dataGraphNeuralAcceleratorStatistics |= enabled->dataGraphNeuralAcceleratorStatistics == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT: {
const VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT*>(pNext);
features->primitiveRestartIndex |= enabled->primitiveRestartIndex == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV: {
const VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV* enabled =
reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV*>(pNext);
features->cooperativeMatrixDecodeVector |= enabled->cooperativeMatrixDecodeVector == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: {
const VkPhysicalDeviceAccelerationStructureFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(pNext);
features->accelerationStructure |= enabled->accelerationStructure == VK_TRUE;
features->accelerationStructureCaptureReplay |= enabled->accelerationStructureCaptureReplay == VK_TRUE;
features->accelerationStructureIndirectBuild |= enabled->accelerationStructureIndirectBuild == VK_TRUE;
features->accelerationStructureHostCommands |= enabled->accelerationStructureHostCommands == VK_TRUE;
features->descriptorBindingAccelerationStructureUpdateAfterBind |=
enabled->descriptorBindingAccelerationStructureUpdateAfterBind == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: {
const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(pNext);
features->rayTracingPipeline |= enabled->rayTracingPipeline == VK_TRUE;
features->rayTracingPipelineShaderGroupHandleCaptureReplay |=
enabled->rayTracingPipelineShaderGroupHandleCaptureReplay == VK_TRUE;
features->rayTracingPipelineShaderGroupHandleCaptureReplayMixed |=
enabled->rayTracingPipelineShaderGroupHandleCaptureReplayMixed == VK_TRUE;
features->rayTracingPipelineTraceRaysIndirect |= enabled->rayTracingPipelineTraceRaysIndirect == VK_TRUE;
features->rayTraversalPrimitiveCulling |= enabled->rayTraversalPrimitiveCulling == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: {
const VkPhysicalDeviceRayQueryFeaturesKHR* enabled =
reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR*>(pNext);
features->rayQuery |= enabled->rayQuery == VK_TRUE;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: {
const VkPhysicalDeviceMeshShaderFeaturesEXT* enabled =
reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesEXT*>(pNext);
features->taskShader |= enabled->taskShader == VK_TRUE;
features->meshShader |= enabled->meshShader == VK_TRUE;
features->multiviewMeshShader |= enabled->multiviewMeshShader == VK_TRUE;
features->primitiveFragmentShadingRateMeshShader |= enabled->primitiveFragmentShadingRateMeshShader == VK_TRUE;
features->meshShaderQueries |= enabled->meshShaderQueries == VK_TRUE;
break;
}
default:
break;
}
}
// Some older extensions were made without features, but equivalent features were
// added to the core spec when they were promoted. When those extensions are
// enabled, treat validation rules as if the corresponding feature is enabled.
for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
vvl::Extension extension = GetExtension(pCreateInfo->ppEnabledExtensionNames[i]);
if (extension == vvl::Extension::_VK_EXT_descriptor_indexing) {
features->descriptorIndexing = true;
}
if (extension == vvl::Extension::_VK_EXT_sampler_filter_minmax) {
features->samplerFilterMinmax = true;
}
if (extension == vvl::Extension::_VK_EXT_shader_viewport_index_layer) {
features->shaderOutputViewportIndex = true;
features->shaderOutputLayer = true;
}
if (extension == vvl::Extension::_VK_KHR_draw_indirect_count) {
features->drawIndirectCount = true;
}
if (extension == vvl::Extension::_VK_KHR_sampler_mirror_clamp_to_edge) {
features->samplerMirrorClampToEdge = true;
}
if (extension == vvl::Extension::_VK_KHR_shader_draw_parameters) {
features->shaderDrawParameters = true;
}
}
// texelBufferAlignment was not promoted to VkPhysicalDeviceVulkan13Features
// but the feature is automatically enabled.
// Setting the feature explicitly to 'false' doesn't change that
if (api_version >= VK_API_VERSION_1_3) {
features->texelBufferAlignment = true;
}
}
// NOLINTEND