fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2025-12-23 22:00:13 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

vulkan: Add helpers for filling exts for core features and properties.

Browse source 
This is boilerplate that drivers have to replicate, so make a nice helper.
The feature/property macro lists are are copy and pasted from anv, though
the helper functions has been split between 1.1 and 1.2 (and thus the macros
refactored).

Reviewed-by: Jason Ekstrand <jason@jlekstrand.net>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/12967>
This commit is contained in:
Emma Anholt 2021-09-21 15:03:21 -07:00 • committed by Marge Bot
parent 9d40877f72
commit 19ff5019b7
2 changed files with 339 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

329
src/vulkan/util/vk_device.c
View file

@ -259,3 +259,332 @@ vk_common_GetImageSparseMemoryRequirements(VkDevice _device,
STACK_ARRAY_FINISH(mem_reqs2); STACK_ARRAY_FINISH(mem_reqs2);
} }
#define CORE_FEATURE(feature) features->feature = core->feature
bool
vk_get_physical_device_core_1_1_feature_ext(struct VkBaseOutStructure *ext,
const VkPhysicalDeviceVulkan11Features *core)
{
switch (ext->sType) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: {
VkPhysicalDevice16BitStorageFeatures *features = (void *)ext;
CORE_FEATURE(storageBuffer16BitAccess);
CORE_FEATURE(uniformAndStorageBuffer16BitAccess);
CORE_FEATURE(storagePushConstant16);
CORE_FEATURE(storageInputOutput16);
return true;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: {
VkPhysicalDeviceMultiviewFeatures *features = (void *)ext;
CORE_FEATURE(multiview);
CORE_FEATURE(multiviewGeometryShader);
CORE_FEATURE(multiviewTessellationShader);
return true;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: {
VkPhysicalDeviceProtectedMemoryFeatures *features = (void *)ext;
CORE_FEATURE(protectedMemory);
return true;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: {
VkPhysicalDeviceSamplerYcbcrConversionFeatures *features = (void *) ext;
CORE_FEATURE(samplerYcbcrConversion);
return true;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: {
VkPhysicalDeviceShaderDrawParametersFeatures *features = (void *)ext;
CORE_FEATURE(shaderDrawParameters);
return true;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: {
VkPhysicalDeviceVariablePointersFeatures *features = (void *)ext;
CORE_FEATURE(variablePointersStorageBuffer);
CORE_FEATURE(variablePointers);
return true;
}
default:
return false;
}
}
bool
vk_get_physical_device_core_1_2_feature_ext(struct VkBaseOutStructure *ext,
const VkPhysicalDeviceVulkan12Features *core)
{
switch (ext->sType) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR: {
VkPhysicalDevice8BitStorageFeaturesKHR *features = (void *)ext;
CORE_FEATURE(storageBuffer8BitAccess);
CORE_FEATURE(uniformAndStorageBuffer8BitAccess);
CORE_FEATURE(storagePushConstant8);
return true;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR: {
VkPhysicalDeviceBufferDeviceAddressFeaturesKHR *features = (void *)ext;
CORE_FEATURE(bufferDeviceAddress);
CORE_FEATURE(bufferDeviceAddressCaptureReplay);
CORE_FEATURE(bufferDeviceAddressMultiDevice);
return true;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: {
VkPhysicalDeviceDescriptorIndexingFeaturesEXT *features = (void *)ext;
CORE_FEATURE(shaderInputAttachmentArrayDynamicIndexing);
CORE_FEATURE(shaderUniformTexelBufferArrayDynamicIndexing);
CORE_FEATURE(shaderStorageTexelBufferArrayDynamicIndexing);
CORE_FEATURE(shaderUniformBufferArrayNonUniformIndexing);
CORE_FEATURE(shaderSampledImageArrayNonUniformIndexing);
CORE_FEATURE(shaderStorageBufferArrayNonUniformIndexing);
CORE_FEATURE(shaderStorageImageArrayNonUniformIndexing);
CORE_FEATURE(shaderInputAttachmentArrayNonUniformIndexing);
CORE_FEATURE(shaderUniformTexelBufferArrayNonUniformIndexing);
CORE_FEATURE(shaderStorageTexelBufferArrayNonUniformIndexing);
CORE_FEATURE(descriptorBindingUniformBufferUpdateAfterBind);
CORE_FEATURE(descriptorBindingSampledImageUpdateAfterBind);
CORE_FEATURE(descriptorBindingStorageImageUpdateAfterBind);
CORE_FEATURE(descriptorBindingStorageBufferUpdateAfterBind);
CORE_FEATURE(descriptorBindingUniformTexelBufferUpdateAfterBind);
CORE_FEATURE(descriptorBindingStorageTexelBufferUpdateAfterBind);
CORE_FEATURE(descriptorBindingUpdateUnusedWhilePending);
CORE_FEATURE(descriptorBindingPartiallyBound);
CORE_FEATURE(descriptorBindingVariableDescriptorCount);
CORE_FEATURE(runtimeDescriptorArray);
return true;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR: {
VkPhysicalDeviceFloat16Int8FeaturesKHR *features = (void *)ext;
CORE_FEATURE(shaderFloat16);
CORE_FEATURE(shaderInt8);
return true;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT: {
VkPhysicalDeviceHostQueryResetFeaturesEXT *features = (void *)ext;
CORE_FEATURE(hostQueryReset);
return true;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR: {
VkPhysicalDeviceImagelessFramebufferFeaturesKHR *features = (void *)ext;
CORE_FEATURE(imagelessFramebuffer);
return true;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT: {
VkPhysicalDeviceScalarBlockLayoutFeaturesEXT *features =(void *)ext;
CORE_FEATURE(scalarBlockLayout);
return true;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR: {
VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR *features = (void *)ext;
CORE_FEATURE(separateDepthStencilLayouts);
return true;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR: {
VkPhysicalDeviceShaderAtomicInt64FeaturesKHR *features = (void *)ext;
CORE_FEATURE(shaderBufferInt64Atomics);
CORE_FEATURE(shaderSharedInt64Atomics);
return true;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR: {
VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR *features = (void *)ext;
CORE_FEATURE(shaderSubgroupExtendedTypes);
return true;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR: {
VkPhysicalDeviceTimelineSemaphoreFeaturesKHR *features = (void *) ext;
CORE_FEATURE(timelineSemaphore);
return true;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR: {
VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR *features = (void *)ext;
CORE_FEATURE(uniformBufferStandardLayout);
return true;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR: {
VkPhysicalDeviceVulkanMemoryModelFeaturesKHR *features = (void *)ext;
CORE_FEATURE(vulkanMemoryModel);
CORE_FEATURE(vulkanMemoryModelDeviceScope);
CORE_FEATURE(vulkanMemoryModelAvailabilityVisibilityChains);
return true;
}
default:
return false;
}
}
#undef CORE_FEATURE
#define CORE_RENAMED_PROPERTY(ext_property, core_property) \
memcpy(&properties->ext_property, &core->core_property, sizeof(core->core_property))
#define CORE_PROPERTY(property) CORE_RENAMED_PROPERTY(property, property)
bool
vk_get_physical_device_core_1_1_property_ext(struct VkBaseOutStructure *ext,
const VkPhysicalDeviceVulkan11Properties *core)
{
switch (ext->sType) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: {
VkPhysicalDeviceIDProperties *properties = (void *)ext;
CORE_PROPERTY(deviceUUID);
CORE_PROPERTY(driverUUID);
CORE_PROPERTY(deviceLUID);
CORE_PROPERTY(deviceLUIDValid);
return true;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: {
VkPhysicalDeviceMaintenance3Properties *properties = (void *)ext;
CORE_PROPERTY(maxPerSetDescriptors);
CORE_PROPERTY(maxMemoryAllocationSize);
return true;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: {
VkPhysicalDeviceMultiviewProperties *properties = (void *)ext;
CORE_PROPERTY(maxMultiviewViewCount);
CORE_PROPERTY(maxMultiviewInstanceIndex);
return true;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: {
VkPhysicalDevicePointClippingProperties *properties = (void *) ext;
CORE_PROPERTY(pointClippingBehavior);
return true;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: {
VkPhysicalDeviceProtectedMemoryProperties *properties = (void *)ext;
CORE_PROPERTY(protectedNoFault);
return true;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: {
VkPhysicalDeviceSubgroupProperties *properties = (void *)ext;
CORE_PROPERTY(subgroupSize);
CORE_RENAMED_PROPERTY(supportedStages,
subgroupSupportedStages);
CORE_RENAMED_PROPERTY(supportedOperations,
subgroupSupportedOperations);
CORE_RENAMED_PROPERTY(quadOperationsInAllStages,
subgroupQuadOperationsInAllStages);
return true;
}
default:
return false;
}
}
bool
vk_get_physical_device_core_1_2_property_ext(struct VkBaseOutStructure *ext,
const VkPhysicalDeviceVulkan12Properties *core)
{
switch (ext->sType) {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR: {
VkPhysicalDeviceDepthStencilResolvePropertiesKHR *properties = (void *)ext;
CORE_PROPERTY(supportedDepthResolveModes);
CORE_PROPERTY(supportedStencilResolveModes);
CORE_PROPERTY(independentResolveNone);
CORE_PROPERTY(independentResolve);
return true;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT: {
VkPhysicalDeviceDescriptorIndexingPropertiesEXT *properties = (void *)ext;
CORE_PROPERTY(maxUpdateAfterBindDescriptorsInAllPools);
CORE_PROPERTY(shaderUniformBufferArrayNonUniformIndexingNative);
CORE_PROPERTY(shaderSampledImageArrayNonUniformIndexingNative);
CORE_PROPERTY(shaderStorageBufferArrayNonUniformIndexingNative);
CORE_PROPERTY(shaderStorageImageArrayNonUniformIndexingNative);
CORE_PROPERTY(shaderInputAttachmentArrayNonUniformIndexingNative);
CORE_PROPERTY(robustBufferAccessUpdateAfterBind);
CORE_PROPERTY(quadDivergentImplicitLod);
CORE_PROPERTY(maxPerStageDescriptorUpdateAfterBindSamplers);
CORE_PROPERTY(maxPerStageDescriptorUpdateAfterBindUniformBuffers);
CORE_PROPERTY(maxPerStageDescriptorUpdateAfterBindStorageBuffers);
CORE_PROPERTY(maxPerStageDescriptorUpdateAfterBindSampledImages);
CORE_PROPERTY(maxPerStageDescriptorUpdateAfterBindStorageImages);
CORE_PROPERTY(maxPerStageDescriptorUpdateAfterBindInputAttachments);
CORE_PROPERTY(maxPerStageUpdateAfterBindResources);
CORE_PROPERTY(maxDescriptorSetUpdateAfterBindSamplers);
CORE_PROPERTY(maxDescriptorSetUpdateAfterBindUniformBuffers);
CORE_PROPERTY(maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
CORE_PROPERTY(maxDescriptorSetUpdateAfterBindStorageBuffers);
CORE_PROPERTY(maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
CORE_PROPERTY(maxDescriptorSetUpdateAfterBindSampledImages);
CORE_PROPERTY(maxDescriptorSetUpdateAfterBindStorageImages);
CORE_PROPERTY(maxDescriptorSetUpdateAfterBindInputAttachments);
return true;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR: {
VkPhysicalDeviceDriverPropertiesKHR *properties = (void *) ext;
CORE_PROPERTY(driverID);
CORE_PROPERTY(driverName);
CORE_PROPERTY(driverInfo);
CORE_PROPERTY(conformanceVersion);
return true;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT: {
VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT *properties = (void *)ext;
CORE_PROPERTY(filterMinmaxImageComponentMapping);
CORE_PROPERTY(filterMinmaxSingleComponentFormats);
return true;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR : {
VkPhysicalDeviceFloatControlsPropertiesKHR *properties = (void *)ext;
CORE_PROPERTY(denormBehaviorIndependence);
CORE_PROPERTY(roundingModeIndependence);
CORE_PROPERTY(shaderDenormFlushToZeroFloat16);
CORE_PROPERTY(shaderDenormPreserveFloat16);
CORE_PROPERTY(shaderRoundingModeRTEFloat16);
CORE_PROPERTY(shaderRoundingModeRTZFloat16);
CORE_PROPERTY(shaderSignedZeroInfNanPreserveFloat16);
CORE_PROPERTY(shaderDenormFlushToZeroFloat32);
CORE_PROPERTY(shaderDenormPreserveFloat32);
CORE_PROPERTY(shaderRoundingModeRTEFloat32);
CORE_PROPERTY(shaderRoundingModeRTZFloat32);
CORE_PROPERTY(shaderSignedZeroInfNanPreserveFloat32);
CORE_PROPERTY(shaderDenormFlushToZeroFloat64);
CORE_PROPERTY(shaderDenormPreserveFloat64);
CORE_PROPERTY(shaderRoundingModeRTEFloat64);
CORE_PROPERTY(shaderRoundingModeRTZFloat64);
CORE_PROPERTY(shaderSignedZeroInfNanPreserveFloat64);
return true;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR: {
VkPhysicalDeviceTimelineSemaphorePropertiesKHR *properties = (void *) ext;
CORE_PROPERTY(maxTimelineSemaphoreValueDifference);
return true;
}
default:
return false;
}
}
#undef CORE_RENAMED_PROPERTY
#undef CORE_PROPERTY

10
src/vulkan/util/vk_device.h
View file

@ -66,6 +66,16 @@ PFN_vkVoidFunction
vk_device_get_proc_addr(const struct vk_device *device, vk_device_get_proc_addr(const struct vk_device *device,
const char *name); const char *name);
bool vk_get_physical_device_core_1_1_feature_ext(struct VkBaseOutStructure *ext,
const VkPhysicalDeviceVulkan11Features *core);
bool vk_get_physical_device_core_1_2_feature_ext(struct VkBaseOutStructure *ext,
const VkPhysicalDeviceVulkan12Features *core);
bool vk_get_physical_device_core_1_1_property_ext(struct VkBaseOutStructure *ext,
const VkPhysicalDeviceVulkan11Properties *core);
bool vk_get_physical_device_core_1_2_property_ext(struct VkBaseOutStructure *ext,
const VkPhysicalDeviceVulkan12Properties *core);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif