external/vulkancts/modules/vulkan/pipeline/vktPipelineDerivativeTests.cpp \
external/vulkancts/modules/vulkan/pipeline/vktPipelineDynamicOffsetTests.cpp \
external/vulkancts/modules/vulkan/pipeline/vktPipelineEarlyDestroyTests.cpp \
+ external/vulkancts/modules/vulkan/pipeline/vktPipelineExecutablePropertiesTests.cpp \
external/vulkancts/modules/vulkan/pipeline/vktPipelineFramebufferAttachmentTests.cpp \
external/vulkancts/modules/vulkan/pipeline/vktPipelineImageSamplingInstance.cpp \
external/vulkancts/modules/vulkan/pipeline/vktPipelineImageTests.cpp \
dEQP-VK.pipeline.depth_range_unrestricted.depthclampingdisabled.d16_unorm_compare_op_less_or_equal_clear_value_-7_wc_2_viewport_min_-12_max_12
dEQP-VK.pipeline.depth_range_unrestricted.depthclampingdisabled.d16_unorm_compare_op_less_or_equal_clear_value_-7_wc_6_viewport_min_-12_max_12
dEQP-VK.pipeline.depth_range_unrestricted.depthclampingdisabled.d16_unorm_compare_op_less_or_equal_clear_value_-7_wc_12_viewport_min_-12_max_12
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_fragment_stage
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_geometry_stage_fragment_stage
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_tessellation_control_stage_tessellation_evaluation_stage_fragment_stage
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_fragment_stage_statistics
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_geometry_stage_fragment_stage_statistics
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_tessellation_control_stage_tessellation_evaluation_stage_fragment_stage_statistics
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_fragment_stage_internal_representations
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_geometry_stage_fragment_stage_internal_representations
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_tessellation_control_stage_tessellation_evaluation_stage_fragment_stage_internal_representations
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_fragment_stage_statistics_internal_representations
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_geometry_stage_fragment_stage_statistics_internal_representations
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_tessellation_control_stage_tessellation_evaluation_stage_fragment_stage_statistics_internal_representations
+dEQP-VK.pipeline.executable_properties.compute.compute_stage
+dEQP-VK.pipeline.executable_properties.compute.compute_stage_statistics
+dEQP-VK.pipeline.executable_properties.compute.compute_stage_internal_representations
+dEQP-VK.pipeline.executable_properties.compute.compute_stage_statistics_internal_representations
dEQP-VK.pipeline.vertex_only.position_to_ssbo
dEQP-VK.binding_model.shader_access.primary_cmd_buf.sampler_mutable.no_access.single_descriptor.1d
dEQP-VK.binding_model.shader_access.primary_cmd_buf.sampler_mutable.no_access.single_descriptor.1d_base_mip
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = 1000261000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000,
+ VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR = 1000269001,
+ VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR = 1000269002,
+ VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR = 1000269003,
+ VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004,
+ VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = 1000276000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = 1000281001,
VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM_KHR = 0x7FFFFFFF,
};
+enum VkPipelineExecutableStatisticFormatKHR
+{
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR = 0,
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR = 1,
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR = 2,
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR = 3,
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_KHR_LAST,
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_MAX_ENUM_KHR = 0x7FFFFFFF,
+};
+
enum VkDebugReportObjectTypeEXT
{
VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0,
enum VkPipelineCreateFlagBits
{
- VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
- VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
- VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
- VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008,
- VK_PIPELINE_CREATE_DISPATCH_BASE = 0x00000010,
- VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0x00000020,
- VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
- VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE,
- VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF,
+ VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
+ VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
+ VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
+ VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008,
+ VK_PIPELINE_CREATE_DISPATCH_BASE = 0x00000010,
+ VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0x00000020,
+ VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR = 0x00000040,
+ VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080,
+ VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
+ VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE,
+ VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF,
};
typedef deUint32 VkPipelineCreateFlags;
#define VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION 3
#define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION 1
#define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION 1
+#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION 1
#define VK_EXT_DEBUG_REPORT_SPEC_VERSION 9
#define VK_NV_GLSL_SHADER_SPEC_VERSION 1
#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION 1
virtual void releaseProfilingLockKHR (VkDevice device) const;
virtual void cmdDrawIndirectCountKHR (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride) const;
virtual void cmdDrawIndexedIndirectCountKHR (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride) const;
+virtual VkResult getPipelineExecutablePropertiesKHR (VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, deUint32* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties) const;
+virtual VkResult getPipelineExecutableStatisticsKHR (VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, deUint32* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics) const;
+virtual VkResult getPipelineExecutableInternalRepresentationsKHR (VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, deUint32* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) const;
virtual VkResult debugMarkerSetObjectTagEXT (VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) const;
virtual VkResult debugMarkerSetObjectNameEXT (VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo) const;
virtual void cmdDebugMarkerBeginEXT (VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) const;
m_vk.cmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
}
+VkResult DeviceDriver::getPipelineExecutablePropertiesKHR (VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, deUint32* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties) const
+{
+ return m_vk.getPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount, pProperties);
+}
+
+VkResult DeviceDriver::getPipelineExecutableStatisticsKHR (VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, deUint32* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics) const
+{
+ return m_vk.getPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount, pStatistics);
+}
+
+VkResult DeviceDriver::getPipelineExecutableInternalRepresentationsKHR (VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, deUint32* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) const
+{
+ return m_vk.getPipelineExecutableInternalRepresentationsKHR(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations);
+}
+
VkResult DeviceDriver::debugMarkerSetObjectTagEXT (VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) const
{
return m_vk.debugMarkerSetObjectTagEXT(device, pTagInfo);
"VK_KHR_vulkan_memory_model",
"VK_KHR_uniform_buffer_standard_layout",
"VK_KHR_imageless_framebuffer",
+ "VK_KHR_pipeline_executable_properties",
};
#define VK_NV_MESH_SHADER_EXTENSION_NAME "VK_NV_mesh_shader"
#define VK_KHR_MULTIVIEW_EXTENSION_NAME "VK_KHR_multiview"
#define DECL_KHR_PERFORMANCE_COUNTER_EXTENSION_NAME "not_existent_feature"
+#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME "VK_KHR_pipeline_executable_properties"
#define DECL_PROTECTED_MEMORY_EXTENSION_NAME "not_existent_feature"
#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME "VK_NV_representative_fragment_test"
#define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion"
#define VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME "VK_EXT_ycbcr_image_arrays"
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDevice16BitStorageFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, VK_KHR_16BIT_STORAGE_EXTENSION_NAME, VK_KHR_16BIT_STORAGE_SPEC_VERSION, 44); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDevice8BitStorageFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR, VK_KHR_8BIT_STORAGE_EXTENSION_NAME, VK_KHR_8BIT_STORAGE_SPEC_VERSION, 43); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME, VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION, 42); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME, VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION, 41); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV, VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME, VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION, 40); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceConditionalRenderingFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME, VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION, 39); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCooperativeMatrixFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV, VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME, VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION, 38); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCornerSampledImageFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV, VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME, VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION, 37); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCoverageReductionModeFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV, VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME, VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION, 36); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV, VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME, VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION, 35); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDepthClipEnableFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME, VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION, 34); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDescriptorIndexingFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT, VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME, VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION, 33); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceExclusiveScissorFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV, VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME, VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION, 32); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentDensityMapFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME, VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION, 31); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV, VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME, VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION, 30); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT, VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME, VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION, 29); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceHostQueryResetFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT, VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME, VK_EXT_HOST_QUERY_RESET_SPEC_VERSION, 28); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceImagelessFramebufferFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR, VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME, VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION, 27); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceIndexTypeUint8FeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME, VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION, 26); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceInlineUniformBlockFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT, VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME, VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION, 25); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceLineRasterizationFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME, VK_EXT_LINE_RASTERIZATION_SPEC_VERSION, 24); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMemoryPriorityFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME, VK_EXT_MEMORY_PRIORITY_SPEC_VERSION, 23); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMeshShaderFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV, VK_NV_MESH_SHADER_EXTENSION_NAME, VK_NV_MESH_SHADER_SPEC_VERSION, 22); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMultiviewFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, VK_KHR_MULTIVIEW_EXTENSION_NAME, VK_KHR_MULTIVIEW_SPEC_VERSION, 21); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDevicePerformanceCounterFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTER_FEATURES_KHR, DECL_KHR_PERFORMANCE_COUNTER_EXTENSION_NAME, 0, 20); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDevice16BitStorageFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, VK_KHR_16BIT_STORAGE_EXTENSION_NAME, VK_KHR_16BIT_STORAGE_SPEC_VERSION, 45); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDevice8BitStorageFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR, VK_KHR_8BIT_STORAGE_EXTENSION_NAME, VK_KHR_8BIT_STORAGE_SPEC_VERSION, 44); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME, VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION, 43); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME, VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION, 42); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV, VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME, VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION, 41); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceConditionalRenderingFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME, VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION, 40); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCooperativeMatrixFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV, VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME, VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION, 39); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCornerSampledImageFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV, VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME, VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION, 38); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCoverageReductionModeFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV, VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME, VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION, 37); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV, VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME, VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION, 36); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDepthClipEnableFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME, VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION, 35); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDescriptorIndexingFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT, VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME, VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION, 34); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceExclusiveScissorFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV, VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME, VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION, 33); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentDensityMapFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME, VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION, 32); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV, VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME, VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION, 31); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT, VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME, VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION, 30); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceHostQueryResetFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT, VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME, VK_EXT_HOST_QUERY_RESET_SPEC_VERSION, 29); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceImagelessFramebufferFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR, VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME, VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION, 28); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceIndexTypeUint8FeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME, VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION, 27); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceInlineUniformBlockFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT, VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME, VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION, 26); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceLineRasterizationFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME, VK_EXT_LINE_RASTERIZATION_SPEC_VERSION, 25); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMemoryPriorityFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME, VK_EXT_MEMORY_PRIORITY_SPEC_VERSION, 24); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMeshShaderFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV, VK_NV_MESH_SHADER_EXTENSION_NAME, VK_NV_MESH_SHADER_SPEC_VERSION, 23); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMultiviewFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, VK_KHR_MULTIVIEW_EXTENSION_NAME, VK_KHR_MULTIVIEW_SPEC_VERSION, 22); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDevicePerformanceCounterFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTER_FEATURES_KHR, DECL_KHR_PERFORMANCE_COUNTER_EXTENSION_NAME, 0, 21); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR, VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME, VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION, 20); }
template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceProtectedMemoryFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, DECL_PROTECTED_MEMORY_EXTENSION_NAME, 0, 19); }
template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION, 18); }
template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceSamplerYcbcrConversionFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME, VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION, 17); }
{ createFeatureStructWrapper<VkPhysicalDeviceMeshShaderFeaturesNV>, VK_NV_MESH_SHADER_EXTENSION_NAME, VK_NV_MESH_SHADER_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDeviceMultiviewFeatures>, VK_KHR_MULTIVIEW_EXTENSION_NAME, VK_KHR_MULTIVIEW_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDevicePerformanceCounterFeaturesKHR>, DECL_KHR_PERFORMANCE_COUNTER_EXTENSION_NAME, 0 },
+ { createFeatureStructWrapper<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR>, VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME, VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDeviceProtectedMemoryFeatures>, DECL_PROTECTED_MEMORY_EXTENSION_NAME, 0 },
{ createFeatureStructWrapper<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV>, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDeviceSamplerYcbcrConversionFeatures>, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME, VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION },
const vk::VkPhysicalDeviceMeshShaderFeaturesNV& getMeshShaderFeatures (void) const;
const vk::VkPhysicalDeviceMultiviewFeatures& getMultiviewFeatures (void) const;
const vk::VkPhysicalDevicePerformanceCounterFeaturesKHR& getPerformanceCounterFeatures (void) const;
+const vk::VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& getPipelineExecutablePropertiesFeatures (void) const;
const vk::VkPhysicalDeviceProtectedMemoryFeatures& getProtectedMemoryFeatures (void) const;
const vk::VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& getRepresentativeFragmentTestFeatures (void) const;
const vk::VkPhysicalDeviceSamplerYcbcrConversionFeatures& getSamplerYcbcrConversionFeatures (void) const;
const vk::VkPhysicalDeviceMeshShaderFeaturesNV& Context::getMeshShaderFeatures (void) const { return m_device->getMeshShaderFeatures(); }
const vk::VkPhysicalDeviceMultiviewFeatures& Context::getMultiviewFeatures (void) const { return m_device->getMultiviewFeatures(); }
const vk::VkPhysicalDevicePerformanceCounterFeaturesKHR& Context::getPerformanceCounterFeatures (void) const { return m_device->getPerformanceCounterFeatures(); }
+const vk::VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& Context::getPipelineExecutablePropertiesFeatures (void) const { return m_device->getPipelineExecutablePropertiesFeatures(); }
const vk::VkPhysicalDeviceProtectedMemoryFeatures& Context::getProtectedMemoryFeatures (void) const { return m_device->getProtectedMemoryFeatures(); }
const vk::VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& Context::getRepresentativeFragmentTestFeatures (void) const { return m_device->getRepresentativeFragmentTestFeatures(); }
const vk::VkPhysicalDeviceSamplerYcbcrConversionFeatures& Context::getSamplerYcbcrConversionFeatures (void) const { return m_device->getSamplerYcbcrConversionFeatures(); }
const VkPhysicalDeviceMeshShaderFeaturesNV& getMeshShaderFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceMeshShaderFeaturesNV>(); }
const VkPhysicalDeviceMultiviewFeatures& getMultiviewFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceMultiviewFeatures>(); }
const VkPhysicalDevicePerformanceCounterFeaturesKHR& getPerformanceCounterFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDevicePerformanceCounterFeaturesKHR>(); }
+const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& getPipelineExecutablePropertiesFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR>(); }
const VkPhysicalDeviceProtectedMemoryFeatures& getProtectedMemoryFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceProtectedMemoryFeatures>(); }
const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& getRepresentativeFragmentTestFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV>(); }
const VkPhysicalDeviceSamplerYcbcrConversionFeatures& getSamplerYcbcrConversionFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceSamplerYcbcrConversionFeatures>(); }
ReleaseProfilingLockKHRFunc releaseProfilingLockKHR;
CmdDrawIndirectCountKHRFunc cmdDrawIndirectCountKHR;
CmdDrawIndexedIndirectCountKHRFunc cmdDrawIndexedIndirectCountKHR;
+GetPipelineExecutablePropertiesKHRFunc getPipelineExecutablePropertiesKHR;
+GetPipelineExecutableStatisticsKHRFunc getPipelineExecutableStatisticsKHR;
+GetPipelineExecutableInternalRepresentationsKHRFunc getPipelineExecutableInternalRepresentationsKHR;
DebugMarkerSetObjectTagEXTFunc debugMarkerSetObjectTagEXT;
DebugMarkerSetObjectNameEXTFunc debugMarkerSetObjectNameEXT;
CmdDebugMarkerBeginEXTFunc cmdDebugMarkerBeginEXT;
functions.push_back("vkCmdDrawIndirectCountKHR");
functions.push_back("vkCmdDrawIndexedIndirectCountKHR");
}
+ else if (extName == "VK_KHR_pipeline_executable_properties")
+ {
+ functions.push_back("vkGetPipelineExecutablePropertiesKHR");
+ functions.push_back("vkGetPipelineExecutableStatisticsKHR");
+ functions.push_back("vkGetPipelineExecutableInternalRepresentationsKHR");
+ }
else if (extName == "VK_EXT_debug_marker")
{
functions.push_back("vkDebugMarkerSetObjectTagEXT");
"VK_KHR_bind_memory2",
"VK_KHR_maintenance3",
"VK_KHR_draw_indirect_count",
+ "VK_KHR_pipeline_executable_properties",
"VK_EXT_debug_marker",
"VK_EXT_transform_feedback",
"VK_NVX_image_view_handle",
typedef VKAPI_ATTR void (VKAPI_CALL* GetDescriptorSetLayoutSupportKHRFunc) (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport);
typedef VKAPI_ATTR void (VKAPI_CALL* CmdDrawIndirectCountKHRFunc) (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride);
typedef VKAPI_ATTR void (VKAPI_CALL* CmdDrawIndexedIndirectCountKHRFunc) (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride);
+typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetPipelineExecutablePropertiesKHRFunc) (VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, deUint32* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties);
+typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetPipelineExecutableStatisticsKHRFunc) (VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, deUint32* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics);
+typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetPipelineExecutableInternalRepresentationsKHRFunc) (VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, deUint32* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
typedef VKAPI_ATTR VkResult (VKAPI_CALL* CreateDebugReportCallbackEXTFunc) (VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback);
typedef VKAPI_ATTR void (VKAPI_CALL* DestroyDebugReportCallbackEXTFunc) (VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator);
typedef VKAPI_ATTR void (VKAPI_CALL* DebugReportMessageEXTFunc) (VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, deUint64 object, deUintptr location, deInt32 messageCode, const char* pLayerPrefix, const char* pMessage);
return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR;
}
+template<> VkStructureType getStructureType<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
+}
+
+template<> VkStructureType getStructureType<VkPipelineInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkPipelineExecutablePropertiesKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR;
+}
+
+template<> VkStructureType getStructureType<VkPipelineExecutableInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkPipelineExecutableStatisticKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR;
+}
+
+template<> VkStructureType getStructureType<VkPipelineExecutableInternalRepresentationKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR;
+}
+
template<> VkStructureType getStructureType<VkDebugReportCallbackCreateInfoEXT> (void)
{
return VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-m_vk.getDeviceProcAddr = (GetDeviceProcAddrFunc) GET_PROC_ADDR("vkGetDeviceProcAddr");
-m_vk.destroyDevice = (DestroyDeviceFunc) GET_PROC_ADDR("vkDestroyDevice");
-m_vk.getDeviceQueue = (GetDeviceQueueFunc) GET_PROC_ADDR("vkGetDeviceQueue");
-m_vk.queueSubmit = (QueueSubmitFunc) GET_PROC_ADDR("vkQueueSubmit");
-m_vk.queueWaitIdle = (QueueWaitIdleFunc) GET_PROC_ADDR("vkQueueWaitIdle");
-m_vk.deviceWaitIdle = (DeviceWaitIdleFunc) GET_PROC_ADDR("vkDeviceWaitIdle");
-m_vk.allocateMemory = (AllocateMemoryFunc) GET_PROC_ADDR("vkAllocateMemory");
-m_vk.freeMemory = (FreeMemoryFunc) GET_PROC_ADDR("vkFreeMemory");
-m_vk.mapMemory = (MapMemoryFunc) GET_PROC_ADDR("vkMapMemory");
-m_vk.unmapMemory = (UnmapMemoryFunc) GET_PROC_ADDR("vkUnmapMemory");
-m_vk.flushMappedMemoryRanges = (FlushMappedMemoryRangesFunc) GET_PROC_ADDR("vkFlushMappedMemoryRanges");
-m_vk.invalidateMappedMemoryRanges = (InvalidateMappedMemoryRangesFunc) GET_PROC_ADDR("vkInvalidateMappedMemoryRanges");
-m_vk.getDeviceMemoryCommitment = (GetDeviceMemoryCommitmentFunc) GET_PROC_ADDR("vkGetDeviceMemoryCommitment");
-m_vk.bindBufferMemory = (BindBufferMemoryFunc) GET_PROC_ADDR("vkBindBufferMemory");
-m_vk.bindImageMemory = (BindImageMemoryFunc) GET_PROC_ADDR("vkBindImageMemory");
-m_vk.getBufferMemoryRequirements = (GetBufferMemoryRequirementsFunc) GET_PROC_ADDR("vkGetBufferMemoryRequirements");
-m_vk.getImageMemoryRequirements = (GetImageMemoryRequirementsFunc) GET_PROC_ADDR("vkGetImageMemoryRequirements");
-m_vk.getImageSparseMemoryRequirements = (GetImageSparseMemoryRequirementsFunc) GET_PROC_ADDR("vkGetImageSparseMemoryRequirements");
-m_vk.queueBindSparse = (QueueBindSparseFunc) GET_PROC_ADDR("vkQueueBindSparse");
-m_vk.createFence = (CreateFenceFunc) GET_PROC_ADDR("vkCreateFence");
-m_vk.destroyFence = (DestroyFenceFunc) GET_PROC_ADDR("vkDestroyFence");
-m_vk.resetFences = (ResetFencesFunc) GET_PROC_ADDR("vkResetFences");
-m_vk.getFenceStatus = (GetFenceStatusFunc) GET_PROC_ADDR("vkGetFenceStatus");
-m_vk.waitForFences = (WaitForFencesFunc) GET_PROC_ADDR("vkWaitForFences");
-m_vk.createSemaphore = (CreateSemaphoreFunc) GET_PROC_ADDR("vkCreateSemaphore");
-m_vk.destroySemaphore = (DestroySemaphoreFunc) GET_PROC_ADDR("vkDestroySemaphore");
-m_vk.createEvent = (CreateEventFunc) GET_PROC_ADDR("vkCreateEvent");
-m_vk.destroyEvent = (DestroyEventFunc) GET_PROC_ADDR("vkDestroyEvent");
-m_vk.getEventStatus = (GetEventStatusFunc) GET_PROC_ADDR("vkGetEventStatus");
-m_vk.setEvent = (SetEventFunc) GET_PROC_ADDR("vkSetEvent");
-m_vk.resetEvent = (ResetEventFunc) GET_PROC_ADDR("vkResetEvent");
-m_vk.createQueryPool = (CreateQueryPoolFunc) GET_PROC_ADDR("vkCreateQueryPool");
-m_vk.destroyQueryPool = (DestroyQueryPoolFunc) GET_PROC_ADDR("vkDestroyQueryPool");
-m_vk.getQueryPoolResults = (GetQueryPoolResultsFunc) GET_PROC_ADDR("vkGetQueryPoolResults");
-m_vk.createBuffer = (CreateBufferFunc) GET_PROC_ADDR("vkCreateBuffer");
-m_vk.destroyBuffer = (DestroyBufferFunc) GET_PROC_ADDR("vkDestroyBuffer");
-m_vk.createBufferView = (CreateBufferViewFunc) GET_PROC_ADDR("vkCreateBufferView");
-m_vk.destroyBufferView = (DestroyBufferViewFunc) GET_PROC_ADDR("vkDestroyBufferView");
-m_vk.createImage = (CreateImageFunc) GET_PROC_ADDR("vkCreateImage");
-m_vk.destroyImage = (DestroyImageFunc) GET_PROC_ADDR("vkDestroyImage");
-m_vk.getImageSubresourceLayout = (GetImageSubresourceLayoutFunc) GET_PROC_ADDR("vkGetImageSubresourceLayout");
-m_vk.createImageView = (CreateImageViewFunc) GET_PROC_ADDR("vkCreateImageView");
-m_vk.destroyImageView = (DestroyImageViewFunc) GET_PROC_ADDR("vkDestroyImageView");
-m_vk.createShaderModule = (CreateShaderModuleFunc) GET_PROC_ADDR("vkCreateShaderModule");
-m_vk.destroyShaderModule = (DestroyShaderModuleFunc) GET_PROC_ADDR("vkDestroyShaderModule");
-m_vk.createPipelineCache = (CreatePipelineCacheFunc) GET_PROC_ADDR("vkCreatePipelineCache");
-m_vk.destroyPipelineCache = (DestroyPipelineCacheFunc) GET_PROC_ADDR("vkDestroyPipelineCache");
-m_vk.getPipelineCacheData = (GetPipelineCacheDataFunc) GET_PROC_ADDR("vkGetPipelineCacheData");
-m_vk.mergePipelineCaches = (MergePipelineCachesFunc) GET_PROC_ADDR("vkMergePipelineCaches");
-m_vk.createGraphicsPipelines = (CreateGraphicsPipelinesFunc) GET_PROC_ADDR("vkCreateGraphicsPipelines");
-m_vk.createComputePipelines = (CreateComputePipelinesFunc) GET_PROC_ADDR("vkCreateComputePipelines");
-m_vk.destroyPipeline = (DestroyPipelineFunc) GET_PROC_ADDR("vkDestroyPipeline");
-m_vk.createPipelineLayout = (CreatePipelineLayoutFunc) GET_PROC_ADDR("vkCreatePipelineLayout");
-m_vk.destroyPipelineLayout = (DestroyPipelineLayoutFunc) GET_PROC_ADDR("vkDestroyPipelineLayout");
-m_vk.createSampler = (CreateSamplerFunc) GET_PROC_ADDR("vkCreateSampler");
-m_vk.destroySampler = (DestroySamplerFunc) GET_PROC_ADDR("vkDestroySampler");
-m_vk.createDescriptorSetLayout = (CreateDescriptorSetLayoutFunc) GET_PROC_ADDR("vkCreateDescriptorSetLayout");
-m_vk.destroyDescriptorSetLayout = (DestroyDescriptorSetLayoutFunc) GET_PROC_ADDR("vkDestroyDescriptorSetLayout");
-m_vk.createDescriptorPool = (CreateDescriptorPoolFunc) GET_PROC_ADDR("vkCreateDescriptorPool");
-m_vk.destroyDescriptorPool = (DestroyDescriptorPoolFunc) GET_PROC_ADDR("vkDestroyDescriptorPool");
-m_vk.resetDescriptorPool = (ResetDescriptorPoolFunc) GET_PROC_ADDR("vkResetDescriptorPool");
-m_vk.allocateDescriptorSets = (AllocateDescriptorSetsFunc) GET_PROC_ADDR("vkAllocateDescriptorSets");
-m_vk.freeDescriptorSets = (FreeDescriptorSetsFunc) GET_PROC_ADDR("vkFreeDescriptorSets");
-m_vk.updateDescriptorSets = (UpdateDescriptorSetsFunc) GET_PROC_ADDR("vkUpdateDescriptorSets");
-m_vk.createFramebuffer = (CreateFramebufferFunc) GET_PROC_ADDR("vkCreateFramebuffer");
-m_vk.destroyFramebuffer = (DestroyFramebufferFunc) GET_PROC_ADDR("vkDestroyFramebuffer");
-m_vk.createRenderPass = (CreateRenderPassFunc) GET_PROC_ADDR("vkCreateRenderPass");
-m_vk.destroyRenderPass = (DestroyRenderPassFunc) GET_PROC_ADDR("vkDestroyRenderPass");
-m_vk.getRenderAreaGranularity = (GetRenderAreaGranularityFunc) GET_PROC_ADDR("vkGetRenderAreaGranularity");
-m_vk.createCommandPool = (CreateCommandPoolFunc) GET_PROC_ADDR("vkCreateCommandPool");
-m_vk.destroyCommandPool = (DestroyCommandPoolFunc) GET_PROC_ADDR("vkDestroyCommandPool");
-m_vk.resetCommandPool = (ResetCommandPoolFunc) GET_PROC_ADDR("vkResetCommandPool");
-m_vk.allocateCommandBuffers = (AllocateCommandBuffersFunc) GET_PROC_ADDR("vkAllocateCommandBuffers");
-m_vk.freeCommandBuffers = (FreeCommandBuffersFunc) GET_PROC_ADDR("vkFreeCommandBuffers");
-m_vk.beginCommandBuffer = (BeginCommandBufferFunc) GET_PROC_ADDR("vkBeginCommandBuffer");
-m_vk.endCommandBuffer = (EndCommandBufferFunc) GET_PROC_ADDR("vkEndCommandBuffer");
-m_vk.resetCommandBuffer = (ResetCommandBufferFunc) GET_PROC_ADDR("vkResetCommandBuffer");
-m_vk.cmdBindPipeline = (CmdBindPipelineFunc) GET_PROC_ADDR("vkCmdBindPipeline");
-m_vk.cmdSetViewport = (CmdSetViewportFunc) GET_PROC_ADDR("vkCmdSetViewport");
-m_vk.cmdSetScissor = (CmdSetScissorFunc) GET_PROC_ADDR("vkCmdSetScissor");
-m_vk.cmdSetLineWidth = (CmdSetLineWidthFunc) GET_PROC_ADDR("vkCmdSetLineWidth");
-m_vk.cmdSetDepthBias = (CmdSetDepthBiasFunc) GET_PROC_ADDR("vkCmdSetDepthBias");
-m_vk.cmdSetBlendConstants = (CmdSetBlendConstantsFunc) GET_PROC_ADDR("vkCmdSetBlendConstants");
-m_vk.cmdSetDepthBounds = (CmdSetDepthBoundsFunc) GET_PROC_ADDR("vkCmdSetDepthBounds");
-m_vk.cmdSetStencilCompareMask = (CmdSetStencilCompareMaskFunc) GET_PROC_ADDR("vkCmdSetStencilCompareMask");
-m_vk.cmdSetStencilWriteMask = (CmdSetStencilWriteMaskFunc) GET_PROC_ADDR("vkCmdSetStencilWriteMask");
-m_vk.cmdSetStencilReference = (CmdSetStencilReferenceFunc) GET_PROC_ADDR("vkCmdSetStencilReference");
-m_vk.cmdBindDescriptorSets = (CmdBindDescriptorSetsFunc) GET_PROC_ADDR("vkCmdBindDescriptorSets");
-m_vk.cmdBindIndexBuffer = (CmdBindIndexBufferFunc) GET_PROC_ADDR("vkCmdBindIndexBuffer");
-m_vk.cmdBindVertexBuffers = (CmdBindVertexBuffersFunc) GET_PROC_ADDR("vkCmdBindVertexBuffers");
-m_vk.cmdDraw = (CmdDrawFunc) GET_PROC_ADDR("vkCmdDraw");
-m_vk.cmdDrawIndexed = (CmdDrawIndexedFunc) GET_PROC_ADDR("vkCmdDrawIndexed");
-m_vk.cmdDrawIndirect = (CmdDrawIndirectFunc) GET_PROC_ADDR("vkCmdDrawIndirect");
-m_vk.cmdDrawIndexedIndirect = (CmdDrawIndexedIndirectFunc) GET_PROC_ADDR("vkCmdDrawIndexedIndirect");
-m_vk.cmdDispatch = (CmdDispatchFunc) GET_PROC_ADDR("vkCmdDispatch");
-m_vk.cmdDispatchIndirect = (CmdDispatchIndirectFunc) GET_PROC_ADDR("vkCmdDispatchIndirect");
-m_vk.cmdCopyBuffer = (CmdCopyBufferFunc) GET_PROC_ADDR("vkCmdCopyBuffer");
-m_vk.cmdCopyImage = (CmdCopyImageFunc) GET_PROC_ADDR("vkCmdCopyImage");
-m_vk.cmdBlitImage = (CmdBlitImageFunc) GET_PROC_ADDR("vkCmdBlitImage");
-m_vk.cmdCopyBufferToImage = (CmdCopyBufferToImageFunc) GET_PROC_ADDR("vkCmdCopyBufferToImage");
-m_vk.cmdCopyImageToBuffer = (CmdCopyImageToBufferFunc) GET_PROC_ADDR("vkCmdCopyImageToBuffer");
-m_vk.cmdUpdateBuffer = (CmdUpdateBufferFunc) GET_PROC_ADDR("vkCmdUpdateBuffer");
-m_vk.cmdFillBuffer = (CmdFillBufferFunc) GET_PROC_ADDR("vkCmdFillBuffer");
-m_vk.cmdClearColorImage = (CmdClearColorImageFunc) GET_PROC_ADDR("vkCmdClearColorImage");
-m_vk.cmdClearDepthStencilImage = (CmdClearDepthStencilImageFunc) GET_PROC_ADDR("vkCmdClearDepthStencilImage");
-m_vk.cmdClearAttachments = (CmdClearAttachmentsFunc) GET_PROC_ADDR("vkCmdClearAttachments");
-m_vk.cmdResolveImage = (CmdResolveImageFunc) GET_PROC_ADDR("vkCmdResolveImage");
-m_vk.cmdSetEvent = (CmdSetEventFunc) GET_PROC_ADDR("vkCmdSetEvent");
-m_vk.cmdResetEvent = (CmdResetEventFunc) GET_PROC_ADDR("vkCmdResetEvent");
-m_vk.cmdWaitEvents = (CmdWaitEventsFunc) GET_PROC_ADDR("vkCmdWaitEvents");
-m_vk.cmdPipelineBarrier = (CmdPipelineBarrierFunc) GET_PROC_ADDR("vkCmdPipelineBarrier");
-m_vk.cmdBeginQuery = (CmdBeginQueryFunc) GET_PROC_ADDR("vkCmdBeginQuery");
-m_vk.cmdEndQuery = (CmdEndQueryFunc) GET_PROC_ADDR("vkCmdEndQuery");
-m_vk.cmdResetQueryPool = (CmdResetQueryPoolFunc) GET_PROC_ADDR("vkCmdResetQueryPool");
-m_vk.cmdWriteTimestamp = (CmdWriteTimestampFunc) GET_PROC_ADDR("vkCmdWriteTimestamp");
-m_vk.cmdCopyQueryPoolResults = (CmdCopyQueryPoolResultsFunc) GET_PROC_ADDR("vkCmdCopyQueryPoolResults");
-m_vk.cmdPushConstants = (CmdPushConstantsFunc) GET_PROC_ADDR("vkCmdPushConstants");
-m_vk.cmdBeginRenderPass = (CmdBeginRenderPassFunc) GET_PROC_ADDR("vkCmdBeginRenderPass");
-m_vk.cmdNextSubpass = (CmdNextSubpassFunc) GET_PROC_ADDR("vkCmdNextSubpass");
-m_vk.cmdEndRenderPass = (CmdEndRenderPassFunc) GET_PROC_ADDR("vkCmdEndRenderPass");
-m_vk.cmdExecuteCommands = (CmdExecuteCommandsFunc) GET_PROC_ADDR("vkCmdExecuteCommands");
-m_vk.bindBufferMemory2 = (BindBufferMemory2Func) GET_PROC_ADDR("vkBindBufferMemory2");
+m_vk.getDeviceProcAddr = (GetDeviceProcAddrFunc) GET_PROC_ADDR("vkGetDeviceProcAddr");
+m_vk.destroyDevice = (DestroyDeviceFunc) GET_PROC_ADDR("vkDestroyDevice");
+m_vk.getDeviceQueue = (GetDeviceQueueFunc) GET_PROC_ADDR("vkGetDeviceQueue");
+m_vk.queueSubmit = (QueueSubmitFunc) GET_PROC_ADDR("vkQueueSubmit");
+m_vk.queueWaitIdle = (QueueWaitIdleFunc) GET_PROC_ADDR("vkQueueWaitIdle");
+m_vk.deviceWaitIdle = (DeviceWaitIdleFunc) GET_PROC_ADDR("vkDeviceWaitIdle");
+m_vk.allocateMemory = (AllocateMemoryFunc) GET_PROC_ADDR("vkAllocateMemory");
+m_vk.freeMemory = (FreeMemoryFunc) GET_PROC_ADDR("vkFreeMemory");
+m_vk.mapMemory = (MapMemoryFunc) GET_PROC_ADDR("vkMapMemory");
+m_vk.unmapMemory = (UnmapMemoryFunc) GET_PROC_ADDR("vkUnmapMemory");
+m_vk.flushMappedMemoryRanges = (FlushMappedMemoryRangesFunc) GET_PROC_ADDR("vkFlushMappedMemoryRanges");
+m_vk.invalidateMappedMemoryRanges = (InvalidateMappedMemoryRangesFunc) GET_PROC_ADDR("vkInvalidateMappedMemoryRanges");
+m_vk.getDeviceMemoryCommitment = (GetDeviceMemoryCommitmentFunc) GET_PROC_ADDR("vkGetDeviceMemoryCommitment");
+m_vk.bindBufferMemory = (BindBufferMemoryFunc) GET_PROC_ADDR("vkBindBufferMemory");
+m_vk.bindImageMemory = (BindImageMemoryFunc) GET_PROC_ADDR("vkBindImageMemory");
+m_vk.getBufferMemoryRequirements = (GetBufferMemoryRequirementsFunc) GET_PROC_ADDR("vkGetBufferMemoryRequirements");
+m_vk.getImageMemoryRequirements = (GetImageMemoryRequirementsFunc) GET_PROC_ADDR("vkGetImageMemoryRequirements");
+m_vk.getImageSparseMemoryRequirements = (GetImageSparseMemoryRequirementsFunc) GET_PROC_ADDR("vkGetImageSparseMemoryRequirements");
+m_vk.queueBindSparse = (QueueBindSparseFunc) GET_PROC_ADDR("vkQueueBindSparse");
+m_vk.createFence = (CreateFenceFunc) GET_PROC_ADDR("vkCreateFence");
+m_vk.destroyFence = (DestroyFenceFunc) GET_PROC_ADDR("vkDestroyFence");
+m_vk.resetFences = (ResetFencesFunc) GET_PROC_ADDR("vkResetFences");
+m_vk.getFenceStatus = (GetFenceStatusFunc) GET_PROC_ADDR("vkGetFenceStatus");
+m_vk.waitForFences = (WaitForFencesFunc) GET_PROC_ADDR("vkWaitForFences");
+m_vk.createSemaphore = (CreateSemaphoreFunc) GET_PROC_ADDR("vkCreateSemaphore");
+m_vk.destroySemaphore = (DestroySemaphoreFunc) GET_PROC_ADDR("vkDestroySemaphore");
+m_vk.createEvent = (CreateEventFunc) GET_PROC_ADDR("vkCreateEvent");
+m_vk.destroyEvent = (DestroyEventFunc) GET_PROC_ADDR("vkDestroyEvent");
+m_vk.getEventStatus = (GetEventStatusFunc) GET_PROC_ADDR("vkGetEventStatus");
+m_vk.setEvent = (SetEventFunc) GET_PROC_ADDR("vkSetEvent");
+m_vk.resetEvent = (ResetEventFunc) GET_PROC_ADDR("vkResetEvent");
+m_vk.createQueryPool = (CreateQueryPoolFunc) GET_PROC_ADDR("vkCreateQueryPool");
+m_vk.destroyQueryPool = (DestroyQueryPoolFunc) GET_PROC_ADDR("vkDestroyQueryPool");
+m_vk.getQueryPoolResults = (GetQueryPoolResultsFunc) GET_PROC_ADDR("vkGetQueryPoolResults");
+m_vk.createBuffer = (CreateBufferFunc) GET_PROC_ADDR("vkCreateBuffer");
+m_vk.destroyBuffer = (DestroyBufferFunc) GET_PROC_ADDR("vkDestroyBuffer");
+m_vk.createBufferView = (CreateBufferViewFunc) GET_PROC_ADDR("vkCreateBufferView");
+m_vk.destroyBufferView = (DestroyBufferViewFunc) GET_PROC_ADDR("vkDestroyBufferView");
+m_vk.createImage = (CreateImageFunc) GET_PROC_ADDR("vkCreateImage");
+m_vk.destroyImage = (DestroyImageFunc) GET_PROC_ADDR("vkDestroyImage");
+m_vk.getImageSubresourceLayout = (GetImageSubresourceLayoutFunc) GET_PROC_ADDR("vkGetImageSubresourceLayout");
+m_vk.createImageView = (CreateImageViewFunc) GET_PROC_ADDR("vkCreateImageView");
+m_vk.destroyImageView = (DestroyImageViewFunc) GET_PROC_ADDR("vkDestroyImageView");
+m_vk.createShaderModule = (CreateShaderModuleFunc) GET_PROC_ADDR("vkCreateShaderModule");
+m_vk.destroyShaderModule = (DestroyShaderModuleFunc) GET_PROC_ADDR("vkDestroyShaderModule");
+m_vk.createPipelineCache = (CreatePipelineCacheFunc) GET_PROC_ADDR("vkCreatePipelineCache");
+m_vk.destroyPipelineCache = (DestroyPipelineCacheFunc) GET_PROC_ADDR("vkDestroyPipelineCache");
+m_vk.getPipelineCacheData = (GetPipelineCacheDataFunc) GET_PROC_ADDR("vkGetPipelineCacheData");
+m_vk.mergePipelineCaches = (MergePipelineCachesFunc) GET_PROC_ADDR("vkMergePipelineCaches");
+m_vk.createGraphicsPipelines = (CreateGraphicsPipelinesFunc) GET_PROC_ADDR("vkCreateGraphicsPipelines");
+m_vk.createComputePipelines = (CreateComputePipelinesFunc) GET_PROC_ADDR("vkCreateComputePipelines");
+m_vk.destroyPipeline = (DestroyPipelineFunc) GET_PROC_ADDR("vkDestroyPipeline");
+m_vk.createPipelineLayout = (CreatePipelineLayoutFunc) GET_PROC_ADDR("vkCreatePipelineLayout");
+m_vk.destroyPipelineLayout = (DestroyPipelineLayoutFunc) GET_PROC_ADDR("vkDestroyPipelineLayout");
+m_vk.createSampler = (CreateSamplerFunc) GET_PROC_ADDR("vkCreateSampler");
+m_vk.destroySampler = (DestroySamplerFunc) GET_PROC_ADDR("vkDestroySampler");
+m_vk.createDescriptorSetLayout = (CreateDescriptorSetLayoutFunc) GET_PROC_ADDR("vkCreateDescriptorSetLayout");
+m_vk.destroyDescriptorSetLayout = (DestroyDescriptorSetLayoutFunc) GET_PROC_ADDR("vkDestroyDescriptorSetLayout");
+m_vk.createDescriptorPool = (CreateDescriptorPoolFunc) GET_PROC_ADDR("vkCreateDescriptorPool");
+m_vk.destroyDescriptorPool = (DestroyDescriptorPoolFunc) GET_PROC_ADDR("vkDestroyDescriptorPool");
+m_vk.resetDescriptorPool = (ResetDescriptorPoolFunc) GET_PROC_ADDR("vkResetDescriptorPool");
+m_vk.allocateDescriptorSets = (AllocateDescriptorSetsFunc) GET_PROC_ADDR("vkAllocateDescriptorSets");
+m_vk.freeDescriptorSets = (FreeDescriptorSetsFunc) GET_PROC_ADDR("vkFreeDescriptorSets");
+m_vk.updateDescriptorSets = (UpdateDescriptorSetsFunc) GET_PROC_ADDR("vkUpdateDescriptorSets");
+m_vk.createFramebuffer = (CreateFramebufferFunc) GET_PROC_ADDR("vkCreateFramebuffer");
+m_vk.destroyFramebuffer = (DestroyFramebufferFunc) GET_PROC_ADDR("vkDestroyFramebuffer");
+m_vk.createRenderPass = (CreateRenderPassFunc) GET_PROC_ADDR("vkCreateRenderPass");
+m_vk.destroyRenderPass = (DestroyRenderPassFunc) GET_PROC_ADDR("vkDestroyRenderPass");
+m_vk.getRenderAreaGranularity = (GetRenderAreaGranularityFunc) GET_PROC_ADDR("vkGetRenderAreaGranularity");
+m_vk.createCommandPool = (CreateCommandPoolFunc) GET_PROC_ADDR("vkCreateCommandPool");
+m_vk.destroyCommandPool = (DestroyCommandPoolFunc) GET_PROC_ADDR("vkDestroyCommandPool");
+m_vk.resetCommandPool = (ResetCommandPoolFunc) GET_PROC_ADDR("vkResetCommandPool");
+m_vk.allocateCommandBuffers = (AllocateCommandBuffersFunc) GET_PROC_ADDR("vkAllocateCommandBuffers");
+m_vk.freeCommandBuffers = (FreeCommandBuffersFunc) GET_PROC_ADDR("vkFreeCommandBuffers");
+m_vk.beginCommandBuffer = (BeginCommandBufferFunc) GET_PROC_ADDR("vkBeginCommandBuffer");
+m_vk.endCommandBuffer = (EndCommandBufferFunc) GET_PROC_ADDR("vkEndCommandBuffer");
+m_vk.resetCommandBuffer = (ResetCommandBufferFunc) GET_PROC_ADDR("vkResetCommandBuffer");
+m_vk.cmdBindPipeline = (CmdBindPipelineFunc) GET_PROC_ADDR("vkCmdBindPipeline");
+m_vk.cmdSetViewport = (CmdSetViewportFunc) GET_PROC_ADDR("vkCmdSetViewport");
+m_vk.cmdSetScissor = (CmdSetScissorFunc) GET_PROC_ADDR("vkCmdSetScissor");
+m_vk.cmdSetLineWidth = (CmdSetLineWidthFunc) GET_PROC_ADDR("vkCmdSetLineWidth");
+m_vk.cmdSetDepthBias = (CmdSetDepthBiasFunc) GET_PROC_ADDR("vkCmdSetDepthBias");
+m_vk.cmdSetBlendConstants = (CmdSetBlendConstantsFunc) GET_PROC_ADDR("vkCmdSetBlendConstants");
+m_vk.cmdSetDepthBounds = (CmdSetDepthBoundsFunc) GET_PROC_ADDR("vkCmdSetDepthBounds");
+m_vk.cmdSetStencilCompareMask = (CmdSetStencilCompareMaskFunc) GET_PROC_ADDR("vkCmdSetStencilCompareMask");
+m_vk.cmdSetStencilWriteMask = (CmdSetStencilWriteMaskFunc) GET_PROC_ADDR("vkCmdSetStencilWriteMask");
+m_vk.cmdSetStencilReference = (CmdSetStencilReferenceFunc) GET_PROC_ADDR("vkCmdSetStencilReference");
+m_vk.cmdBindDescriptorSets = (CmdBindDescriptorSetsFunc) GET_PROC_ADDR("vkCmdBindDescriptorSets");
+m_vk.cmdBindIndexBuffer = (CmdBindIndexBufferFunc) GET_PROC_ADDR("vkCmdBindIndexBuffer");
+m_vk.cmdBindVertexBuffers = (CmdBindVertexBuffersFunc) GET_PROC_ADDR("vkCmdBindVertexBuffers");
+m_vk.cmdDraw = (CmdDrawFunc) GET_PROC_ADDR("vkCmdDraw");
+m_vk.cmdDrawIndexed = (CmdDrawIndexedFunc) GET_PROC_ADDR("vkCmdDrawIndexed");
+m_vk.cmdDrawIndirect = (CmdDrawIndirectFunc) GET_PROC_ADDR("vkCmdDrawIndirect");
+m_vk.cmdDrawIndexedIndirect = (CmdDrawIndexedIndirectFunc) GET_PROC_ADDR("vkCmdDrawIndexedIndirect");
+m_vk.cmdDispatch = (CmdDispatchFunc) GET_PROC_ADDR("vkCmdDispatch");
+m_vk.cmdDispatchIndirect = (CmdDispatchIndirectFunc) GET_PROC_ADDR("vkCmdDispatchIndirect");
+m_vk.cmdCopyBuffer = (CmdCopyBufferFunc) GET_PROC_ADDR("vkCmdCopyBuffer");
+m_vk.cmdCopyImage = (CmdCopyImageFunc) GET_PROC_ADDR("vkCmdCopyImage");
+m_vk.cmdBlitImage = (CmdBlitImageFunc) GET_PROC_ADDR("vkCmdBlitImage");
+m_vk.cmdCopyBufferToImage = (CmdCopyBufferToImageFunc) GET_PROC_ADDR("vkCmdCopyBufferToImage");
+m_vk.cmdCopyImageToBuffer = (CmdCopyImageToBufferFunc) GET_PROC_ADDR("vkCmdCopyImageToBuffer");
+m_vk.cmdUpdateBuffer = (CmdUpdateBufferFunc) GET_PROC_ADDR("vkCmdUpdateBuffer");
+m_vk.cmdFillBuffer = (CmdFillBufferFunc) GET_PROC_ADDR("vkCmdFillBuffer");
+m_vk.cmdClearColorImage = (CmdClearColorImageFunc) GET_PROC_ADDR("vkCmdClearColorImage");
+m_vk.cmdClearDepthStencilImage = (CmdClearDepthStencilImageFunc) GET_PROC_ADDR("vkCmdClearDepthStencilImage");
+m_vk.cmdClearAttachments = (CmdClearAttachmentsFunc) GET_PROC_ADDR("vkCmdClearAttachments");
+m_vk.cmdResolveImage = (CmdResolveImageFunc) GET_PROC_ADDR("vkCmdResolveImage");
+m_vk.cmdSetEvent = (CmdSetEventFunc) GET_PROC_ADDR("vkCmdSetEvent");
+m_vk.cmdResetEvent = (CmdResetEventFunc) GET_PROC_ADDR("vkCmdResetEvent");
+m_vk.cmdWaitEvents = (CmdWaitEventsFunc) GET_PROC_ADDR("vkCmdWaitEvents");
+m_vk.cmdPipelineBarrier = (CmdPipelineBarrierFunc) GET_PROC_ADDR("vkCmdPipelineBarrier");
+m_vk.cmdBeginQuery = (CmdBeginQueryFunc) GET_PROC_ADDR("vkCmdBeginQuery");
+m_vk.cmdEndQuery = (CmdEndQueryFunc) GET_PROC_ADDR("vkCmdEndQuery");
+m_vk.cmdResetQueryPool = (CmdResetQueryPoolFunc) GET_PROC_ADDR("vkCmdResetQueryPool");
+m_vk.cmdWriteTimestamp = (CmdWriteTimestampFunc) GET_PROC_ADDR("vkCmdWriteTimestamp");
+m_vk.cmdCopyQueryPoolResults = (CmdCopyQueryPoolResultsFunc) GET_PROC_ADDR("vkCmdCopyQueryPoolResults");
+m_vk.cmdPushConstants = (CmdPushConstantsFunc) GET_PROC_ADDR("vkCmdPushConstants");
+m_vk.cmdBeginRenderPass = (CmdBeginRenderPassFunc) GET_PROC_ADDR("vkCmdBeginRenderPass");
+m_vk.cmdNextSubpass = (CmdNextSubpassFunc) GET_PROC_ADDR("vkCmdNextSubpass");
+m_vk.cmdEndRenderPass = (CmdEndRenderPassFunc) GET_PROC_ADDR("vkCmdEndRenderPass");
+m_vk.cmdExecuteCommands = (CmdExecuteCommandsFunc) GET_PROC_ADDR("vkCmdExecuteCommands");
+m_vk.bindBufferMemory2 = (BindBufferMemory2Func) GET_PROC_ADDR("vkBindBufferMemory2");
if (!m_vk.bindBufferMemory2)
- m_vk.bindBufferMemory2 = (BindBufferMemory2Func) GET_PROC_ADDR("vkBindBufferMemory2KHR");
-m_vk.bindImageMemory2 = (BindImageMemory2Func) GET_PROC_ADDR("vkBindImageMemory2");
+ m_vk.bindBufferMemory2 = (BindBufferMemory2Func) GET_PROC_ADDR("vkBindBufferMemory2KHR");
+m_vk.bindImageMemory2 = (BindImageMemory2Func) GET_PROC_ADDR("vkBindImageMemory2");
if (!m_vk.bindImageMemory2)
- m_vk.bindImageMemory2 = (BindImageMemory2Func) GET_PROC_ADDR("vkBindImageMemory2KHR");
-m_vk.getDeviceGroupPeerMemoryFeatures = (GetDeviceGroupPeerMemoryFeaturesFunc) GET_PROC_ADDR("vkGetDeviceGroupPeerMemoryFeatures");
+ m_vk.bindImageMemory2 = (BindImageMemory2Func) GET_PROC_ADDR("vkBindImageMemory2KHR");
+m_vk.getDeviceGroupPeerMemoryFeatures = (GetDeviceGroupPeerMemoryFeaturesFunc) GET_PROC_ADDR("vkGetDeviceGroupPeerMemoryFeatures");
if (!m_vk.getDeviceGroupPeerMemoryFeatures)
- m_vk.getDeviceGroupPeerMemoryFeatures = (GetDeviceGroupPeerMemoryFeaturesFunc) GET_PROC_ADDR("vkGetDeviceGroupPeerMemoryFeaturesKHR");
-m_vk.cmdSetDeviceMask = (CmdSetDeviceMaskFunc) GET_PROC_ADDR("vkCmdSetDeviceMask");
+ m_vk.getDeviceGroupPeerMemoryFeatures = (GetDeviceGroupPeerMemoryFeaturesFunc) GET_PROC_ADDR("vkGetDeviceGroupPeerMemoryFeaturesKHR");
+m_vk.cmdSetDeviceMask = (CmdSetDeviceMaskFunc) GET_PROC_ADDR("vkCmdSetDeviceMask");
if (!m_vk.cmdSetDeviceMask)
- m_vk.cmdSetDeviceMask = (CmdSetDeviceMaskFunc) GET_PROC_ADDR("vkCmdSetDeviceMaskKHR");
-m_vk.cmdDispatchBase = (CmdDispatchBaseFunc) GET_PROC_ADDR("vkCmdDispatchBase");
+ m_vk.cmdSetDeviceMask = (CmdSetDeviceMaskFunc) GET_PROC_ADDR("vkCmdSetDeviceMaskKHR");
+m_vk.cmdDispatchBase = (CmdDispatchBaseFunc) GET_PROC_ADDR("vkCmdDispatchBase");
if (!m_vk.cmdDispatchBase)
- m_vk.cmdDispatchBase = (CmdDispatchBaseFunc) GET_PROC_ADDR("vkCmdDispatchBaseKHR");
-m_vk.getImageMemoryRequirements2 = (GetImageMemoryRequirements2Func) GET_PROC_ADDR("vkGetImageMemoryRequirements2");
+ m_vk.cmdDispatchBase = (CmdDispatchBaseFunc) GET_PROC_ADDR("vkCmdDispatchBaseKHR");
+m_vk.getImageMemoryRequirements2 = (GetImageMemoryRequirements2Func) GET_PROC_ADDR("vkGetImageMemoryRequirements2");
if (!m_vk.getImageMemoryRequirements2)
- m_vk.getImageMemoryRequirements2 = (GetImageMemoryRequirements2Func) GET_PROC_ADDR("vkGetImageMemoryRequirements2KHR");
-m_vk.getBufferMemoryRequirements2 = (GetBufferMemoryRequirements2Func) GET_PROC_ADDR("vkGetBufferMemoryRequirements2");
+ m_vk.getImageMemoryRequirements2 = (GetImageMemoryRequirements2Func) GET_PROC_ADDR("vkGetImageMemoryRequirements2KHR");
+m_vk.getBufferMemoryRequirements2 = (GetBufferMemoryRequirements2Func) GET_PROC_ADDR("vkGetBufferMemoryRequirements2");
if (!m_vk.getBufferMemoryRequirements2)
- m_vk.getBufferMemoryRequirements2 = (GetBufferMemoryRequirements2Func) GET_PROC_ADDR("vkGetBufferMemoryRequirements2KHR");
-m_vk.getImageSparseMemoryRequirements2 = (GetImageSparseMemoryRequirements2Func) GET_PROC_ADDR("vkGetImageSparseMemoryRequirements2");
+ m_vk.getBufferMemoryRequirements2 = (GetBufferMemoryRequirements2Func) GET_PROC_ADDR("vkGetBufferMemoryRequirements2KHR");
+m_vk.getImageSparseMemoryRequirements2 = (GetImageSparseMemoryRequirements2Func) GET_PROC_ADDR("vkGetImageSparseMemoryRequirements2");
if (!m_vk.getImageSparseMemoryRequirements2)
- m_vk.getImageSparseMemoryRequirements2 = (GetImageSparseMemoryRequirements2Func) GET_PROC_ADDR("vkGetImageSparseMemoryRequirements2KHR");
-m_vk.trimCommandPool = (TrimCommandPoolFunc) GET_PROC_ADDR("vkTrimCommandPool");
+ m_vk.getImageSparseMemoryRequirements2 = (GetImageSparseMemoryRequirements2Func) GET_PROC_ADDR("vkGetImageSparseMemoryRequirements2KHR");
+m_vk.trimCommandPool = (TrimCommandPoolFunc) GET_PROC_ADDR("vkTrimCommandPool");
if (!m_vk.trimCommandPool)
- m_vk.trimCommandPool = (TrimCommandPoolFunc) GET_PROC_ADDR("vkTrimCommandPoolKHR");
-m_vk.getDeviceQueue2 = (GetDeviceQueue2Func) GET_PROC_ADDR("vkGetDeviceQueue2");
-m_vk.createSamplerYcbcrConversion = (CreateSamplerYcbcrConversionFunc) GET_PROC_ADDR("vkCreateSamplerYcbcrConversion");
+ m_vk.trimCommandPool = (TrimCommandPoolFunc) GET_PROC_ADDR("vkTrimCommandPoolKHR");
+m_vk.getDeviceQueue2 = (GetDeviceQueue2Func) GET_PROC_ADDR("vkGetDeviceQueue2");
+m_vk.createSamplerYcbcrConversion = (CreateSamplerYcbcrConversionFunc) GET_PROC_ADDR("vkCreateSamplerYcbcrConversion");
if (!m_vk.createSamplerYcbcrConversion)
- m_vk.createSamplerYcbcrConversion = (CreateSamplerYcbcrConversionFunc) GET_PROC_ADDR("vkCreateSamplerYcbcrConversionKHR");
-m_vk.destroySamplerYcbcrConversion = (DestroySamplerYcbcrConversionFunc) GET_PROC_ADDR("vkDestroySamplerYcbcrConversion");
+ m_vk.createSamplerYcbcrConversion = (CreateSamplerYcbcrConversionFunc) GET_PROC_ADDR("vkCreateSamplerYcbcrConversionKHR");
+m_vk.destroySamplerYcbcrConversion = (DestroySamplerYcbcrConversionFunc) GET_PROC_ADDR("vkDestroySamplerYcbcrConversion");
if (!m_vk.destroySamplerYcbcrConversion)
- m_vk.destroySamplerYcbcrConversion = (DestroySamplerYcbcrConversionFunc) GET_PROC_ADDR("vkDestroySamplerYcbcrConversionKHR");
-m_vk.createDescriptorUpdateTemplate = (CreateDescriptorUpdateTemplateFunc) GET_PROC_ADDR("vkCreateDescriptorUpdateTemplate");
+ m_vk.destroySamplerYcbcrConversion = (DestroySamplerYcbcrConversionFunc) GET_PROC_ADDR("vkDestroySamplerYcbcrConversionKHR");
+m_vk.createDescriptorUpdateTemplate = (CreateDescriptorUpdateTemplateFunc) GET_PROC_ADDR("vkCreateDescriptorUpdateTemplate");
if (!m_vk.createDescriptorUpdateTemplate)
- m_vk.createDescriptorUpdateTemplate = (CreateDescriptorUpdateTemplateFunc) GET_PROC_ADDR("vkCreateDescriptorUpdateTemplateKHR");
-m_vk.destroyDescriptorUpdateTemplate = (DestroyDescriptorUpdateTemplateFunc) GET_PROC_ADDR("vkDestroyDescriptorUpdateTemplate");
+ m_vk.createDescriptorUpdateTemplate = (CreateDescriptorUpdateTemplateFunc) GET_PROC_ADDR("vkCreateDescriptorUpdateTemplateKHR");
+m_vk.destroyDescriptorUpdateTemplate = (DestroyDescriptorUpdateTemplateFunc) GET_PROC_ADDR("vkDestroyDescriptorUpdateTemplate");
if (!m_vk.destroyDescriptorUpdateTemplate)
- m_vk.destroyDescriptorUpdateTemplate = (DestroyDescriptorUpdateTemplateFunc) GET_PROC_ADDR("vkDestroyDescriptorUpdateTemplateKHR");
-m_vk.updateDescriptorSetWithTemplate = (UpdateDescriptorSetWithTemplateFunc) GET_PROC_ADDR("vkUpdateDescriptorSetWithTemplate");
+ m_vk.destroyDescriptorUpdateTemplate = (DestroyDescriptorUpdateTemplateFunc) GET_PROC_ADDR("vkDestroyDescriptorUpdateTemplateKHR");
+m_vk.updateDescriptorSetWithTemplate = (UpdateDescriptorSetWithTemplateFunc) GET_PROC_ADDR("vkUpdateDescriptorSetWithTemplate");
if (!m_vk.updateDescriptorSetWithTemplate)
- m_vk.updateDescriptorSetWithTemplate = (UpdateDescriptorSetWithTemplateFunc) GET_PROC_ADDR("vkUpdateDescriptorSetWithTemplateKHR");
-m_vk.getDescriptorSetLayoutSupport = (GetDescriptorSetLayoutSupportFunc) GET_PROC_ADDR("vkGetDescriptorSetLayoutSupport");
+ m_vk.updateDescriptorSetWithTemplate = (UpdateDescriptorSetWithTemplateFunc) GET_PROC_ADDR("vkUpdateDescriptorSetWithTemplateKHR");
+m_vk.getDescriptorSetLayoutSupport = (GetDescriptorSetLayoutSupportFunc) GET_PROC_ADDR("vkGetDescriptorSetLayoutSupport");
if (!m_vk.getDescriptorSetLayoutSupport)
- m_vk.getDescriptorSetLayoutSupport = (GetDescriptorSetLayoutSupportFunc) GET_PROC_ADDR("vkGetDescriptorSetLayoutSupportKHR");
-m_vk.createSwapchainKHR = (CreateSwapchainKHRFunc) GET_PROC_ADDR("vkCreateSwapchainKHR");
-m_vk.destroySwapchainKHR = (DestroySwapchainKHRFunc) GET_PROC_ADDR("vkDestroySwapchainKHR");
-m_vk.getSwapchainImagesKHR = (GetSwapchainImagesKHRFunc) GET_PROC_ADDR("vkGetSwapchainImagesKHR");
-m_vk.acquireNextImageKHR = (AcquireNextImageKHRFunc) GET_PROC_ADDR("vkAcquireNextImageKHR");
-m_vk.queuePresentKHR = (QueuePresentKHRFunc) GET_PROC_ADDR("vkQueuePresentKHR");
-m_vk.getDeviceGroupPresentCapabilitiesKHR = (GetDeviceGroupPresentCapabilitiesKHRFunc) GET_PROC_ADDR("vkGetDeviceGroupPresentCapabilitiesKHR");
-m_vk.getDeviceGroupSurfacePresentModesKHR = (GetDeviceGroupSurfacePresentModesKHRFunc) GET_PROC_ADDR("vkGetDeviceGroupSurfacePresentModesKHR");
-m_vk.acquireNextImage2KHR = (AcquireNextImage2KHRFunc) GET_PROC_ADDR("vkAcquireNextImage2KHR");
-m_vk.createSharedSwapchainsKHR = (CreateSharedSwapchainsKHRFunc) GET_PROC_ADDR("vkCreateSharedSwapchainsKHR");
-m_vk.getMemoryFdKHR = (GetMemoryFdKHRFunc) GET_PROC_ADDR("vkGetMemoryFdKHR");
-m_vk.getMemoryFdPropertiesKHR = (GetMemoryFdPropertiesKHRFunc) GET_PROC_ADDR("vkGetMemoryFdPropertiesKHR");
-m_vk.importSemaphoreFdKHR = (ImportSemaphoreFdKHRFunc) GET_PROC_ADDR("vkImportSemaphoreFdKHR");
-m_vk.getSemaphoreFdKHR = (GetSemaphoreFdKHRFunc) GET_PROC_ADDR("vkGetSemaphoreFdKHR");
-m_vk.cmdPushDescriptorSetKHR = (CmdPushDescriptorSetKHRFunc) GET_PROC_ADDR("vkCmdPushDescriptorSetKHR");
-m_vk.cmdPushDescriptorSetWithTemplateKHR = (CmdPushDescriptorSetWithTemplateKHRFunc) GET_PROC_ADDR("vkCmdPushDescriptorSetWithTemplateKHR");
-m_vk.createRenderPass2KHR = (CreateRenderPass2KHRFunc) GET_PROC_ADDR("vkCreateRenderPass2KHR");
-m_vk.cmdBeginRenderPass2KHR = (CmdBeginRenderPass2KHRFunc) GET_PROC_ADDR("vkCmdBeginRenderPass2KHR");
-m_vk.cmdNextSubpass2KHR = (CmdNextSubpass2KHRFunc) GET_PROC_ADDR("vkCmdNextSubpass2KHR");
-m_vk.cmdEndRenderPass2KHR = (CmdEndRenderPass2KHRFunc) GET_PROC_ADDR("vkCmdEndRenderPass2KHR");
-m_vk.getSwapchainStatusKHR = (GetSwapchainStatusKHRFunc) GET_PROC_ADDR("vkGetSwapchainStatusKHR");
-m_vk.importFenceFdKHR = (ImportFenceFdKHRFunc) GET_PROC_ADDR("vkImportFenceFdKHR");
-m_vk.getFenceFdKHR = (GetFenceFdKHRFunc) GET_PROC_ADDR("vkGetFenceFdKHR");
-m_vk.acquireProfilingLockKHR = (AcquireProfilingLockKHRFunc) GET_PROC_ADDR("vkAcquireProfilingLockKHR");
-m_vk.releaseProfilingLockKHR = (ReleaseProfilingLockKHRFunc) GET_PROC_ADDR("vkReleaseProfilingLockKHR");
-m_vk.cmdDrawIndirectCountKHR = (CmdDrawIndirectCountKHRFunc) GET_PROC_ADDR("vkCmdDrawIndirectCountKHR");
-m_vk.cmdDrawIndexedIndirectCountKHR = (CmdDrawIndexedIndirectCountKHRFunc) GET_PROC_ADDR("vkCmdDrawIndexedIndirectCountKHR");
-m_vk.debugMarkerSetObjectTagEXT = (DebugMarkerSetObjectTagEXTFunc) GET_PROC_ADDR("vkDebugMarkerSetObjectTagEXT");
-m_vk.debugMarkerSetObjectNameEXT = (DebugMarkerSetObjectNameEXTFunc) GET_PROC_ADDR("vkDebugMarkerSetObjectNameEXT");
-m_vk.cmdDebugMarkerBeginEXT = (CmdDebugMarkerBeginEXTFunc) GET_PROC_ADDR("vkCmdDebugMarkerBeginEXT");
-m_vk.cmdDebugMarkerEndEXT = (CmdDebugMarkerEndEXTFunc) GET_PROC_ADDR("vkCmdDebugMarkerEndEXT");
-m_vk.cmdDebugMarkerInsertEXT = (CmdDebugMarkerInsertEXTFunc) GET_PROC_ADDR("vkCmdDebugMarkerInsertEXT");
-m_vk.cmdBindTransformFeedbackBuffersEXT = (CmdBindTransformFeedbackBuffersEXTFunc) GET_PROC_ADDR("vkCmdBindTransformFeedbackBuffersEXT");
-m_vk.cmdBeginTransformFeedbackEXT = (CmdBeginTransformFeedbackEXTFunc) GET_PROC_ADDR("vkCmdBeginTransformFeedbackEXT");
-m_vk.cmdEndTransformFeedbackEXT = (CmdEndTransformFeedbackEXTFunc) GET_PROC_ADDR("vkCmdEndTransformFeedbackEXT");
-m_vk.cmdBeginQueryIndexedEXT = (CmdBeginQueryIndexedEXTFunc) GET_PROC_ADDR("vkCmdBeginQueryIndexedEXT");
-m_vk.cmdEndQueryIndexedEXT = (CmdEndQueryIndexedEXTFunc) GET_PROC_ADDR("vkCmdEndQueryIndexedEXT");
-m_vk.cmdDrawIndirectByteCountEXT = (CmdDrawIndirectByteCountEXTFunc) GET_PROC_ADDR("vkCmdDrawIndirectByteCountEXT");
-m_vk.getImageViewHandleNVX = (GetImageViewHandleNVXFunc) GET_PROC_ADDR("vkGetImageViewHandleNVX");
-m_vk.cmdDrawIndirectCountAMD = (CmdDrawIndirectCountAMDFunc) GET_PROC_ADDR("vkCmdDrawIndirectCountAMD");
-m_vk.cmdDrawIndexedIndirectCountAMD = (CmdDrawIndexedIndirectCountAMDFunc) GET_PROC_ADDR("vkCmdDrawIndexedIndirectCountAMD");
-m_vk.getShaderInfoAMD = (GetShaderInfoAMDFunc) GET_PROC_ADDR("vkGetShaderInfoAMD");
-m_vk.cmdBeginConditionalRenderingEXT = (CmdBeginConditionalRenderingEXTFunc) GET_PROC_ADDR("vkCmdBeginConditionalRenderingEXT");
-m_vk.cmdEndConditionalRenderingEXT = (CmdEndConditionalRenderingEXTFunc) GET_PROC_ADDR("vkCmdEndConditionalRenderingEXT");
-m_vk.cmdProcessCommandsNVX = (CmdProcessCommandsNVXFunc) GET_PROC_ADDR("vkCmdProcessCommandsNVX");
-m_vk.cmdReserveSpaceForCommandsNVX = (CmdReserveSpaceForCommandsNVXFunc) GET_PROC_ADDR("vkCmdReserveSpaceForCommandsNVX");
-m_vk.createIndirectCommandsLayoutNVX = (CreateIndirectCommandsLayoutNVXFunc) GET_PROC_ADDR("vkCreateIndirectCommandsLayoutNVX");
-m_vk.destroyIndirectCommandsLayoutNVX = (DestroyIndirectCommandsLayoutNVXFunc) GET_PROC_ADDR("vkDestroyIndirectCommandsLayoutNVX");
-m_vk.createObjectTableNVX = (CreateObjectTableNVXFunc) GET_PROC_ADDR("vkCreateObjectTableNVX");
-m_vk.destroyObjectTableNVX = (DestroyObjectTableNVXFunc) GET_PROC_ADDR("vkDestroyObjectTableNVX");
-m_vk.registerObjectsNVX = (RegisterObjectsNVXFunc) GET_PROC_ADDR("vkRegisterObjectsNVX");
-m_vk.unregisterObjectsNVX = (UnregisterObjectsNVXFunc) GET_PROC_ADDR("vkUnregisterObjectsNVX");
-m_vk.cmdSetViewportWScalingNV = (CmdSetViewportWScalingNVFunc) GET_PROC_ADDR("vkCmdSetViewportWScalingNV");
-m_vk.displayPowerControlEXT = (DisplayPowerControlEXTFunc) GET_PROC_ADDR("vkDisplayPowerControlEXT");
-m_vk.registerDeviceEventEXT = (RegisterDeviceEventEXTFunc) GET_PROC_ADDR("vkRegisterDeviceEventEXT");
-m_vk.registerDisplayEventEXT = (RegisterDisplayEventEXTFunc) GET_PROC_ADDR("vkRegisterDisplayEventEXT");
-m_vk.getSwapchainCounterEXT = (GetSwapchainCounterEXTFunc) GET_PROC_ADDR("vkGetSwapchainCounterEXT");
-m_vk.getRefreshCycleDurationGOOGLE = (GetRefreshCycleDurationGOOGLEFunc) GET_PROC_ADDR("vkGetRefreshCycleDurationGOOGLE");
-m_vk.getPastPresentationTimingGOOGLE = (GetPastPresentationTimingGOOGLEFunc) GET_PROC_ADDR("vkGetPastPresentationTimingGOOGLE");
-m_vk.cmdSetDiscardRectangleEXT = (CmdSetDiscardRectangleEXTFunc) GET_PROC_ADDR("vkCmdSetDiscardRectangleEXT");
-m_vk.setHdrMetadataEXT = (SetHdrMetadataEXTFunc) GET_PROC_ADDR("vkSetHdrMetadataEXT");
-m_vk.setDebugUtilsObjectNameEXT = (SetDebugUtilsObjectNameEXTFunc) GET_PROC_ADDR("vkSetDebugUtilsObjectNameEXT");
-m_vk.setDebugUtilsObjectTagEXT = (SetDebugUtilsObjectTagEXTFunc) GET_PROC_ADDR("vkSetDebugUtilsObjectTagEXT");
-m_vk.queueBeginDebugUtilsLabelEXT = (QueueBeginDebugUtilsLabelEXTFunc) GET_PROC_ADDR("vkQueueBeginDebugUtilsLabelEXT");
-m_vk.queueEndDebugUtilsLabelEXT = (QueueEndDebugUtilsLabelEXTFunc) GET_PROC_ADDR("vkQueueEndDebugUtilsLabelEXT");
-m_vk.queueInsertDebugUtilsLabelEXT = (QueueInsertDebugUtilsLabelEXTFunc) GET_PROC_ADDR("vkQueueInsertDebugUtilsLabelEXT");
-m_vk.cmdBeginDebugUtilsLabelEXT = (CmdBeginDebugUtilsLabelEXTFunc) GET_PROC_ADDR("vkCmdBeginDebugUtilsLabelEXT");
-m_vk.cmdEndDebugUtilsLabelEXT = (CmdEndDebugUtilsLabelEXTFunc) GET_PROC_ADDR("vkCmdEndDebugUtilsLabelEXT");
-m_vk.cmdInsertDebugUtilsLabelEXT = (CmdInsertDebugUtilsLabelEXTFunc) GET_PROC_ADDR("vkCmdInsertDebugUtilsLabelEXT");
-m_vk.cmdSetSampleLocationsEXT = (CmdSetSampleLocationsEXTFunc) GET_PROC_ADDR("vkCmdSetSampleLocationsEXT");
-m_vk.getImageDrmFormatModifierPropertiesEXT = (GetImageDrmFormatModifierPropertiesEXTFunc) GET_PROC_ADDR("vkGetImageDrmFormatModifierPropertiesEXT");
-m_vk.createValidationCacheEXT = (CreateValidationCacheEXTFunc) GET_PROC_ADDR("vkCreateValidationCacheEXT");
-m_vk.destroyValidationCacheEXT = (DestroyValidationCacheEXTFunc) GET_PROC_ADDR("vkDestroyValidationCacheEXT");
-m_vk.mergeValidationCachesEXT = (MergeValidationCachesEXTFunc) GET_PROC_ADDR("vkMergeValidationCachesEXT");
-m_vk.getValidationCacheDataEXT = (GetValidationCacheDataEXTFunc) GET_PROC_ADDR("vkGetValidationCacheDataEXT");
-m_vk.cmdBindShadingRateImageNV = (CmdBindShadingRateImageNVFunc) GET_PROC_ADDR("vkCmdBindShadingRateImageNV");
-m_vk.cmdSetViewportShadingRatePaletteNV = (CmdSetViewportShadingRatePaletteNVFunc) GET_PROC_ADDR("vkCmdSetViewportShadingRatePaletteNV");
-m_vk.cmdSetCoarseSampleOrderNV = (CmdSetCoarseSampleOrderNVFunc) GET_PROC_ADDR("vkCmdSetCoarseSampleOrderNV");
-m_vk.createAccelerationStructureNV = (CreateAccelerationStructureNVFunc) GET_PROC_ADDR("vkCreateAccelerationStructureNV");
-m_vk.destroyAccelerationStructureNV = (DestroyAccelerationStructureNVFunc) GET_PROC_ADDR("vkDestroyAccelerationStructureNV");
-m_vk.getAccelerationStructureMemoryRequirementsNV = (GetAccelerationStructureMemoryRequirementsNVFunc) GET_PROC_ADDR("vkGetAccelerationStructureMemoryRequirementsNV");
-m_vk.bindAccelerationStructureMemoryNV = (BindAccelerationStructureMemoryNVFunc) GET_PROC_ADDR("vkBindAccelerationStructureMemoryNV");
-m_vk.cmdBuildAccelerationStructureNV = (CmdBuildAccelerationStructureNVFunc) GET_PROC_ADDR("vkCmdBuildAccelerationStructureNV");
-m_vk.cmdCopyAccelerationStructureNV = (CmdCopyAccelerationStructureNVFunc) GET_PROC_ADDR("vkCmdCopyAccelerationStructureNV");
-m_vk.cmdTraceRaysNV = (CmdTraceRaysNVFunc) GET_PROC_ADDR("vkCmdTraceRaysNV");
-m_vk.createRayTracingPipelinesNV = (CreateRayTracingPipelinesNVFunc) GET_PROC_ADDR("vkCreateRayTracingPipelinesNV");
-m_vk.getRayTracingShaderGroupHandlesNV = (GetRayTracingShaderGroupHandlesNVFunc) GET_PROC_ADDR("vkGetRayTracingShaderGroupHandlesNV");
-m_vk.getAccelerationStructureHandleNV = (GetAccelerationStructureHandleNVFunc) GET_PROC_ADDR("vkGetAccelerationStructureHandleNV");
-m_vk.cmdWriteAccelerationStructuresPropertiesNV = (CmdWriteAccelerationStructuresPropertiesNVFunc) GET_PROC_ADDR("vkCmdWriteAccelerationStructuresPropertiesNV");
-m_vk.compileDeferredNV = (CompileDeferredNVFunc) GET_PROC_ADDR("vkCompileDeferredNV");
-m_vk.getMemoryHostPointerPropertiesEXT = (GetMemoryHostPointerPropertiesEXTFunc) GET_PROC_ADDR("vkGetMemoryHostPointerPropertiesEXT");
-m_vk.cmdWriteBufferMarkerAMD = (CmdWriteBufferMarkerAMDFunc) GET_PROC_ADDR("vkCmdWriteBufferMarkerAMD");
-m_vk.getCalibratedTimestampsEXT = (GetCalibratedTimestampsEXTFunc) GET_PROC_ADDR("vkGetCalibratedTimestampsEXT");
-m_vk.cmdDrawMeshTasksNV = (CmdDrawMeshTasksNVFunc) GET_PROC_ADDR("vkCmdDrawMeshTasksNV");
-m_vk.cmdDrawMeshTasksIndirectNV = (CmdDrawMeshTasksIndirectNVFunc) GET_PROC_ADDR("vkCmdDrawMeshTasksIndirectNV");
-m_vk.cmdDrawMeshTasksIndirectCountNV = (CmdDrawMeshTasksIndirectCountNVFunc) GET_PROC_ADDR("vkCmdDrawMeshTasksIndirectCountNV");
-m_vk.cmdSetExclusiveScissorNV = (CmdSetExclusiveScissorNVFunc) GET_PROC_ADDR("vkCmdSetExclusiveScissorNV");
-m_vk.cmdSetCheckpointNV = (CmdSetCheckpointNVFunc) GET_PROC_ADDR("vkCmdSetCheckpointNV");
-m_vk.getQueueCheckpointDataNV = (GetQueueCheckpointDataNVFunc) GET_PROC_ADDR("vkGetQueueCheckpointDataNV");
-m_vk.initializePerformanceApiINTEL = (InitializePerformanceApiINTELFunc) GET_PROC_ADDR("vkInitializePerformanceApiINTEL");
-m_vk.uninitializePerformanceApiINTEL = (UninitializePerformanceApiINTELFunc) GET_PROC_ADDR("vkUninitializePerformanceApiINTEL");
-m_vk.cmdSetPerformanceMarkerINTEL = (CmdSetPerformanceMarkerINTELFunc) GET_PROC_ADDR("vkCmdSetPerformanceMarkerINTEL");
-m_vk.cmdSetPerformanceStreamMarkerINTEL = (CmdSetPerformanceStreamMarkerINTELFunc) GET_PROC_ADDR("vkCmdSetPerformanceStreamMarkerINTEL");
-m_vk.cmdSetPerformanceOverrideINTEL = (CmdSetPerformanceOverrideINTELFunc) GET_PROC_ADDR("vkCmdSetPerformanceOverrideINTEL");
-m_vk.acquirePerformanceConfigurationINTEL = (AcquirePerformanceConfigurationINTELFunc) GET_PROC_ADDR("vkAcquirePerformanceConfigurationINTEL");
-m_vk.releasePerformanceConfigurationINTEL = (ReleasePerformanceConfigurationINTELFunc) GET_PROC_ADDR("vkReleasePerformanceConfigurationINTEL");
-m_vk.queueSetPerformanceConfigurationINTEL = (QueueSetPerformanceConfigurationINTELFunc) GET_PROC_ADDR("vkQueueSetPerformanceConfigurationINTEL");
-m_vk.getPerformanceParameterINTEL = (GetPerformanceParameterINTELFunc) GET_PROC_ADDR("vkGetPerformanceParameterINTEL");
-m_vk.setLocalDimmingAMD = (SetLocalDimmingAMDFunc) GET_PROC_ADDR("vkSetLocalDimmingAMD");
-m_vk.getBufferDeviceAddressEXT = (GetBufferDeviceAddressEXTFunc) GET_PROC_ADDR("vkGetBufferDeviceAddressEXT");
-m_vk.cmdSetLineStippleEXT = (CmdSetLineStippleEXTFunc) GET_PROC_ADDR("vkCmdSetLineStippleEXT");
-m_vk.resetQueryPoolEXT = (ResetQueryPoolEXTFunc) GET_PROC_ADDR("vkResetQueryPoolEXT");
-m_vk.getAndroidHardwareBufferPropertiesANDROID = (GetAndroidHardwareBufferPropertiesANDROIDFunc) GET_PROC_ADDR("vkGetAndroidHardwareBufferPropertiesANDROID");
-m_vk.getMemoryAndroidHardwareBufferANDROID = (GetMemoryAndroidHardwareBufferANDROIDFunc) GET_PROC_ADDR("vkGetMemoryAndroidHardwareBufferANDROID");
-m_vk.getMemoryWin32HandleKHR = (GetMemoryWin32HandleKHRFunc) GET_PROC_ADDR("vkGetMemoryWin32HandleKHR");
-m_vk.getMemoryWin32HandlePropertiesKHR = (GetMemoryWin32HandlePropertiesKHRFunc) GET_PROC_ADDR("vkGetMemoryWin32HandlePropertiesKHR");
-m_vk.importSemaphoreWin32HandleKHR = (ImportSemaphoreWin32HandleKHRFunc) GET_PROC_ADDR("vkImportSemaphoreWin32HandleKHR");
-m_vk.getSemaphoreWin32HandleKHR = (GetSemaphoreWin32HandleKHRFunc) GET_PROC_ADDR("vkGetSemaphoreWin32HandleKHR");
-m_vk.importFenceWin32HandleKHR = (ImportFenceWin32HandleKHRFunc) GET_PROC_ADDR("vkImportFenceWin32HandleKHR");
-m_vk.getFenceWin32HandleKHR = (GetFenceWin32HandleKHRFunc) GET_PROC_ADDR("vkGetFenceWin32HandleKHR");
-m_vk.getMemoryWin32HandleNV = (GetMemoryWin32HandleNVFunc) GET_PROC_ADDR("vkGetMemoryWin32HandleNV");
-m_vk.acquireFullScreenExclusiveModeEXT = (AcquireFullScreenExclusiveModeEXTFunc) GET_PROC_ADDR("vkAcquireFullScreenExclusiveModeEXT");
-m_vk.releaseFullScreenExclusiveModeEXT = (ReleaseFullScreenExclusiveModeEXTFunc) GET_PROC_ADDR("vkReleaseFullScreenExclusiveModeEXT");
-m_vk.getDeviceGroupSurfacePresentModes2EXT = (GetDeviceGroupSurfacePresentModes2EXTFunc) GET_PROC_ADDR("vkGetDeviceGroupSurfacePresentModes2EXT");
+ m_vk.getDescriptorSetLayoutSupport = (GetDescriptorSetLayoutSupportFunc) GET_PROC_ADDR("vkGetDescriptorSetLayoutSupportKHR");
+m_vk.createSwapchainKHR = (CreateSwapchainKHRFunc) GET_PROC_ADDR("vkCreateSwapchainKHR");
+m_vk.destroySwapchainKHR = (DestroySwapchainKHRFunc) GET_PROC_ADDR("vkDestroySwapchainKHR");
+m_vk.getSwapchainImagesKHR = (GetSwapchainImagesKHRFunc) GET_PROC_ADDR("vkGetSwapchainImagesKHR");
+m_vk.acquireNextImageKHR = (AcquireNextImageKHRFunc) GET_PROC_ADDR("vkAcquireNextImageKHR");
+m_vk.queuePresentKHR = (QueuePresentKHRFunc) GET_PROC_ADDR("vkQueuePresentKHR");
+m_vk.getDeviceGroupPresentCapabilitiesKHR = (GetDeviceGroupPresentCapabilitiesKHRFunc) GET_PROC_ADDR("vkGetDeviceGroupPresentCapabilitiesKHR");
+m_vk.getDeviceGroupSurfacePresentModesKHR = (GetDeviceGroupSurfacePresentModesKHRFunc) GET_PROC_ADDR("vkGetDeviceGroupSurfacePresentModesKHR");
+m_vk.acquireNextImage2KHR = (AcquireNextImage2KHRFunc) GET_PROC_ADDR("vkAcquireNextImage2KHR");
+m_vk.createSharedSwapchainsKHR = (CreateSharedSwapchainsKHRFunc) GET_PROC_ADDR("vkCreateSharedSwapchainsKHR");
+m_vk.getMemoryFdKHR = (GetMemoryFdKHRFunc) GET_PROC_ADDR("vkGetMemoryFdKHR");
+m_vk.getMemoryFdPropertiesKHR = (GetMemoryFdPropertiesKHRFunc) GET_PROC_ADDR("vkGetMemoryFdPropertiesKHR");
+m_vk.importSemaphoreFdKHR = (ImportSemaphoreFdKHRFunc) GET_PROC_ADDR("vkImportSemaphoreFdKHR");
+m_vk.getSemaphoreFdKHR = (GetSemaphoreFdKHRFunc) GET_PROC_ADDR("vkGetSemaphoreFdKHR");
+m_vk.cmdPushDescriptorSetKHR = (CmdPushDescriptorSetKHRFunc) GET_PROC_ADDR("vkCmdPushDescriptorSetKHR");
+m_vk.cmdPushDescriptorSetWithTemplateKHR = (CmdPushDescriptorSetWithTemplateKHRFunc) GET_PROC_ADDR("vkCmdPushDescriptorSetWithTemplateKHR");
+m_vk.createRenderPass2KHR = (CreateRenderPass2KHRFunc) GET_PROC_ADDR("vkCreateRenderPass2KHR");
+m_vk.cmdBeginRenderPass2KHR = (CmdBeginRenderPass2KHRFunc) GET_PROC_ADDR("vkCmdBeginRenderPass2KHR");
+m_vk.cmdNextSubpass2KHR = (CmdNextSubpass2KHRFunc) GET_PROC_ADDR("vkCmdNextSubpass2KHR");
+m_vk.cmdEndRenderPass2KHR = (CmdEndRenderPass2KHRFunc) GET_PROC_ADDR("vkCmdEndRenderPass2KHR");
+m_vk.getSwapchainStatusKHR = (GetSwapchainStatusKHRFunc) GET_PROC_ADDR("vkGetSwapchainStatusKHR");
+m_vk.importFenceFdKHR = (ImportFenceFdKHRFunc) GET_PROC_ADDR("vkImportFenceFdKHR");
+m_vk.getFenceFdKHR = (GetFenceFdKHRFunc) GET_PROC_ADDR("vkGetFenceFdKHR");
+m_vk.acquireProfilingLockKHR = (AcquireProfilingLockKHRFunc) GET_PROC_ADDR("vkAcquireProfilingLockKHR");
+m_vk.releaseProfilingLockKHR = (ReleaseProfilingLockKHRFunc) GET_PROC_ADDR("vkReleaseProfilingLockKHR");
+m_vk.cmdDrawIndirectCountKHR = (CmdDrawIndirectCountKHRFunc) GET_PROC_ADDR("vkCmdDrawIndirectCountKHR");
+m_vk.cmdDrawIndexedIndirectCountKHR = (CmdDrawIndexedIndirectCountKHRFunc) GET_PROC_ADDR("vkCmdDrawIndexedIndirectCountKHR");
+m_vk.getPipelineExecutablePropertiesKHR = (GetPipelineExecutablePropertiesKHRFunc) GET_PROC_ADDR("vkGetPipelineExecutablePropertiesKHR");
+m_vk.getPipelineExecutableStatisticsKHR = (GetPipelineExecutableStatisticsKHRFunc) GET_PROC_ADDR("vkGetPipelineExecutableStatisticsKHR");
+m_vk.getPipelineExecutableInternalRepresentationsKHR = (GetPipelineExecutableInternalRepresentationsKHRFunc) GET_PROC_ADDR("vkGetPipelineExecutableInternalRepresentationsKHR");
+m_vk.debugMarkerSetObjectTagEXT = (DebugMarkerSetObjectTagEXTFunc) GET_PROC_ADDR("vkDebugMarkerSetObjectTagEXT");
+m_vk.debugMarkerSetObjectNameEXT = (DebugMarkerSetObjectNameEXTFunc) GET_PROC_ADDR("vkDebugMarkerSetObjectNameEXT");
+m_vk.cmdDebugMarkerBeginEXT = (CmdDebugMarkerBeginEXTFunc) GET_PROC_ADDR("vkCmdDebugMarkerBeginEXT");
+m_vk.cmdDebugMarkerEndEXT = (CmdDebugMarkerEndEXTFunc) GET_PROC_ADDR("vkCmdDebugMarkerEndEXT");
+m_vk.cmdDebugMarkerInsertEXT = (CmdDebugMarkerInsertEXTFunc) GET_PROC_ADDR("vkCmdDebugMarkerInsertEXT");
+m_vk.cmdBindTransformFeedbackBuffersEXT = (CmdBindTransformFeedbackBuffersEXTFunc) GET_PROC_ADDR("vkCmdBindTransformFeedbackBuffersEXT");
+m_vk.cmdBeginTransformFeedbackEXT = (CmdBeginTransformFeedbackEXTFunc) GET_PROC_ADDR("vkCmdBeginTransformFeedbackEXT");
+m_vk.cmdEndTransformFeedbackEXT = (CmdEndTransformFeedbackEXTFunc) GET_PROC_ADDR("vkCmdEndTransformFeedbackEXT");
+m_vk.cmdBeginQueryIndexedEXT = (CmdBeginQueryIndexedEXTFunc) GET_PROC_ADDR("vkCmdBeginQueryIndexedEXT");
+m_vk.cmdEndQueryIndexedEXT = (CmdEndQueryIndexedEXTFunc) GET_PROC_ADDR("vkCmdEndQueryIndexedEXT");
+m_vk.cmdDrawIndirectByteCountEXT = (CmdDrawIndirectByteCountEXTFunc) GET_PROC_ADDR("vkCmdDrawIndirectByteCountEXT");
+m_vk.getImageViewHandleNVX = (GetImageViewHandleNVXFunc) GET_PROC_ADDR("vkGetImageViewHandleNVX");
+m_vk.cmdDrawIndirectCountAMD = (CmdDrawIndirectCountAMDFunc) GET_PROC_ADDR("vkCmdDrawIndirectCountAMD");
+m_vk.cmdDrawIndexedIndirectCountAMD = (CmdDrawIndexedIndirectCountAMDFunc) GET_PROC_ADDR("vkCmdDrawIndexedIndirectCountAMD");
+m_vk.getShaderInfoAMD = (GetShaderInfoAMDFunc) GET_PROC_ADDR("vkGetShaderInfoAMD");
+m_vk.cmdBeginConditionalRenderingEXT = (CmdBeginConditionalRenderingEXTFunc) GET_PROC_ADDR("vkCmdBeginConditionalRenderingEXT");
+m_vk.cmdEndConditionalRenderingEXT = (CmdEndConditionalRenderingEXTFunc) GET_PROC_ADDR("vkCmdEndConditionalRenderingEXT");
+m_vk.cmdProcessCommandsNVX = (CmdProcessCommandsNVXFunc) GET_PROC_ADDR("vkCmdProcessCommandsNVX");
+m_vk.cmdReserveSpaceForCommandsNVX = (CmdReserveSpaceForCommandsNVXFunc) GET_PROC_ADDR("vkCmdReserveSpaceForCommandsNVX");
+m_vk.createIndirectCommandsLayoutNVX = (CreateIndirectCommandsLayoutNVXFunc) GET_PROC_ADDR("vkCreateIndirectCommandsLayoutNVX");
+m_vk.destroyIndirectCommandsLayoutNVX = (DestroyIndirectCommandsLayoutNVXFunc) GET_PROC_ADDR("vkDestroyIndirectCommandsLayoutNVX");
+m_vk.createObjectTableNVX = (CreateObjectTableNVXFunc) GET_PROC_ADDR("vkCreateObjectTableNVX");
+m_vk.destroyObjectTableNVX = (DestroyObjectTableNVXFunc) GET_PROC_ADDR("vkDestroyObjectTableNVX");
+m_vk.registerObjectsNVX = (RegisterObjectsNVXFunc) GET_PROC_ADDR("vkRegisterObjectsNVX");
+m_vk.unregisterObjectsNVX = (UnregisterObjectsNVXFunc) GET_PROC_ADDR("vkUnregisterObjectsNVX");
+m_vk.cmdSetViewportWScalingNV = (CmdSetViewportWScalingNVFunc) GET_PROC_ADDR("vkCmdSetViewportWScalingNV");
+m_vk.displayPowerControlEXT = (DisplayPowerControlEXTFunc) GET_PROC_ADDR("vkDisplayPowerControlEXT");
+m_vk.registerDeviceEventEXT = (RegisterDeviceEventEXTFunc) GET_PROC_ADDR("vkRegisterDeviceEventEXT");
+m_vk.registerDisplayEventEXT = (RegisterDisplayEventEXTFunc) GET_PROC_ADDR("vkRegisterDisplayEventEXT");
+m_vk.getSwapchainCounterEXT = (GetSwapchainCounterEXTFunc) GET_PROC_ADDR("vkGetSwapchainCounterEXT");
+m_vk.getRefreshCycleDurationGOOGLE = (GetRefreshCycleDurationGOOGLEFunc) GET_PROC_ADDR("vkGetRefreshCycleDurationGOOGLE");
+m_vk.getPastPresentationTimingGOOGLE = (GetPastPresentationTimingGOOGLEFunc) GET_PROC_ADDR("vkGetPastPresentationTimingGOOGLE");
+m_vk.cmdSetDiscardRectangleEXT = (CmdSetDiscardRectangleEXTFunc) GET_PROC_ADDR("vkCmdSetDiscardRectangleEXT");
+m_vk.setHdrMetadataEXT = (SetHdrMetadataEXTFunc) GET_PROC_ADDR("vkSetHdrMetadataEXT");
+m_vk.setDebugUtilsObjectNameEXT = (SetDebugUtilsObjectNameEXTFunc) GET_PROC_ADDR("vkSetDebugUtilsObjectNameEXT");
+m_vk.setDebugUtilsObjectTagEXT = (SetDebugUtilsObjectTagEXTFunc) GET_PROC_ADDR("vkSetDebugUtilsObjectTagEXT");
+m_vk.queueBeginDebugUtilsLabelEXT = (QueueBeginDebugUtilsLabelEXTFunc) GET_PROC_ADDR("vkQueueBeginDebugUtilsLabelEXT");
+m_vk.queueEndDebugUtilsLabelEXT = (QueueEndDebugUtilsLabelEXTFunc) GET_PROC_ADDR("vkQueueEndDebugUtilsLabelEXT");
+m_vk.queueInsertDebugUtilsLabelEXT = (QueueInsertDebugUtilsLabelEXTFunc) GET_PROC_ADDR("vkQueueInsertDebugUtilsLabelEXT");
+m_vk.cmdBeginDebugUtilsLabelEXT = (CmdBeginDebugUtilsLabelEXTFunc) GET_PROC_ADDR("vkCmdBeginDebugUtilsLabelEXT");
+m_vk.cmdEndDebugUtilsLabelEXT = (CmdEndDebugUtilsLabelEXTFunc) GET_PROC_ADDR("vkCmdEndDebugUtilsLabelEXT");
+m_vk.cmdInsertDebugUtilsLabelEXT = (CmdInsertDebugUtilsLabelEXTFunc) GET_PROC_ADDR("vkCmdInsertDebugUtilsLabelEXT");
+m_vk.cmdSetSampleLocationsEXT = (CmdSetSampleLocationsEXTFunc) GET_PROC_ADDR("vkCmdSetSampleLocationsEXT");
+m_vk.getImageDrmFormatModifierPropertiesEXT = (GetImageDrmFormatModifierPropertiesEXTFunc) GET_PROC_ADDR("vkGetImageDrmFormatModifierPropertiesEXT");
+m_vk.createValidationCacheEXT = (CreateValidationCacheEXTFunc) GET_PROC_ADDR("vkCreateValidationCacheEXT");
+m_vk.destroyValidationCacheEXT = (DestroyValidationCacheEXTFunc) GET_PROC_ADDR("vkDestroyValidationCacheEXT");
+m_vk.mergeValidationCachesEXT = (MergeValidationCachesEXTFunc) GET_PROC_ADDR("vkMergeValidationCachesEXT");
+m_vk.getValidationCacheDataEXT = (GetValidationCacheDataEXTFunc) GET_PROC_ADDR("vkGetValidationCacheDataEXT");
+m_vk.cmdBindShadingRateImageNV = (CmdBindShadingRateImageNVFunc) GET_PROC_ADDR("vkCmdBindShadingRateImageNV");
+m_vk.cmdSetViewportShadingRatePaletteNV = (CmdSetViewportShadingRatePaletteNVFunc) GET_PROC_ADDR("vkCmdSetViewportShadingRatePaletteNV");
+m_vk.cmdSetCoarseSampleOrderNV = (CmdSetCoarseSampleOrderNVFunc) GET_PROC_ADDR("vkCmdSetCoarseSampleOrderNV");
+m_vk.createAccelerationStructureNV = (CreateAccelerationStructureNVFunc) GET_PROC_ADDR("vkCreateAccelerationStructureNV");
+m_vk.destroyAccelerationStructureNV = (DestroyAccelerationStructureNVFunc) GET_PROC_ADDR("vkDestroyAccelerationStructureNV");
+m_vk.getAccelerationStructureMemoryRequirementsNV = (GetAccelerationStructureMemoryRequirementsNVFunc) GET_PROC_ADDR("vkGetAccelerationStructureMemoryRequirementsNV");
+m_vk.bindAccelerationStructureMemoryNV = (BindAccelerationStructureMemoryNVFunc) GET_PROC_ADDR("vkBindAccelerationStructureMemoryNV");
+m_vk.cmdBuildAccelerationStructureNV = (CmdBuildAccelerationStructureNVFunc) GET_PROC_ADDR("vkCmdBuildAccelerationStructureNV");
+m_vk.cmdCopyAccelerationStructureNV = (CmdCopyAccelerationStructureNVFunc) GET_PROC_ADDR("vkCmdCopyAccelerationStructureNV");
+m_vk.cmdTraceRaysNV = (CmdTraceRaysNVFunc) GET_PROC_ADDR("vkCmdTraceRaysNV");
+m_vk.createRayTracingPipelinesNV = (CreateRayTracingPipelinesNVFunc) GET_PROC_ADDR("vkCreateRayTracingPipelinesNV");
+m_vk.getRayTracingShaderGroupHandlesNV = (GetRayTracingShaderGroupHandlesNVFunc) GET_PROC_ADDR("vkGetRayTracingShaderGroupHandlesNV");
+m_vk.getAccelerationStructureHandleNV = (GetAccelerationStructureHandleNVFunc) GET_PROC_ADDR("vkGetAccelerationStructureHandleNV");
+m_vk.cmdWriteAccelerationStructuresPropertiesNV = (CmdWriteAccelerationStructuresPropertiesNVFunc) GET_PROC_ADDR("vkCmdWriteAccelerationStructuresPropertiesNV");
+m_vk.compileDeferredNV = (CompileDeferredNVFunc) GET_PROC_ADDR("vkCompileDeferredNV");
+m_vk.getMemoryHostPointerPropertiesEXT = (GetMemoryHostPointerPropertiesEXTFunc) GET_PROC_ADDR("vkGetMemoryHostPointerPropertiesEXT");
+m_vk.cmdWriteBufferMarkerAMD = (CmdWriteBufferMarkerAMDFunc) GET_PROC_ADDR("vkCmdWriteBufferMarkerAMD");
+m_vk.getCalibratedTimestampsEXT = (GetCalibratedTimestampsEXTFunc) GET_PROC_ADDR("vkGetCalibratedTimestampsEXT");
+m_vk.cmdDrawMeshTasksNV = (CmdDrawMeshTasksNVFunc) GET_PROC_ADDR("vkCmdDrawMeshTasksNV");
+m_vk.cmdDrawMeshTasksIndirectNV = (CmdDrawMeshTasksIndirectNVFunc) GET_PROC_ADDR("vkCmdDrawMeshTasksIndirectNV");
+m_vk.cmdDrawMeshTasksIndirectCountNV = (CmdDrawMeshTasksIndirectCountNVFunc) GET_PROC_ADDR("vkCmdDrawMeshTasksIndirectCountNV");
+m_vk.cmdSetExclusiveScissorNV = (CmdSetExclusiveScissorNVFunc) GET_PROC_ADDR("vkCmdSetExclusiveScissorNV");
+m_vk.cmdSetCheckpointNV = (CmdSetCheckpointNVFunc) GET_PROC_ADDR("vkCmdSetCheckpointNV");
+m_vk.getQueueCheckpointDataNV = (GetQueueCheckpointDataNVFunc) GET_PROC_ADDR("vkGetQueueCheckpointDataNV");
+m_vk.initializePerformanceApiINTEL = (InitializePerformanceApiINTELFunc) GET_PROC_ADDR("vkInitializePerformanceApiINTEL");
+m_vk.uninitializePerformanceApiINTEL = (UninitializePerformanceApiINTELFunc) GET_PROC_ADDR("vkUninitializePerformanceApiINTEL");
+m_vk.cmdSetPerformanceMarkerINTEL = (CmdSetPerformanceMarkerINTELFunc) GET_PROC_ADDR("vkCmdSetPerformanceMarkerINTEL");
+m_vk.cmdSetPerformanceStreamMarkerINTEL = (CmdSetPerformanceStreamMarkerINTELFunc) GET_PROC_ADDR("vkCmdSetPerformanceStreamMarkerINTEL");
+m_vk.cmdSetPerformanceOverrideINTEL = (CmdSetPerformanceOverrideINTELFunc) GET_PROC_ADDR("vkCmdSetPerformanceOverrideINTEL");
+m_vk.acquirePerformanceConfigurationINTEL = (AcquirePerformanceConfigurationINTELFunc) GET_PROC_ADDR("vkAcquirePerformanceConfigurationINTEL");
+m_vk.releasePerformanceConfigurationINTEL = (ReleasePerformanceConfigurationINTELFunc) GET_PROC_ADDR("vkReleasePerformanceConfigurationINTEL");
+m_vk.queueSetPerformanceConfigurationINTEL = (QueueSetPerformanceConfigurationINTELFunc) GET_PROC_ADDR("vkQueueSetPerformanceConfigurationINTEL");
+m_vk.getPerformanceParameterINTEL = (GetPerformanceParameterINTELFunc) GET_PROC_ADDR("vkGetPerformanceParameterINTEL");
+m_vk.setLocalDimmingAMD = (SetLocalDimmingAMDFunc) GET_PROC_ADDR("vkSetLocalDimmingAMD");
+m_vk.getBufferDeviceAddressEXT = (GetBufferDeviceAddressEXTFunc) GET_PROC_ADDR("vkGetBufferDeviceAddressEXT");
+m_vk.cmdSetLineStippleEXT = (CmdSetLineStippleEXTFunc) GET_PROC_ADDR("vkCmdSetLineStippleEXT");
+m_vk.resetQueryPoolEXT = (ResetQueryPoolEXTFunc) GET_PROC_ADDR("vkResetQueryPoolEXT");
+m_vk.getAndroidHardwareBufferPropertiesANDROID = (GetAndroidHardwareBufferPropertiesANDROIDFunc) GET_PROC_ADDR("vkGetAndroidHardwareBufferPropertiesANDROID");
+m_vk.getMemoryAndroidHardwareBufferANDROID = (GetMemoryAndroidHardwareBufferANDROIDFunc) GET_PROC_ADDR("vkGetMemoryAndroidHardwareBufferANDROID");
+m_vk.getMemoryWin32HandleKHR = (GetMemoryWin32HandleKHRFunc) GET_PROC_ADDR("vkGetMemoryWin32HandleKHR");
+m_vk.getMemoryWin32HandlePropertiesKHR = (GetMemoryWin32HandlePropertiesKHRFunc) GET_PROC_ADDR("vkGetMemoryWin32HandlePropertiesKHR");
+m_vk.importSemaphoreWin32HandleKHR = (ImportSemaphoreWin32HandleKHRFunc) GET_PROC_ADDR("vkImportSemaphoreWin32HandleKHR");
+m_vk.getSemaphoreWin32HandleKHR = (GetSemaphoreWin32HandleKHRFunc) GET_PROC_ADDR("vkGetSemaphoreWin32HandleKHR");
+m_vk.importFenceWin32HandleKHR = (ImportFenceWin32HandleKHRFunc) GET_PROC_ADDR("vkImportFenceWin32HandleKHR");
+m_vk.getFenceWin32HandleKHR = (GetFenceWin32HandleKHRFunc) GET_PROC_ADDR("vkGetFenceWin32HandleKHR");
+m_vk.getMemoryWin32HandleNV = (GetMemoryWin32HandleNVFunc) GET_PROC_ADDR("vkGetMemoryWin32HandleNV");
+m_vk.acquireFullScreenExclusiveModeEXT = (AcquireFullScreenExclusiveModeEXTFunc) GET_PROC_ADDR("vkAcquireFullScreenExclusiveModeEXT");
+m_vk.releaseFullScreenExclusiveModeEXT = (ReleaseFullScreenExclusiveModeEXTFunc) GET_PROC_ADDR("vkReleaseFullScreenExclusiveModeEXT");
+m_vk.getDeviceGroupSurfacePresentModes2EXT = (GetDeviceGroupSurfacePresentModes2EXTFunc) GET_PROC_ADDR("vkGetDeviceGroupSurfacePresentModes2EXT");
nextPtr = &physicalDeviceMultiviewFeatures.pNext;
}
+ vk::VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR physicalDevicePipelineExecutablePropertiesFeaturesKHR;
+ if (vk::isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_pipeline_executable_properties"))
+ {
+ deMemset(&physicalDevicePipelineExecutablePropertiesFeaturesKHR, 0, sizeof(physicalDevicePipelineExecutablePropertiesFeaturesKHR));
+ physicalDevicePipelineExecutablePropertiesFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
+ *nextPtr = &physicalDevicePipelineExecutablePropertiesFeaturesKHR;
+ nextPtr = &physicalDevicePipelineExecutablePropertiesFeaturesKHR.pNext;
+ }
+
vk::VkPhysicalDeviceScalarBlockLayoutFeaturesEXT physicalDeviceScalarBlockLayoutFeaturesEXT;
if (vk::isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_EXT_scalar_block_layout"))
{
}
}
+ if ( vk::isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_pipeline_executable_properties") )
+ {
+ if ( physicalDevicePipelineExecutablePropertiesFeaturesKHR.pipelineExecutableInfo == VK_FALSE )
+ {
+ log << tcu::TestLog::Message << "Mandatory feature pipelineExecutableInfo not supported" << tcu::TestLog::EndMessage;
+ result = false;
+ }
+ }
+
return result;
}
DE_UNREF(stride);
}
+VKAPI_ATTR VkResult VKAPI_CALL getPipelineExecutablePropertiesKHR (VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, deUint32* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties)
+{
+ DE_UNREF(device);
+ DE_UNREF(pPipelineInfo);
+ DE_UNREF(pExecutableCount);
+ DE_UNREF(pProperties);
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL getPipelineExecutableStatisticsKHR (VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, deUint32* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics)
+{
+ DE_UNREF(device);
+ DE_UNREF(pExecutableInfo);
+ DE_UNREF(pStatisticCount);
+ DE_UNREF(pStatistics);
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL getPipelineExecutableInternalRepresentationsKHR (VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, deUint32* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations)
+{
+ DE_UNREF(device);
+ DE_UNREF(pExecutableInfo);
+ DE_UNREF(pInternalRepresentationCount);
+ DE_UNREF(pInternalRepresentations);
+ return VK_SUCCESS;
+}
+
VKAPI_ATTR void VKAPI_CALL debugReportMessageEXT (VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, deUint64 object, deUintptr location, deInt32 messageCode, const char* pLayerPrefix, const char* pMessage)
{
DE_UNREF(instance);
static const tcu::StaticFunctionLibrary::Entry s_deviceFunctions[] =
{
- VK_NULL_FUNC_ENTRY(vkGetDeviceProcAddr, getDeviceProcAddr),
- VK_NULL_FUNC_ENTRY(vkDestroyDevice, destroyDevice),
- VK_NULL_FUNC_ENTRY(vkGetDeviceQueue, getDeviceQueue),
- VK_NULL_FUNC_ENTRY(vkQueueSubmit, queueSubmit),
- VK_NULL_FUNC_ENTRY(vkQueueWaitIdle, queueWaitIdle),
- VK_NULL_FUNC_ENTRY(vkDeviceWaitIdle, deviceWaitIdle),
- VK_NULL_FUNC_ENTRY(vkAllocateMemory, allocateMemory),
- VK_NULL_FUNC_ENTRY(vkFreeMemory, freeMemory),
- VK_NULL_FUNC_ENTRY(vkMapMemory, mapMemory),
- VK_NULL_FUNC_ENTRY(vkUnmapMemory, unmapMemory),
- VK_NULL_FUNC_ENTRY(vkFlushMappedMemoryRanges, flushMappedMemoryRanges),
- VK_NULL_FUNC_ENTRY(vkInvalidateMappedMemoryRanges, invalidateMappedMemoryRanges),
- VK_NULL_FUNC_ENTRY(vkGetDeviceMemoryCommitment, getDeviceMemoryCommitment),
- VK_NULL_FUNC_ENTRY(vkBindBufferMemory, bindBufferMemory),
- VK_NULL_FUNC_ENTRY(vkBindImageMemory, bindImageMemory),
- VK_NULL_FUNC_ENTRY(vkGetBufferMemoryRequirements, getBufferMemoryRequirements),
- VK_NULL_FUNC_ENTRY(vkGetImageMemoryRequirements, getImageMemoryRequirements),
- VK_NULL_FUNC_ENTRY(vkGetImageSparseMemoryRequirements, getImageSparseMemoryRequirements),
- VK_NULL_FUNC_ENTRY(vkQueueBindSparse, queueBindSparse),
- VK_NULL_FUNC_ENTRY(vkCreateFence, createFence),
- VK_NULL_FUNC_ENTRY(vkDestroyFence, destroyFence),
- VK_NULL_FUNC_ENTRY(vkResetFences, resetFences),
- VK_NULL_FUNC_ENTRY(vkGetFenceStatus, getFenceStatus),
- VK_NULL_FUNC_ENTRY(vkWaitForFences, waitForFences),
- VK_NULL_FUNC_ENTRY(vkCreateSemaphore, createSemaphore),
- VK_NULL_FUNC_ENTRY(vkDestroySemaphore, destroySemaphore),
- VK_NULL_FUNC_ENTRY(vkCreateEvent, createEvent),
- VK_NULL_FUNC_ENTRY(vkDestroyEvent, destroyEvent),
- VK_NULL_FUNC_ENTRY(vkGetEventStatus, getEventStatus),
- VK_NULL_FUNC_ENTRY(vkSetEvent, setEvent),
- VK_NULL_FUNC_ENTRY(vkResetEvent, resetEvent),
- VK_NULL_FUNC_ENTRY(vkCreateQueryPool, createQueryPool),
- VK_NULL_FUNC_ENTRY(vkDestroyQueryPool, destroyQueryPool),
- VK_NULL_FUNC_ENTRY(vkGetQueryPoolResults, getQueryPoolResults),
- VK_NULL_FUNC_ENTRY(vkCreateBuffer, createBuffer),
- VK_NULL_FUNC_ENTRY(vkDestroyBuffer, destroyBuffer),
- VK_NULL_FUNC_ENTRY(vkCreateBufferView, createBufferView),
- VK_NULL_FUNC_ENTRY(vkDestroyBufferView, destroyBufferView),
- VK_NULL_FUNC_ENTRY(vkCreateImage, createImage),
- VK_NULL_FUNC_ENTRY(vkDestroyImage, destroyImage),
- VK_NULL_FUNC_ENTRY(vkGetImageSubresourceLayout, getImageSubresourceLayout),
- VK_NULL_FUNC_ENTRY(vkCreateImageView, createImageView),
- VK_NULL_FUNC_ENTRY(vkDestroyImageView, destroyImageView),
- VK_NULL_FUNC_ENTRY(vkCreateShaderModule, createShaderModule),
- VK_NULL_FUNC_ENTRY(vkDestroyShaderModule, destroyShaderModule),
- VK_NULL_FUNC_ENTRY(vkCreatePipelineCache, createPipelineCache),
- VK_NULL_FUNC_ENTRY(vkDestroyPipelineCache, destroyPipelineCache),
- VK_NULL_FUNC_ENTRY(vkGetPipelineCacheData, getPipelineCacheData),
- VK_NULL_FUNC_ENTRY(vkMergePipelineCaches, mergePipelineCaches),
- VK_NULL_FUNC_ENTRY(vkCreateGraphicsPipelines, createGraphicsPipelines),
- VK_NULL_FUNC_ENTRY(vkCreateComputePipelines, createComputePipelines),
- VK_NULL_FUNC_ENTRY(vkDestroyPipeline, destroyPipeline),
- VK_NULL_FUNC_ENTRY(vkCreatePipelineLayout, createPipelineLayout),
- VK_NULL_FUNC_ENTRY(vkDestroyPipelineLayout, destroyPipelineLayout),
- VK_NULL_FUNC_ENTRY(vkCreateSampler, createSampler),
- VK_NULL_FUNC_ENTRY(vkDestroySampler, destroySampler),
- VK_NULL_FUNC_ENTRY(vkCreateDescriptorSetLayout, createDescriptorSetLayout),
- VK_NULL_FUNC_ENTRY(vkDestroyDescriptorSetLayout, destroyDescriptorSetLayout),
- VK_NULL_FUNC_ENTRY(vkCreateDescriptorPool, createDescriptorPool),
- VK_NULL_FUNC_ENTRY(vkDestroyDescriptorPool, destroyDescriptorPool),
- VK_NULL_FUNC_ENTRY(vkResetDescriptorPool, resetDescriptorPool),
- VK_NULL_FUNC_ENTRY(vkAllocateDescriptorSets, allocateDescriptorSets),
- VK_NULL_FUNC_ENTRY(vkFreeDescriptorSets, freeDescriptorSets),
- VK_NULL_FUNC_ENTRY(vkUpdateDescriptorSets, updateDescriptorSets),
- VK_NULL_FUNC_ENTRY(vkCreateFramebuffer, createFramebuffer),
- VK_NULL_FUNC_ENTRY(vkDestroyFramebuffer, destroyFramebuffer),
- VK_NULL_FUNC_ENTRY(vkCreateRenderPass, createRenderPass),
- VK_NULL_FUNC_ENTRY(vkDestroyRenderPass, destroyRenderPass),
- VK_NULL_FUNC_ENTRY(vkGetRenderAreaGranularity, getRenderAreaGranularity),
- VK_NULL_FUNC_ENTRY(vkCreateCommandPool, createCommandPool),
- VK_NULL_FUNC_ENTRY(vkDestroyCommandPool, destroyCommandPool),
- VK_NULL_FUNC_ENTRY(vkResetCommandPool, resetCommandPool),
- VK_NULL_FUNC_ENTRY(vkAllocateCommandBuffers, allocateCommandBuffers),
- VK_NULL_FUNC_ENTRY(vkFreeCommandBuffers, freeCommandBuffers),
- VK_NULL_FUNC_ENTRY(vkBeginCommandBuffer, beginCommandBuffer),
- VK_NULL_FUNC_ENTRY(vkEndCommandBuffer, endCommandBuffer),
- VK_NULL_FUNC_ENTRY(vkResetCommandBuffer, resetCommandBuffer),
- VK_NULL_FUNC_ENTRY(vkCmdBindPipeline, cmdBindPipeline),
- VK_NULL_FUNC_ENTRY(vkCmdSetViewport, cmdSetViewport),
- VK_NULL_FUNC_ENTRY(vkCmdSetScissor, cmdSetScissor),
- VK_NULL_FUNC_ENTRY(vkCmdSetLineWidth, cmdSetLineWidth),
- VK_NULL_FUNC_ENTRY(vkCmdSetDepthBias, cmdSetDepthBias),
- VK_NULL_FUNC_ENTRY(vkCmdSetBlendConstants, cmdSetBlendConstants),
- VK_NULL_FUNC_ENTRY(vkCmdSetDepthBounds, cmdSetDepthBounds),
- VK_NULL_FUNC_ENTRY(vkCmdSetStencilCompareMask, cmdSetStencilCompareMask),
- VK_NULL_FUNC_ENTRY(vkCmdSetStencilWriteMask, cmdSetStencilWriteMask),
- VK_NULL_FUNC_ENTRY(vkCmdSetStencilReference, cmdSetStencilReference),
- VK_NULL_FUNC_ENTRY(vkCmdBindDescriptorSets, cmdBindDescriptorSets),
- VK_NULL_FUNC_ENTRY(vkCmdBindIndexBuffer, cmdBindIndexBuffer),
- VK_NULL_FUNC_ENTRY(vkCmdBindVertexBuffers, cmdBindVertexBuffers),
- VK_NULL_FUNC_ENTRY(vkCmdDraw, cmdDraw),
- VK_NULL_FUNC_ENTRY(vkCmdDrawIndexed, cmdDrawIndexed),
- VK_NULL_FUNC_ENTRY(vkCmdDrawIndirect, cmdDrawIndirect),
- VK_NULL_FUNC_ENTRY(vkCmdDrawIndexedIndirect, cmdDrawIndexedIndirect),
- VK_NULL_FUNC_ENTRY(vkCmdDispatch, cmdDispatch),
- VK_NULL_FUNC_ENTRY(vkCmdDispatchIndirect, cmdDispatchIndirect),
- VK_NULL_FUNC_ENTRY(vkCmdCopyBuffer, cmdCopyBuffer),
- VK_NULL_FUNC_ENTRY(vkCmdCopyImage, cmdCopyImage),
- VK_NULL_FUNC_ENTRY(vkCmdBlitImage, cmdBlitImage),
- VK_NULL_FUNC_ENTRY(vkCmdCopyBufferToImage, cmdCopyBufferToImage),
- VK_NULL_FUNC_ENTRY(vkCmdCopyImageToBuffer, cmdCopyImageToBuffer),
- VK_NULL_FUNC_ENTRY(vkCmdUpdateBuffer, cmdUpdateBuffer),
- VK_NULL_FUNC_ENTRY(vkCmdFillBuffer, cmdFillBuffer),
- VK_NULL_FUNC_ENTRY(vkCmdClearColorImage, cmdClearColorImage),
- VK_NULL_FUNC_ENTRY(vkCmdClearDepthStencilImage, cmdClearDepthStencilImage),
- VK_NULL_FUNC_ENTRY(vkCmdClearAttachments, cmdClearAttachments),
- VK_NULL_FUNC_ENTRY(vkCmdResolveImage, cmdResolveImage),
- VK_NULL_FUNC_ENTRY(vkCmdSetEvent, cmdSetEvent),
- VK_NULL_FUNC_ENTRY(vkCmdResetEvent, cmdResetEvent),
- VK_NULL_FUNC_ENTRY(vkCmdWaitEvents, cmdWaitEvents),
- VK_NULL_FUNC_ENTRY(vkCmdPipelineBarrier, cmdPipelineBarrier),
- VK_NULL_FUNC_ENTRY(vkCmdBeginQuery, cmdBeginQuery),
- VK_NULL_FUNC_ENTRY(vkCmdEndQuery, cmdEndQuery),
- VK_NULL_FUNC_ENTRY(vkCmdResetQueryPool, cmdResetQueryPool),
- VK_NULL_FUNC_ENTRY(vkCmdWriteTimestamp, cmdWriteTimestamp),
- VK_NULL_FUNC_ENTRY(vkCmdCopyQueryPoolResults, cmdCopyQueryPoolResults),
- VK_NULL_FUNC_ENTRY(vkCmdPushConstants, cmdPushConstants),
- VK_NULL_FUNC_ENTRY(vkCmdBeginRenderPass, cmdBeginRenderPass),
- VK_NULL_FUNC_ENTRY(vkCmdNextSubpass, cmdNextSubpass),
- VK_NULL_FUNC_ENTRY(vkCmdEndRenderPass, cmdEndRenderPass),
- VK_NULL_FUNC_ENTRY(vkCmdExecuteCommands, cmdExecuteCommands),
- VK_NULL_FUNC_ENTRY(vkBindBufferMemory2, bindBufferMemory2),
- VK_NULL_FUNC_ENTRY(vkBindImageMemory2, bindImageMemory2),
- VK_NULL_FUNC_ENTRY(vkGetDeviceGroupPeerMemoryFeatures, getDeviceGroupPeerMemoryFeatures),
- VK_NULL_FUNC_ENTRY(vkCmdSetDeviceMask, cmdSetDeviceMask),
- VK_NULL_FUNC_ENTRY(vkCmdDispatchBase, cmdDispatchBase),
- VK_NULL_FUNC_ENTRY(vkGetImageMemoryRequirements2, getImageMemoryRequirements2),
- VK_NULL_FUNC_ENTRY(vkGetBufferMemoryRequirements2, getBufferMemoryRequirements2),
- VK_NULL_FUNC_ENTRY(vkGetImageSparseMemoryRequirements2, getImageSparseMemoryRequirements2),
- VK_NULL_FUNC_ENTRY(vkTrimCommandPool, trimCommandPool),
- VK_NULL_FUNC_ENTRY(vkGetDeviceQueue2, getDeviceQueue2),
- VK_NULL_FUNC_ENTRY(vkCreateSamplerYcbcrConversion, createSamplerYcbcrConversion),
- VK_NULL_FUNC_ENTRY(vkDestroySamplerYcbcrConversion, destroySamplerYcbcrConversion),
- VK_NULL_FUNC_ENTRY(vkCreateDescriptorUpdateTemplate, createDescriptorUpdateTemplate),
- VK_NULL_FUNC_ENTRY(vkDestroyDescriptorUpdateTemplate, destroyDescriptorUpdateTemplate),
- VK_NULL_FUNC_ENTRY(vkUpdateDescriptorSetWithTemplate, updateDescriptorSetWithTemplate),
- VK_NULL_FUNC_ENTRY(vkGetDescriptorSetLayoutSupport, getDescriptorSetLayoutSupport),
- VK_NULL_FUNC_ENTRY(vkCreateSwapchainKHR, createSwapchainKHR),
- VK_NULL_FUNC_ENTRY(vkDestroySwapchainKHR, destroySwapchainKHR),
- VK_NULL_FUNC_ENTRY(vkGetSwapchainImagesKHR, getSwapchainImagesKHR),
- VK_NULL_FUNC_ENTRY(vkAcquireNextImageKHR, acquireNextImageKHR),
- VK_NULL_FUNC_ENTRY(vkQueuePresentKHR, queuePresentKHR),
- VK_NULL_FUNC_ENTRY(vkGetDeviceGroupPresentCapabilitiesKHR, getDeviceGroupPresentCapabilitiesKHR),
- VK_NULL_FUNC_ENTRY(vkGetDeviceGroupSurfacePresentModesKHR, getDeviceGroupSurfacePresentModesKHR),
- VK_NULL_FUNC_ENTRY(vkAcquireNextImage2KHR, acquireNextImage2KHR),
- VK_NULL_FUNC_ENTRY(vkCreateSharedSwapchainsKHR, createSharedSwapchainsKHR),
- VK_NULL_FUNC_ENTRY(vkGetDeviceGroupPeerMemoryFeaturesKHR, getDeviceGroupPeerMemoryFeatures),
- VK_NULL_FUNC_ENTRY(vkCmdSetDeviceMaskKHR, cmdSetDeviceMask),
- VK_NULL_FUNC_ENTRY(vkCmdDispatchBaseKHR, cmdDispatchBase),
- VK_NULL_FUNC_ENTRY(vkTrimCommandPoolKHR, trimCommandPool),
- VK_NULL_FUNC_ENTRY(vkGetMemoryFdKHR, getMemoryFdKHR),
- VK_NULL_FUNC_ENTRY(vkGetMemoryFdPropertiesKHR, getMemoryFdPropertiesKHR),
- VK_NULL_FUNC_ENTRY(vkImportSemaphoreFdKHR, importSemaphoreFdKHR),
- VK_NULL_FUNC_ENTRY(vkGetSemaphoreFdKHR, getSemaphoreFdKHR),
- VK_NULL_FUNC_ENTRY(vkCmdPushDescriptorSetKHR, cmdPushDescriptorSetKHR),
- VK_NULL_FUNC_ENTRY(vkCmdPushDescriptorSetWithTemplateKHR, cmdPushDescriptorSetWithTemplateKHR),
- VK_NULL_FUNC_ENTRY(vkCreateDescriptorUpdateTemplateKHR, createDescriptorUpdateTemplate),
- VK_NULL_FUNC_ENTRY(vkDestroyDescriptorUpdateTemplateKHR, destroyDescriptorUpdateTemplate),
- VK_NULL_FUNC_ENTRY(vkUpdateDescriptorSetWithTemplateKHR, updateDescriptorSetWithTemplate),
- VK_NULL_FUNC_ENTRY(vkCreateRenderPass2KHR, createRenderPass2KHR),
- VK_NULL_FUNC_ENTRY(vkCmdBeginRenderPass2KHR, cmdBeginRenderPass2KHR),
- VK_NULL_FUNC_ENTRY(vkCmdNextSubpass2KHR, cmdNextSubpass2KHR),
- VK_NULL_FUNC_ENTRY(vkCmdEndRenderPass2KHR, cmdEndRenderPass2KHR),
- VK_NULL_FUNC_ENTRY(vkGetSwapchainStatusKHR, getSwapchainStatusKHR),
- VK_NULL_FUNC_ENTRY(vkImportFenceFdKHR, importFenceFdKHR),
- VK_NULL_FUNC_ENTRY(vkGetFenceFdKHR, getFenceFdKHR),
- VK_NULL_FUNC_ENTRY(vkAcquireProfilingLockKHR, acquireProfilingLockKHR),
- VK_NULL_FUNC_ENTRY(vkReleaseProfilingLockKHR, releaseProfilingLockKHR),
- VK_NULL_FUNC_ENTRY(vkGetImageMemoryRequirements2KHR, getImageMemoryRequirements2),
- VK_NULL_FUNC_ENTRY(vkGetBufferMemoryRequirements2KHR, getBufferMemoryRequirements2),
- VK_NULL_FUNC_ENTRY(vkGetImageSparseMemoryRequirements2KHR, getImageSparseMemoryRequirements2),
- VK_NULL_FUNC_ENTRY(vkCreateSamplerYcbcrConversionKHR, createSamplerYcbcrConversion),
- VK_NULL_FUNC_ENTRY(vkDestroySamplerYcbcrConversionKHR, destroySamplerYcbcrConversion),
- VK_NULL_FUNC_ENTRY(vkBindBufferMemory2KHR, bindBufferMemory2),
- VK_NULL_FUNC_ENTRY(vkBindImageMemory2KHR, bindImageMemory2),
- VK_NULL_FUNC_ENTRY(vkGetDescriptorSetLayoutSupportKHR, getDescriptorSetLayoutSupport),
- VK_NULL_FUNC_ENTRY(vkCmdDrawIndirectCountKHR, cmdDrawIndirectCountKHR),
- VK_NULL_FUNC_ENTRY(vkCmdDrawIndexedIndirectCountKHR, cmdDrawIndexedIndirectCountKHR),
- VK_NULL_FUNC_ENTRY(vkDebugMarkerSetObjectTagEXT, debugMarkerSetObjectTagEXT),
- VK_NULL_FUNC_ENTRY(vkDebugMarkerSetObjectNameEXT, debugMarkerSetObjectNameEXT),
- VK_NULL_FUNC_ENTRY(vkCmdDebugMarkerBeginEXT, cmdDebugMarkerBeginEXT),
- VK_NULL_FUNC_ENTRY(vkCmdDebugMarkerEndEXT, cmdDebugMarkerEndEXT),
- VK_NULL_FUNC_ENTRY(vkCmdDebugMarkerInsertEXT, cmdDebugMarkerInsertEXT),
- VK_NULL_FUNC_ENTRY(vkCmdBindTransformFeedbackBuffersEXT, cmdBindTransformFeedbackBuffersEXT),
- VK_NULL_FUNC_ENTRY(vkCmdBeginTransformFeedbackEXT, cmdBeginTransformFeedbackEXT),
- VK_NULL_FUNC_ENTRY(vkCmdEndTransformFeedbackEXT, cmdEndTransformFeedbackEXT),
- VK_NULL_FUNC_ENTRY(vkCmdBeginQueryIndexedEXT, cmdBeginQueryIndexedEXT),
- VK_NULL_FUNC_ENTRY(vkCmdEndQueryIndexedEXT, cmdEndQueryIndexedEXT),
- VK_NULL_FUNC_ENTRY(vkCmdDrawIndirectByteCountEXT, cmdDrawIndirectByteCountEXT),
- VK_NULL_FUNC_ENTRY(vkGetImageViewHandleNVX, getImageViewHandleNVX),
- VK_NULL_FUNC_ENTRY(vkCmdDrawIndirectCountAMD, cmdDrawIndirectCountAMD),
- VK_NULL_FUNC_ENTRY(vkCmdDrawIndexedIndirectCountAMD, cmdDrawIndexedIndirectCountAMD),
- VK_NULL_FUNC_ENTRY(vkGetShaderInfoAMD, getShaderInfoAMD),
- VK_NULL_FUNC_ENTRY(vkCmdBeginConditionalRenderingEXT, cmdBeginConditionalRenderingEXT),
- VK_NULL_FUNC_ENTRY(vkCmdEndConditionalRenderingEXT, cmdEndConditionalRenderingEXT),
- VK_NULL_FUNC_ENTRY(vkCmdProcessCommandsNVX, cmdProcessCommandsNVX),
- VK_NULL_FUNC_ENTRY(vkCmdReserveSpaceForCommandsNVX, cmdReserveSpaceForCommandsNVX),
- VK_NULL_FUNC_ENTRY(vkCreateIndirectCommandsLayoutNVX, createIndirectCommandsLayoutNVX),
- VK_NULL_FUNC_ENTRY(vkDestroyIndirectCommandsLayoutNVX, destroyIndirectCommandsLayoutNVX),
- VK_NULL_FUNC_ENTRY(vkCreateObjectTableNVX, createObjectTableNVX),
- VK_NULL_FUNC_ENTRY(vkDestroyObjectTableNVX, destroyObjectTableNVX),
- VK_NULL_FUNC_ENTRY(vkRegisterObjectsNVX, registerObjectsNVX),
- VK_NULL_FUNC_ENTRY(vkUnregisterObjectsNVX, unregisterObjectsNVX),
- VK_NULL_FUNC_ENTRY(vkCmdSetViewportWScalingNV, cmdSetViewportWScalingNV),
- VK_NULL_FUNC_ENTRY(vkDisplayPowerControlEXT, displayPowerControlEXT),
- VK_NULL_FUNC_ENTRY(vkRegisterDeviceEventEXT, registerDeviceEventEXT),
- VK_NULL_FUNC_ENTRY(vkRegisterDisplayEventEXT, registerDisplayEventEXT),
- VK_NULL_FUNC_ENTRY(vkGetSwapchainCounterEXT, getSwapchainCounterEXT),
- VK_NULL_FUNC_ENTRY(vkGetRefreshCycleDurationGOOGLE, getRefreshCycleDurationGOOGLE),
- VK_NULL_FUNC_ENTRY(vkGetPastPresentationTimingGOOGLE, getPastPresentationTimingGOOGLE),
- VK_NULL_FUNC_ENTRY(vkCmdSetDiscardRectangleEXT, cmdSetDiscardRectangleEXT),
- VK_NULL_FUNC_ENTRY(vkSetHdrMetadataEXT, setHdrMetadataEXT),
- VK_NULL_FUNC_ENTRY(vkSetDebugUtilsObjectNameEXT, setDebugUtilsObjectNameEXT),
- VK_NULL_FUNC_ENTRY(vkSetDebugUtilsObjectTagEXT, setDebugUtilsObjectTagEXT),
- VK_NULL_FUNC_ENTRY(vkQueueBeginDebugUtilsLabelEXT, queueBeginDebugUtilsLabelEXT),
- VK_NULL_FUNC_ENTRY(vkQueueEndDebugUtilsLabelEXT, queueEndDebugUtilsLabelEXT),
- VK_NULL_FUNC_ENTRY(vkQueueInsertDebugUtilsLabelEXT, queueInsertDebugUtilsLabelEXT),
- VK_NULL_FUNC_ENTRY(vkCmdBeginDebugUtilsLabelEXT, cmdBeginDebugUtilsLabelEXT),
- VK_NULL_FUNC_ENTRY(vkCmdEndDebugUtilsLabelEXT, cmdEndDebugUtilsLabelEXT),
- VK_NULL_FUNC_ENTRY(vkCmdInsertDebugUtilsLabelEXT, cmdInsertDebugUtilsLabelEXT),
- VK_NULL_FUNC_ENTRY(vkCmdSetSampleLocationsEXT, cmdSetSampleLocationsEXT),
- VK_NULL_FUNC_ENTRY(vkGetImageDrmFormatModifierPropertiesEXT, getImageDrmFormatModifierPropertiesEXT),
- VK_NULL_FUNC_ENTRY(vkCreateValidationCacheEXT, createValidationCacheEXT),
- VK_NULL_FUNC_ENTRY(vkDestroyValidationCacheEXT, destroyValidationCacheEXT),
- VK_NULL_FUNC_ENTRY(vkMergeValidationCachesEXT, mergeValidationCachesEXT),
- VK_NULL_FUNC_ENTRY(vkGetValidationCacheDataEXT, getValidationCacheDataEXT),
- VK_NULL_FUNC_ENTRY(vkCmdBindShadingRateImageNV, cmdBindShadingRateImageNV),
- VK_NULL_FUNC_ENTRY(vkCmdSetViewportShadingRatePaletteNV, cmdSetViewportShadingRatePaletteNV),
- VK_NULL_FUNC_ENTRY(vkCmdSetCoarseSampleOrderNV, cmdSetCoarseSampleOrderNV),
- VK_NULL_FUNC_ENTRY(vkCreateAccelerationStructureNV, createAccelerationStructureNV),
- VK_NULL_FUNC_ENTRY(vkDestroyAccelerationStructureNV, destroyAccelerationStructureNV),
- VK_NULL_FUNC_ENTRY(vkGetAccelerationStructureMemoryRequirementsNV, getAccelerationStructureMemoryRequirementsNV),
- VK_NULL_FUNC_ENTRY(vkBindAccelerationStructureMemoryNV, bindAccelerationStructureMemoryNV),
- VK_NULL_FUNC_ENTRY(vkCmdBuildAccelerationStructureNV, cmdBuildAccelerationStructureNV),
- VK_NULL_FUNC_ENTRY(vkCmdCopyAccelerationStructureNV, cmdCopyAccelerationStructureNV),
- VK_NULL_FUNC_ENTRY(vkCmdTraceRaysNV, cmdTraceRaysNV),
- VK_NULL_FUNC_ENTRY(vkCreateRayTracingPipelinesNV, createRayTracingPipelinesNV),
- VK_NULL_FUNC_ENTRY(vkGetRayTracingShaderGroupHandlesNV, getRayTracingShaderGroupHandlesNV),
- VK_NULL_FUNC_ENTRY(vkGetAccelerationStructureHandleNV, getAccelerationStructureHandleNV),
- VK_NULL_FUNC_ENTRY(vkCmdWriteAccelerationStructuresPropertiesNV, cmdWriteAccelerationStructuresPropertiesNV),
- VK_NULL_FUNC_ENTRY(vkCompileDeferredNV, compileDeferredNV),
- VK_NULL_FUNC_ENTRY(vkGetMemoryHostPointerPropertiesEXT, getMemoryHostPointerPropertiesEXT),
- VK_NULL_FUNC_ENTRY(vkCmdWriteBufferMarkerAMD, cmdWriteBufferMarkerAMD),
- VK_NULL_FUNC_ENTRY(vkGetCalibratedTimestampsEXT, getCalibratedTimestampsEXT),
- VK_NULL_FUNC_ENTRY(vkCmdDrawMeshTasksNV, cmdDrawMeshTasksNV),
- VK_NULL_FUNC_ENTRY(vkCmdDrawMeshTasksIndirectNV, cmdDrawMeshTasksIndirectNV),
- VK_NULL_FUNC_ENTRY(vkCmdDrawMeshTasksIndirectCountNV, cmdDrawMeshTasksIndirectCountNV),
- VK_NULL_FUNC_ENTRY(vkCmdSetExclusiveScissorNV, cmdSetExclusiveScissorNV),
- VK_NULL_FUNC_ENTRY(vkCmdSetCheckpointNV, cmdSetCheckpointNV),
- VK_NULL_FUNC_ENTRY(vkGetQueueCheckpointDataNV, getQueueCheckpointDataNV),
- VK_NULL_FUNC_ENTRY(vkInitializePerformanceApiINTEL, initializePerformanceApiINTEL),
- VK_NULL_FUNC_ENTRY(vkUninitializePerformanceApiINTEL, uninitializePerformanceApiINTEL),
- VK_NULL_FUNC_ENTRY(vkCmdSetPerformanceMarkerINTEL, cmdSetPerformanceMarkerINTEL),
- VK_NULL_FUNC_ENTRY(vkCmdSetPerformanceStreamMarkerINTEL, cmdSetPerformanceStreamMarkerINTEL),
- VK_NULL_FUNC_ENTRY(vkCmdSetPerformanceOverrideINTEL, cmdSetPerformanceOverrideINTEL),
- VK_NULL_FUNC_ENTRY(vkAcquirePerformanceConfigurationINTEL, acquirePerformanceConfigurationINTEL),
- VK_NULL_FUNC_ENTRY(vkReleasePerformanceConfigurationINTEL, releasePerformanceConfigurationINTEL),
- VK_NULL_FUNC_ENTRY(vkQueueSetPerformanceConfigurationINTEL, queueSetPerformanceConfigurationINTEL),
- VK_NULL_FUNC_ENTRY(vkGetPerformanceParameterINTEL, getPerformanceParameterINTEL),
- VK_NULL_FUNC_ENTRY(vkSetLocalDimmingAMD, setLocalDimmingAMD),
- VK_NULL_FUNC_ENTRY(vkGetBufferDeviceAddressEXT, getBufferDeviceAddressEXT),
- VK_NULL_FUNC_ENTRY(vkCmdSetLineStippleEXT, cmdSetLineStippleEXT),
- VK_NULL_FUNC_ENTRY(vkResetQueryPoolEXT, resetQueryPoolEXT),
- VK_NULL_FUNC_ENTRY(vkGetAndroidHardwareBufferPropertiesANDROID, getAndroidHardwareBufferPropertiesANDROID),
- VK_NULL_FUNC_ENTRY(vkGetMemoryAndroidHardwareBufferANDROID, getMemoryAndroidHardwareBufferANDROID),
- VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandleKHR, getMemoryWin32HandleKHR),
- VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandlePropertiesKHR, getMemoryWin32HandlePropertiesKHR),
- VK_NULL_FUNC_ENTRY(vkImportSemaphoreWin32HandleKHR, importSemaphoreWin32HandleKHR),
- VK_NULL_FUNC_ENTRY(vkGetSemaphoreWin32HandleKHR, getSemaphoreWin32HandleKHR),
- VK_NULL_FUNC_ENTRY(vkImportFenceWin32HandleKHR, importFenceWin32HandleKHR),
- VK_NULL_FUNC_ENTRY(vkGetFenceWin32HandleKHR, getFenceWin32HandleKHR),
- VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandleNV, getMemoryWin32HandleNV),
- VK_NULL_FUNC_ENTRY(vkAcquireFullScreenExclusiveModeEXT, acquireFullScreenExclusiveModeEXT),
- VK_NULL_FUNC_ENTRY(vkReleaseFullScreenExclusiveModeEXT, releaseFullScreenExclusiveModeEXT),
- VK_NULL_FUNC_ENTRY(vkGetDeviceGroupSurfacePresentModes2EXT, getDeviceGroupSurfacePresentModes2EXT),
+ VK_NULL_FUNC_ENTRY(vkGetDeviceProcAddr, getDeviceProcAddr),
+ VK_NULL_FUNC_ENTRY(vkDestroyDevice, destroyDevice),
+ VK_NULL_FUNC_ENTRY(vkGetDeviceQueue, getDeviceQueue),
+ VK_NULL_FUNC_ENTRY(vkQueueSubmit, queueSubmit),
+ VK_NULL_FUNC_ENTRY(vkQueueWaitIdle, queueWaitIdle),
+ VK_NULL_FUNC_ENTRY(vkDeviceWaitIdle, deviceWaitIdle),
+ VK_NULL_FUNC_ENTRY(vkAllocateMemory, allocateMemory),
+ VK_NULL_FUNC_ENTRY(vkFreeMemory, freeMemory),
+ VK_NULL_FUNC_ENTRY(vkMapMemory, mapMemory),
+ VK_NULL_FUNC_ENTRY(vkUnmapMemory, unmapMemory),
+ VK_NULL_FUNC_ENTRY(vkFlushMappedMemoryRanges, flushMappedMemoryRanges),
+ VK_NULL_FUNC_ENTRY(vkInvalidateMappedMemoryRanges, invalidateMappedMemoryRanges),
+ VK_NULL_FUNC_ENTRY(vkGetDeviceMemoryCommitment, getDeviceMemoryCommitment),
+ VK_NULL_FUNC_ENTRY(vkBindBufferMemory, bindBufferMemory),
+ VK_NULL_FUNC_ENTRY(vkBindImageMemory, bindImageMemory),
+ VK_NULL_FUNC_ENTRY(vkGetBufferMemoryRequirements, getBufferMemoryRequirements),
+ VK_NULL_FUNC_ENTRY(vkGetImageMemoryRequirements, getImageMemoryRequirements),
+ VK_NULL_FUNC_ENTRY(vkGetImageSparseMemoryRequirements, getImageSparseMemoryRequirements),
+ VK_NULL_FUNC_ENTRY(vkQueueBindSparse, queueBindSparse),
+ VK_NULL_FUNC_ENTRY(vkCreateFence, createFence),
+ VK_NULL_FUNC_ENTRY(vkDestroyFence, destroyFence),
+ VK_NULL_FUNC_ENTRY(vkResetFences, resetFences),
+ VK_NULL_FUNC_ENTRY(vkGetFenceStatus, getFenceStatus),
+ VK_NULL_FUNC_ENTRY(vkWaitForFences, waitForFences),
+ VK_NULL_FUNC_ENTRY(vkCreateSemaphore, createSemaphore),
+ VK_NULL_FUNC_ENTRY(vkDestroySemaphore, destroySemaphore),
+ VK_NULL_FUNC_ENTRY(vkCreateEvent, createEvent),
+ VK_NULL_FUNC_ENTRY(vkDestroyEvent, destroyEvent),
+ VK_NULL_FUNC_ENTRY(vkGetEventStatus, getEventStatus),
+ VK_NULL_FUNC_ENTRY(vkSetEvent, setEvent),
+ VK_NULL_FUNC_ENTRY(vkResetEvent, resetEvent),
+ VK_NULL_FUNC_ENTRY(vkCreateQueryPool, createQueryPool),
+ VK_NULL_FUNC_ENTRY(vkDestroyQueryPool, destroyQueryPool),
+ VK_NULL_FUNC_ENTRY(vkGetQueryPoolResults, getQueryPoolResults),
+ VK_NULL_FUNC_ENTRY(vkCreateBuffer, createBuffer),
+ VK_NULL_FUNC_ENTRY(vkDestroyBuffer, destroyBuffer),
+ VK_NULL_FUNC_ENTRY(vkCreateBufferView, createBufferView),
+ VK_NULL_FUNC_ENTRY(vkDestroyBufferView, destroyBufferView),
+ VK_NULL_FUNC_ENTRY(vkCreateImage, createImage),
+ VK_NULL_FUNC_ENTRY(vkDestroyImage, destroyImage),
+ VK_NULL_FUNC_ENTRY(vkGetImageSubresourceLayout, getImageSubresourceLayout),
+ VK_NULL_FUNC_ENTRY(vkCreateImageView, createImageView),
+ VK_NULL_FUNC_ENTRY(vkDestroyImageView, destroyImageView),
+ VK_NULL_FUNC_ENTRY(vkCreateShaderModule, createShaderModule),
+ VK_NULL_FUNC_ENTRY(vkDestroyShaderModule, destroyShaderModule),
+ VK_NULL_FUNC_ENTRY(vkCreatePipelineCache, createPipelineCache),
+ VK_NULL_FUNC_ENTRY(vkDestroyPipelineCache, destroyPipelineCache),
+ VK_NULL_FUNC_ENTRY(vkGetPipelineCacheData, getPipelineCacheData),
+ VK_NULL_FUNC_ENTRY(vkMergePipelineCaches, mergePipelineCaches),
+ VK_NULL_FUNC_ENTRY(vkCreateGraphicsPipelines, createGraphicsPipelines),
+ VK_NULL_FUNC_ENTRY(vkCreateComputePipelines, createComputePipelines),
+ VK_NULL_FUNC_ENTRY(vkDestroyPipeline, destroyPipeline),
+ VK_NULL_FUNC_ENTRY(vkCreatePipelineLayout, createPipelineLayout),
+ VK_NULL_FUNC_ENTRY(vkDestroyPipelineLayout, destroyPipelineLayout),
+ VK_NULL_FUNC_ENTRY(vkCreateSampler, createSampler),
+ VK_NULL_FUNC_ENTRY(vkDestroySampler, destroySampler),
+ VK_NULL_FUNC_ENTRY(vkCreateDescriptorSetLayout, createDescriptorSetLayout),
+ VK_NULL_FUNC_ENTRY(vkDestroyDescriptorSetLayout, destroyDescriptorSetLayout),
+ VK_NULL_FUNC_ENTRY(vkCreateDescriptorPool, createDescriptorPool),
+ VK_NULL_FUNC_ENTRY(vkDestroyDescriptorPool, destroyDescriptorPool),
+ VK_NULL_FUNC_ENTRY(vkResetDescriptorPool, resetDescriptorPool),
+ VK_NULL_FUNC_ENTRY(vkAllocateDescriptorSets, allocateDescriptorSets),
+ VK_NULL_FUNC_ENTRY(vkFreeDescriptorSets, freeDescriptorSets),
+ VK_NULL_FUNC_ENTRY(vkUpdateDescriptorSets, updateDescriptorSets),
+ VK_NULL_FUNC_ENTRY(vkCreateFramebuffer, createFramebuffer),
+ VK_NULL_FUNC_ENTRY(vkDestroyFramebuffer, destroyFramebuffer),
+ VK_NULL_FUNC_ENTRY(vkCreateRenderPass, createRenderPass),
+ VK_NULL_FUNC_ENTRY(vkDestroyRenderPass, destroyRenderPass),
+ VK_NULL_FUNC_ENTRY(vkGetRenderAreaGranularity, getRenderAreaGranularity),
+ VK_NULL_FUNC_ENTRY(vkCreateCommandPool, createCommandPool),
+ VK_NULL_FUNC_ENTRY(vkDestroyCommandPool, destroyCommandPool),
+ VK_NULL_FUNC_ENTRY(vkResetCommandPool, resetCommandPool),
+ VK_NULL_FUNC_ENTRY(vkAllocateCommandBuffers, allocateCommandBuffers),
+ VK_NULL_FUNC_ENTRY(vkFreeCommandBuffers, freeCommandBuffers),
+ VK_NULL_FUNC_ENTRY(vkBeginCommandBuffer, beginCommandBuffer),
+ VK_NULL_FUNC_ENTRY(vkEndCommandBuffer, endCommandBuffer),
+ VK_NULL_FUNC_ENTRY(vkResetCommandBuffer, resetCommandBuffer),
+ VK_NULL_FUNC_ENTRY(vkCmdBindPipeline, cmdBindPipeline),
+ VK_NULL_FUNC_ENTRY(vkCmdSetViewport, cmdSetViewport),
+ VK_NULL_FUNC_ENTRY(vkCmdSetScissor, cmdSetScissor),
+ VK_NULL_FUNC_ENTRY(vkCmdSetLineWidth, cmdSetLineWidth),
+ VK_NULL_FUNC_ENTRY(vkCmdSetDepthBias, cmdSetDepthBias),
+ VK_NULL_FUNC_ENTRY(vkCmdSetBlendConstants, cmdSetBlendConstants),
+ VK_NULL_FUNC_ENTRY(vkCmdSetDepthBounds, cmdSetDepthBounds),
+ VK_NULL_FUNC_ENTRY(vkCmdSetStencilCompareMask, cmdSetStencilCompareMask),
+ VK_NULL_FUNC_ENTRY(vkCmdSetStencilWriteMask, cmdSetStencilWriteMask),
+ VK_NULL_FUNC_ENTRY(vkCmdSetStencilReference, cmdSetStencilReference),
+ VK_NULL_FUNC_ENTRY(vkCmdBindDescriptorSets, cmdBindDescriptorSets),
+ VK_NULL_FUNC_ENTRY(vkCmdBindIndexBuffer, cmdBindIndexBuffer),
+ VK_NULL_FUNC_ENTRY(vkCmdBindVertexBuffers, cmdBindVertexBuffers),
+ VK_NULL_FUNC_ENTRY(vkCmdDraw, cmdDraw),
+ VK_NULL_FUNC_ENTRY(vkCmdDrawIndexed, cmdDrawIndexed),
+ VK_NULL_FUNC_ENTRY(vkCmdDrawIndirect, cmdDrawIndirect),
+ VK_NULL_FUNC_ENTRY(vkCmdDrawIndexedIndirect, cmdDrawIndexedIndirect),
+ VK_NULL_FUNC_ENTRY(vkCmdDispatch, cmdDispatch),
+ VK_NULL_FUNC_ENTRY(vkCmdDispatchIndirect, cmdDispatchIndirect),
+ VK_NULL_FUNC_ENTRY(vkCmdCopyBuffer, cmdCopyBuffer),
+ VK_NULL_FUNC_ENTRY(vkCmdCopyImage, cmdCopyImage),
+ VK_NULL_FUNC_ENTRY(vkCmdBlitImage, cmdBlitImage),
+ VK_NULL_FUNC_ENTRY(vkCmdCopyBufferToImage, cmdCopyBufferToImage),
+ VK_NULL_FUNC_ENTRY(vkCmdCopyImageToBuffer, cmdCopyImageToBuffer),
+ VK_NULL_FUNC_ENTRY(vkCmdUpdateBuffer, cmdUpdateBuffer),
+ VK_NULL_FUNC_ENTRY(vkCmdFillBuffer, cmdFillBuffer),
+ VK_NULL_FUNC_ENTRY(vkCmdClearColorImage, cmdClearColorImage),
+ VK_NULL_FUNC_ENTRY(vkCmdClearDepthStencilImage, cmdClearDepthStencilImage),
+ VK_NULL_FUNC_ENTRY(vkCmdClearAttachments, cmdClearAttachments),
+ VK_NULL_FUNC_ENTRY(vkCmdResolveImage, cmdResolveImage),
+ VK_NULL_FUNC_ENTRY(vkCmdSetEvent, cmdSetEvent),
+ VK_NULL_FUNC_ENTRY(vkCmdResetEvent, cmdResetEvent),
+ VK_NULL_FUNC_ENTRY(vkCmdWaitEvents, cmdWaitEvents),
+ VK_NULL_FUNC_ENTRY(vkCmdPipelineBarrier, cmdPipelineBarrier),
+ VK_NULL_FUNC_ENTRY(vkCmdBeginQuery, cmdBeginQuery),
+ VK_NULL_FUNC_ENTRY(vkCmdEndQuery, cmdEndQuery),
+ VK_NULL_FUNC_ENTRY(vkCmdResetQueryPool, cmdResetQueryPool),
+ VK_NULL_FUNC_ENTRY(vkCmdWriteTimestamp, cmdWriteTimestamp),
+ VK_NULL_FUNC_ENTRY(vkCmdCopyQueryPoolResults, cmdCopyQueryPoolResults),
+ VK_NULL_FUNC_ENTRY(vkCmdPushConstants, cmdPushConstants),
+ VK_NULL_FUNC_ENTRY(vkCmdBeginRenderPass, cmdBeginRenderPass),
+ VK_NULL_FUNC_ENTRY(vkCmdNextSubpass, cmdNextSubpass),
+ VK_NULL_FUNC_ENTRY(vkCmdEndRenderPass, cmdEndRenderPass),
+ VK_NULL_FUNC_ENTRY(vkCmdExecuteCommands, cmdExecuteCommands),
+ VK_NULL_FUNC_ENTRY(vkBindBufferMemory2, bindBufferMemory2),
+ VK_NULL_FUNC_ENTRY(vkBindImageMemory2, bindImageMemory2),
+ VK_NULL_FUNC_ENTRY(vkGetDeviceGroupPeerMemoryFeatures, getDeviceGroupPeerMemoryFeatures),
+ VK_NULL_FUNC_ENTRY(vkCmdSetDeviceMask, cmdSetDeviceMask),
+ VK_NULL_FUNC_ENTRY(vkCmdDispatchBase, cmdDispatchBase),
+ VK_NULL_FUNC_ENTRY(vkGetImageMemoryRequirements2, getImageMemoryRequirements2),
+ VK_NULL_FUNC_ENTRY(vkGetBufferMemoryRequirements2, getBufferMemoryRequirements2),
+ VK_NULL_FUNC_ENTRY(vkGetImageSparseMemoryRequirements2, getImageSparseMemoryRequirements2),
+ VK_NULL_FUNC_ENTRY(vkTrimCommandPool, trimCommandPool),
+ VK_NULL_FUNC_ENTRY(vkGetDeviceQueue2, getDeviceQueue2),
+ VK_NULL_FUNC_ENTRY(vkCreateSamplerYcbcrConversion, createSamplerYcbcrConversion),
+ VK_NULL_FUNC_ENTRY(vkDestroySamplerYcbcrConversion, destroySamplerYcbcrConversion),
+ VK_NULL_FUNC_ENTRY(vkCreateDescriptorUpdateTemplate, createDescriptorUpdateTemplate),
+ VK_NULL_FUNC_ENTRY(vkDestroyDescriptorUpdateTemplate, destroyDescriptorUpdateTemplate),
+ VK_NULL_FUNC_ENTRY(vkUpdateDescriptorSetWithTemplate, updateDescriptorSetWithTemplate),
+ VK_NULL_FUNC_ENTRY(vkGetDescriptorSetLayoutSupport, getDescriptorSetLayoutSupport),
+ VK_NULL_FUNC_ENTRY(vkCreateSwapchainKHR, createSwapchainKHR),
+ VK_NULL_FUNC_ENTRY(vkDestroySwapchainKHR, destroySwapchainKHR),
+ VK_NULL_FUNC_ENTRY(vkGetSwapchainImagesKHR, getSwapchainImagesKHR),
+ VK_NULL_FUNC_ENTRY(vkAcquireNextImageKHR, acquireNextImageKHR),
+ VK_NULL_FUNC_ENTRY(vkQueuePresentKHR, queuePresentKHR),
+ VK_NULL_FUNC_ENTRY(vkGetDeviceGroupPresentCapabilitiesKHR, getDeviceGroupPresentCapabilitiesKHR),
+ VK_NULL_FUNC_ENTRY(vkGetDeviceGroupSurfacePresentModesKHR, getDeviceGroupSurfacePresentModesKHR),
+ VK_NULL_FUNC_ENTRY(vkAcquireNextImage2KHR, acquireNextImage2KHR),
+ VK_NULL_FUNC_ENTRY(vkCreateSharedSwapchainsKHR, createSharedSwapchainsKHR),
+ VK_NULL_FUNC_ENTRY(vkGetDeviceGroupPeerMemoryFeaturesKHR, getDeviceGroupPeerMemoryFeatures),
+ VK_NULL_FUNC_ENTRY(vkCmdSetDeviceMaskKHR, cmdSetDeviceMask),
+ VK_NULL_FUNC_ENTRY(vkCmdDispatchBaseKHR, cmdDispatchBase),
+ VK_NULL_FUNC_ENTRY(vkTrimCommandPoolKHR, trimCommandPool),
+ VK_NULL_FUNC_ENTRY(vkGetMemoryFdKHR, getMemoryFdKHR),
+ VK_NULL_FUNC_ENTRY(vkGetMemoryFdPropertiesKHR, getMemoryFdPropertiesKHR),
+ VK_NULL_FUNC_ENTRY(vkImportSemaphoreFdKHR, importSemaphoreFdKHR),
+ VK_NULL_FUNC_ENTRY(vkGetSemaphoreFdKHR, getSemaphoreFdKHR),
+ VK_NULL_FUNC_ENTRY(vkCmdPushDescriptorSetKHR, cmdPushDescriptorSetKHR),
+ VK_NULL_FUNC_ENTRY(vkCmdPushDescriptorSetWithTemplateKHR, cmdPushDescriptorSetWithTemplateKHR),
+ VK_NULL_FUNC_ENTRY(vkCreateDescriptorUpdateTemplateKHR, createDescriptorUpdateTemplate),
+ VK_NULL_FUNC_ENTRY(vkDestroyDescriptorUpdateTemplateKHR, destroyDescriptorUpdateTemplate),
+ VK_NULL_FUNC_ENTRY(vkUpdateDescriptorSetWithTemplateKHR, updateDescriptorSetWithTemplate),
+ VK_NULL_FUNC_ENTRY(vkCreateRenderPass2KHR, createRenderPass2KHR),
+ VK_NULL_FUNC_ENTRY(vkCmdBeginRenderPass2KHR, cmdBeginRenderPass2KHR),
+ VK_NULL_FUNC_ENTRY(vkCmdNextSubpass2KHR, cmdNextSubpass2KHR),
+ VK_NULL_FUNC_ENTRY(vkCmdEndRenderPass2KHR, cmdEndRenderPass2KHR),
+ VK_NULL_FUNC_ENTRY(vkGetSwapchainStatusKHR, getSwapchainStatusKHR),
+ VK_NULL_FUNC_ENTRY(vkImportFenceFdKHR, importFenceFdKHR),
+ VK_NULL_FUNC_ENTRY(vkGetFenceFdKHR, getFenceFdKHR),
+ VK_NULL_FUNC_ENTRY(vkAcquireProfilingLockKHR, acquireProfilingLockKHR),
+ VK_NULL_FUNC_ENTRY(vkReleaseProfilingLockKHR, releaseProfilingLockKHR),
+ VK_NULL_FUNC_ENTRY(vkGetImageMemoryRequirements2KHR, getImageMemoryRequirements2),
+ VK_NULL_FUNC_ENTRY(vkGetBufferMemoryRequirements2KHR, getBufferMemoryRequirements2),
+ VK_NULL_FUNC_ENTRY(vkGetImageSparseMemoryRequirements2KHR, getImageSparseMemoryRequirements2),
+ VK_NULL_FUNC_ENTRY(vkCreateSamplerYcbcrConversionKHR, createSamplerYcbcrConversion),
+ VK_NULL_FUNC_ENTRY(vkDestroySamplerYcbcrConversionKHR, destroySamplerYcbcrConversion),
+ VK_NULL_FUNC_ENTRY(vkBindBufferMemory2KHR, bindBufferMemory2),
+ VK_NULL_FUNC_ENTRY(vkBindImageMemory2KHR, bindImageMemory2),
+ VK_NULL_FUNC_ENTRY(vkGetDescriptorSetLayoutSupportKHR, getDescriptorSetLayoutSupport),
+ VK_NULL_FUNC_ENTRY(vkCmdDrawIndirectCountKHR, cmdDrawIndirectCountKHR),
+ VK_NULL_FUNC_ENTRY(vkCmdDrawIndexedIndirectCountKHR, cmdDrawIndexedIndirectCountKHR),
+ VK_NULL_FUNC_ENTRY(vkGetPipelineExecutablePropertiesKHR, getPipelineExecutablePropertiesKHR),
+ VK_NULL_FUNC_ENTRY(vkGetPipelineExecutableStatisticsKHR, getPipelineExecutableStatisticsKHR),
+ VK_NULL_FUNC_ENTRY(vkGetPipelineExecutableInternalRepresentationsKHR, getPipelineExecutableInternalRepresentationsKHR),
+ VK_NULL_FUNC_ENTRY(vkDebugMarkerSetObjectTagEXT, debugMarkerSetObjectTagEXT),
+ VK_NULL_FUNC_ENTRY(vkDebugMarkerSetObjectNameEXT, debugMarkerSetObjectNameEXT),
+ VK_NULL_FUNC_ENTRY(vkCmdDebugMarkerBeginEXT, cmdDebugMarkerBeginEXT),
+ VK_NULL_FUNC_ENTRY(vkCmdDebugMarkerEndEXT, cmdDebugMarkerEndEXT),
+ VK_NULL_FUNC_ENTRY(vkCmdDebugMarkerInsertEXT, cmdDebugMarkerInsertEXT),
+ VK_NULL_FUNC_ENTRY(vkCmdBindTransformFeedbackBuffersEXT, cmdBindTransformFeedbackBuffersEXT),
+ VK_NULL_FUNC_ENTRY(vkCmdBeginTransformFeedbackEXT, cmdBeginTransformFeedbackEXT),
+ VK_NULL_FUNC_ENTRY(vkCmdEndTransformFeedbackEXT, cmdEndTransformFeedbackEXT),
+ VK_NULL_FUNC_ENTRY(vkCmdBeginQueryIndexedEXT, cmdBeginQueryIndexedEXT),
+ VK_NULL_FUNC_ENTRY(vkCmdEndQueryIndexedEXT, cmdEndQueryIndexedEXT),
+ VK_NULL_FUNC_ENTRY(vkCmdDrawIndirectByteCountEXT, cmdDrawIndirectByteCountEXT),
+ VK_NULL_FUNC_ENTRY(vkGetImageViewHandleNVX, getImageViewHandleNVX),
+ VK_NULL_FUNC_ENTRY(vkCmdDrawIndirectCountAMD, cmdDrawIndirectCountAMD),
+ VK_NULL_FUNC_ENTRY(vkCmdDrawIndexedIndirectCountAMD, cmdDrawIndexedIndirectCountAMD),
+ VK_NULL_FUNC_ENTRY(vkGetShaderInfoAMD, getShaderInfoAMD),
+ VK_NULL_FUNC_ENTRY(vkCmdBeginConditionalRenderingEXT, cmdBeginConditionalRenderingEXT),
+ VK_NULL_FUNC_ENTRY(vkCmdEndConditionalRenderingEXT, cmdEndConditionalRenderingEXT),
+ VK_NULL_FUNC_ENTRY(vkCmdProcessCommandsNVX, cmdProcessCommandsNVX),
+ VK_NULL_FUNC_ENTRY(vkCmdReserveSpaceForCommandsNVX, cmdReserveSpaceForCommandsNVX),
+ VK_NULL_FUNC_ENTRY(vkCreateIndirectCommandsLayoutNVX, createIndirectCommandsLayoutNVX),
+ VK_NULL_FUNC_ENTRY(vkDestroyIndirectCommandsLayoutNVX, destroyIndirectCommandsLayoutNVX),
+ VK_NULL_FUNC_ENTRY(vkCreateObjectTableNVX, createObjectTableNVX),
+ VK_NULL_FUNC_ENTRY(vkDestroyObjectTableNVX, destroyObjectTableNVX),
+ VK_NULL_FUNC_ENTRY(vkRegisterObjectsNVX, registerObjectsNVX),
+ VK_NULL_FUNC_ENTRY(vkUnregisterObjectsNVX, unregisterObjectsNVX),
+ VK_NULL_FUNC_ENTRY(vkCmdSetViewportWScalingNV, cmdSetViewportWScalingNV),
+ VK_NULL_FUNC_ENTRY(vkDisplayPowerControlEXT, displayPowerControlEXT),
+ VK_NULL_FUNC_ENTRY(vkRegisterDeviceEventEXT, registerDeviceEventEXT),
+ VK_NULL_FUNC_ENTRY(vkRegisterDisplayEventEXT, registerDisplayEventEXT),
+ VK_NULL_FUNC_ENTRY(vkGetSwapchainCounterEXT, getSwapchainCounterEXT),
+ VK_NULL_FUNC_ENTRY(vkGetRefreshCycleDurationGOOGLE, getRefreshCycleDurationGOOGLE),
+ VK_NULL_FUNC_ENTRY(vkGetPastPresentationTimingGOOGLE, getPastPresentationTimingGOOGLE),
+ VK_NULL_FUNC_ENTRY(vkCmdSetDiscardRectangleEXT, cmdSetDiscardRectangleEXT),
+ VK_NULL_FUNC_ENTRY(vkSetHdrMetadataEXT, setHdrMetadataEXT),
+ VK_NULL_FUNC_ENTRY(vkSetDebugUtilsObjectNameEXT, setDebugUtilsObjectNameEXT),
+ VK_NULL_FUNC_ENTRY(vkSetDebugUtilsObjectTagEXT, setDebugUtilsObjectTagEXT),
+ VK_NULL_FUNC_ENTRY(vkQueueBeginDebugUtilsLabelEXT, queueBeginDebugUtilsLabelEXT),
+ VK_NULL_FUNC_ENTRY(vkQueueEndDebugUtilsLabelEXT, queueEndDebugUtilsLabelEXT),
+ VK_NULL_FUNC_ENTRY(vkQueueInsertDebugUtilsLabelEXT, queueInsertDebugUtilsLabelEXT),
+ VK_NULL_FUNC_ENTRY(vkCmdBeginDebugUtilsLabelEXT, cmdBeginDebugUtilsLabelEXT),
+ VK_NULL_FUNC_ENTRY(vkCmdEndDebugUtilsLabelEXT, cmdEndDebugUtilsLabelEXT),
+ VK_NULL_FUNC_ENTRY(vkCmdInsertDebugUtilsLabelEXT, cmdInsertDebugUtilsLabelEXT),
+ VK_NULL_FUNC_ENTRY(vkCmdSetSampleLocationsEXT, cmdSetSampleLocationsEXT),
+ VK_NULL_FUNC_ENTRY(vkGetImageDrmFormatModifierPropertiesEXT, getImageDrmFormatModifierPropertiesEXT),
+ VK_NULL_FUNC_ENTRY(vkCreateValidationCacheEXT, createValidationCacheEXT),
+ VK_NULL_FUNC_ENTRY(vkDestroyValidationCacheEXT, destroyValidationCacheEXT),
+ VK_NULL_FUNC_ENTRY(vkMergeValidationCachesEXT, mergeValidationCachesEXT),
+ VK_NULL_FUNC_ENTRY(vkGetValidationCacheDataEXT, getValidationCacheDataEXT),
+ VK_NULL_FUNC_ENTRY(vkCmdBindShadingRateImageNV, cmdBindShadingRateImageNV),
+ VK_NULL_FUNC_ENTRY(vkCmdSetViewportShadingRatePaletteNV, cmdSetViewportShadingRatePaletteNV),
+ VK_NULL_FUNC_ENTRY(vkCmdSetCoarseSampleOrderNV, cmdSetCoarseSampleOrderNV),
+ VK_NULL_FUNC_ENTRY(vkCreateAccelerationStructureNV, createAccelerationStructureNV),
+ VK_NULL_FUNC_ENTRY(vkDestroyAccelerationStructureNV, destroyAccelerationStructureNV),
+ VK_NULL_FUNC_ENTRY(vkGetAccelerationStructureMemoryRequirementsNV, getAccelerationStructureMemoryRequirementsNV),
+ VK_NULL_FUNC_ENTRY(vkBindAccelerationStructureMemoryNV, bindAccelerationStructureMemoryNV),
+ VK_NULL_FUNC_ENTRY(vkCmdBuildAccelerationStructureNV, cmdBuildAccelerationStructureNV),
+ VK_NULL_FUNC_ENTRY(vkCmdCopyAccelerationStructureNV, cmdCopyAccelerationStructureNV),
+ VK_NULL_FUNC_ENTRY(vkCmdTraceRaysNV, cmdTraceRaysNV),
+ VK_NULL_FUNC_ENTRY(vkCreateRayTracingPipelinesNV, createRayTracingPipelinesNV),
+ VK_NULL_FUNC_ENTRY(vkGetRayTracingShaderGroupHandlesNV, getRayTracingShaderGroupHandlesNV),
+ VK_NULL_FUNC_ENTRY(vkGetAccelerationStructureHandleNV, getAccelerationStructureHandleNV),
+ VK_NULL_FUNC_ENTRY(vkCmdWriteAccelerationStructuresPropertiesNV, cmdWriteAccelerationStructuresPropertiesNV),
+ VK_NULL_FUNC_ENTRY(vkCompileDeferredNV, compileDeferredNV),
+ VK_NULL_FUNC_ENTRY(vkGetMemoryHostPointerPropertiesEXT, getMemoryHostPointerPropertiesEXT),
+ VK_NULL_FUNC_ENTRY(vkCmdWriteBufferMarkerAMD, cmdWriteBufferMarkerAMD),
+ VK_NULL_FUNC_ENTRY(vkGetCalibratedTimestampsEXT, getCalibratedTimestampsEXT),
+ VK_NULL_FUNC_ENTRY(vkCmdDrawMeshTasksNV, cmdDrawMeshTasksNV),
+ VK_NULL_FUNC_ENTRY(vkCmdDrawMeshTasksIndirectNV, cmdDrawMeshTasksIndirectNV),
+ VK_NULL_FUNC_ENTRY(vkCmdDrawMeshTasksIndirectCountNV, cmdDrawMeshTasksIndirectCountNV),
+ VK_NULL_FUNC_ENTRY(vkCmdSetExclusiveScissorNV, cmdSetExclusiveScissorNV),
+ VK_NULL_FUNC_ENTRY(vkCmdSetCheckpointNV, cmdSetCheckpointNV),
+ VK_NULL_FUNC_ENTRY(vkGetQueueCheckpointDataNV, getQueueCheckpointDataNV),
+ VK_NULL_FUNC_ENTRY(vkInitializePerformanceApiINTEL, initializePerformanceApiINTEL),
+ VK_NULL_FUNC_ENTRY(vkUninitializePerformanceApiINTEL, uninitializePerformanceApiINTEL),
+ VK_NULL_FUNC_ENTRY(vkCmdSetPerformanceMarkerINTEL, cmdSetPerformanceMarkerINTEL),
+ VK_NULL_FUNC_ENTRY(vkCmdSetPerformanceStreamMarkerINTEL, cmdSetPerformanceStreamMarkerINTEL),
+ VK_NULL_FUNC_ENTRY(vkCmdSetPerformanceOverrideINTEL, cmdSetPerformanceOverrideINTEL),
+ VK_NULL_FUNC_ENTRY(vkAcquirePerformanceConfigurationINTEL, acquirePerformanceConfigurationINTEL),
+ VK_NULL_FUNC_ENTRY(vkReleasePerformanceConfigurationINTEL, releasePerformanceConfigurationINTEL),
+ VK_NULL_FUNC_ENTRY(vkQueueSetPerformanceConfigurationINTEL, queueSetPerformanceConfigurationINTEL),
+ VK_NULL_FUNC_ENTRY(vkGetPerformanceParameterINTEL, getPerformanceParameterINTEL),
+ VK_NULL_FUNC_ENTRY(vkSetLocalDimmingAMD, setLocalDimmingAMD),
+ VK_NULL_FUNC_ENTRY(vkGetBufferDeviceAddressEXT, getBufferDeviceAddressEXT),
+ VK_NULL_FUNC_ENTRY(vkCmdSetLineStippleEXT, cmdSetLineStippleEXT),
+ VK_NULL_FUNC_ENTRY(vkResetQueryPoolEXT, resetQueryPoolEXT),
+ VK_NULL_FUNC_ENTRY(vkGetAndroidHardwareBufferPropertiesANDROID, getAndroidHardwareBufferPropertiesANDROID),
+ VK_NULL_FUNC_ENTRY(vkGetMemoryAndroidHardwareBufferANDROID, getMemoryAndroidHardwareBufferANDROID),
+ VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandleKHR, getMemoryWin32HandleKHR),
+ VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandlePropertiesKHR, getMemoryWin32HandlePropertiesKHR),
+ VK_NULL_FUNC_ENTRY(vkImportSemaphoreWin32HandleKHR, importSemaphoreWin32HandleKHR),
+ VK_NULL_FUNC_ENTRY(vkGetSemaphoreWin32HandleKHR, getSemaphoreWin32HandleKHR),
+ VK_NULL_FUNC_ENTRY(vkImportFenceWin32HandleKHR, importFenceWin32HandleKHR),
+ VK_NULL_FUNC_ENTRY(vkGetFenceWin32HandleKHR, getFenceWin32HandleKHR),
+ VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandleNV, getMemoryWin32HandleNV),
+ VK_NULL_FUNC_ENTRY(vkAcquireFullScreenExclusiveModeEXT, acquireFullScreenExclusiveModeEXT),
+ VK_NULL_FUNC_ENTRY(vkReleaseFullScreenExclusiveModeEXT, releaseFullScreenExclusiveModeEXT),
+ VK_NULL_FUNC_ENTRY(vkGetDeviceGroupSurfacePresentModes2EXT, getDeviceGroupSurfacePresentModes2EXT),
};
const char* getPerformanceCounterStorageKHRName (VkPerformanceCounterStorageKHR value);
const char* getDriverIdKHRName (VkDriverIdKHR value);
const char* getShaderFloatControlsIndependenceKHRName (VkShaderFloatControlsIndependenceKHR value);
+const char* getPipelineExecutableStatisticFormatKHRName (VkPipelineExecutableStatisticFormatKHR value);
const char* getDebugReportObjectTypeEXTName (VkDebugReportObjectTypeEXT value);
const char* getRasterizationOrderAMDName (VkRasterizationOrderAMD value);
const char* getShaderInfoTypeAMDName (VkShaderInfoTypeAMD value);
inline tcu::Format::Enum<VkPerformanceCounterStorageKHR> getPerformanceCounterStorageKHRStr (VkPerformanceCounterStorageKHR value) { return tcu::Format::Enum<VkPerformanceCounterStorageKHR>(getPerformanceCounterStorageKHRName, value); }
inline tcu::Format::Enum<VkDriverIdKHR> getDriverIdKHRStr (VkDriverIdKHR value) { return tcu::Format::Enum<VkDriverIdKHR>(getDriverIdKHRName, value); }
inline tcu::Format::Enum<VkShaderFloatControlsIndependenceKHR> getShaderFloatControlsIndependenceKHRStr (VkShaderFloatControlsIndependenceKHR value) { return tcu::Format::Enum<VkShaderFloatControlsIndependenceKHR>(getShaderFloatControlsIndependenceKHRName, value); }
+inline tcu::Format::Enum<VkPipelineExecutableStatisticFormatKHR> getPipelineExecutableStatisticFormatKHRStr (VkPipelineExecutableStatisticFormatKHR value) { return tcu::Format::Enum<VkPipelineExecutableStatisticFormatKHR>(getPipelineExecutableStatisticFormatKHRName, value); }
inline tcu::Format::Enum<VkDebugReportObjectTypeEXT> getDebugReportObjectTypeEXTStr (VkDebugReportObjectTypeEXT value) { return tcu::Format::Enum<VkDebugReportObjectTypeEXT>(getDebugReportObjectTypeEXTName, value); }
inline tcu::Format::Enum<VkRasterizationOrderAMD> getRasterizationOrderAMDStr (VkRasterizationOrderAMD value) { return tcu::Format::Enum<VkRasterizationOrderAMD>(getRasterizationOrderAMDName, value); }
inline tcu::Format::Enum<VkShaderInfoTypeAMD> getShaderInfoTypeAMDStr (VkShaderInfoTypeAMD value) { return tcu::Format::Enum<VkShaderInfoTypeAMD>(getShaderInfoTypeAMDName, value); }
inline std::ostream& operator<< (std::ostream& s, VkPerformanceCounterStorageKHR value) { return s << getPerformanceCounterStorageKHRStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkDriverIdKHR value) { return s << getDriverIdKHRStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkShaderFloatControlsIndependenceKHR value) { return s << getShaderFloatControlsIndependenceKHRStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkPipelineExecutableStatisticFormatKHR value) { return s << getPipelineExecutableStatisticFormatKHRStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkDebugReportObjectTypeEXT value) { return s << getDebugReportObjectTypeEXTStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkRasterizationOrderAMD value) { return s << getRasterizationOrderAMDStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkShaderInfoTypeAMD value) { return s << getShaderInfoTypeAMDStr(value); }
std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceVulkanMemoryModelFeaturesKHR& value);
std::ostream& operator<< (std::ostream& s, const VkSurfaceProtectedCapabilitiesKHR& value);
std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR& value);
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& value);
+std::ostream& operator<< (std::ostream& s, const VkPipelineInfoKHR& value);
+std::ostream& operator<< (std::ostream& s, const VkPipelineExecutablePropertiesKHR& value);
+std::ostream& operator<< (std::ostream& s, const VkPipelineExecutableInfoKHR& value);
+std::ostream& operator<< (std::ostream& s, const VkPipelineExecutableStatisticValueKHR& value);
+std::ostream& operator<< (std::ostream& s, const VkPipelineExecutableStatisticKHR& value);
+std::ostream& operator<< (std::ostream& s, const VkPipelineExecutableInternalRepresentationKHR& value);
std::ostream& operator<< (std::ostream& s, const VkDebugReportCallbackCreateInfoEXT& value);
std::ostream& operator<< (std::ostream& s, const VkPipelineRasterizationStateRasterizationOrderAMD& value);
std::ostream& operator<< (std::ostream& s, const VkDebugMarkerObjectNameInfoEXT& value);
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR";
+ case VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR: return "VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR: return "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR";
+ case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR: return "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR: return "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR";
+ case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR: return "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT";
}
}
+const char* getPipelineExecutableStatisticFormatKHRName (VkPipelineExecutableStatisticFormatKHR value)
+{
+ switch (value)
+ {
+ case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR: return "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR";
+ case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR: return "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR";
+ case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR: return "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR";
+ case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR: return "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR";
+ case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_MAX_ENUM_KHR: return "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_MAX_ENUM_KHR";
+ default: return DE_NULL;
+ }
+}
+
const char* getDebugReportObjectTypeEXTName (VkDebugReportObjectTypeEXT value)
{
switch (value)
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT, "VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT"),
- tcu::Format::BitDesc(VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT, "VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT"),
- tcu::Format::BitDesc(VK_PIPELINE_CREATE_DERIVATIVE_BIT, "VK_PIPELINE_CREATE_DERIVATIVE_BIT"),
- tcu::Format::BitDesc(VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, "VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT"),
- tcu::Format::BitDesc(VK_PIPELINE_CREATE_DISPATCH_BASE, "VK_PIPELINE_CREATE_DISPATCH_BASE"),
- tcu::Format::BitDesc(VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV, "VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV"),
- tcu::Format::BitDesc(VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR, "VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR"),
- tcu::Format::BitDesc(VK_PIPELINE_CREATE_DISPATCH_BASE_KHR, "VK_PIPELINE_CREATE_DISPATCH_BASE_KHR"),
- tcu::Format::BitDesc(VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM, "VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM"),
+ tcu::Format::BitDesc(VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT, "VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT, "VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_CREATE_DERIVATIVE_BIT, "VK_PIPELINE_CREATE_DERIVATIVE_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, "VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_CREATE_DISPATCH_BASE, "VK_PIPELINE_CREATE_DISPATCH_BASE"),
+ tcu::Format::BitDesc(VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV, "VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV"),
+ tcu::Format::BitDesc(VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR, "VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR"),
+ tcu::Format::BitDesc(VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR, "VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR"),
+ tcu::Format::BitDesc(VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR, "VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR"),
+ tcu::Format::BitDesc(VK_PIPELINE_CREATE_DISPATCH_BASE_KHR, "VK_PIPELINE_CREATE_DISPATCH_BASE_KHR"),
+ tcu::Format::BitDesc(VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM, "VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
return s;
}
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& value)
+{
+ s << "VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tpipelineExecutableInfo = " << value.pipelineExecutableInfo << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPipelineInfoKHR& value)
+{
+ s << "VkPipelineInfoKHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tpipeline = " << value.pipeline << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPipelineExecutablePropertiesKHR& value)
+{
+ s << "VkPipelineExecutablePropertiesKHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tstages = " << getShaderStageFlagsStr(value.stages) << '\n';
+ s << "\tname = " << '\n' << tcu::formatArray(tcu::Format::HexIterator<char>(DE_ARRAY_BEGIN(value.name)), tcu::Format::HexIterator<char>(DE_ARRAY_END(value.name))) << '\n';
+ s << "\tdescription = " << (const char*)value.description << '\n';
+ s << "\tsubgroupSize = " << value.subgroupSize << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPipelineExecutableInfoKHR& value)
+{
+ s << "VkPipelineExecutableInfoKHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tpipeline = " << value.pipeline << '\n';
+ s << "\texecutableIndex = " << value.executableIndex << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPipelineExecutableStatisticValueKHR& value)
+{
+ s << "VkPipelineExecutableStatisticValueKHR = {\n";
+ s << "\tb32 = " << value.b32 << '\n';
+ s << "\ti64 = " << value.i64 << '\n';
+ s << "\tu64 = " << value.u64 << '\n';
+ s << "\tf64 = " << value.f64 << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPipelineExecutableStatisticKHR& value)
+{
+ s << "VkPipelineExecutableStatisticKHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tname = " << '\n' << tcu::formatArray(tcu::Format::HexIterator<char>(DE_ARRAY_BEGIN(value.name)), tcu::Format::HexIterator<char>(DE_ARRAY_END(value.name))) << '\n';
+ s << "\tdescription = " << (const char*)value.description << '\n';
+ s << "\tformat = " << value.format << '\n';
+ s << "\tvalue = " << value.value << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPipelineExecutableInternalRepresentationKHR& value)
+{
+ s << "VkPipelineExecutableInternalRepresentationKHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tname = " << '\n' << tcu::formatArray(tcu::Format::HexIterator<char>(DE_ARRAY_BEGIN(value.name)), tcu::Format::HexIterator<char>(DE_ARRAY_END(value.name))) << '\n';
+ s << "\tdescription = " << (const char*)value.description << '\n';
+ s << "\tisText = " << value.isText << '\n';
+ s << "\tdataSize = " << value.dataSize << '\n';
+ s << "\tpData = " << value.pData << '\n';
+ s << '}';
+ return s;
+}
+
std::ostream& operator<< (std::ostream& s, const VkDebugReportCallbackCreateInfoEXT& value)
{
s << "VkDebugReportCallbackCreateInfoEXT = {\n";
VkBool32 uniformBufferStandardLayout;
};
+struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR
+{
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 pipelineExecutableInfo;
+};
+
+struct VkPipelineInfoKHR
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkPipeline pipeline;
+};
+
+struct VkPipelineExecutablePropertiesKHR
+{
+ VkStructureType sType;
+ void* pNext;
+ VkShaderStageFlags stages;
+ char name[VK_MAX_DESCRIPTION_SIZE];
+ char description[VK_MAX_DESCRIPTION_SIZE];
+ deUint32 subgroupSize;
+};
+
+struct VkPipelineExecutableInfoKHR
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkPipeline pipeline;
+ deUint32 executableIndex;
+};
+
+union VkPipelineExecutableStatisticValueKHR
+{
+ VkBool32 b32;
+ deInt64 i64;
+ deUint64 u64;
+ double f64;
+};
+
+struct VkPipelineExecutableStatisticKHR
+{
+ VkStructureType sType;
+ void* pNext;
+ char name[VK_MAX_DESCRIPTION_SIZE];
+ char description[VK_MAX_DESCRIPTION_SIZE];
+ VkPipelineExecutableStatisticFormatKHR format;
+ VkPipelineExecutableStatisticValueKHR value;
+};
+
+struct VkPipelineExecutableInternalRepresentationKHR
+{
+ VkStructureType sType;
+ void* pNext;
+ char name[VK_MAX_DESCRIPTION_SIZE];
+ char description[VK_MAX_DESCRIPTION_SIZE];
+ VkBool32 isText;
+ deUintptr dataSize;
+ void* pData;
+};
+
struct VkDebugReportCallbackCreateInfoEXT
{
VkStructureType sType;
virtual void releaseProfilingLockKHR (VkDevice device) const = 0;
virtual void cmdDrawIndirectCountKHR (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride) const = 0;
virtual void cmdDrawIndexedIndirectCountKHR (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride) const = 0;
+virtual VkResult getPipelineExecutablePropertiesKHR (VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, deUint32* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties) const = 0;
+virtual VkResult getPipelineExecutableStatisticsKHR (VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, deUint32* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics) const = 0;
+virtual VkResult getPipelineExecutableInternalRepresentationsKHR (VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, deUint32* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) const = 0;
virtual VkResult debugMarkerSetObjectTagEXT (VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) const = 0;
virtual VkResult debugMarkerSetObjectNameEXT (VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo) const = 0;
virtual void cmdDebugMarkerBeginEXT (VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) const = 0;
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = 1000261000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000,
+ VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR = 1000269001,
+ VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR = 1000269002,
+ VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR = 1000269003,
+ VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004,
+ VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = 1000276000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = 1000281001,
VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008,
VK_PIPELINE_CREATE_DISPATCH_BASE = 0x00000010,
VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0x00000020,
+ VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR = 0x00000040,
+ VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080,
VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE,
VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+#define VK_KHR_pipeline_executable_properties 1
+#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION 1
+#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME "VK_KHR_pipeline_executable_properties"
+
+typedef enum VkPipelineExecutableStatisticFormatKHR {
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR = 0,
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR = 1,
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR = 2,
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR = 3,
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BEGIN_RANGE_KHR = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR,
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_END_RANGE_KHR = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR,
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_RANGE_SIZE_KHR = (VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR - VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR + 1),
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkPipelineExecutableStatisticFormatKHR;
+typedef struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 pipelineExecutableInfo;
+} VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
+
+typedef struct VkPipelineInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipeline pipeline;
+} VkPipelineInfoKHR;
+
+typedef struct VkPipelineExecutablePropertiesKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkShaderStageFlags stages;
+ char name[VK_MAX_DESCRIPTION_SIZE];
+ char description[VK_MAX_DESCRIPTION_SIZE];
+ deUint32 subgroupSize;
+} VkPipelineExecutablePropertiesKHR;
+
+typedef struct VkPipelineExecutableInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipeline pipeline;
+ deUint32 executableIndex;
+} VkPipelineExecutableInfoKHR;
+
+typedef union VkPipelineExecutableStatisticValueKHR {
+ VkBool32 b32;
+ deInt64 i64;
+ deUint64 u64;
+ double f64;
+} VkPipelineExecutableStatisticValueKHR;
+
+typedef struct VkPipelineExecutableStatisticKHR {
+ VkStructureType sType;
+ void* pNext;
+ char name[VK_MAX_DESCRIPTION_SIZE];
+ char description[VK_MAX_DESCRIPTION_SIZE];
+ VkPipelineExecutableStatisticFormatKHR format;
+ VkPipelineExecutableStatisticValueKHR value;
+} VkPipelineExecutableStatisticKHR;
+
+typedef struct VkPipelineExecutableInternalRepresentationKHR {
+ VkStructureType sType;
+ void* pNext;
+ char name[VK_MAX_DESCRIPTION_SIZE];
+ char description[VK_MAX_DESCRIPTION_SIZE];
+ VkBool32 isText;
+ deUintptr dataSize;
+ void* pData;
+} VkPipelineExecutableInternalRepresentationKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutablePropertiesKHR)(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, deUint32* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableStatisticsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, deUint32* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableInternalRepresentationsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, deUint32* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutablePropertiesKHR(
+ VkDevice device,
+ const VkPipelineInfoKHR* pPipelineInfo,
+ deUint32* pExecutableCount,
+ VkPipelineExecutablePropertiesKHR* pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableStatisticsKHR(
+ VkDevice device,
+ const VkPipelineExecutableInfoKHR* pExecutableInfo,
+ deUint32* pStatisticCount,
+ VkPipelineExecutableStatisticKHR* pStatistics);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableInternalRepresentationsKHR(
+ VkDevice device,
+ const VkPipelineExecutableInfoKHR* pExecutableInfo,
+ deUint32* pInternalRepresentationCount,
+ VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
+#endif
+
+
+
#define VK_EXT_debug_report 1
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)
#define VK_EXT_DEBUG_REPORT_SPEC_VERSION 9
vktPipelineCreationFeedbackTests.hpp
vktPipelineDepthRangeUnrestrictedTests.cpp
vktPipelineDepthRangeUnrestrictedTests.hpp
+ vktPipelineExecutablePropertiesTests.cpp
+ vktPipelineExecutablePropertiesTests.hpp
)
set(DEQP_VK_PIPELINE_LIBS
--- /dev/null
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2019 The Khronos Group Inc.
+ * Copyright (c) 2019 Intel Corporation.
+ *
+ * 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.
+ *
+ *//*!
+ * \file
+ * \brief VK_KHR_pipeline_executable_properties
+ *
+ * These tests creates compute and graphics pipelines with a variety of
+ * stages both with and without a pipeline cache and exercise the new
+ * queries provided by VK_KHR_pipeline_executable_properties.
+ *
+ * For each query type, it asserts that the query works and doesn't crash
+ * and returns consistent results:
+ *
+ * - The tests assert that the same set of pipeline executables is
+ * reported regardless of whether or not a pipeline cache is used.
+ *
+ * - For each pipeline executable, the tests assert that the same set of
+ * statistics is returned regardless of whether or not a pipeline cache
+ * is used.
+ *
+ * - For each pipeline executable, the tests assert that the same set of
+ * statistics is returned regardless of whether or not
+ * CAPTURE_INTERNAL_REPRESENTATIONS_BIT is set.
+ *
+ * - For each pipeline executable, the tests assert that the same set of
+ * internal representations is returned regardless of whether or not a
+ * pipeline cache is used.
+ *
+ * - For each string returned (statistic names, etc.) the tests assert
+ * that the string is NULL terminated.
+ *
+ * - For each statistic, the tests compare the results of the two
+ * compilations and report any differences. (Statistics differing
+ * between two compilations is not considered a failure.)
+ *
+ * - For each binary internal representation, the tests attempt to assert
+ * that the amount of data returned by the implementation matches the
+ * amount the implementation claims. (It's impossible to exactly do
+ * this but the tests give it a good try.)
+ *
+ * All of the returned data is recorded in the output file.
+ *
+ *//*--------------------------------------------------------------------*/
+
+#include "vktPipelineExecutablePropertiesTests.hpp"
+#include "vktPipelineVertexUtil.hpp"
+#include "vktTestCase.hpp"
+#include "vktTestCaseUtil.hpp"
+#include "vkMemUtil.hpp"
+#include "vkBuilderUtil.hpp"
+#include "vkRefUtil.hpp"
+#include "vkTypeUtil.hpp"
+#include "vkObjUtil.hpp"
+#include "tcuTestLog.hpp"
+
+#include <sstream>
+#include <vector>
+
+namespace vkt
+{
+namespace pipeline
+{
+
+using namespace vk;
+
+namespace
+{
+enum
+{
+ VK_MAX_SHADER_STAGES = 6,
+};
+
+enum
+{
+ PIPELINE_CACHE_NDX_INITIAL = 0,
+ PIPELINE_CACHE_NDX_CACHED = 1,
+ PIPELINE_CACHE_NDX_COUNT,
+};
+
+// helper functions
+
+std::string getShaderFlagStr (const VkShaderStageFlagBits shader,
+ bool isDescription)
+{
+ std::ostringstream desc;
+ switch(shader)
+ {
+ case VK_SHADER_STAGE_VERTEX_BIT:
+ {
+ desc << ((isDescription) ? "vertex" : "vertex_stage");
+ break;
+ }
+ case VK_SHADER_STAGE_FRAGMENT_BIT:
+ {
+ desc << ((isDescription) ? "fragment" : "fragment_stage");
+ break;
+ }
+ case VK_SHADER_STAGE_GEOMETRY_BIT:
+ {
+ desc << ((isDescription) ? "geometry" : "geometry_stage");
+ break;
+ }
+ case VK_SHADER_STAGE_COMPUTE_BIT:
+ {
+ desc << ((isDescription) ? "compute" : "compute_stage");
+ break;
+ }
+ case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT:
+ {
+ desc << ((isDescription) ? "tessellation control" : "tessellation_control_stage");
+ break;
+ }
+ case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT:
+ {
+ desc << ((isDescription) ? "tessellation evaluation" : "tessellation_evaluation_stage");
+ break;
+ }
+ default:
+ desc << "unknown shader stage!";
+ DE_FATAL("Unknown shader Stage!");
+ break;
+ };
+
+ return desc.str();
+}
+
+std::string getShaderFlagsStr (const VkShaderStageFlags flags)
+{
+ std::ostringstream stream;
+ bool empty = true;
+ for (deUint32 b = 0; b < 8 * sizeof(flags); b++)
+ {
+ if (flags & (1u << b))
+ {
+ if (empty)
+ {
+ empty = false;
+ }
+ else
+ {
+ stream << ", ";
+ }
+
+ stream << getShaderFlagStr((VkShaderStageFlagBits)(1u << b), true);
+ }
+ }
+
+ if (empty)
+ {
+ stream << "none";
+ }
+
+ return stream.str();
+}
+
+// helper classes
+class ExecutablePropertiesTestParam
+{
+public:
+ ExecutablePropertiesTestParam (const VkShaderStageFlagBits* shaders,
+ deUint32 count,
+ deBool testStatistics,
+ deBool testInternalRepresentations);
+ virtual ~ExecutablePropertiesTestParam (void);
+ virtual const std::string generateTestName (void) const;
+ virtual const std::string generateTestDescription (void) const;
+ VkShaderStageFlagBits getShaderFlag (deUint32 ndx) const { return m_shaders[ndx]; }
+ deUint32 getShaderCount (void) const { return (deUint32)m_shaderCount; }
+ deBool getTestStatistics (void) const { return m_testStatistics; }
+ deBool getTestInternalRepresentations (void) const { return m_testInternalRepresentations; }
+
+protected:
+ VkShaderStageFlagBits m_shaders[VK_MAX_SHADER_STAGES];
+ size_t m_shaderCount;
+ bool m_testStatistics;
+ bool m_testInternalRepresentations;
+};
+
+ExecutablePropertiesTestParam::ExecutablePropertiesTestParam (const VkShaderStageFlagBits* shaders, deUint32 count, deBool testStatistics, deBool testInternalRepresentations)
+{
+ DE_ASSERT(count <= VK_MAX_SHADER_STAGES);
+ for (deUint32 ndx = 0; ndx < count; ndx++)
+ m_shaders[ndx] = shaders[ndx];
+ m_shaderCount = count;
+ m_testStatistics = testStatistics;
+ m_testInternalRepresentations = testInternalRepresentations;
+}
+
+ExecutablePropertiesTestParam::~ExecutablePropertiesTestParam (void)
+{
+}
+
+const std::string ExecutablePropertiesTestParam::generateTestName (void) const
+{
+ std::string result(getShaderFlagStr(m_shaders[0], false));
+
+ for(deUint32 ndx = 1; ndx < m_shaderCount; ndx++)
+ {
+ result += '_' + getShaderFlagStr(m_shaders[ndx], false);
+ }
+
+ if (m_testStatistics)
+ {
+ result += "_statistics";
+ }
+
+ if (m_testInternalRepresentations)
+ {
+ result += "_internal_representations";
+ }
+
+ return result;
+}
+
+const std::string ExecutablePropertiesTestParam::generateTestDescription (void) const
+{
+ std::string result;
+ if (m_testStatistics)
+ {
+ result += "Get pipeline executable statistics";
+ if (m_testInternalRepresentations)
+ {
+ result += " and internal representations";
+ }
+ }
+ else if (m_testInternalRepresentations)
+ {
+ result += "Get pipeline executable internal representations";
+ }
+ else
+ {
+ result += "Get pipeline executable properties";
+ }
+
+ result += " with " + getShaderFlagStr(m_shaders[0], true);
+
+ return result;
+}
+
+class SimpleGraphicsPipelineBuilder
+{
+public:
+ SimpleGraphicsPipelineBuilder (Context& context);
+ ~SimpleGraphicsPipelineBuilder (void) { }
+ void bindShaderStage (VkShaderStageFlagBits stage,
+ const char* sourceName,
+ const char* entryName);
+ void enableTessellationStage (deUint32 patchControlPoints);
+ VkPipeline buildPipeline (tcu::UVec2 renderSize,
+ VkRenderPass renderPass,
+ VkPipelineCache cache,
+ VkPipelineLayout pipelineLayout,
+ VkPipelineCreateFlags flags);
+ void resetBuilder (void);
+
+protected:
+ Context& m_context;
+
+ Move<VkShaderModule> m_shaderModules[VK_MAX_SHADER_STAGES];
+ deUint32 m_shaderStageCount;
+ VkPipelineShaderStageCreateInfo m_shaderStageInfo[VK_MAX_SHADER_STAGES];
+
+ deUint32 m_patchControlPoints;
+};
+
+SimpleGraphicsPipelineBuilder::SimpleGraphicsPipelineBuilder (Context& context)
+ : m_context(context)
+{
+ m_patchControlPoints = 0;
+ m_shaderStageCount = 0;
+}
+
+void SimpleGraphicsPipelineBuilder::resetBuilder (void)
+{
+ m_shaderStageCount = 0;
+}
+
+void SimpleGraphicsPipelineBuilder::bindShaderStage (VkShaderStageFlagBits stage,
+ const char* sourceName,
+ const char* entryName)
+{
+ const DeviceInterface& vk = m_context.getDeviceInterface();
+ const VkDevice vkDevice = m_context.getDevice();
+
+ // Create shader module
+ deUint32* code = (deUint32*)m_context.getBinaryCollection().get(sourceName).getBinary();
+ deUint32 codeSize = (deUint32)m_context.getBinaryCollection().get(sourceName).getSize();
+
+ const VkShaderModuleCreateInfo moduleCreateInfo =
+ {
+ VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // VkShaderModuleCreateFlags flags;
+ codeSize, // deUintptr codeSize;
+ code, // const deUint32* pCode;
+ };
+
+ m_shaderModules[m_shaderStageCount] = createShaderModule(vk, vkDevice, &moduleCreateInfo);
+
+ // Prepare shader stage info
+ m_shaderStageInfo[m_shaderStageCount].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+ m_shaderStageInfo[m_shaderStageCount].pNext = DE_NULL;
+ m_shaderStageInfo[m_shaderStageCount].flags = 0u;
+ m_shaderStageInfo[m_shaderStageCount].stage = stage;
+ m_shaderStageInfo[m_shaderStageCount].module = *m_shaderModules[m_shaderStageCount];
+ m_shaderStageInfo[m_shaderStageCount].pName = entryName;
+ m_shaderStageInfo[m_shaderStageCount].pSpecializationInfo = DE_NULL;
+
+ m_shaderStageCount++;
+}
+
+VkPipeline SimpleGraphicsPipelineBuilder::buildPipeline (tcu::UVec2 renderSize, VkRenderPass renderPass, VkPipelineCache cache,
+ VkPipelineLayout pipelineLayout, VkPipelineCreateFlags flags)
+{
+ const DeviceInterface& vk = m_context.getDeviceInterface();
+ const VkDevice vkDevice = m_context.getDevice();
+
+ // Create pipeline
+ const VkVertexInputBindingDescription vertexInputBindingDescription =
+ {
+ 0u, // deUint32 binding;
+ sizeof(Vertex4RGBA), // deUint32 strideInBytes;
+ VK_VERTEX_INPUT_RATE_VERTEX, // VkVertexInputRate inputRate;
+ };
+
+ const VkVertexInputAttributeDescription vertexInputAttributeDescriptions[2] =
+ {
+ {
+ 0u, // deUint32 location;
+ 0u, // deUint32 binding;
+ VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format;
+ 0u // deUint32 offsetInBytes;
+ },
+ {
+ 1u, // deUint32 location;
+ 0u, // deUint32 binding;
+ VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format;
+ DE_OFFSET_OF(Vertex4RGBA, color), // deUint32 offsetInBytes;
+ }
+ };
+
+ const VkPipelineVertexInputStateCreateInfo vertexInputStateParams =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // VkPipelineVertexInputStateCreateFlags flags;
+ 1u, // deUint32 vertexBindingDescriptionCount;
+ &vertexInputBindingDescription, // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
+ 2u, // deUint32 vertexAttributeDescriptionCount;
+ vertexInputAttributeDescriptions, // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
+ };
+
+ const VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateParams =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // VkPipelineInputAssemblyStateCreateFlags flags;
+ (m_patchControlPoints == 0 ? VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST
+ : VK_PRIMITIVE_TOPOLOGY_PATCH_LIST), // VkPrimitiveTopology topology;
+ VK_FALSE, // VkBool32 primitiveRestartEnable;
+ };
+
+ const VkViewport viewport = makeViewport(renderSize);
+ const VkRect2D scissor = makeRect2D(renderSize);
+
+ const VkPipelineViewportStateCreateInfo viewportStateParams =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // VkPipelineViewportStateCreateFlags flags;
+ 1u, // deUint32 viewportCount;
+ &viewport, // const VkViewport* pViewports;
+ 1u, // deUint32 scissorCount;
+ &scissor // const VkRect2D* pScissors;
+ };
+
+ const VkPipelineRasterizationStateCreateInfo rasterStateParams =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // VkPipelineRasterizationStateCreateFlags flags;
+ VK_FALSE, // VkBool32 depthClampEnable;
+ VK_FALSE, // VkBool32 rasterizerDiscardEnable;
+ VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode;
+ VK_CULL_MODE_NONE, // VkCullModeFlags cullMode;
+ VK_FRONT_FACE_COUNTER_CLOCKWISE, // VkFrontFace frontFace;
+ VK_FALSE, // VkBool32 depthBiasEnable;
+ 0.0f, // float depthBiasConstantFactor;
+ 0.0f, // float depthBiasClamp;
+ 0.0f, // float depthBiasSlopeFactor;
+ 1.0f, // float lineWidth;
+ };
+
+ const VkPipelineColorBlendAttachmentState colorBlendAttachmentState =
+ {
+ VK_FALSE, // VkBool32 blendEnable;
+ VK_BLEND_FACTOR_ONE, // VkBlendFactor srcColorBlendFactor;
+ VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstColorBlendFactor;
+ VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp;
+ VK_BLEND_FACTOR_ONE, // VkBlendFactor srcAlphaBlendFactor;
+ VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstAlphaBlendFactor;
+ VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp;
+ VK_COLOR_COMPONENT_R_BIT |
+ VK_COLOR_COMPONENT_G_BIT |
+ VK_COLOR_COMPONENT_B_BIT |
+ VK_COLOR_COMPONENT_A_BIT // VkColorComponentFlags colorWriteMask;
+ };
+
+ const VkPipelineColorBlendStateCreateInfo colorBlendStateParams =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // VkPipelineColorBlendStateCreateFlags flags;
+ VK_FALSE, // VkBool32 logicOpEnable;
+ VK_LOGIC_OP_COPY, // VkLogicOp logicOp;
+ 1u, // deUint32 attachmentCount;
+ &colorBlendAttachmentState, // const VkPipelineColorBlendAttachmentState* pAttachments;
+ { 0.0f, 0.0f, 0.0f, 0.0f }, // float blendConst[4];
+ };
+
+ const VkPipelineMultisampleStateCreateInfo multisampleStateParams =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // VkPipelineMultisampleStateCreateFlags flags;
+ VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits rasterizationSamples;
+ VK_FALSE, // VkBool32 sampleShadingEnable;
+ 0.0f, // float minSampleShading;
+ DE_NULL, // const VkSampleMask* pSampleMask;
+ VK_FALSE, // VkBool32 alphaToCoverageEnable;
+ VK_FALSE, // VkBool32 alphaToOneEnable;
+ };
+
+ VkPipelineDepthStencilStateCreateInfo depthStencilStateParams =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // VkPipelineDepthStencilStateCreateFlags flags;
+ VK_TRUE, // VkBool32 depthTestEnable;
+ VK_TRUE, // VkBool32 depthWriteEnable;
+ VK_COMPARE_OP_LESS_OR_EQUAL, // VkCompareOp depthCompareOp;
+ VK_FALSE, // VkBool32 depthBoundsTestEnable;
+ VK_FALSE, // VkBool32 stencilTestEnable;
+ // VkStencilOpState front;
+ {
+ VK_STENCIL_OP_KEEP, // VkStencilOp failOp;
+ VK_STENCIL_OP_KEEP, // VkStencilOp passOp;
+ VK_STENCIL_OP_KEEP, // VkStencilOp depthFailOp;
+ VK_COMPARE_OP_NEVER, // VkCompareOp compareOp;
+ 0u, // deUint32 compareMask;
+ 0u, // deUint32 writeMask;
+ 0u, // deUint32 reference;
+ },
+ // VkStencilOpState back;
+ {
+ VK_STENCIL_OP_KEEP, // VkStencilOp failOp;
+ VK_STENCIL_OP_KEEP, // VkStencilOp passOp;
+ VK_STENCIL_OP_KEEP, // VkStencilOp depthFailOp;
+ VK_COMPARE_OP_NEVER, // VkCompareOp compareOp;
+ 0u, // deUint32 compareMask;
+ 0u, // deUint32 writeMask;
+ 0u, // deUint32 reference;
+ },
+ 0.0f, // float minDepthBounds;
+ 1.0f, // float maxDepthBounds;
+ };
+
+ const VkPipelineTessellationStateCreateInfo tessStateCreateInfo =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // VkPipelineTesselationStateCreateFlags flags;
+ m_patchControlPoints, // deUint32 patchControlPoints;
+ };
+ const VkPipelineTessellationStateCreateInfo* pTessCreateInfo = (m_patchControlPoints > 0)
+ ? &tessStateCreateInfo
+ : DE_NULL;
+
+ const VkGraphicsPipelineCreateInfo graphicsPipelineParams =
+ {
+ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ flags, // VkPipelineCreateFlags flags;
+ m_shaderStageCount, // deUint32 stageCount;
+ m_shaderStageInfo, // const VkPipelineShaderStageCreateInfo* pStages;
+ &vertexInputStateParams, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
+ &inputAssemblyStateParams, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
+ pTessCreateInfo, // const VkPipelineTessellationStateCreateInfo* pTessellationState;
+ &viewportStateParams, // const VkPipelineViewportStateCreateInfo* pViewportState;
+ &rasterStateParams, // const VkPipelineRasterizationStateCreateInfo* pRasterState;
+ &multisampleStateParams, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
+ &depthStencilStateParams, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
+ &colorBlendStateParams, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
+ (const VkPipelineDynamicStateCreateInfo*)DE_NULL, // const VkPipelineDynamicStateCreateInfo* pDynamicState;
+ pipelineLayout, // VkPipelineLayout layout;
+ renderPass, // VkRenderPass renderPass;
+ 0u, // deUint32 subpass;
+ DE_NULL, // VkPipeline basePipelineHandle;
+ 0, // deInt32 basePipelineIndex;
+ };
+ VkPipeline pipeline;
+ vk.createGraphicsPipelines(vkDevice, cache, 1u, &graphicsPipelineParams, DE_NULL, &pipeline);
+ return pipeline;
+}
+
+void SimpleGraphicsPipelineBuilder::enableTessellationStage (deUint32 patchControlPoints)
+{
+ m_patchControlPoints = patchControlPoints;
+}
+
+template <class Test>
+vkt::TestCase* newTestCase (tcu::TestContext& testContext,
+ const ExecutablePropertiesTestParam* testParam)
+{
+ return new Test(testContext,
+ testParam->generateTestName().c_str(),
+ testParam->generateTestDescription().c_str(),
+ testParam);
+}
+
+// Test Classes
+class ExecutablePropertiesTest : public vkt::TestCase
+{
+public:
+ ExecutablePropertiesTest(tcu::TestContext& testContext,
+ const std::string& name,
+ const std::string& description,
+ const ExecutablePropertiesTestParam* param)
+ : vkt::TestCase (testContext, name, description)
+ , m_param (*param)
+ { }
+ virtual ~ExecutablePropertiesTest (void) { }
+protected:
+ const ExecutablePropertiesTestParam m_param;
+};
+
+class ExecutablePropertiesTestInstance : public vkt::TestInstance
+{
+public:
+ ExecutablePropertiesTestInstance (Context& context,
+ const ExecutablePropertiesTestParam* param);
+ virtual ~ExecutablePropertiesTestInstance (void);
+ virtual tcu::TestStatus iterate (void);
+protected:
+ virtual tcu::TestStatus verifyStatistics (deUint32 binaryNdx);
+ virtual tcu::TestStatus verifyInternalRepresentations (deUint32 binaryNdx);
+ virtual tcu::TestStatus verifyTestResult (void);
+protected:
+ const ExecutablePropertiesTestParam* m_param;
+
+ Move<VkPipelineCache> m_cache;
+ deBool m_extensions;
+
+ VkPipeline m_pipeline[PIPELINE_CACHE_NDX_COUNT];
+};
+
+ExecutablePropertiesTestInstance::ExecutablePropertiesTestInstance (Context& context,
+ const ExecutablePropertiesTestParam* param)
+ : TestInstance (context)
+ , m_param (param)
+ , m_extensions (m_context.requireDeviceExtension("VK_KHR_pipeline_executable_properties"))
+{
+ const DeviceInterface& vk = m_context.getDeviceInterface();
+ const VkDevice vkDevice = m_context.getDevice();
+
+ const VkPipelineCacheCreateInfo pipelineCacheCreateInfo =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // VkPipelineCacheCreateFlags flags;
+ 0u, // deUintptr initialDataSize;
+ DE_NULL, // const void* pInitialData;
+ };
+
+ m_cache = createPipelineCache(vk, vkDevice, &pipelineCacheCreateInfo);
+}
+
+ExecutablePropertiesTestInstance::~ExecutablePropertiesTestInstance (void)
+{
+}
+
+tcu::TestStatus ExecutablePropertiesTestInstance::iterate (void)
+{
+ return verifyTestResult();
+}
+
+bool
+checkString(const char *string, size_t size)
+{
+ size_t i = 0;
+ for (; i < size; i++)
+ {
+ if (string[i] == 0)
+ {
+ break;
+ }
+ }
+
+ // The string needs to be non-empty and null terminated
+ if (i == 0 || i >= size)
+ {
+ return false;
+ }
+
+ // The rest of the string should be zero
+ for (; i < size; i++)
+ {
+ if (string[i] != 0)
+ {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+tcu::TestStatus ExecutablePropertiesTestInstance::verifyStatistics (deUint32 executableNdx)
+{
+ const DeviceInterface& vk = m_context.getDeviceInterface();
+ const VkDevice vkDevice = m_context.getDevice();
+ tcu::TestLog &log = m_context.getTestContext().getLog();
+
+ std::vector<VkPipelineExecutableStatisticKHR> statistics[PIPELINE_CACHE_NDX_COUNT];
+
+ for (deUint32 ndx = 0; ndx < PIPELINE_CACHE_NDX_COUNT; ndx++)
+ {
+ const VkPipelineExecutableInfoKHR pipelineExecutableInfo =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ m_pipeline[ndx], // VkPipeline pipeline;
+ executableNdx, // uint32_t executableIndex;
+ };
+
+ deUint32 statisticCount = 0;
+ VK_CHECK(vk.getPipelineExecutableStatisticsKHR(vkDevice, &pipelineExecutableInfo, &statisticCount, DE_NULL));
+
+ if (statisticCount == 0)
+ {
+ continue;
+ }
+
+ statistics[ndx].resize(statisticCount);
+ for (deUint32 statNdx = 0; statNdx < statisticCount; statNdx++)
+ {
+ deMemset(&statistics[ndx][statNdx], 0, sizeof(statistics[ndx][statNdx]));
+ statistics[ndx][statNdx].sType = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR;
+ statistics[ndx][statNdx].pNext = DE_NULL;
+ }
+ VK_CHECK(vk.getPipelineExecutableStatisticsKHR(vkDevice, &pipelineExecutableInfo, &statisticCount, &statistics[ndx][0]));
+
+ for (deUint32 statNdx = 0; statNdx < statisticCount; statNdx++)
+ {
+ if (!checkString(statistics[ndx][statNdx].name, DE_LENGTH_OF_ARRAY(statistics[ndx][statNdx].name)))
+ {
+ return tcu::TestStatus::fail("Invalid statistic name string");
+ }
+
+ for (deUint32 otherNdx = 0; otherNdx < statNdx; otherNdx++)
+ {
+ if (deMemCmp(statistics[ndx][statNdx].name, statistics[ndx][otherNdx].name,
+ DE_LENGTH_OF_ARRAY(statistics[ndx][statNdx].name)) == 0)
+ {
+ return tcu::TestStatus::fail("Statistic name string not unique within the executable");
+ }
+ }
+
+ if (!checkString(statistics[ndx][statNdx].description, DE_LENGTH_OF_ARRAY(statistics[ndx][statNdx].description)))
+ {
+ return tcu::TestStatus::fail("Invalid statistic description string");
+ }
+
+ if (statistics[ndx][statNdx].format == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR)
+ {
+ if (statistics[ndx][statNdx].value.b32 != VK_TRUE && statistics[ndx][statNdx].value.b32 != VK_FALSE)
+ {
+ return tcu::TestStatus::fail("Boolean statistic is neither VK_TRUE nor VK_FALSE");
+ }
+ }
+ }
+ }
+
+ if (statistics[0].size() != statistics[1].size())
+ {
+ return tcu::TestStatus::fail("Identical pipelines have different numbers of statistics");
+ }
+
+ if (statistics[0].size() == 0)
+ {
+ return tcu::TestStatus::pass("No statistics reported");
+ }
+
+ // Both compiles had better have specified the same infos
+ for (deUint32 statNdx0 = 0; statNdx0 < statistics[0].size(); statNdx0++)
+ {
+ deUint32 statNdx1 = 0;
+ for (; statNdx1 < statistics[1].size(); statNdx1++)
+ {
+ if (deMemCmp(statistics[0][statNdx0].name, statistics[1][statNdx1].name,
+ DE_LENGTH_OF_ARRAY(statistics[0][statNdx0].name)) == 0)
+ {
+ break;
+ }
+ }
+ if (statNdx1 >= statistics[1].size())
+ {
+ return tcu::TestStatus::fail("Identical pipelines have different statistics");
+ }
+
+ if (deMemCmp(statistics[0][statNdx0].description, statistics[1][statNdx1].description,
+ DE_LENGTH_OF_ARRAY(statistics[0][statNdx0].description)) != 0)
+ {
+ return tcu::TestStatus::fail("Invalid binary description string");
+ }
+
+ if (statistics[0][statNdx0].format != statistics[1][statNdx1].format)
+ {
+ return tcu::TestStatus::fail("Identical pipelines have statistics with different formats");
+ }
+
+ switch (statistics[0][statNdx0].format)
+ {
+ case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR:
+ {
+ bool match = statistics[0][statNdx0].value.b32 == statistics[1][statNdx1].value.b32;
+ log << tcu::TestLog::Message
+ << statistics[0][statNdx0].name << ": "
+ << (statistics[0][statNdx0].value.b32 ? "VK_TRUE" : "VK_FALSE")
+ << (match ? "" : " (non-deterministic)")
+ << " (" << statistics[0][statNdx0].description << ")"
+ << tcu::TestLog::EndMessage;
+ break;
+ }
+ case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR:
+ {
+ bool match = statistics[0][statNdx0].value.i64 == statistics[1][statNdx1].value.i64;
+ log << tcu::TestLog::Message
+ << statistics[0][statNdx0].name << ": "
+ << statistics[0][statNdx0].value.i64
+ << (match ? "" : " (non-deterministic)")
+ << " (" << statistics[0][statNdx0].description << ")"
+ << tcu::TestLog::EndMessage;
+ break;
+ }
+ case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR:
+ {
+ bool match = statistics[0][statNdx0].value.u64 == statistics[1][statNdx1].value.u64;
+ log << tcu::TestLog::Message
+ << statistics[0][statNdx0].name << ": "
+ << statistics[0][statNdx0].value.u64
+ << (match ? "" : " (non-deterministic)")
+ << " (" << statistics[0][statNdx0].description << ")"
+ << tcu::TestLog::EndMessage;
+ break;
+ }
+ case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR:
+ {
+ bool match = statistics[0][statNdx0].value.f64 == statistics[1][statNdx1].value.f64;
+ log << tcu::TestLog::Message
+ << statistics[0][statNdx0].name << ": "
+ << statistics[0][statNdx0].value.f64
+ << (match ? "" : " (non-deterministic)")
+ << " (" << statistics[0][statNdx0].description << ")"
+ << tcu::TestLog::EndMessage;
+ break;
+ }
+ default:
+ return tcu::TestStatus::fail("Invalid statistic format");
+ }
+ }
+
+ return tcu::TestStatus::pass("Pass");
+}
+
+tcu::TestStatus ExecutablePropertiesTestInstance::verifyInternalRepresentations (deUint32 executableNdx)
+{
+ const DeviceInterface& vk = m_context.getDeviceInterface();
+ const VkDevice vkDevice = m_context.getDevice();
+ tcu::TestLog &log = m_context.getTestContext().getLog();
+
+ // We only care about internal representations on the second pipeline.
+ // We still compile twice to ensure that we still get the right thing
+ // even if the pipeline is hot in the cache.
+ const VkPipelineExecutableInfoKHR pipelineExecutableInfo =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ m_pipeline[1], // VkPipeline pipeline;
+ executableNdx, // uint32_t executableIndex;
+ };
+
+ std::vector<VkPipelineExecutableInternalRepresentationKHR> irs;
+ std::vector<std::vector<deUint8>> irDatas;
+
+ deUint32 irCount = 0;
+ VK_CHECK(vk.getPipelineExecutableInternalRepresentationsKHR(vkDevice, &pipelineExecutableInfo, &irCount, DE_NULL));
+
+ if (irCount == 0)
+ {
+ return tcu::TestStatus::pass("No internal representations reported");
+ }
+
+ irs.resize(irCount);
+ irDatas.resize(irCount);
+ for (deUint32 irNdx = 0; irNdx < irCount; irNdx++)
+ {
+ deMemset(&irs[irNdx], 0, sizeof(irs[irNdx]));
+ irs[irNdx].sType = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR;
+ irs[irNdx].pNext = DE_NULL;
+ }
+ VK_CHECK(vk.getPipelineExecutableInternalRepresentationsKHR(vkDevice, &pipelineExecutableInfo, &irCount, &irs[0]));
+
+ for (deUint32 irNdx = 0; irNdx < irCount; irNdx++)
+ {
+ if (!checkString(irs[irNdx].name, DE_LENGTH_OF_ARRAY(irs[irNdx].name)))
+ {
+ return tcu::TestStatus::fail("Invalid internal representation name string");
+ }
+
+ for (deUint32 otherNdx = 0; otherNdx < irNdx; otherNdx++)
+ {
+ if (deMemCmp(irs[irNdx].name, irs[otherNdx].name,
+ DE_LENGTH_OF_ARRAY(irs[irNdx].name)) == 0)
+ {
+ return tcu::TestStatus::fail("Internal representation name string not unique within the executable");
+ }
+ }
+
+ if (!checkString(irs[irNdx].description, DE_LENGTH_OF_ARRAY(irs[irNdx].description)))
+ {
+ return tcu::TestStatus::fail("Invalid binary description string");
+ }
+
+ if (irs[irNdx].dataSize == 0)
+ {
+ return tcu::TestStatus::fail("Internal representation has no data");
+ }
+
+ irDatas[irNdx].resize(irs[irNdx].dataSize);
+ irs[irNdx].pData = &irDatas[irNdx][0];
+ if (irs[irNdx].isText)
+ {
+ // For binary data the size is important. We check that the
+ // implementation fills the whole buffer by filling it with
+ // garbage first and then looking for that same garbage later.
+ for (size_t i = 0; i < irs[irNdx].dataSize; i++)
+ {
+ irDatas[irNdx][i] = (deUint8)(37 * (17 + i));
+ }
+ }
+ }
+
+ VK_CHECK(vk.getPipelineExecutableInternalRepresentationsKHR(vkDevice, &pipelineExecutableInfo, &irCount, &irs[0]));
+
+ for (deUint32 irNdx = 0; irNdx < irCount; irNdx++)
+ {
+ if (irs[irNdx].isText)
+ {
+ if (!checkString((char *)irs[irNdx].pData, irs[irNdx].dataSize))
+ {
+ return tcu::TestStatus::fail("Textual internal representation isn't a valid string");
+ }
+ log << tcu::TestLog::Section(irs[irNdx].name, irs[irNdx].description)
+ << tcu::LogKernelSource((char *)irs[irNdx].pData)
+ << tcu::TestLog::EndSection;
+ }
+ else
+ {
+ size_t maxMatchingChunkSize = 0;
+ size_t matchingChunkSize = 0;
+ for (size_t i = 0; i < irs[irNdx].dataSize; i++)
+ {
+ if (irDatas[irNdx][i] == (deUint8)(37 * (17 + i)))
+ {
+ matchingChunkSize++;
+ if (matchingChunkSize > maxMatchingChunkSize)
+ {
+ maxMatchingChunkSize = matchingChunkSize;
+ }
+ }
+ else
+ {
+ matchingChunkSize = 0;
+ }
+ }
+
+ // 64 bytes of our random data still being in the buffer probably
+ // isn't a coincidence
+ if (matchingChunkSize == irs[irNdx].dataSize || matchingChunkSize >= 64)
+ {
+ return tcu::TestStatus::fail("Implementation didn't fill the whole internal representation data buffer");
+ }
+
+ log << tcu::TestLog::Section(irs[irNdx].name, irs[irNdx].description)
+ << tcu::TestLog::Message << "Received " << irs[irNdx].dataSize << "B of binary data" << tcu::TestLog::EndMessage
+ << tcu::TestLog::EndSection;
+ }
+ }
+
+ return tcu::TestStatus::pass("Pass");
+}
+
+tcu::TestStatus ExecutablePropertiesTestInstance::verifyTestResult (void)
+{
+ const DeviceInterface& vk = m_context.getDeviceInterface();
+ const VkDevice vkDevice = m_context.getDevice();
+ tcu::TestLog &log = m_context.getTestContext().getLog();
+
+ std::vector<VkPipelineExecutablePropertiesKHR> props[PIPELINE_CACHE_NDX_COUNT];
+
+ for (deUint32 ndx = 0; ndx < PIPELINE_CACHE_NDX_COUNT; ndx++)
+ {
+ const VkPipelineInfoKHR pipelineInfo =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ m_pipeline[ndx], // VkPipeline pipeline;
+
+ };
+ deUint32 executableCount = 0;
+ VK_CHECK(vk.getPipelineExecutablePropertiesKHR(vkDevice, &pipelineInfo, &executableCount, DE_NULL));
+
+ if (executableCount == 0)
+ {
+ continue;
+ }
+
+ props[ndx].resize(executableCount);
+ for (deUint32 execNdx = 0; execNdx < executableCount; execNdx++)
+ {
+ deMemset(&props[ndx][execNdx], 0, sizeof(props[ndx][execNdx]));
+ props[ndx][execNdx].sType = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR;
+ props[ndx][execNdx].pNext = DE_NULL;
+ }
+ VK_CHECK(vk.getPipelineExecutablePropertiesKHR(vkDevice, &pipelineInfo, &executableCount, &props[ndx][0]));
+
+ for (deUint32 execNdx = 0; execNdx < executableCount; execNdx++)
+ {
+ if (!checkString(props[ndx][execNdx].name, DE_LENGTH_OF_ARRAY(props[ndx][execNdx].name)))
+ {
+ return tcu::TestStatus::fail("Invalid binary name string");
+ }
+
+ for (deUint32 otherNdx = 0; otherNdx < execNdx; otherNdx++)
+ {
+ if (deMemCmp(props[ndx][execNdx].name, props[ndx][otherNdx].name,
+ DE_LENGTH_OF_ARRAY(props[ndx][execNdx].name)) == 0)
+ {
+ return tcu::TestStatus::fail("Binary name string not unique within the pipeline");
+ }
+ }
+
+ if (!checkString(props[ndx][execNdx].description, DE_LENGTH_OF_ARRAY(props[ndx][execNdx].description)))
+ {
+ return tcu::TestStatus::fail("Invalid binary description string");
+ }
+
+ // Check that the binary only contains stages actually used to
+ // compile the pipeline
+ VkShaderStageFlags stages = props[ndx][execNdx].stages;
+ for (deUint32 stageNdx = 0; stageNdx < m_param->getShaderCount(); stageNdx++)
+ {
+ stages &= ~m_param->getShaderFlag(stageNdx);
+ }
+ if (stages != 0)
+ {
+ return tcu::TestStatus::fail("Binary uses unprovided stage");
+ }
+ }
+ }
+
+ if (props[0].size() != props[1].size())
+ {
+ return tcu::TestStatus::fail("Identical pipelines have different numbers of props");
+ }
+
+ if (props[0].size() == 0)
+ {
+ return tcu::TestStatus::pass("No executables reported");
+ }
+
+ // Both compiles had better have specified the same infos
+ for (deUint32 execNdx0 = 0; execNdx0 < props[0].size(); execNdx0++)
+ {
+ deUint32 execNdx1 = 0;
+ for (; execNdx1 < props[1].size(); execNdx1++)
+ {
+ if (deMemCmp(props[0][execNdx0].name, props[1][execNdx1].name,
+ DE_LENGTH_OF_ARRAY(props[0][execNdx0].name)) == 0)
+ {
+ break;
+ }
+ }
+ if (execNdx1 >= props[1].size())
+ {
+ return tcu::TestStatus::fail("Identical pipelines have different sets of executables");
+ }
+
+ if (deMemCmp(props[0][execNdx0].description, props[1][execNdx1].description,
+ DE_LENGTH_OF_ARRAY(props[0][execNdx0].description)) != 0)
+ {
+ return tcu::TestStatus::fail("Same binary has different descriptions");
+ }
+
+ if (props[0][execNdx0].stages != props[1][execNdx1].stages)
+ {
+ return tcu::TestStatus::fail("Same binary has different stages");
+ }
+
+ if (props[0][execNdx0].subgroupSize != props[1][execNdx1].subgroupSize)
+ {
+ return tcu::TestStatus::fail("Same binary has different subgroup sizes");
+ }
+ }
+
+ log << tcu::TestLog::Section("Binaries", "Binaries reported for this pipeline");
+ log << tcu::TestLog::Message << "Pipeline reported " << props[0].size() << " props" << tcu::TestLog::EndMessage;
+
+ tcu::TestStatus status = tcu::TestStatus::pass("Pass");
+ for (deUint32 execNdx = 0; execNdx < props[0].size(); execNdx++)
+ {
+ log << tcu::TestLog::Section(props[0][execNdx].name, props[0][execNdx].description);
+ log << tcu::TestLog::Message << "Name: " << props[0][execNdx].name << tcu::TestLog::EndMessage;
+ log << tcu::TestLog::Message << "Description: " << props[0][execNdx].description << tcu::TestLog::EndMessage;
+ log << tcu::TestLog::Message << "Stages: " << getShaderFlagsStr(props[0][execNdx].stages) << tcu::TestLog::EndMessage;
+ log << tcu::TestLog::Message << "Subgroup Size: " << props[0][execNdx].subgroupSize << tcu::TestLog::EndMessage;
+
+ if (m_param->getTestStatistics())
+ {
+ status = verifyStatistics(execNdx);
+ if (status.getCode() != QP_TEST_RESULT_PASS)
+ {
+ log << tcu::TestLog::EndSection;
+ break;
+ }
+ }
+
+ if (m_param->getTestInternalRepresentations())
+ {
+ status = verifyInternalRepresentations(execNdx);
+ if (status.getCode() != QP_TEST_RESULT_PASS)
+ {
+ log << tcu::TestLog::EndSection;
+ break;
+ }
+ }
+
+ log << tcu::TestLog::EndSection;
+ }
+
+ log << tcu::TestLog::EndSection;
+
+ return status;
+}
+
+class GraphicsExecutablePropertiesTest : public ExecutablePropertiesTest
+{
+public:
+ GraphicsExecutablePropertiesTest (tcu::TestContext& testContext,
+ const std::string& name,
+ const std::string& description,
+ const ExecutablePropertiesTestParam* param)
+ : ExecutablePropertiesTest (testContext, name, description, param)
+ { }
+ virtual ~GraphicsExecutablePropertiesTest (void) { }
+ virtual void initPrograms (SourceCollections& programCollection) const;
+ virtual TestInstance* createInstance (Context& context) const;
+};
+
+class GraphicsExecutablePropertiesTestInstance : public ExecutablePropertiesTestInstance
+{
+public:
+ GraphicsExecutablePropertiesTestInstance (Context& context,
+ const ExecutablePropertiesTestParam* param);
+ virtual ~GraphicsExecutablePropertiesTestInstance (void);
+protected:
+ const tcu::UVec2 m_renderSize;
+ const VkFormat m_colorFormat;
+ const VkFormat m_depthFormat;
+ Move<VkPipelineLayout> m_pipelineLayout;
+
+ SimpleGraphicsPipelineBuilder m_pipelineBuilder;
+ SimpleGraphicsPipelineBuilder m_missPipelineBuilder;
+ Move<VkRenderPass> m_renderPass;
+};
+
+void GraphicsExecutablePropertiesTest::initPrograms (SourceCollections& programCollection) const
+{
+ for (deUint32 shaderNdx = 0; shaderNdx < m_param.getShaderCount(); shaderNdx++)
+ {
+ switch(m_param.getShaderFlag(shaderNdx))
+ {
+ case VK_SHADER_STAGE_VERTEX_BIT:
+ programCollection.glslSources.add("color_vert") << glu::VertexSource(
+ "#version 310 es\n"
+ "layout(location = 0) in vec4 position;\n"
+ "layout(location = 1) in vec4 color;\n"
+ "layout(location = 0) out highp vec4 vtxColor;\n"
+ "void main (void)\n"
+ "{\n"
+ " gl_Position = position;\n"
+ " vtxColor = color;\n"
+ "}\n");
+ break;
+ case VK_SHADER_STAGE_FRAGMENT_BIT:
+ programCollection.glslSources.add("color_frag") << glu::FragmentSource(
+ "#version 310 es\n"
+ "layout(location = 0) in highp vec4 vtxColor;\n"
+ "layout(location = 0) out highp vec4 fragColor;\n"
+ "void main (void)\n"
+ "{\n"
+ " fragColor = vtxColor;\n"
+ "}\n");
+ break;
+
+ case VK_SHADER_STAGE_GEOMETRY_BIT:
+ programCollection.glslSources.add("dummy_geo") << glu::GeometrySource(
+ "#version 450 \n"
+ "layout(triangles) in;\n"
+ "layout(triangle_strip, max_vertices = 3) out;\n"
+ "layout(location = 0) in highp vec4 in_vtxColor[];\n"
+ "layout(location = 0) out highp vec4 vtxColor;\n"
+ "out gl_PerVertex { vec4 gl_Position; float gl_PointSize; };\n"
+ "in gl_PerVertex { vec4 gl_Position; float gl_PointSize; } gl_in[];\n"
+ "void main (void)\n"
+ "{\n"
+ " for(int ndx=0; ndx<3; ndx++)\n"
+ " {\n"
+ " gl_Position = gl_in[ndx].gl_Position;\n"
+ " gl_PointSize = gl_in[ndx].gl_PointSize;\n"
+ " vtxColor = in_vtxColor[ndx];\n"
+ " EmitVertex();\n"
+ " }\n"
+ " EndPrimitive();\n"
+ "}\n");
+ break;
+
+ case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT:
+ programCollection.glslSources.add("basic_tcs") << glu::TessellationControlSource(
+ "#version 450 \n"
+ "layout(vertices = 3) out;\n"
+ "layout(location = 0) in highp vec4 color[];\n"
+ "layout(location = 0) out highp vec4 vtxColor[];\n"
+ "out gl_PerVertex { vec4 gl_Position; float gl_PointSize; } gl_out[3];\n"
+ "in gl_PerVertex { vec4 gl_Position; float gl_PointSize; } gl_in[gl_MaxPatchVertices];\n"
+ "void main()\n"
+ "{\n"
+ " gl_TessLevelOuter[0] = 4.0;\n"
+ " gl_TessLevelOuter[1] = 4.0;\n"
+ " gl_TessLevelOuter[2] = 4.0;\n"
+ " gl_TessLevelInner[0] = 4.0;\n"
+ " gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
+ " gl_out[gl_InvocationID].gl_PointSize = gl_in[gl_InvocationID].gl_PointSize;\n"
+ " vtxColor[gl_InvocationID] = color[gl_InvocationID];\n"
+ "}\n");
+ break;
+
+ case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT:
+ programCollection.glslSources.add("basic_tes") << glu::TessellationEvaluationSource(
+ "#version 450 \n"
+ "layout(triangles, fractional_even_spacing, ccw) in;\n"
+ "layout(location = 0) in highp vec4 colors[];\n"
+ "layout(location = 0) out highp vec4 vtxColor;\n"
+ "out gl_PerVertex { vec4 gl_Position; float gl_PointSize; };\n"
+ "in gl_PerVertex { vec4 gl_Position; float gl_PointSize; } gl_in[gl_MaxPatchVertices];\n"
+ "void main() \n"
+ "{\n"
+ " float u = gl_TessCoord.x;\n"
+ " float v = gl_TessCoord.y;\n"
+ " float w = gl_TessCoord.z;\n"
+ " vec4 pos = vec4(0);\n"
+ " vec4 color = vec4(0);\n"
+ " pos.xyz += u * gl_in[0].gl_Position.xyz;\n"
+ " color.xyz += u * colors[0].xyz;\n"
+ " pos.xyz += v * gl_in[1].gl_Position.xyz;\n"
+ " color.xyz += v * colors[1].xyz;\n"
+ " pos.xyz += w * gl_in[2].gl_Position.xyz;\n"
+ " color.xyz += w * colors[2].xyz;\n"
+ " pos.w = 1.0;\n"
+ " color.w = 1.0;\n"
+ " gl_Position = pos;\n"
+ " gl_PointSize = gl_in[0].gl_PointSize;"
+ " vtxColor = color;\n"
+ "}\n");
+ break;
+
+ default:
+ DE_FATAL("Unknown Shader Stage!");
+ break;
+ };
+ }
+}
+
+TestInstance* GraphicsExecutablePropertiesTest::createInstance (Context& context) const
+{
+ return new GraphicsExecutablePropertiesTestInstance(context, &m_param);
+}
+
+GraphicsExecutablePropertiesTestInstance::GraphicsExecutablePropertiesTestInstance (Context& context,
+ const ExecutablePropertiesTestParam* param)
+ : ExecutablePropertiesTestInstance (context, param)
+ , m_renderSize (32u, 32u)
+ , m_colorFormat (VK_FORMAT_R8G8B8A8_UNORM)
+ , m_depthFormat (VK_FORMAT_D16_UNORM)
+ , m_pipelineBuilder (context)
+ , m_missPipelineBuilder (context)
+{
+ const DeviceInterface& vk = m_context.getDeviceInterface();
+ const VkDevice vkDevice = m_context.getDevice();
+
+ // Create pipeline layout
+ {
+ const VkPipelineLayoutCreateInfo pipelineLayoutParams =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // VkPipelineLayoutCreateFlags flags;
+ 0u, // deUint32 setLayoutCount;
+ DE_NULL, // const VkDescriptorSetLayout* pSetLayouts;
+ 0u, // deUint32 pushConstantRangeCount;
+ DE_NULL // const VkPushConstantRange* pPushConstantRanges;
+ };
+
+ m_pipelineLayout = createPipelineLayout(vk, vkDevice, &pipelineLayoutParams);
+ }
+
+ // Create render pass
+ m_renderPass = makeRenderPass(vk, vkDevice, m_colorFormat, m_depthFormat);
+
+ // Bind shader stages
+
+ VkPhysicalDeviceFeatures features = m_context.getDeviceFeatures();
+ for (deUint32 ndx = 0; ndx < PIPELINE_CACHE_NDX_COUNT; ndx++)
+ {
+ for (deUint32 shaderNdx = 0; shaderNdx < m_param->getShaderCount(); shaderNdx++)
+ {
+ switch(m_param->getShaderFlag(shaderNdx))
+ {
+ case VK_SHADER_STAGE_VERTEX_BIT:
+ m_pipelineBuilder.bindShaderStage(VK_SHADER_STAGE_VERTEX_BIT, "color_vert", "main");
+ break;
+ case VK_SHADER_STAGE_FRAGMENT_BIT:
+ m_pipelineBuilder.bindShaderStage(VK_SHADER_STAGE_FRAGMENT_BIT, "color_frag", "main");
+ break;
+ case VK_SHADER_STAGE_GEOMETRY_BIT:
+ if (features.geometryShader == VK_FALSE)
+ {
+ TCU_THROW(NotSupportedError, "Geometry Shader Not Supported");
+ }
+ else
+ {
+ m_pipelineBuilder.bindShaderStage(VK_SHADER_STAGE_GEOMETRY_BIT, "dummy_geo", "main");
+ }
+ break;
+ case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT:
+ if (features.tessellationShader == VK_FALSE)
+ {
+ TCU_THROW(NotSupportedError, "Tessellation Not Supported");
+ }
+ else
+ {
+ m_pipelineBuilder.bindShaderStage(VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, "basic_tcs", "main");
+ m_pipelineBuilder.enableTessellationStage(3);
+ }
+ break;
+ case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT:
+ if (features.tessellationShader == VK_FALSE)
+ {
+ TCU_THROW(NotSupportedError, "Tessellation Not Supported");
+ }
+ else
+ {
+ m_pipelineBuilder.bindShaderStage(VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, "basic_tes", "main");
+ m_pipelineBuilder.enableTessellationStage(3);
+ }
+ break;
+ default:
+ DE_FATAL("Unknown Shader Stage!");
+ break;
+ };
+
+ }
+
+ VkPipelineCreateFlags flags = 0;
+ if (param->getTestStatistics())
+ {
+ flags |= VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR;
+ }
+
+ // Only check gather internal representations on the second
+ // pipeline. This way, it's more obvious if they failed to capture
+ // due to the pipeline being cached.
+ if (ndx == PIPELINE_CACHE_NDX_CACHED && param->getTestInternalRepresentations())
+ {
+ flags |= VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR;
+ }
+
+ m_pipeline[ndx] = m_pipelineBuilder.buildPipeline(m_renderSize, *m_renderPass, *m_cache, *m_pipelineLayout, flags);
+ m_pipelineBuilder.resetBuilder();
+ }
+}
+
+GraphicsExecutablePropertiesTestInstance::~GraphicsExecutablePropertiesTestInstance (void)
+{
+}
+
+class ComputeExecutablePropertiesTest : public ExecutablePropertiesTest
+{
+public:
+ ComputeExecutablePropertiesTest (tcu::TestContext& testContext,
+ const std::string& name,
+ const std::string& description,
+ const ExecutablePropertiesTestParam* param)
+ : ExecutablePropertiesTest (testContext, name, description, param)
+ { }
+ virtual ~ComputeExecutablePropertiesTest (void) { }
+ virtual void initPrograms (SourceCollections& programCollection) const;
+ virtual TestInstance* createInstance (Context& context) const;
+};
+
+class ComputeExecutablePropertiesTestInstance : public ExecutablePropertiesTestInstance
+{
+public:
+ ComputeExecutablePropertiesTestInstance (Context& context,
+ const ExecutablePropertiesTestParam* param);
+ virtual ~ComputeExecutablePropertiesTestInstance (void);
+protected:
+ void buildDescriptorSets (deUint32 ndx);
+ void buildShader (deUint32 ndx);
+ void buildPipeline (deUint32 ndx);
+protected:
+ Move<VkBuffer> m_inputBuf;
+ de::MovePtr<Allocation> m_inputBufferAlloc;
+ Move<VkShaderModule> m_computeShaderModule[PIPELINE_CACHE_NDX_COUNT];
+
+ Move<VkBuffer> m_outputBuf[PIPELINE_CACHE_NDX_COUNT];
+ de::MovePtr<Allocation> m_outputBufferAlloc[PIPELINE_CACHE_NDX_COUNT];
+
+ Move<VkDescriptorPool> m_descriptorPool[PIPELINE_CACHE_NDX_COUNT];
+ Move<VkDescriptorSetLayout> m_descriptorSetLayout[PIPELINE_CACHE_NDX_COUNT];
+ Move<VkDescriptorSet> m_descriptorSet[PIPELINE_CACHE_NDX_COUNT];
+
+ Move<VkPipelineLayout> m_pipelineLayout[PIPELINE_CACHE_NDX_COUNT];
+};
+
+void ComputeExecutablePropertiesTest::initPrograms (SourceCollections& programCollection) const
+{
+ programCollection.glslSources.add("basic_compute") << glu::ComputeSource(
+ "#version 310 es\n"
+ "layout(local_size_x = 1) in;\n"
+ "layout(std430) buffer;\n"
+ "layout(binding = 0) readonly buffer Input0\n"
+ "{\n"
+ " vec4 elements[];\n"
+ "} input_data0;\n"
+ "layout(binding = 1) writeonly buffer Output\n"
+ "{\n"
+ " vec4 elements[];\n"
+ "} output_data;\n"
+ "void main()\n"
+ "{\n"
+ " uint ident = gl_GlobalInvocationID.x;\n"
+ " output_data.elements[ident] = input_data0.elements[ident] * input_data0.elements[ident];\n"
+ "}");
+}
+
+TestInstance* ComputeExecutablePropertiesTest::createInstance (Context& context) const
+{
+ return new ComputeExecutablePropertiesTestInstance(context, &m_param);
+}
+
+void ComputeExecutablePropertiesTestInstance::buildDescriptorSets (deUint32 ndx)
+{
+ const DeviceInterface& vk = m_context.getDeviceInterface();
+ const VkDevice vkDevice = m_context.getDevice();
+
+ // Create descriptor set layout
+ DescriptorSetLayoutBuilder descLayoutBuilder;
+ for (deUint32 bindingNdx = 0u; bindingNdx < 2u; bindingNdx++)
+ descLayoutBuilder.addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_COMPUTE_BIT);
+ m_descriptorSetLayout[ndx] = descLayoutBuilder.build(vk, vkDevice);
+}
+
+void ComputeExecutablePropertiesTestInstance::buildShader (deUint32 ndx)
+{
+ const DeviceInterface& vk = m_context.getDeviceInterface();
+ const VkDevice vkDevice = m_context.getDevice();
+
+ // Create compute shader
+ VkShaderModuleCreateInfo shaderModuleCreateInfo =
+ {
+ VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // VkShaderModuleCreateFlags flags;
+ m_context.getBinaryCollection().get("basic_compute").getSize(), // deUintptr codeSize;
+ (deUint32*)m_context.getBinaryCollection().get("basic_compute").getBinary(), // const deUint32* pCode;
+ };
+ m_computeShaderModule[ndx] = createShaderModule(vk, vkDevice, &shaderModuleCreateInfo);
+}
+
+void ComputeExecutablePropertiesTestInstance::buildPipeline (deUint32 ndx)
+{
+ const DeviceInterface& vk = m_context.getDeviceInterface();
+ const VkDevice vkDevice = m_context.getDevice();
+
+ // Create compute pipeline layout
+ const VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // VkPipelineLayoutCreateFlags flags;
+ 1u, // deUint32 setLayoutCount;
+ &m_descriptorSetLayout[ndx].get(), // const VkDescriptorSetLayout* pSetLayouts;
+ 0u, // deUint32 pushConstantRangeCount;
+ DE_NULL, // const VkPushConstantRange* pPushConstantRanges;
+ };
+
+ m_pipelineLayout[ndx] = createPipelineLayout(vk, vkDevice, &pipelineLayoutCreateInfo);
+
+ const VkPipelineShaderStageCreateInfo stageCreateInfo =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // VkPipelineShaderStageCreateFlags flags;
+ VK_SHADER_STAGE_COMPUTE_BIT, // VkShaderStageFlagBits stage;
+ *m_computeShaderModule[ndx], // VkShaderModule module;
+ "main", // const char* pName;
+ DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
+ };
+
+ VkPipelineCreateFlags flags = 0;
+ if (m_param->getTestStatistics())
+ {
+ flags |= VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR;
+ }
+
+ // Only check gather internal representations on the second
+ // pipeline. This way, it's more obvious if they failed to capture
+ // due to the pipeline being cached.
+ if (ndx == PIPELINE_CACHE_NDX_CACHED && m_param->getTestInternalRepresentations())
+ {
+ flags |= VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR;
+ }
+
+ const VkComputePipelineCreateInfo pipelineCreateInfo =
+ {
+ VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ flags, // VkPipelineCreateFlags flags;
+ stageCreateInfo, // VkPipelineShaderStageCreateInfo stage;
+ *m_pipelineLayout[ndx], // VkPipelineLayout layout;
+ (VkPipeline)0, // VkPipeline basePipelineHandle;
+ 0u, // deInt32 basePipelineIndex;
+ };
+
+ vk.createComputePipelines(vkDevice, *m_cache, 1u, &pipelineCreateInfo, DE_NULL, &m_pipeline[ndx]);
+}
+
+ComputeExecutablePropertiesTestInstance::ComputeExecutablePropertiesTestInstance (Context& context,
+ const ExecutablePropertiesTestParam* param)
+ : ExecutablePropertiesTestInstance (context, param)
+{
+ for (deUint32 ndx = 0; ndx < PIPELINE_CACHE_NDX_COUNT; ndx++)
+ {
+ buildDescriptorSets(ndx);
+ buildShader(ndx);
+ buildPipeline(ndx);
+ }
+}
+
+ComputeExecutablePropertiesTestInstance::~ComputeExecutablePropertiesTestInstance (void)
+{
+}
+
+} // anonymous
+
+tcu::TestCaseGroup* createExecutablePropertiesTests (tcu::TestContext& testCtx)
+{
+
+ de::MovePtr<tcu::TestCaseGroup> binaryInfoTests (new tcu::TestCaseGroup(testCtx, "executable_properties", "pipeline binary statistics tests"));
+
+ // Graphics Pipeline Tests
+ {
+ de::MovePtr<tcu::TestCaseGroup> graphicsTests (new tcu::TestCaseGroup(testCtx, "graphics", "Test pipeline binary info with graphics pipeline."));
+
+ const VkShaderStageFlagBits testParamShaders0[] =
+ {
+ VK_SHADER_STAGE_VERTEX_BIT,
+ VK_SHADER_STAGE_FRAGMENT_BIT,
+ };
+ const VkShaderStageFlagBits testParamShaders1[] =
+ {
+ VK_SHADER_STAGE_VERTEX_BIT,
+ VK_SHADER_STAGE_GEOMETRY_BIT,
+ VK_SHADER_STAGE_FRAGMENT_BIT,
+ };
+ const VkShaderStageFlagBits testParamShaders2[] =
+ {
+ VK_SHADER_STAGE_VERTEX_BIT,
+ VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT,
+ VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT,
+ VK_SHADER_STAGE_FRAGMENT_BIT,
+ };
+ const ExecutablePropertiesTestParam testParams[] =
+ {
+ ExecutablePropertiesTestParam(testParamShaders0, DE_LENGTH_OF_ARRAY(testParamShaders0), DE_FALSE, DE_FALSE),
+ ExecutablePropertiesTestParam(testParamShaders1, DE_LENGTH_OF_ARRAY(testParamShaders1), DE_FALSE, DE_FALSE),
+ ExecutablePropertiesTestParam(testParamShaders2, DE_LENGTH_OF_ARRAY(testParamShaders2), DE_FALSE, DE_FALSE),
+ ExecutablePropertiesTestParam(testParamShaders0, DE_LENGTH_OF_ARRAY(testParamShaders0), DE_TRUE, DE_FALSE),
+ ExecutablePropertiesTestParam(testParamShaders1, DE_LENGTH_OF_ARRAY(testParamShaders1), DE_TRUE, DE_FALSE),
+ ExecutablePropertiesTestParam(testParamShaders2, DE_LENGTH_OF_ARRAY(testParamShaders2), DE_TRUE, DE_FALSE),
+ ExecutablePropertiesTestParam(testParamShaders0, DE_LENGTH_OF_ARRAY(testParamShaders0), DE_FALSE, DE_TRUE),
+ ExecutablePropertiesTestParam(testParamShaders1, DE_LENGTH_OF_ARRAY(testParamShaders1), DE_FALSE, DE_TRUE),
+ ExecutablePropertiesTestParam(testParamShaders2, DE_LENGTH_OF_ARRAY(testParamShaders2), DE_FALSE, DE_TRUE),
+ ExecutablePropertiesTestParam(testParamShaders0, DE_LENGTH_OF_ARRAY(testParamShaders0), DE_TRUE, DE_TRUE),
+ ExecutablePropertiesTestParam(testParamShaders1, DE_LENGTH_OF_ARRAY(testParamShaders1), DE_TRUE, DE_TRUE),
+ ExecutablePropertiesTestParam(testParamShaders2, DE_LENGTH_OF_ARRAY(testParamShaders2), DE_TRUE, DE_TRUE),
+ };
+
+ for (deUint32 i = 0; i < DE_LENGTH_OF_ARRAY(testParams); i++)
+ graphicsTests->addChild(newTestCase<GraphicsExecutablePropertiesTest>(testCtx, &testParams[i]));
+
+ binaryInfoTests->addChild(graphicsTests.release());
+ }
+
+ // Compute Pipeline Tests
+ {
+ de::MovePtr<tcu::TestCaseGroup> computeTests (new tcu::TestCaseGroup(testCtx, "compute", "Test pipeline binary info with compute pipeline."));
+
+ const VkShaderStageFlagBits testParamShaders0[] =
+ {
+ VK_SHADER_STAGE_COMPUTE_BIT,
+ };
+ const ExecutablePropertiesTestParam testParams[] =
+ {
+ ExecutablePropertiesTestParam(testParamShaders0, DE_LENGTH_OF_ARRAY(testParamShaders0), DE_FALSE, DE_FALSE),
+ ExecutablePropertiesTestParam(testParamShaders0, DE_LENGTH_OF_ARRAY(testParamShaders0), DE_TRUE, DE_FALSE),
+ ExecutablePropertiesTestParam(testParamShaders0, DE_LENGTH_OF_ARRAY(testParamShaders0), DE_FALSE, DE_TRUE),
+ ExecutablePropertiesTestParam(testParamShaders0, DE_LENGTH_OF_ARRAY(testParamShaders0), DE_TRUE, DE_TRUE),
+ };
+
+ for (deUint32 i = 0; i < DE_LENGTH_OF_ARRAY(testParams); i++)
+ computeTests->addChild(newTestCase<ComputeExecutablePropertiesTest>(testCtx, &testParams[i]));
+
+ binaryInfoTests->addChild(computeTests.release());
+ }
+
+ return binaryInfoTests.release();
+}
+
+} // pipeline
+
+} // vkt
--- /dev/null
+#ifndef _VKTPIPELINEEXECUTABLEPROPERTIESTESTS_HPP
+#define _VKTPIPELINEEXECUTABLEPROPERTIESTESTS_HPP
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2019 The Khronos Group Inc.
+ * Copyright (c) 2019 Intel Corporation.
+ *
+ * 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.
+ *
+ *//*!
+ * \file
+ * \brief Pipeline Creation Feedback Tests
+ *//*--------------------------------------------------------------------*/
+
+#include "vktTestCase.hpp"
+
+namespace vkt
+{
+namespace pipeline
+{
+
+tcu::TestCaseGroup* createExecutablePropertiesTests (tcu::TestContext& testCtx);
+
+} // pipeline
+} // vkt
+
+#endif // _VKTPIPELINEEXECUTABLEPROPERTIESTESTS_HPP
#include "vktPipelineDerivativeTests.hpp"
#include "vktPipelineCreationFeedbackTests.hpp"
#include "vktPipelineDepthRangeUnrestrictedTests.hpp"
+#include "vktPipelineExecutablePropertiesTests.hpp"
#include "vktPipelineVertexOnlyTests.hpp"
#include "vktTestGroupUtil.hpp"
pipelineTests->addChild(createDerivativeTests (testCtx));
pipelineTests->addChild(createCreationFeedbackTests (testCtx));
pipelineTests->addChild(createDepthRangeUnrestrictedTests (testCtx));
+ pipelineTests->addChild(createExecutablePropertiesTests (testCtx));
pipelineTests->addChild(createVertexOnlyTests (testCtx));
}
dEQP-VK.pipeline.depth_range_unrestricted.depthclampingdisabled.d16_unorm_compare_op_less_or_equal_clear_value_-7_wc_2_viewport_min_-12_max_12
dEQP-VK.pipeline.depth_range_unrestricted.depthclampingdisabled.d16_unorm_compare_op_less_or_equal_clear_value_-7_wc_6_viewport_min_-12_max_12
dEQP-VK.pipeline.depth_range_unrestricted.depthclampingdisabled.d16_unorm_compare_op_less_or_equal_clear_value_-7_wc_12_viewport_min_-12_max_12
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_fragment_stage
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_geometry_stage_fragment_stage
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_tessellation_control_stage_tessellation_evaluation_stage_fragment_stage
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_fragment_stage_statistics
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_geometry_stage_fragment_stage_statistics
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_tessellation_control_stage_tessellation_evaluation_stage_fragment_stage_statistics
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_fragment_stage_internal_representations
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_geometry_stage_fragment_stage_internal_representations
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_tessellation_control_stage_tessellation_evaluation_stage_fragment_stage_internal_representations
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_fragment_stage_statistics_internal_representations
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_geometry_stage_fragment_stage_statistics_internal_representations
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_tessellation_control_stage_tessellation_evaluation_stage_fragment_stage_statistics_internal_representations
+dEQP-VK.pipeline.executable_properties.compute.compute_stage
+dEQP-VK.pipeline.executable_properties.compute.compute_stage_statistics
+dEQP-VK.pipeline.executable_properties.compute.compute_stage_internal_representations
+dEQP-VK.pipeline.executable_properties.compute.compute_stage_statistics_internal_representations
dEQP-VK.pipeline.vertex_only.position_to_ssbo
dEQP-VK.binding_model.shader_access.primary_cmd_buf.sampler_mutable.no_access.single_descriptor.1d
dEQP-VK.binding_model.shader_access.primary_cmd_buf.sampler_mutable.no_access.single_descriptor.1d_base_mip
dEQP-VK.pipeline.depth_range_unrestricted.depthclampingdisabled.d16_unorm_compare_op_less_or_equal_clear_value_-7_wc_2_viewport_min_-12_max_12
dEQP-VK.pipeline.depth_range_unrestricted.depthclampingdisabled.d16_unorm_compare_op_less_or_equal_clear_value_-7_wc_6_viewport_min_-12_max_12
dEQP-VK.pipeline.depth_range_unrestricted.depthclampingdisabled.d16_unorm_compare_op_less_or_equal_clear_value_-7_wc_12_viewport_min_-12_max_12
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_fragment_stage
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_geometry_stage_fragment_stage
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_tessellation_control_stage_tessellation_evaluation_stage_fragment_stage
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_fragment_stage_statistics
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_geometry_stage_fragment_stage_statistics
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_tessellation_control_stage_tessellation_evaluation_stage_fragment_stage_statistics
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_fragment_stage_internal_representations
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_geometry_stage_fragment_stage_internal_representations
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_tessellation_control_stage_tessellation_evaluation_stage_fragment_stage_internal_representations
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_fragment_stage_statistics_internal_representations
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_geometry_stage_fragment_stage_statistics_internal_representations
+dEQP-VK.pipeline.executable_properties.graphics.vertex_stage_tessellation_control_stage_tessellation_evaluation_stage_fragment_stage_statistics_internal_representations
+dEQP-VK.pipeline.executable_properties.compute.compute_stage
+dEQP-VK.pipeline.executable_properties.compute.compute_stage_statistics
+dEQP-VK.pipeline.executable_properties.compute.compute_stage_internal_representations
+dEQP-VK.pipeline.executable_properties.compute.compute_stage_statistics_internal_representations
dEQP-VK.pipeline.vertex_only.position_to_ssbo
dEQP-VK.binding_model.shader_access.primary_cmd_buf.sampler_mutable.no_access.single_descriptor.1d
dEQP-VK.binding_model.shader_access.primary_cmd_buf.sampler_mutable.no_access.single_descriptor.1d_base_mip
VK_KHR_shader_atomic_int64 DEVICE
VK_KHR_vulkan_memory_model DEVICE
VK_KHR_uniform_buffer_standard_layout DEVICE
-VK_KHR_imageless_framebuffer DEVICE
\ No newline at end of file
+VK_KHR_imageless_framebuffer DEVICE
+VK_KHR_pipeline_executable_properties DEVICE
VkPhysicalDeviceInlineUniformBlockFeaturesEXT inlineUniformBlock VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT EXTENSIONS ( VK_EXT_inline_uniform_block )
VkPhysicalDeviceInlineUniformBlockFeaturesEXT descriptorBindingInlineUniformBlockUpdateAfterBind VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT EXTENSIONS ( VK_EXT_inline_uniform_block VK_EXT_descriptor_indexing )
VkPhysicalDeviceScalarBlockLayoutFeaturesEXT scalarBlockLayout VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT EXTENSIONS ( VK_EXT_scalar_block_layout )
-VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR uniformBufferStandardLayout VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR EXTENSIONS ( VK_KHR_uniform_buffer_standard_layout )
\ No newline at end of file
+VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR uniformBufferStandardLayout VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR EXTENSIONS ( VK_KHR_uniform_buffer_standard_layout )
+VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR pipelineExecutableInfo VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR EXTENSIONS ( VK_KHR_pipeline_executable_properties )
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = 1000261000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000,
+ VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR = 1000269001,
+ VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR = 1000269002,
+ VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR = 1000269003,
+ VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004,
+ VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = 1000276000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = 1000281001,
VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008,
VK_PIPELINE_CREATE_DISPATCH_BASE = 0x00000010,
VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0x00000020,
+ VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR = 0x00000040,
+ VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080,
VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE,
VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+#define VK_KHR_pipeline_executable_properties 1
+#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION 1
+#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME "VK_KHR_pipeline_executable_properties"
+
+typedef enum VkPipelineExecutableStatisticFormatKHR {
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR = 0,
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR = 1,
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR = 2,
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR = 3,
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BEGIN_RANGE_KHR = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR,
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_END_RANGE_KHR = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR,
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_RANGE_SIZE_KHR = (VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR - VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR + 1),
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkPipelineExecutableStatisticFormatKHR;
+typedef struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 pipelineExecutableInfo;
+} VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
+
+typedef struct VkPipelineInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipeline pipeline;
+} VkPipelineInfoKHR;
+
+typedef struct VkPipelineExecutablePropertiesKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkShaderStageFlags stages;
+ char name[VK_MAX_DESCRIPTION_SIZE];
+ char description[VK_MAX_DESCRIPTION_SIZE];
+ uint32_t subgroupSize;
+} VkPipelineExecutablePropertiesKHR;
+
+typedef struct VkPipelineExecutableInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipeline pipeline;
+ uint32_t executableIndex;
+} VkPipelineExecutableInfoKHR;
+
+typedef union VkPipelineExecutableStatisticValueKHR {
+ VkBool32 b32;
+ int64_t i64;
+ uint64_t u64;
+ double f64;
+} VkPipelineExecutableStatisticValueKHR;
+
+typedef struct VkPipelineExecutableStatisticKHR {
+ VkStructureType sType;
+ void* pNext;
+ char name[VK_MAX_DESCRIPTION_SIZE];
+ char description[VK_MAX_DESCRIPTION_SIZE];
+ VkPipelineExecutableStatisticFormatKHR format;
+ VkPipelineExecutableStatisticValueKHR value;
+} VkPipelineExecutableStatisticKHR;
+
+typedef struct VkPipelineExecutableInternalRepresentationKHR {
+ VkStructureType sType;
+ void* pNext;
+ char name[VK_MAX_DESCRIPTION_SIZE];
+ char description[VK_MAX_DESCRIPTION_SIZE];
+ VkBool32 isText;
+ size_t dataSize;
+ void* pData;
+} VkPipelineExecutableInternalRepresentationKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutablePropertiesKHR)(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableStatisticsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableInternalRepresentationsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutablePropertiesKHR(
+ VkDevice device,
+ const VkPipelineInfoKHR* pPipelineInfo,
+ uint32_t* pExecutableCount,
+ VkPipelineExecutablePropertiesKHR* pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableStatisticsKHR(
+ VkDevice device,
+ const VkPipelineExecutableInfoKHR* pExecutableInfo,
+ uint32_t* pStatisticCount,
+ VkPipelineExecutableStatisticKHR* pStatistics);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableInternalRepresentationsKHR(
+ VkDevice device,
+ const VkPipelineExecutableInfoKHR* pExecutableInfo,
+ uint32_t* pInternalRepresentationCount,
+ VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
+#endif
+
+
+
#define VK_EXT_debug_report 1
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)
#define VK_EXT_DEBUG_REPORT_SPEC_VERSION 9
projects / platform / upstream / VK-GL-CTS.git / commitdiff