/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-enum { VK_API_VERSION = VK_MAKE_VERSION(0, 138, 2) };
+enum { VK_API_VERSION = VK_MAKE_VERSION(0, 170, 2) };
enum { VK_MAX_PHYSICAL_DEVICE_NAME = 256 };
enum { VK_MAX_EXTENSION_NAME = 256 };
enum { VK_UUID_LENGTH = 16 };
enum { VK_MAX_DESCRIPTION = 256 };
enum { VK_FALSE = 0 };
enum { VK_TRUE = 1 };
-enum { VK_ATTACHMENT_UNUSED = (~0u) };
-
-VK_DEFINE_HANDLE (VkInstance, HANDLE_TYPE_INSTANCE);
-VK_DEFINE_HANDLE (VkPhysicalDevice, HANDLE_TYPE_PHYSICAL_DEVICE);
-VK_DEFINE_HANDLE (VkDevice, HANDLE_TYPE_DEVICE);
-VK_DEFINE_HANDLE (VkQueue, HANDLE_TYPE_QUEUE);
-VK_DEFINE_HANDLE (VkCmdBuffer, HANDLE_TYPE_CMD_BUFFER);
-VK_DEFINE_NONDISP_HANDLE (VkFence, HANDLE_TYPE_FENCE);
-VK_DEFINE_NONDISP_HANDLE (VkDeviceMemory, HANDLE_TYPE_DEVICE_MEMORY);
-VK_DEFINE_NONDISP_HANDLE (VkBuffer, HANDLE_TYPE_BUFFER);
-VK_DEFINE_NONDISP_HANDLE (VkImage, HANDLE_TYPE_IMAGE);
-VK_DEFINE_NONDISP_HANDLE (VkSemaphore, HANDLE_TYPE_SEMAPHORE);
-VK_DEFINE_NONDISP_HANDLE (VkEvent, HANDLE_TYPE_EVENT);
-VK_DEFINE_NONDISP_HANDLE (VkQueryPool, HANDLE_TYPE_QUERY_POOL);
-VK_DEFINE_NONDISP_HANDLE (VkBufferView, HANDLE_TYPE_BUFFER_VIEW);
-VK_DEFINE_NONDISP_HANDLE (VkImageView, HANDLE_TYPE_IMAGE_VIEW);
-VK_DEFINE_NONDISP_HANDLE (VkAttachmentView, HANDLE_TYPE_ATTACHMENT_VIEW);
-VK_DEFINE_NONDISP_HANDLE (VkShaderModule, HANDLE_TYPE_SHADER_MODULE);
-VK_DEFINE_NONDISP_HANDLE (VkShader, HANDLE_TYPE_SHADER);
-VK_DEFINE_NONDISP_HANDLE (VkPipelineCache, HANDLE_TYPE_PIPELINE_CACHE);
-VK_DEFINE_NONDISP_HANDLE (VkPipelineLayout, HANDLE_TYPE_PIPELINE_LAYOUT);
-VK_DEFINE_NONDISP_HANDLE (VkRenderPass, HANDLE_TYPE_RENDER_PASS);
-VK_DEFINE_NONDISP_HANDLE (VkPipeline, HANDLE_TYPE_PIPELINE);
-VK_DEFINE_NONDISP_HANDLE (VkDescriptorSetLayout, HANDLE_TYPE_DESCRIPTOR_SET_LAYOUT);
-VK_DEFINE_NONDISP_HANDLE (VkSampler, HANDLE_TYPE_SAMPLER);
-VK_DEFINE_NONDISP_HANDLE (VkDescriptorPool, HANDLE_TYPE_DESCRIPTOR_POOL);
-VK_DEFINE_NONDISP_HANDLE (VkDescriptorSet, HANDLE_TYPE_DESCRIPTOR_SET);
-VK_DEFINE_NONDISP_HANDLE (VkDynamicViewportState, HANDLE_TYPE_DYNAMIC_VIEWPORT_STATE);
-VK_DEFINE_NONDISP_HANDLE (VkDynamicRasterState, HANDLE_TYPE_DYNAMIC_RASTER_STATE);
-VK_DEFINE_NONDISP_HANDLE (VkDynamicColorBlendState, HANDLE_TYPE_DYNAMIC_COLOR_BLEND_STATE);
-VK_DEFINE_NONDISP_HANDLE (VkDynamicDepthStencilState, HANDLE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE);
-VK_DEFINE_NONDISP_HANDLE (VkFramebuffer, HANDLE_TYPE_FRAMEBUFFER);
-VK_DEFINE_NONDISP_HANDLE (VkCmdPool, HANDLE_TYPE_CMD_POOL);
+enum { VK_ATTACHMENT_UNUSED = (~0U) };
+
+VK_DEFINE_HANDLE (VkInstance, HANDLE_TYPE_INSTANCE);
+VK_DEFINE_HANDLE (VkPhysicalDevice, HANDLE_TYPE_PHYSICAL_DEVICE);
+VK_DEFINE_HANDLE (VkDevice, HANDLE_TYPE_DEVICE);
+VK_DEFINE_HANDLE (VkQueue, HANDLE_TYPE_QUEUE);
+VK_DEFINE_HANDLE (VkCmdBuffer, HANDLE_TYPE_CMD_BUFFER);
+VK_DEFINE_NONDISP_HANDLE (VkFence, HANDLE_TYPE_FENCE);
+VK_DEFINE_NONDISP_HANDLE (VkDeviceMemory, HANDLE_TYPE_DEVICE_MEMORY);
+VK_DEFINE_NONDISP_HANDLE (VkBuffer, HANDLE_TYPE_BUFFER);
+VK_DEFINE_NONDISP_HANDLE (VkImage, HANDLE_TYPE_IMAGE);
+VK_DEFINE_NONDISP_HANDLE (VkSemaphore, HANDLE_TYPE_SEMAPHORE);
+VK_DEFINE_NONDISP_HANDLE (VkEvent, HANDLE_TYPE_EVENT);
+VK_DEFINE_NONDISP_HANDLE (VkQueryPool, HANDLE_TYPE_QUERY_POOL);
+VK_DEFINE_NONDISP_HANDLE (VkBufferView, HANDLE_TYPE_BUFFER_VIEW);
+VK_DEFINE_NONDISP_HANDLE (VkImageView, HANDLE_TYPE_IMAGE_VIEW);
+VK_DEFINE_NONDISP_HANDLE (VkShaderModule, HANDLE_TYPE_SHADER_MODULE);
+VK_DEFINE_NONDISP_HANDLE (VkShader, HANDLE_TYPE_SHADER);
+VK_DEFINE_NONDISP_HANDLE (VkPipelineCache, HANDLE_TYPE_PIPELINE_CACHE);
+VK_DEFINE_NONDISP_HANDLE (VkPipelineLayout, HANDLE_TYPE_PIPELINE_LAYOUT);
+VK_DEFINE_NONDISP_HANDLE (VkRenderPass, HANDLE_TYPE_RENDER_PASS);
+VK_DEFINE_NONDISP_HANDLE (VkPipeline, HANDLE_TYPE_PIPELINE);
+VK_DEFINE_NONDISP_HANDLE (VkDescriptorSetLayout, HANDLE_TYPE_DESCRIPTOR_SET_LAYOUT);
+VK_DEFINE_NONDISP_HANDLE (VkSampler, HANDLE_TYPE_SAMPLER);
+VK_DEFINE_NONDISP_HANDLE (VkDescriptorPool, HANDLE_TYPE_DESCRIPTOR_POOL);
+VK_DEFINE_NONDISP_HANDLE (VkDescriptorSet, HANDLE_TYPE_DESCRIPTOR_SET);
+VK_DEFINE_NONDISP_HANDLE (VkFramebuffer, HANDLE_TYPE_FRAMEBUFFER);
+VK_DEFINE_NONDISP_HANDLE (VkCmdPool, HANDLE_TYPE_CMD_POOL);
enum VkResult
{
- VK_SUCCESS = 0,
- VK_UNSUPPORTED = 1,
- VK_NOT_READY = 2,
- VK_TIMEOUT = 3,
- VK_EVENT_SET = 4,
- VK_EVENT_RESET = 5,
- VK_INCOMPLETE = 6,
- VK_ERROR_UNKNOWN = -1,
- VK_ERROR_UNAVAILABLE = -2,
- VK_ERROR_INITIALIZATION_FAILED = -3,
- VK_ERROR_OUT_OF_HOST_MEMORY = -4,
- VK_ERROR_OUT_OF_DEVICE_MEMORY = -5,
- VK_ERROR_DEVICE_ALREADY_CREATED = -6,
- VK_ERROR_DEVICE_LOST = -7,
- VK_ERROR_INVALID_POINTER = -8,
- VK_ERROR_INVALID_VALUE = -9,
- VK_ERROR_INVALID_HANDLE = -10,
- VK_ERROR_INVALID_ORDINAL = -11,
- VK_ERROR_INVALID_MEMORY_SIZE = -12,
- VK_ERROR_INVALID_EXTENSION = -13,
- VK_ERROR_INVALID_FLAGS = -14,
- VK_ERROR_INVALID_ALIGNMENT = -15,
- VK_ERROR_INVALID_FORMAT = -16,
- VK_ERROR_INVALID_IMAGE = -17,
- VK_ERROR_INVALID_DESCRIPTOR_SET_DATA = -18,
- VK_ERROR_INVALID_QUEUE_TYPE = -19,
- VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION = -20,
- VK_ERROR_BAD_SHADER_CODE = -21,
- VK_ERROR_BAD_PIPELINE_DATA = -22,
- VK_ERROR_NOT_MAPPABLE = -23,
- VK_ERROR_MEMORY_MAP_FAILED = -24,
- VK_ERROR_MEMORY_UNMAP_FAILED = -25,
- VK_ERROR_INCOMPATIBLE_DEVICE = -26,
- VK_ERROR_INCOMPATIBLE_DRIVER = -27,
- VK_ERROR_INCOMPLETE_COMMAND_BUFFER = -28,
- VK_ERROR_BUILDING_COMMAND_BUFFER = -29,
- VK_ERROR_MEMORY_NOT_BOUND = -30,
- VK_ERROR_INCOMPATIBLE_QUEUE = -31,
- VK_ERROR_INVALID_LAYER = -32,
+ VK_SUCCESS = 0,
+ VK_UNSUPPORTED = 1,
+ VK_NOT_READY = 2,
+ VK_TIMEOUT = 3,
+ VK_EVENT_SET = 4,
+ VK_EVENT_RESET = 5,
+ VK_INCOMPLETE = 6,
+ VK_ERROR_OUT_OF_HOST_MEMORY = -1,
+ VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,
+ VK_ERROR_INITIALIZATION_FAILED = -3,
+ VK_ERROR_DEVICE_LOST = -4,
+ VK_ERROR_MEMORY_MAP_FAILED = -5,
+ VK_ERROR_LAYER_NOT_PRESENT = -6,
+ VK_ERROR_EXTENSION_NOT_PRESENT = -7,
+ VK_ERROR_INCOMPATIBLE_DRIVER = -8,
};
enum VkStructureType
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1,
VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 2,
VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 3,
- VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO = 4,
- VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 5,
- VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 6,
- VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 7,
- VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 8,
- VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 9,
- VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO = 10,
- VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO = 11,
- VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO = 12,
- VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO = 13,
- VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 14,
- VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 15,
- VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 16,
- VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 17,
- VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 18,
- VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 19,
- VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 20,
- VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 21,
- VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 22,
- VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 23,
- VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 24,
- VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO = 25,
- VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 26,
- VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 27,
- VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 28,
- VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 29,
- VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 30,
- VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 31,
- VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 32,
- VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 33,
- VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 34,
- VK_STRUCTURE_TYPE_MEMORY_BARRIER = 35,
- VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 36,
- VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 37,
- VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 38,
- VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 39,
- VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 40,
- VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 41,
- VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 42,
- VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 43,
- VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 44,
- VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION = 45,
- VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION = 46,
- VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY = 47,
- VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 48,
- VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 49,
+ VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 4,
+ VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 5,
+ VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 6,
+ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 7,
+ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 8,
+ VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 9,
+ VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10,
+ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 11,
+ VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 12,
+ VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 13,
+ VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 14,
+ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 15,
+ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 16,
+ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 17,
+ VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 18,
+ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 19,
+ VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO = 20,
+ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 21,
+ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 22,
+ VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 23,
+ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 24,
+ VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 25,
+ VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 26,
+ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 27,
+ VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 28,
+ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 29,
+ VK_STRUCTURE_TYPE_MEMORY_BARRIER = 30,
+ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 31,
+ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 32,
+ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33,
+ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 34,
+ VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 35,
+ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 36,
+ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 37,
+ VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 38,
+ VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 39,
+ VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION = 40,
+ VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION = 41,
+ VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY = 42,
+ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
+ VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 44,
+ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 45,
+ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 46,
VK_STRUCTURE_TYPE_LAST
};
VK_FORMAT_R11G11B10_UFLOAT = 87,
VK_FORMAT_R9G9B9E5_UFLOAT = 88,
VK_FORMAT_D16_UNORM = 89,
- VK_FORMAT_D24_UNORM = 90,
+ VK_FORMAT_D24_UNORM_X8 = 90,
VK_FORMAT_D32_SFLOAT = 91,
VK_FORMAT_S8_UINT = 92,
VK_FORMAT_D16_UNORM_S8_UINT = 93,
VK_SHARING_MODE_LAST
};
-enum VkBufferViewType
+enum VkImageLayout
{
- VK_BUFFER_VIEW_TYPE_RAW = 0,
- VK_BUFFER_VIEW_TYPE_FORMATTED = 1,
+ VK_IMAGE_LAYOUT_UNDEFINED = 0,
+ VK_IMAGE_LAYOUT_GENERAL = 1,
+ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2,
+ VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3,
+ VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4,
+ VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5,
+ VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL = 6,
+ VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 7,
+ VK_IMAGE_LAYOUT_PREINITIALIZED = 8,
- VK_BUFFER_VIEW_TYPE_LAST
+ VK_IMAGE_LAYOUT_LAST
};
enum VkImageViewType
VK_BLEND_OP_LAST
};
+enum VkDynamicState
+{
+ VK_DYNAMIC_STATE_VIEWPORT = 0,
+ VK_DYNAMIC_STATE_SCISSOR = 1,
+ VK_DYNAMIC_STATE_LINE_WIDTH = 2,
+ VK_DYNAMIC_STATE_DEPTH_BIAS = 3,
+ VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4,
+ VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5,
+ VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6,
+ VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7,
+ VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8,
+
+ VK_DYNAMIC_STATE_LAST
+};
+
enum VkTexFilter
{
VK_TEX_FILTER_NEAREST = 0,
VK_TEX_MIPMAP_MODE_LAST
};
-enum VkTexAddress
+enum VkTexAddressMode
{
- VK_TEX_ADDRESS_WRAP = 0,
- VK_TEX_ADDRESS_MIRROR = 1,
- VK_TEX_ADDRESS_CLAMP = 2,
- VK_TEX_ADDRESS_MIRROR_ONCE = 3,
- VK_TEX_ADDRESS_CLAMP_BORDER = 4,
+ VK_TEX_ADDRESS_MODE_WRAP = 0,
+ VK_TEX_ADDRESS_MODE_MIRROR = 1,
+ VK_TEX_ADDRESS_MODE_CLAMP = 2,
+ VK_TEX_ADDRESS_MODE_MIRROR_ONCE = 3,
+ VK_TEX_ADDRESS_MODE_CLAMP_BORDER = 4,
- VK_TEX_ADDRESS_LAST
+ VK_TEX_ADDRESS_MODE_LAST
};
enum VkBorderColor
VK_DESCRIPTOR_SET_USAGE_LAST
};
-enum VkImageLayout
-{
- VK_IMAGE_LAYOUT_UNDEFINED = 0,
- VK_IMAGE_LAYOUT_GENERAL = 1,
- VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2,
- VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3,
- VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4,
- VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5,
- VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL = 6,
- VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 7,
-
- VK_IMAGE_LAYOUT_LAST
-};
-
enum VkAttachmentLoadOp
{
VK_ATTACHMENT_LOAD_OP_LOAD = 0,
VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080,
VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100,
VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200,
- VK_FORMAT_FEATURE_CONVERSION_BIT = 0x00000400,
+ VK_FORMAT_FEATURE_BLIT_SOURCE_BIT = 0x00000400,
+ VK_FORMAT_FEATURE_BLIT_DESTINATION_BIT = 0x00000800,
};
typedef deUint32 VkFormatFeatureFlags;
enum VkImageUsageFlagBits
{
- VK_IMAGE_USAGE_GENERAL = 0,
- VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = 0x00000001,
- VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002,
- VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004,
- VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008,
- VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010,
- VK_IMAGE_USAGE_DEPTH_STENCIL_BIT = 0x00000020,
- VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040,
- VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080,
+ VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = 0x00000001,
+ VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002,
+ VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004,
+ VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008,
+ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010,
+ VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020,
+ VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040,
+ VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080,
};
typedef deUint32 VkImageUsageFlags;
+enum VkImageCreateFlagBits
+{
+ VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001,
+ VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
+ VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
+ VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008,
+ VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010,
+};
+typedef deUint32 VkImageCreateFlags;
+
+enum VkSampleCountFlagBits
+{
+ VK_SAMPLE_COUNT_1_BIT = 0x00000001,
+ VK_SAMPLE_COUNT_2_BIT = 0x00000002,
+ VK_SAMPLE_COUNT_4_BIT = 0x00000004,
+ VK_SAMPLE_COUNT_8_BIT = 0x00000008,
+ VK_SAMPLE_COUNT_16_BIT = 0x00000010,
+ VK_SAMPLE_COUNT_32_BIT = 0x00000020,
+ VK_SAMPLE_COUNT_64_BIT = 0x00000040,
+};
+typedef deUint32 VkSampleCountFlags;
+
enum VkQueueFlagBits
{
VK_QUEUE_GRAPHICS_BIT = 0x00000001,
enum VkMemoryHeapFlagBits
{
- VK_MEMORY_HEAP_HOST_LOCAL = 0x00000001,
+ VK_MEMORY_HEAP_HOST_LOCAL_BIT = 0x00000001,
};
typedef deUint32 VkMemoryHeapFlags;
-enum VkDeviceCreateFlagBits
-{
- VK_DEVICE_CREATE_VALIDATION_BIT = 0x00000001,
-};
-typedef deUint32 VkDeviceCreateFlags;
-
enum VkSparseImageFormatFlagBits
{
VK_SPARSE_IMAGE_FMT_SINGLE_MIPTAIL_BIT = 0x00000001,
enum VkBufferUsageFlagBits
{
- VK_BUFFER_USAGE_GENERAL = 0,
VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = 0x00000001,
VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002,
VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,
enum VkBufferCreateFlagBits
{
- VK_BUFFER_CREATE_SPARSE_BIT = 0x00000001,
+ VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001,
VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
};
typedef deUint32 VkBufferCreateFlags;
-enum VkImageCreateFlagBits
+enum VkImageAspectFlagBits
{
- VK_IMAGE_CREATE_SPARSE_BIT = 0x00000001,
- VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
- VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
- VK_IMAGE_CREATE_INVARIANT_DATA_BIT = 0x00000008,
- VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000010,
- VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000020,
+ VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
+ VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
+ VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
+ VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008,
};
-typedef deUint32 VkImageCreateFlags;
+typedef deUint32 VkImageAspectFlags;
-enum VkAttachmentViewCreateFlagBits
+enum VkImageViewCreateFlagBits
{
- VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001,
- VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002,
+ VK_IMAGE_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001,
+ VK_IMAGE_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002,
};
-typedef deUint32 VkAttachmentViewCreateFlags;
+typedef deUint32 VkImageViewCreateFlags;
enum VkChannelFlagBits
{
};
typedef deUint32 VkShaderStageFlags;
+enum VkAttachmentDescriptionFlagBits
+{
+ VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001,
+};
+typedef deUint32 VkAttachmentDescriptionFlags;
+
enum VkSubpassDescriptionFlagBits
{
VK_SUBPASS_DESCRIPTION_NO_OVERDRAW_BIT = 0x00000001,
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400,
VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800,
VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000,
- VK_PIPELINE_STAGE_TRANSITION_BIT = 0x00002000,
- VK_PIPELINE_STAGE_HOST_BIT = 0x00004000,
+ VK_PIPELINE_STAGE_HOST_BIT = 0x00002000,
VK_PIPELINE_STAGE_ALL_GRAPHICS = 0x000007FF,
- VK_PIPELINE_STAGE_ALL_GPU_COMMANDS = 0x00003FFF,
+ VK_PIPELINE_STAGE_ALL_GPU_COMMANDS = 0x00001FFF,
};
typedef deUint32 VkPipelineStageFlags;
enum VkCmdPoolResetFlagBits
{
- VK_CMD_POOL_RESET_RELEASE_RESOURCES = 0x00000001,
+ VK_CMD_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
};
typedef deUint32 VkCmdPoolResetFlags;
enum VkCmdBufferResetFlagBits
{
- VK_CMD_BUFFER_RESET_RELEASE_RESOURCES = 0x00000001,
+ VK_CMD_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
};
typedef deUint32 VkCmdBufferResetFlags;
-enum VkImageAspectFlagBits
+enum VkStencilFaceFlagBits
{
- VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
- VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
- VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
- VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008,
+ VK_STENCIL_FACE_NONE = 0,
+ VK_STENCIL_FACE_FRONT_BIT = 0x00000001,
+ VK_STENCIL_FACE_BACK_BIT = 0x00000002,
};
-typedef deUint32 VkImageAspectFlags;
+typedef deUint32 VkStencilFaceFlags;
enum VkQueryControlFlagBits
{
{
VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
DE_NULL,
+ poolUsage,
+ maxSets,
(deUint32)m_counts.size(), //!< count
typeCountPtr, //!< pTypeCount
};
- return createDescriptorPool(vk, device, poolUsage, maxSets, &createInfo);
+ return createDescriptorPool(vk, device, &createInfo);
}
// DescriptorSetUpdateBuilder
const VkWriteDescriptorSet* const writePtr = (m_writes.empty()) ? (DE_NULL) : (&m_writes[0]);
const VkCopyDescriptorSet* const copyPtr = (m_copies.empty()) ? (DE_NULL) : (&m_copies[0]);
- VK_CHECK(vk.updateDescriptorSets(device, (deUint32)m_writes.size(), writePtr, (deUint32)m_copies.size(), copyPtr));
+ vk.updateDescriptorSets(device, (deUint32)m_writes.size(), writePtr, (deUint32)m_copies.size(), copyPtr);
}
} // vk
// helpers
inline DescriptorSetUpdateBuilder& writeSingle (VkDescriptorSet destSet,
- const Location& destLocation,
+ const Location& destLocation,
VkDescriptorType descriptorType,
const VkDescriptorInfo* descriptor)
{
}
inline DescriptorSetUpdateBuilder& writeArray (VkDescriptorSet destSet,
- const Location& destLocation,
+ const Location& destLocation,
VkDescriptorType descriptorType,
deUint32 numDescriptors,
const VkDescriptorInfo* descriptors)
}
inline DescriptorSetUpdateBuilder& copySingle (VkDescriptorSet srcSet,
- const Location& srcLocation,
+ const Location& srcLocation,
VkDescriptorSet destSet,
- const Location& destLocation)
+ const Location& destLocation)
{
return copy(srcSet, srcLocation.m_binding, srcLocation.m_arrayElement, destSet, destLocation.m_binding, destLocation.m_arrayElement, 1u);
}
inline DescriptorSetUpdateBuilder& copyArray (VkDescriptorSet srcSet,
- const Location& srcLocation,
+ const Location& srcLocation,
VkDescriptorSet destSet,
- const Location& destLocation,
+ const Location& destLocation,
deUint32 count)
{
return copy(srcSet, srcLocation.m_binding, srcLocation.m_arrayElement, destSet, destLocation.m_binding, destLocation.m_arrayElement, count);
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-virtual VkResult destroyDevice (VkDevice device) const;
-virtual VkResult getGlobalExtensionProperties (const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties) const;
-virtual VkResult getPhysicalDeviceExtensionProperties (VkPhysicalDevice physicalDevice, const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties) const;
-virtual VkResult getGlobalLayerProperties (deUint32* pCount, VkLayerProperties* pProperties) const;
-virtual VkResult getPhysicalDeviceLayerProperties (VkPhysicalDevice physicalDevice, deUint32* pCount, VkLayerProperties* pProperties) const;
+virtual void destroyDevice (VkDevice device) const;
virtual VkResult getDeviceQueue (VkDevice device, deUint32 queueFamilyIndex, deUint32 queueIndex, VkQueue* pQueue) const;
virtual VkResult queueSubmit (VkQueue queue, deUint32 cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence) const;
virtual VkResult queueWaitIdle (VkQueue queue) const;
virtual VkResult deviceWaitIdle (VkDevice device) const;
virtual VkResult allocMemory (VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem) const;
-virtual VkResult freeMemory (VkDevice device, VkDeviceMemory mem) const;
+virtual void freeMemory (VkDevice device, VkDeviceMemory mem) const;
virtual VkResult mapMemory (VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) const;
-virtual VkResult unmapMemory (VkDevice device, VkDeviceMemory mem) const;
+virtual void unmapMemory (VkDevice device, VkDeviceMemory mem) const;
virtual VkResult flushMappedMemoryRanges (VkDevice device, deUint32 memRangeCount, const VkMappedMemoryRange* pMemRanges) const;
virtual VkResult invalidateMappedMemoryRanges (VkDevice device, deUint32 memRangeCount, const VkMappedMemoryRange* pMemRanges) const;
virtual VkResult getDeviceMemoryCommitment (VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) const;
virtual VkResult queueBindSparseImageOpaqueMemory (VkQueue queue, VkImage image, deUint32 numBindings, const VkSparseMemoryBindInfo* pBindInfo) const;
virtual VkResult queueBindSparseImageMemory (VkQueue queue, VkImage image, deUint32 numBindings, const VkSparseImageMemoryBindInfo* pBindInfo) const;
virtual VkResult createFence (VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence) const;
-virtual VkResult destroyFence (VkDevice device, VkFence fence) const;
+virtual void destroyFence (VkDevice device, VkFence fence) const;
virtual VkResult resetFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences) const;
virtual VkResult getFenceStatus (VkDevice device, VkFence fence) const;
virtual VkResult waitForFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences, VkBool32 waitAll, deUint64 timeout) const;
virtual VkResult createSemaphore (VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore) const;
-virtual VkResult destroySemaphore (VkDevice device, VkSemaphore semaphore) const;
+virtual void destroySemaphore (VkDevice device, VkSemaphore semaphore) const;
virtual VkResult queueSignalSemaphore (VkQueue queue, VkSemaphore semaphore) const;
virtual VkResult queueWaitSemaphore (VkQueue queue, VkSemaphore semaphore) const;
virtual VkResult createEvent (VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent) const;
-virtual VkResult destroyEvent (VkDevice device, VkEvent event) const;
+virtual void destroyEvent (VkDevice device, VkEvent event) const;
virtual VkResult getEventStatus (VkDevice device, VkEvent event) const;
virtual VkResult setEvent (VkDevice device, VkEvent event) const;
virtual VkResult resetEvent (VkDevice device, VkEvent event) const;
virtual VkResult createQueryPool (VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool) const;
-virtual VkResult destroyQueryPool (VkDevice device, VkQueryPool queryPool) const;
+virtual void destroyQueryPool (VkDevice device, VkQueryPool queryPool) const;
virtual VkResult getQueryPoolResults (VkDevice device, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, deUintptr* pDataSize, void* pData, VkQueryResultFlags flags) const;
virtual VkResult createBuffer (VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer) const;
-virtual VkResult destroyBuffer (VkDevice device, VkBuffer buffer) const;
+virtual void destroyBuffer (VkDevice device, VkBuffer buffer) const;
virtual VkResult createBufferView (VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView) const;
-virtual VkResult destroyBufferView (VkDevice device, VkBufferView bufferView) const;
+virtual void destroyBufferView (VkDevice device, VkBufferView bufferView) const;
virtual VkResult createImage (VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage) const;
-virtual VkResult destroyImage (VkDevice device, VkImage image) const;
+virtual void destroyImage (VkDevice device, VkImage image) const;
virtual VkResult getImageSubresourceLayout (VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) const;
virtual VkResult createImageView (VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView) const;
-virtual VkResult destroyImageView (VkDevice device, VkImageView imageView) const;
-virtual VkResult createAttachmentView (VkDevice device, const VkAttachmentViewCreateInfo* pCreateInfo, VkAttachmentView* pView) const;
-virtual VkResult destroyAttachmentView (VkDevice device, VkAttachmentView attachmentView) const;
+virtual void destroyImageView (VkDevice device, VkImageView imageView) const;
virtual VkResult createShaderModule (VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule) const;
-virtual VkResult destroyShaderModule (VkDevice device, VkShaderModule shaderModule) const;
+virtual void destroyShaderModule (VkDevice device, VkShaderModule shaderModule) const;
virtual VkResult createShader (VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader) const;
-virtual VkResult destroyShader (VkDevice device, VkShader shader) const;
+virtual void destroyShader (VkDevice device, VkShader shader) const;
virtual VkResult createPipelineCache (VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache) const;
-virtual VkResult destroyPipelineCache (VkDevice device, VkPipelineCache pipelineCache) const;
+virtual void destroyPipelineCache (VkDevice device, VkPipelineCache pipelineCache) const;
virtual deUintptr getPipelineCacheSize (VkDevice device, VkPipelineCache pipelineCache) const;
virtual VkResult getPipelineCacheData (VkDevice device, VkPipelineCache pipelineCache, void* pData) const;
virtual VkResult mergePipelineCaches (VkDevice device, VkPipelineCache destCache, deUint32 srcCacheCount, const VkPipelineCache* pSrcCaches) const;
virtual VkResult createGraphicsPipelines (VkDevice device, VkPipelineCache pipelineCache, deUint32 count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines) const;
virtual VkResult createComputePipelines (VkDevice device, VkPipelineCache pipelineCache, deUint32 count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines) const;
-virtual VkResult destroyPipeline (VkDevice device, VkPipeline pipeline) const;
+virtual void destroyPipeline (VkDevice device, VkPipeline pipeline) const;
virtual VkResult createPipelineLayout (VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout) const;
-virtual VkResult destroyPipelineLayout (VkDevice device, VkPipelineLayout pipelineLayout) const;
+virtual void destroyPipelineLayout (VkDevice device, VkPipelineLayout pipelineLayout) const;
virtual VkResult createSampler (VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) const;
-virtual VkResult destroySampler (VkDevice device, VkSampler sampler) const;
+virtual void destroySampler (VkDevice device, VkSampler sampler) const;
virtual VkResult createDescriptorSetLayout (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout) const;
-virtual VkResult destroyDescriptorSetLayout (VkDevice device, VkDescriptorSetLayout descriptorSetLayout) const;
-virtual VkResult createDescriptorPool (VkDevice device, VkDescriptorPoolUsage poolUsage, deUint32 maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) const;
-virtual VkResult destroyDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool) const;
+virtual void destroyDescriptorSetLayout (VkDevice device, VkDescriptorSetLayout descriptorSetLayout) const;
+virtual VkResult createDescriptorPool (VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) const;
+virtual void destroyDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool) const;
virtual VkResult resetDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool) const;
-virtual VkResult allocDescriptorSets (VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, deUint32 count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, deUint32* pCount) const;
+virtual VkResult allocDescriptorSets (VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, deUint32 count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets) const;
virtual VkResult freeDescriptorSets (VkDevice device, VkDescriptorPool descriptorPool, deUint32 count, const VkDescriptorSet* pDescriptorSets) const;
-virtual VkResult updateDescriptorSets (VkDevice device, deUint32 writeCount, const VkWriteDescriptorSet* pDescriptorWrites, deUint32 copyCount, const VkCopyDescriptorSet* pDescriptorCopies) const;
-virtual VkResult createDynamicViewportState (VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState) const;
-virtual VkResult destroyDynamicViewportState (VkDevice device, VkDynamicViewportState dynamicViewportState) const;
-virtual VkResult createDynamicRasterState (VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState) const;
-virtual VkResult destroyDynamicRasterState (VkDevice device, VkDynamicRasterState dynamicRasterState) const;
-virtual VkResult createDynamicColorBlendState (VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState) const;
-virtual VkResult destroyDynamicColorBlendState (VkDevice device, VkDynamicColorBlendState dynamicColorBlendState) const;
-virtual VkResult createDynamicDepthStencilState (VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, VkDynamicDepthStencilState* pState) const;
-virtual VkResult destroyDynamicDepthStencilState (VkDevice device, VkDynamicDepthStencilState dynamicDepthStencilState) const;
+virtual void updateDescriptorSets (VkDevice device, deUint32 writeCount, const VkWriteDescriptorSet* pDescriptorWrites, deUint32 copyCount, const VkCopyDescriptorSet* pDescriptorCopies) const;
virtual VkResult createFramebuffer (VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer) const;
-virtual VkResult destroyFramebuffer (VkDevice device, VkFramebuffer framebuffer) const;
+virtual void destroyFramebuffer (VkDevice device, VkFramebuffer framebuffer) const;
virtual VkResult createRenderPass (VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass) const;
-virtual VkResult destroyRenderPass (VkDevice device, VkRenderPass renderPass) const;
+virtual void destroyRenderPass (VkDevice device, VkRenderPass renderPass) const;
virtual VkResult getRenderAreaGranularity (VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) const;
virtual VkResult createCommandPool (VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool) const;
-virtual VkResult destroyCommandPool (VkDevice device, VkCmdPool cmdPool) const;
+virtual void destroyCommandPool (VkDevice device, VkCmdPool cmdPool) const;
virtual VkResult resetCommandPool (VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags) const;
virtual VkResult createCommandBuffer (VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer) const;
-virtual VkResult destroyCommandBuffer (VkDevice device, VkCmdBuffer commandBuffer) const;
+virtual void destroyCommandBuffer (VkDevice device, VkCmdBuffer commandBuffer) const;
virtual VkResult beginCommandBuffer (VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) const;
virtual VkResult endCommandBuffer (VkCmdBuffer cmdBuffer) const;
virtual VkResult resetCommandBuffer (VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags) const;
virtual void cmdBindPipeline (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) const;
-virtual void cmdBindDynamicViewportState (VkCmdBuffer cmdBuffer, VkDynamicViewportState dynamicViewportState) const;
-virtual void cmdBindDynamicRasterState (VkCmdBuffer cmdBuffer, VkDynamicRasterState dynamicRasterState) const;
-virtual void cmdBindDynamicColorBlendState (VkCmdBuffer cmdBuffer, VkDynamicColorBlendState dynamicColorBlendState) const;
-virtual void cmdBindDynamicDepthStencilState (VkCmdBuffer cmdBuffer, VkDynamicDepthStencilState dynamicDepthStencilState) const;
+virtual void cmdSetViewport (VkCmdBuffer cmdBuffer, deUint32 viewportCount, const VkViewport* pViewports) const;
+virtual void cmdSetScissor (VkCmdBuffer cmdBuffer, deUint32 scissorCount, const VkRect2D* pScissors) const;
+virtual void cmdSetLineWidth (VkCmdBuffer cmdBuffer, float lineWidth) const;
+virtual void cmdSetDepthBias (VkCmdBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias) const;
+virtual void cmdSetBlendConstants (VkCmdBuffer cmdBuffer, const float blendConst) const;
+virtual void cmdSetDepthBounds (VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds) const;
+virtual void cmdSetStencilCompareMask (VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, deUint32 stencilCompareMask) const;
+virtual void cmdSetStencilWriteMask (VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, deUint32 stencilWriteMask) const;
+virtual void cmdSetStencilReference (VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, deUint32 stencilReference) const;
virtual void cmdBindDescriptorSets (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 firstSet, deUint32 setCount, const VkDescriptorSet* pDescriptorSets, deUint32 dynamicOffsetCount, const deUint32* pDynamicOffsets) const;
virtual void cmdBindIndexBuffer (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) const;
virtual void cmdBindVertexBuffers (VkCmdBuffer cmdBuffer, deUint32 startBinding, deUint32 bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) const;
-virtual void cmdDraw (VkCmdBuffer cmdBuffer, deUint32 firstVertex, deUint32 vertexCount, deUint32 firstInstance, deUint32 instanceCount) const;
-virtual void cmdDrawIndexed (VkCmdBuffer cmdBuffer, deUint32 firstIndex, deUint32 indexCount, deInt32 vertexOffset, deUint32 firstInstance, deUint32 instanceCount) const;
+virtual void cmdDraw (VkCmdBuffer cmdBuffer, deUint32 vertexCount, deUint32 instanceCount, deUint32 firstVertex, deUint32 firstInstance) const;
+virtual void cmdDrawIndexed (VkCmdBuffer cmdBuffer, deUint32 indexCount, deUint32 instanceCount, deUint32 firstIndex, deInt32 vertexOffset, deUint32 firstInstance) const;
virtual void cmdDrawIndirect (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 count, deUint32 stride) const;
virtual void cmdDrawIndexedIndirect (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 count, deUint32 stride) const;
virtual void cmdDispatch (VkCmdBuffer cmdBuffer, deUint32 x, deUint32 y, deUint32 z) const;
virtual void cmdUpdateBuffer (VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const deUint32* pData) const;
virtual void cmdFillBuffer (VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, deUint32 data) const;
virtual void cmdClearColorImage (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, deUint32 rangeCount, const VkImageSubresourceRange* pRanges) const;
-virtual void cmdClearDepthStencilImage (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, deUint32 stencil, deUint32 rangeCount, const VkImageSubresourceRange* pRanges) const;
+virtual void cmdClearDepthStencilImage (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, deUint32 rangeCount, const VkImageSubresourceRange* pRanges) const;
virtual void cmdClearColorAttachment (VkCmdBuffer cmdBuffer, deUint32 colorAttachment, VkImageLayout imageLayout, const VkClearColorValue* pColor, deUint32 rectCount, const VkRect3D* pRects) const;
-virtual void cmdClearDepthStencilAttachment (VkCmdBuffer cmdBuffer, VkImageAspectFlags imageAspectMask, VkImageLayout imageLayout, float depth, deUint32 stencil, deUint32 rectCount, const VkRect3D* pRects) const;
+virtual void cmdClearDepthStencilAttachment (VkCmdBuffer cmdBuffer, VkImageAspectFlags aspectMask, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, deUint32 rectCount, const VkRect3D* pRects) const;
virtual void cmdResolveImage (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageResolve* pRegions) const;
virtual void cmdSetEvent (VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) const;
virtual void cmdResetEvent (VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) const;
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-virtual VkResult destroyInstance (VkInstance instance) const;
+virtual void destroyInstance (VkInstance instance) const;
virtual VkResult enumeratePhysicalDevices (VkInstance instance, deUint32* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) const;
virtual VkResult getPhysicalDeviceFeatures (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) const;
virtual VkResult getPhysicalDeviceFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) const;
-virtual VkResult getPhysicalDeviceImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageFormatProperties* pImageFormatProperties) const;
-virtual VkResult getPhysicalDeviceLimits (VkPhysicalDevice physicalDevice, VkPhysicalDeviceLimits* pLimits) const;
+virtual VkResult getPhysicalDeviceImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) const;
virtual VkResult getPhysicalDeviceProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) const;
-virtual VkResult getPhysicalDeviceQueueCount (VkPhysicalDevice physicalDevice, deUint32* pCount) const;
-virtual VkResult getPhysicalDeviceQueueProperties (VkPhysicalDevice physicalDevice, deUint32 count, VkPhysicalDeviceQueueProperties* pQueueProperties) const;
+virtual VkResult getPhysicalDeviceQueueFamilyProperties (VkPhysicalDevice physicalDevice, deUint32* pCount, VkQueueFamilyProperties* pQueueFamilyProperties) const;
virtual VkResult getPhysicalDeviceMemoryProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) const;
virtual PFN_vkVoidFunction getDeviceProcAddr (VkDevice device, const char* pName) const;
virtual VkResult createDevice (VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) const;
+virtual VkResult enumerateDeviceExtensionProperties (VkPhysicalDevice physicalDevice, const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties) const;
+virtual VkResult enumerateDeviceLayerProperties (VkPhysicalDevice physicalDevice, deUint32* pCount, VkLayerProperties* pProperties) const;
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-virtual VkResult createInstance (const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance) const;
-virtual PFN_vkVoidFunction getInstanceProcAddr (VkInstance instance, const char* pName) const;
+virtual VkResult createInstance (const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance) const;
+virtual PFN_vkVoidFunction getInstanceProcAddr (VkInstance instance, const char* pName) const;
+virtual VkResult enumerateInstanceExtensionProperties (const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties) const;
+virtual VkResult enumerateInstanceLayerProperties (deUint32* pCount, VkLayerProperties* pProperties) const;
* be lost! Modify the generating script instead.
*/
-VkResult DeviceDriver::destroyDevice (VkDevice device) const
+void DeviceDriver::destroyDevice (VkDevice device) const
{
- return m_vk.destroyDevice(device);
-}
-
-VkResult DeviceDriver::getGlobalExtensionProperties (const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties) const
-{
- return m_vk.getGlobalExtensionProperties(pLayerName, pCount, pProperties);
-}
-
-VkResult DeviceDriver::getPhysicalDeviceExtensionProperties (VkPhysicalDevice physicalDevice, const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties) const
-{
- return m_vk.getPhysicalDeviceExtensionProperties(physicalDevice, pLayerName, pCount, pProperties);
-}
-
-VkResult DeviceDriver::getGlobalLayerProperties (deUint32* pCount, VkLayerProperties* pProperties) const
-{
- return m_vk.getGlobalLayerProperties(pCount, pProperties);
-}
-
-VkResult DeviceDriver::getPhysicalDeviceLayerProperties (VkPhysicalDevice physicalDevice, deUint32* pCount, VkLayerProperties* pProperties) const
-{
- return m_vk.getPhysicalDeviceLayerProperties(physicalDevice, pCount, pProperties);
+ m_vk.destroyDevice(device);
}
VkResult DeviceDriver::getDeviceQueue (VkDevice device, deUint32 queueFamilyIndex, deUint32 queueIndex, VkQueue* pQueue) const
return m_vk.allocMemory(device, pAllocInfo, pMem);
}
-VkResult DeviceDriver::freeMemory (VkDevice device, VkDeviceMemory mem) const
+void DeviceDriver::freeMemory (VkDevice device, VkDeviceMemory mem) const
{
- return m_vk.freeMemory(device, mem);
+ m_vk.freeMemory(device, mem);
}
VkResult DeviceDriver::mapMemory (VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) const
return m_vk.mapMemory(device, mem, offset, size, flags, ppData);
}
-VkResult DeviceDriver::unmapMemory (VkDevice device, VkDeviceMemory mem) const
+void DeviceDriver::unmapMemory (VkDevice device, VkDeviceMemory mem) const
{
- return m_vk.unmapMemory(device, mem);
+ m_vk.unmapMemory(device, mem);
}
VkResult DeviceDriver::flushMappedMemoryRanges (VkDevice device, deUint32 memRangeCount, const VkMappedMemoryRange* pMemRanges) const
return m_vk.createFence(device, pCreateInfo, pFence);
}
-VkResult DeviceDriver::destroyFence (VkDevice device, VkFence fence) const
+void DeviceDriver::destroyFence (VkDevice device, VkFence fence) const
{
- return m_vk.destroyFence(device, fence);
+ m_vk.destroyFence(device, fence);
}
VkResult DeviceDriver::resetFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences) const
return m_vk.createSemaphore(device, pCreateInfo, pSemaphore);
}
-VkResult DeviceDriver::destroySemaphore (VkDevice device, VkSemaphore semaphore) const
+void DeviceDriver::destroySemaphore (VkDevice device, VkSemaphore semaphore) const
{
- return m_vk.destroySemaphore(device, semaphore);
+ m_vk.destroySemaphore(device, semaphore);
}
VkResult DeviceDriver::queueSignalSemaphore (VkQueue queue, VkSemaphore semaphore) const
return m_vk.createEvent(device, pCreateInfo, pEvent);
}
-VkResult DeviceDriver::destroyEvent (VkDevice device, VkEvent event) const
+void DeviceDriver::destroyEvent (VkDevice device, VkEvent event) const
{
- return m_vk.destroyEvent(device, event);
+ m_vk.destroyEvent(device, event);
}
VkResult DeviceDriver::getEventStatus (VkDevice device, VkEvent event) const
return m_vk.createQueryPool(device, pCreateInfo, pQueryPool);
}
-VkResult DeviceDriver::destroyQueryPool (VkDevice device, VkQueryPool queryPool) const
+void DeviceDriver::destroyQueryPool (VkDevice device, VkQueryPool queryPool) const
{
- return m_vk.destroyQueryPool(device, queryPool);
+ m_vk.destroyQueryPool(device, queryPool);
}
VkResult DeviceDriver::getQueryPoolResults (VkDevice device, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, deUintptr* pDataSize, void* pData, VkQueryResultFlags flags) const
return m_vk.createBuffer(device, pCreateInfo, pBuffer);
}
-VkResult DeviceDriver::destroyBuffer (VkDevice device, VkBuffer buffer) const
+void DeviceDriver::destroyBuffer (VkDevice device, VkBuffer buffer) const
{
- return m_vk.destroyBuffer(device, buffer);
+ m_vk.destroyBuffer(device, buffer);
}
VkResult DeviceDriver::createBufferView (VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView) const
return m_vk.createBufferView(device, pCreateInfo, pView);
}
-VkResult DeviceDriver::destroyBufferView (VkDevice device, VkBufferView bufferView) const
+void DeviceDriver::destroyBufferView (VkDevice device, VkBufferView bufferView) const
{
- return m_vk.destroyBufferView(device, bufferView);
+ m_vk.destroyBufferView(device, bufferView);
}
VkResult DeviceDriver::createImage (VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage) const
return m_vk.createImage(device, pCreateInfo, pImage);
}
-VkResult DeviceDriver::destroyImage (VkDevice device, VkImage image) const
+void DeviceDriver::destroyImage (VkDevice device, VkImage image) const
{
- return m_vk.destroyImage(device, image);
+ m_vk.destroyImage(device, image);
}
VkResult DeviceDriver::getImageSubresourceLayout (VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) const
return m_vk.createImageView(device, pCreateInfo, pView);
}
-VkResult DeviceDriver::destroyImageView (VkDevice device, VkImageView imageView) const
-{
- return m_vk.destroyImageView(device, imageView);
-}
-
-VkResult DeviceDriver::createAttachmentView (VkDevice device, const VkAttachmentViewCreateInfo* pCreateInfo, VkAttachmentView* pView) const
+void DeviceDriver::destroyImageView (VkDevice device, VkImageView imageView) const
{
- return m_vk.createAttachmentView(device, pCreateInfo, pView);
-}
-
-VkResult DeviceDriver::destroyAttachmentView (VkDevice device, VkAttachmentView attachmentView) const
-{
- return m_vk.destroyAttachmentView(device, attachmentView);
+ m_vk.destroyImageView(device, imageView);
}
VkResult DeviceDriver::createShaderModule (VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule) const
return m_vk.createShaderModule(device, pCreateInfo, pShaderModule);
}
-VkResult DeviceDriver::destroyShaderModule (VkDevice device, VkShaderModule shaderModule) const
+void DeviceDriver::destroyShaderModule (VkDevice device, VkShaderModule shaderModule) const
{
- return m_vk.destroyShaderModule(device, shaderModule);
+ m_vk.destroyShaderModule(device, shaderModule);
}
VkResult DeviceDriver::createShader (VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader) const
return m_vk.createShader(device, pCreateInfo, pShader);
}
-VkResult DeviceDriver::destroyShader (VkDevice device, VkShader shader) const
+void DeviceDriver::destroyShader (VkDevice device, VkShader shader) const
{
- return m_vk.destroyShader(device, shader);
+ m_vk.destroyShader(device, shader);
}
VkResult DeviceDriver::createPipelineCache (VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache) const
return m_vk.createPipelineCache(device, pCreateInfo, pPipelineCache);
}
-VkResult DeviceDriver::destroyPipelineCache (VkDevice device, VkPipelineCache pipelineCache) const
+void DeviceDriver::destroyPipelineCache (VkDevice device, VkPipelineCache pipelineCache) const
{
- return m_vk.destroyPipelineCache(device, pipelineCache);
+ m_vk.destroyPipelineCache(device, pipelineCache);
}
deUintptr DeviceDriver::getPipelineCacheSize (VkDevice device, VkPipelineCache pipelineCache) const
return m_vk.createComputePipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
}
-VkResult DeviceDriver::destroyPipeline (VkDevice device, VkPipeline pipeline) const
+void DeviceDriver::destroyPipeline (VkDevice device, VkPipeline pipeline) const
{
- return m_vk.destroyPipeline(device, pipeline);
+ m_vk.destroyPipeline(device, pipeline);
}
VkResult DeviceDriver::createPipelineLayout (VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout) const
return m_vk.createPipelineLayout(device, pCreateInfo, pPipelineLayout);
}
-VkResult DeviceDriver::destroyPipelineLayout (VkDevice device, VkPipelineLayout pipelineLayout) const
+void DeviceDriver::destroyPipelineLayout (VkDevice device, VkPipelineLayout pipelineLayout) const
{
- return m_vk.destroyPipelineLayout(device, pipelineLayout);
+ m_vk.destroyPipelineLayout(device, pipelineLayout);
}
VkResult DeviceDriver::createSampler (VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) const
return m_vk.createSampler(device, pCreateInfo, pSampler);
}
-VkResult DeviceDriver::destroySampler (VkDevice device, VkSampler sampler) const
+void DeviceDriver::destroySampler (VkDevice device, VkSampler sampler) const
{
- return m_vk.destroySampler(device, sampler);
+ m_vk.destroySampler(device, sampler);
}
VkResult DeviceDriver::createDescriptorSetLayout (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout) const
return m_vk.createDescriptorSetLayout(device, pCreateInfo, pSetLayout);
}
-VkResult DeviceDriver::destroyDescriptorSetLayout (VkDevice device, VkDescriptorSetLayout descriptorSetLayout) const
+void DeviceDriver::destroyDescriptorSetLayout (VkDevice device, VkDescriptorSetLayout descriptorSetLayout) const
{
- return m_vk.destroyDescriptorSetLayout(device, descriptorSetLayout);
+ m_vk.destroyDescriptorSetLayout(device, descriptorSetLayout);
}
-VkResult DeviceDriver::createDescriptorPool (VkDevice device, VkDescriptorPoolUsage poolUsage, deUint32 maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) const
+VkResult DeviceDriver::createDescriptorPool (VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) const
{
- return m_vk.createDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool);
+ return m_vk.createDescriptorPool(device, pCreateInfo, pDescriptorPool);
}
-VkResult DeviceDriver::destroyDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool) const
+void DeviceDriver::destroyDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool) const
{
- return m_vk.destroyDescriptorPool(device, descriptorPool);
+ m_vk.destroyDescriptorPool(device, descriptorPool);
}
VkResult DeviceDriver::resetDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool) const
return m_vk.resetDescriptorPool(device, descriptorPool);
}
-VkResult DeviceDriver::allocDescriptorSets (VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, deUint32 count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, deUint32* pCount) const
+VkResult DeviceDriver::allocDescriptorSets (VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, deUint32 count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets) const
{
- return m_vk.allocDescriptorSets(device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount);
+ return m_vk.allocDescriptorSets(device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets);
}
VkResult DeviceDriver::freeDescriptorSets (VkDevice device, VkDescriptorPool descriptorPool, deUint32 count, const VkDescriptorSet* pDescriptorSets) const
return m_vk.freeDescriptorSets(device, descriptorPool, count, pDescriptorSets);
}
-VkResult DeviceDriver::updateDescriptorSets (VkDevice device, deUint32 writeCount, const VkWriteDescriptorSet* pDescriptorWrites, deUint32 copyCount, const VkCopyDescriptorSet* pDescriptorCopies) const
-{
- return m_vk.updateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies);
-}
-
-VkResult DeviceDriver::createDynamicViewportState (VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState) const
-{
- return m_vk.createDynamicViewportState(device, pCreateInfo, pState);
-}
-
-VkResult DeviceDriver::destroyDynamicViewportState (VkDevice device, VkDynamicViewportState dynamicViewportState) const
+void DeviceDriver::updateDescriptorSets (VkDevice device, deUint32 writeCount, const VkWriteDescriptorSet* pDescriptorWrites, deUint32 copyCount, const VkCopyDescriptorSet* pDescriptorCopies) const
{
- return m_vk.destroyDynamicViewportState(device, dynamicViewportState);
-}
-
-VkResult DeviceDriver::createDynamicRasterState (VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState) const
-{
- return m_vk.createDynamicRasterState(device, pCreateInfo, pState);
-}
-
-VkResult DeviceDriver::destroyDynamicRasterState (VkDevice device, VkDynamicRasterState dynamicRasterState) const
-{
- return m_vk.destroyDynamicRasterState(device, dynamicRasterState);
-}
-
-VkResult DeviceDriver::createDynamicColorBlendState (VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState) const
-{
- return m_vk.createDynamicColorBlendState(device, pCreateInfo, pState);
-}
-
-VkResult DeviceDriver::destroyDynamicColorBlendState (VkDevice device, VkDynamicColorBlendState dynamicColorBlendState) const
-{
- return m_vk.destroyDynamicColorBlendState(device, dynamicColorBlendState);
-}
-
-VkResult DeviceDriver::createDynamicDepthStencilState (VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, VkDynamicDepthStencilState* pState) const
-{
- return m_vk.createDynamicDepthStencilState(device, pCreateInfo, pState);
-}
-
-VkResult DeviceDriver::destroyDynamicDepthStencilState (VkDevice device, VkDynamicDepthStencilState dynamicDepthStencilState) const
-{
- return m_vk.destroyDynamicDepthStencilState(device, dynamicDepthStencilState);
+ m_vk.updateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies);
}
VkResult DeviceDriver::createFramebuffer (VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer) const
return m_vk.createFramebuffer(device, pCreateInfo, pFramebuffer);
}
-VkResult DeviceDriver::destroyFramebuffer (VkDevice device, VkFramebuffer framebuffer) const
+void DeviceDriver::destroyFramebuffer (VkDevice device, VkFramebuffer framebuffer) const
{
- return m_vk.destroyFramebuffer(device, framebuffer);
+ m_vk.destroyFramebuffer(device, framebuffer);
}
VkResult DeviceDriver::createRenderPass (VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass) const
return m_vk.createRenderPass(device, pCreateInfo, pRenderPass);
}
-VkResult DeviceDriver::destroyRenderPass (VkDevice device, VkRenderPass renderPass) const
+void DeviceDriver::destroyRenderPass (VkDevice device, VkRenderPass renderPass) const
{
- return m_vk.destroyRenderPass(device, renderPass);
+ m_vk.destroyRenderPass(device, renderPass);
}
VkResult DeviceDriver::getRenderAreaGranularity (VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) const
return m_vk.createCommandPool(device, pCreateInfo, pCmdPool);
}
-VkResult DeviceDriver::destroyCommandPool (VkDevice device, VkCmdPool cmdPool) const
+void DeviceDriver::destroyCommandPool (VkDevice device, VkCmdPool cmdPool) const
{
- return m_vk.destroyCommandPool(device, cmdPool);
+ m_vk.destroyCommandPool(device, cmdPool);
}
VkResult DeviceDriver::resetCommandPool (VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags) const
return m_vk.createCommandBuffer(device, pCreateInfo, pCmdBuffer);
}
-VkResult DeviceDriver::destroyCommandBuffer (VkDevice device, VkCmdBuffer commandBuffer) const
+void DeviceDriver::destroyCommandBuffer (VkDevice device, VkCmdBuffer commandBuffer) const
{
- return m_vk.destroyCommandBuffer(device, commandBuffer);
+ m_vk.destroyCommandBuffer(device, commandBuffer);
}
VkResult DeviceDriver::beginCommandBuffer (VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) const
m_vk.cmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
}
-void DeviceDriver::cmdBindDynamicViewportState (VkCmdBuffer cmdBuffer, VkDynamicViewportState dynamicViewportState) const
+void DeviceDriver::cmdSetViewport (VkCmdBuffer cmdBuffer, deUint32 viewportCount, const VkViewport* pViewports) const
+{
+ m_vk.cmdSetViewport(cmdBuffer, viewportCount, pViewports);
+}
+
+void DeviceDriver::cmdSetScissor (VkCmdBuffer cmdBuffer, deUint32 scissorCount, const VkRect2D* pScissors) const
+{
+ m_vk.cmdSetScissor(cmdBuffer, scissorCount, pScissors);
+}
+
+void DeviceDriver::cmdSetLineWidth (VkCmdBuffer cmdBuffer, float lineWidth) const
+{
+ m_vk.cmdSetLineWidth(cmdBuffer, lineWidth);
+}
+
+void DeviceDriver::cmdSetDepthBias (VkCmdBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias) const
+{
+ m_vk.cmdSetDepthBias(cmdBuffer, depthBias, depthBiasClamp, slopeScaledDepthBias);
+}
+
+void DeviceDriver::cmdSetBlendConstants (VkCmdBuffer cmdBuffer, const float blendConst) const
+{
+ m_vk.cmdSetBlendConstants(cmdBuffer, blendConst);
+}
+
+void DeviceDriver::cmdSetDepthBounds (VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds) const
{
- m_vk.cmdBindDynamicViewportState(cmdBuffer, dynamicViewportState);
+ m_vk.cmdSetDepthBounds(cmdBuffer, minDepthBounds, maxDepthBounds);
}
-void DeviceDriver::cmdBindDynamicRasterState (VkCmdBuffer cmdBuffer, VkDynamicRasterState dynamicRasterState) const
+void DeviceDriver::cmdSetStencilCompareMask (VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, deUint32 stencilCompareMask) const
{
- m_vk.cmdBindDynamicRasterState(cmdBuffer, dynamicRasterState);
+ m_vk.cmdSetStencilCompareMask(cmdBuffer, faceMask, stencilCompareMask);
}
-void DeviceDriver::cmdBindDynamicColorBlendState (VkCmdBuffer cmdBuffer, VkDynamicColorBlendState dynamicColorBlendState) const
+void DeviceDriver::cmdSetStencilWriteMask (VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, deUint32 stencilWriteMask) const
{
- m_vk.cmdBindDynamicColorBlendState(cmdBuffer, dynamicColorBlendState);
+ m_vk.cmdSetStencilWriteMask(cmdBuffer, faceMask, stencilWriteMask);
}
-void DeviceDriver::cmdBindDynamicDepthStencilState (VkCmdBuffer cmdBuffer, VkDynamicDepthStencilState dynamicDepthStencilState) const
+void DeviceDriver::cmdSetStencilReference (VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, deUint32 stencilReference) const
{
- m_vk.cmdBindDynamicDepthStencilState(cmdBuffer, dynamicDepthStencilState);
+ m_vk.cmdSetStencilReference(cmdBuffer, faceMask, stencilReference);
}
void DeviceDriver::cmdBindDescriptorSets (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 firstSet, deUint32 setCount, const VkDescriptorSet* pDescriptorSets, deUint32 dynamicOffsetCount, const deUint32* pDynamicOffsets) const
m_vk.cmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
}
-void DeviceDriver::cmdDraw (VkCmdBuffer cmdBuffer, deUint32 firstVertex, deUint32 vertexCount, deUint32 firstInstance, deUint32 instanceCount) const
+void DeviceDriver::cmdDraw (VkCmdBuffer cmdBuffer, deUint32 vertexCount, deUint32 instanceCount, deUint32 firstVertex, deUint32 firstInstance) const
{
- m_vk.cmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount);
+ m_vk.cmdDraw(cmdBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
}
-void DeviceDriver::cmdDrawIndexed (VkCmdBuffer cmdBuffer, deUint32 firstIndex, deUint32 indexCount, deInt32 vertexOffset, deUint32 firstInstance, deUint32 instanceCount) const
+void DeviceDriver::cmdDrawIndexed (VkCmdBuffer cmdBuffer, deUint32 indexCount, deUint32 instanceCount, deUint32 firstIndex, deInt32 vertexOffset, deUint32 firstInstance) const
{
- m_vk.cmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
+ m_vk.cmdDrawIndexed(cmdBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
}
void DeviceDriver::cmdDrawIndirect (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 count, deUint32 stride) const
m_vk.cmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges);
}
-void DeviceDriver::cmdClearDepthStencilImage (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, deUint32 stencil, deUint32 rangeCount, const VkImageSubresourceRange* pRanges) const
+void DeviceDriver::cmdClearDepthStencilImage (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, deUint32 rangeCount, const VkImageSubresourceRange* pRanges) const
{
- m_vk.cmdClearDepthStencilImage(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);
+ m_vk.cmdClearDepthStencilImage(cmdBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
}
void DeviceDriver::cmdClearColorAttachment (VkCmdBuffer cmdBuffer, deUint32 colorAttachment, VkImageLayout imageLayout, const VkClearColorValue* pColor, deUint32 rectCount, const VkRect3D* pRects) const
m_vk.cmdClearColorAttachment(cmdBuffer, colorAttachment, imageLayout, pColor, rectCount, pRects);
}
-void DeviceDriver::cmdClearDepthStencilAttachment (VkCmdBuffer cmdBuffer, VkImageAspectFlags imageAspectMask, VkImageLayout imageLayout, float depth, deUint32 stencil, deUint32 rectCount, const VkRect3D* pRects) const
+void DeviceDriver::cmdClearDepthStencilAttachment (VkCmdBuffer cmdBuffer, VkImageAspectFlags aspectMask, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, deUint32 rectCount, const VkRect3D* pRects) const
{
- m_vk.cmdClearDepthStencilAttachment(cmdBuffer, imageAspectMask, imageLayout, depth, stencil, rectCount, pRects);
+ m_vk.cmdClearDepthStencilAttachment(cmdBuffer, aspectMask, imageLayout, pDepthStencil, rectCount, pRects);
}
void DeviceDriver::cmdResolveImage (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageResolve* pRegions) const
* be lost! Modify the generating script instead.
*/
DestroyDeviceFunc destroyDevice;
-GetGlobalExtensionPropertiesFunc getGlobalExtensionProperties;
-GetPhysicalDeviceExtensionPropertiesFunc getPhysicalDeviceExtensionProperties;
-GetGlobalLayerPropertiesFunc getGlobalLayerProperties;
-GetPhysicalDeviceLayerPropertiesFunc getPhysicalDeviceLayerProperties;
GetDeviceQueueFunc getDeviceQueue;
QueueSubmitFunc queueSubmit;
QueueWaitIdleFunc queueWaitIdle;
GetImageSubresourceLayoutFunc getImageSubresourceLayout;
CreateImageViewFunc createImageView;
DestroyImageViewFunc destroyImageView;
-CreateAttachmentViewFunc createAttachmentView;
-DestroyAttachmentViewFunc destroyAttachmentView;
CreateShaderModuleFunc createShaderModule;
DestroyShaderModuleFunc destroyShaderModule;
CreateShaderFunc createShader;
AllocDescriptorSetsFunc allocDescriptorSets;
FreeDescriptorSetsFunc freeDescriptorSets;
UpdateDescriptorSetsFunc updateDescriptorSets;
-CreateDynamicViewportStateFunc createDynamicViewportState;
-DestroyDynamicViewportStateFunc destroyDynamicViewportState;
-CreateDynamicRasterStateFunc createDynamicRasterState;
-DestroyDynamicRasterStateFunc destroyDynamicRasterState;
-CreateDynamicColorBlendStateFunc createDynamicColorBlendState;
-DestroyDynamicColorBlendStateFunc destroyDynamicColorBlendState;
-CreateDynamicDepthStencilStateFunc createDynamicDepthStencilState;
-DestroyDynamicDepthStencilStateFunc destroyDynamicDepthStencilState;
CreateFramebufferFunc createFramebuffer;
DestroyFramebufferFunc destroyFramebuffer;
CreateRenderPassFunc createRenderPass;
EndCommandBufferFunc endCommandBuffer;
ResetCommandBufferFunc resetCommandBuffer;
CmdBindPipelineFunc cmdBindPipeline;
-CmdBindDynamicViewportStateFunc cmdBindDynamicViewportState;
-CmdBindDynamicRasterStateFunc cmdBindDynamicRasterState;
-CmdBindDynamicColorBlendStateFunc cmdBindDynamicColorBlendState;
-CmdBindDynamicDepthStencilStateFunc cmdBindDynamicDepthStencilState;
+CmdSetViewportFunc cmdSetViewport;
+CmdSetScissorFunc cmdSetScissor;
+CmdSetLineWidthFunc cmdSetLineWidth;
+CmdSetDepthBiasFunc cmdSetDepthBias;
+CmdSetBlendConstantsFunc cmdSetBlendConstants;
+CmdSetDepthBoundsFunc cmdSetDepthBounds;
+CmdSetStencilCompareMaskFunc cmdSetStencilCompareMask;
+CmdSetStencilWriteMaskFunc cmdSetStencilWriteMask;
+CmdSetStencilReferenceFunc cmdSetStencilReference;
CmdBindDescriptorSetsFunc cmdBindDescriptorSets;
CmdBindIndexBufferFunc cmdBindIndexBuffer;
CmdBindVertexBuffersFunc cmdBindVertexBuffers;
* be lost! Modify the generating script instead.
*/
typedef VK_APICALL VkResult (VK_APIENTRY* CreateInstanceFunc) (const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroyInstanceFunc) (VkInstance instance);
+typedef VK_APICALL void (VK_APIENTRY* DestroyInstanceFunc) (VkInstance instance);
typedef VK_APICALL VkResult (VK_APIENTRY* EnumeratePhysicalDevicesFunc) (VkInstance instance, deUint32* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
typedef VK_APICALL VkResult (VK_APIENTRY* GetPhysicalDeviceFeaturesFunc) (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
typedef VK_APICALL VkResult (VK_APIENTRY* GetPhysicalDeviceFormatPropertiesFunc) (VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
-typedef VK_APICALL VkResult (VK_APIENTRY* GetPhysicalDeviceImageFormatPropertiesFunc) (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageFormatProperties* pImageFormatProperties);
-typedef VK_APICALL VkResult (VK_APIENTRY* GetPhysicalDeviceLimitsFunc) (VkPhysicalDevice physicalDevice, VkPhysicalDeviceLimits* pLimits);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetPhysicalDeviceImageFormatPropertiesFunc) (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
typedef VK_APICALL VkResult (VK_APIENTRY* GetPhysicalDevicePropertiesFunc) (VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
-typedef VK_APICALL VkResult (VK_APIENTRY* GetPhysicalDeviceQueueCountFunc) (VkPhysicalDevice physicalDevice, deUint32* pCount);
-typedef VK_APICALL VkResult (VK_APIENTRY* GetPhysicalDeviceQueuePropertiesFunc) (VkPhysicalDevice physicalDevice, deUint32 count, VkPhysicalDeviceQueueProperties* pQueueProperties);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetPhysicalDeviceQueueFamilyPropertiesFunc) (VkPhysicalDevice physicalDevice, deUint32* pCount, VkQueueFamilyProperties* pQueueFamilyProperties);
typedef VK_APICALL VkResult (VK_APIENTRY* GetPhysicalDeviceMemoryPropertiesFunc) (VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
typedef VK_APICALL PFN_vkVoidFunction (VK_APIENTRY* GetInstanceProcAddrFunc) (VkInstance instance, const char* pName);
typedef VK_APICALL PFN_vkVoidFunction (VK_APIENTRY* GetDeviceProcAddrFunc) (VkDevice device, const char* pName);
typedef VK_APICALL VkResult (VK_APIENTRY* CreateDeviceFunc) (VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroyDeviceFunc) (VkDevice device);
-typedef VK_APICALL VkResult (VK_APIENTRY* GetGlobalExtensionPropertiesFunc) (const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties);
-typedef VK_APICALL VkResult (VK_APIENTRY* GetPhysicalDeviceExtensionPropertiesFunc) (VkPhysicalDevice physicalDevice, const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties);
-typedef VK_APICALL VkResult (VK_APIENTRY* GetGlobalLayerPropertiesFunc) (deUint32* pCount, VkLayerProperties* pProperties);
-typedef VK_APICALL VkResult (VK_APIENTRY* GetPhysicalDeviceLayerPropertiesFunc) (VkPhysicalDevice physicalDevice, deUint32* pCount, VkLayerProperties* pProperties);
+typedef VK_APICALL void (VK_APIENTRY* DestroyDeviceFunc) (VkDevice device);
+typedef VK_APICALL VkResult (VK_APIENTRY* EnumerateInstanceExtensionPropertiesFunc) (const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties);
+typedef VK_APICALL VkResult (VK_APIENTRY* EnumerateDeviceExtensionPropertiesFunc) (VkPhysicalDevice physicalDevice, const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties);
+typedef VK_APICALL VkResult (VK_APIENTRY* EnumerateInstanceLayerPropertiesFunc) (deUint32* pCount, VkLayerProperties* pProperties);
+typedef VK_APICALL VkResult (VK_APIENTRY* EnumerateDeviceLayerPropertiesFunc) (VkPhysicalDevice physicalDevice, deUint32* pCount, VkLayerProperties* pProperties);
typedef VK_APICALL VkResult (VK_APIENTRY* GetDeviceQueueFunc) (VkDevice device, deUint32 queueFamilyIndex, deUint32 queueIndex, VkQueue* pQueue);
typedef VK_APICALL VkResult (VK_APIENTRY* QueueSubmitFunc) (VkQueue queue, deUint32 cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence);
typedef VK_APICALL VkResult (VK_APIENTRY* QueueWaitIdleFunc) (VkQueue queue);
typedef VK_APICALL VkResult (VK_APIENTRY* DeviceWaitIdleFunc) (VkDevice device);
typedef VK_APICALL VkResult (VK_APIENTRY* AllocMemoryFunc) (VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem);
-typedef VK_APICALL VkResult (VK_APIENTRY* FreeMemoryFunc) (VkDevice device, VkDeviceMemory mem);
+typedef VK_APICALL void (VK_APIENTRY* FreeMemoryFunc) (VkDevice device, VkDeviceMemory mem);
typedef VK_APICALL VkResult (VK_APIENTRY* MapMemoryFunc) (VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
-typedef VK_APICALL VkResult (VK_APIENTRY* UnmapMemoryFunc) (VkDevice device, VkDeviceMemory mem);
+typedef VK_APICALL void (VK_APIENTRY* UnmapMemoryFunc) (VkDevice device, VkDeviceMemory mem);
typedef VK_APICALL VkResult (VK_APIENTRY* FlushMappedMemoryRangesFunc) (VkDevice device, deUint32 memRangeCount, const VkMappedMemoryRange* pMemRanges);
typedef VK_APICALL VkResult (VK_APIENTRY* InvalidateMappedMemoryRangesFunc) (VkDevice device, deUint32 memRangeCount, const VkMappedMemoryRange* pMemRanges);
typedef VK_APICALL VkResult (VK_APIENTRY* GetDeviceMemoryCommitmentFunc) (VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
typedef VK_APICALL VkResult (VK_APIENTRY* QueueBindSparseImageOpaqueMemoryFunc) (VkQueue queue, VkImage image, deUint32 numBindings, const VkSparseMemoryBindInfo* pBindInfo);
typedef VK_APICALL VkResult (VK_APIENTRY* QueueBindSparseImageMemoryFunc) (VkQueue queue, VkImage image, deUint32 numBindings, const VkSparseImageMemoryBindInfo* pBindInfo);
typedef VK_APICALL VkResult (VK_APIENTRY* CreateFenceFunc) (VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroyFenceFunc) (VkDevice device, VkFence fence);
+typedef VK_APICALL void (VK_APIENTRY* DestroyFenceFunc) (VkDevice device, VkFence fence);
typedef VK_APICALL VkResult (VK_APIENTRY* ResetFencesFunc) (VkDevice device, deUint32 fenceCount, const VkFence* pFences);
typedef VK_APICALL VkResult (VK_APIENTRY* GetFenceStatusFunc) (VkDevice device, VkFence fence);
typedef VK_APICALL VkResult (VK_APIENTRY* WaitForFencesFunc) (VkDevice device, deUint32 fenceCount, const VkFence* pFences, VkBool32 waitAll, deUint64 timeout);
typedef VK_APICALL VkResult (VK_APIENTRY* CreateSemaphoreFunc) (VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroySemaphoreFunc) (VkDevice device, VkSemaphore semaphore);
+typedef VK_APICALL void (VK_APIENTRY* DestroySemaphoreFunc) (VkDevice device, VkSemaphore semaphore);
typedef VK_APICALL VkResult (VK_APIENTRY* QueueSignalSemaphoreFunc) (VkQueue queue, VkSemaphore semaphore);
typedef VK_APICALL VkResult (VK_APIENTRY* QueueWaitSemaphoreFunc) (VkQueue queue, VkSemaphore semaphore);
typedef VK_APICALL VkResult (VK_APIENTRY* CreateEventFunc) (VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroyEventFunc) (VkDevice device, VkEvent event);
+typedef VK_APICALL void (VK_APIENTRY* DestroyEventFunc) (VkDevice device, VkEvent event);
typedef VK_APICALL VkResult (VK_APIENTRY* GetEventStatusFunc) (VkDevice device, VkEvent event);
typedef VK_APICALL VkResult (VK_APIENTRY* SetEventFunc) (VkDevice device, VkEvent event);
typedef VK_APICALL VkResult (VK_APIENTRY* ResetEventFunc) (VkDevice device, VkEvent event);
typedef VK_APICALL VkResult (VK_APIENTRY* CreateQueryPoolFunc) (VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroyQueryPoolFunc) (VkDevice device, VkQueryPool queryPool);
+typedef VK_APICALL void (VK_APIENTRY* DestroyQueryPoolFunc) (VkDevice device, VkQueryPool queryPool);
typedef VK_APICALL VkResult (VK_APIENTRY* GetQueryPoolResultsFunc) (VkDevice device, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, deUintptr* pDataSize, void* pData, VkQueryResultFlags flags);
typedef VK_APICALL VkResult (VK_APIENTRY* CreateBufferFunc) (VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroyBufferFunc) (VkDevice device, VkBuffer buffer);
+typedef VK_APICALL void (VK_APIENTRY* DestroyBufferFunc) (VkDevice device, VkBuffer buffer);
typedef VK_APICALL VkResult (VK_APIENTRY* CreateBufferViewFunc) (VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroyBufferViewFunc) (VkDevice device, VkBufferView bufferView);
+typedef VK_APICALL void (VK_APIENTRY* DestroyBufferViewFunc) (VkDevice device, VkBufferView bufferView);
typedef VK_APICALL VkResult (VK_APIENTRY* CreateImageFunc) (VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroyImageFunc) (VkDevice device, VkImage image);
+typedef VK_APICALL void (VK_APIENTRY* DestroyImageFunc) (VkDevice device, VkImage image);
typedef VK_APICALL VkResult (VK_APIENTRY* GetImageSubresourceLayoutFunc) (VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
typedef VK_APICALL VkResult (VK_APIENTRY* CreateImageViewFunc) (VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroyImageViewFunc) (VkDevice device, VkImageView imageView);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateAttachmentViewFunc) (VkDevice device, const VkAttachmentViewCreateInfo* pCreateInfo, VkAttachmentView* pView);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroyAttachmentViewFunc) (VkDevice device, VkAttachmentView attachmentView);
+typedef VK_APICALL void (VK_APIENTRY* DestroyImageViewFunc) (VkDevice device, VkImageView imageView);
typedef VK_APICALL VkResult (VK_APIENTRY* CreateShaderModuleFunc) (VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroyShaderModuleFunc) (VkDevice device, VkShaderModule shaderModule);
+typedef VK_APICALL void (VK_APIENTRY* DestroyShaderModuleFunc) (VkDevice device, VkShaderModule shaderModule);
typedef VK_APICALL VkResult (VK_APIENTRY* CreateShaderFunc) (VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroyShaderFunc) (VkDevice device, VkShader shader);
+typedef VK_APICALL void (VK_APIENTRY* DestroyShaderFunc) (VkDevice device, VkShader shader);
typedef VK_APICALL VkResult (VK_APIENTRY* CreatePipelineCacheFunc) (VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroyPipelineCacheFunc) (VkDevice device, VkPipelineCache pipelineCache);
+typedef VK_APICALL void (VK_APIENTRY* DestroyPipelineCacheFunc) (VkDevice device, VkPipelineCache pipelineCache);
typedef VK_APICALL deUintptr (VK_APIENTRY* GetPipelineCacheSizeFunc) (VkDevice device, VkPipelineCache pipelineCache);
typedef VK_APICALL VkResult (VK_APIENTRY* GetPipelineCacheDataFunc) (VkDevice device, VkPipelineCache pipelineCache, void* pData);
typedef VK_APICALL VkResult (VK_APIENTRY* MergePipelineCachesFunc) (VkDevice device, VkPipelineCache destCache, deUint32 srcCacheCount, const VkPipelineCache* pSrcCaches);
typedef VK_APICALL VkResult (VK_APIENTRY* CreateGraphicsPipelinesFunc) (VkDevice device, VkPipelineCache pipelineCache, deUint32 count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
typedef VK_APICALL VkResult (VK_APIENTRY* CreateComputePipelinesFunc) (VkDevice device, VkPipelineCache pipelineCache, deUint32 count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroyPipelineFunc) (VkDevice device, VkPipeline pipeline);
+typedef VK_APICALL void (VK_APIENTRY* DestroyPipelineFunc) (VkDevice device, VkPipeline pipeline);
typedef VK_APICALL VkResult (VK_APIENTRY* CreatePipelineLayoutFunc) (VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroyPipelineLayoutFunc) (VkDevice device, VkPipelineLayout pipelineLayout);
+typedef VK_APICALL void (VK_APIENTRY* DestroyPipelineLayoutFunc) (VkDevice device, VkPipelineLayout pipelineLayout);
typedef VK_APICALL VkResult (VK_APIENTRY* CreateSamplerFunc) (VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroySamplerFunc) (VkDevice device, VkSampler sampler);
+typedef VK_APICALL void (VK_APIENTRY* DestroySamplerFunc) (VkDevice device, VkSampler sampler);
typedef VK_APICALL VkResult (VK_APIENTRY* CreateDescriptorSetLayoutFunc) (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroyDescriptorSetLayoutFunc) (VkDevice device, VkDescriptorSetLayout descriptorSetLayout);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateDescriptorPoolFunc) (VkDevice device, VkDescriptorPoolUsage poolUsage, deUint32 maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroyDescriptorPoolFunc) (VkDevice device, VkDescriptorPool descriptorPool);
+typedef VK_APICALL void (VK_APIENTRY* DestroyDescriptorSetLayoutFunc) (VkDevice device, VkDescriptorSetLayout descriptorSetLayout);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateDescriptorPoolFunc) (VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool);
+typedef VK_APICALL void (VK_APIENTRY* DestroyDescriptorPoolFunc) (VkDevice device, VkDescriptorPool descriptorPool);
typedef VK_APICALL VkResult (VK_APIENTRY* ResetDescriptorPoolFunc) (VkDevice device, VkDescriptorPool descriptorPool);
-typedef VK_APICALL VkResult (VK_APIENTRY* AllocDescriptorSetsFunc) (VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, deUint32 count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, deUint32* pCount);
+typedef VK_APICALL VkResult (VK_APIENTRY* AllocDescriptorSetsFunc) (VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, deUint32 count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets);
typedef VK_APICALL VkResult (VK_APIENTRY* FreeDescriptorSetsFunc) (VkDevice device, VkDescriptorPool descriptorPool, deUint32 count, const VkDescriptorSet* pDescriptorSets);
-typedef VK_APICALL VkResult (VK_APIENTRY* UpdateDescriptorSetsFunc) (VkDevice device, deUint32 writeCount, const VkWriteDescriptorSet* pDescriptorWrites, deUint32 copyCount, const VkCopyDescriptorSet* pDescriptorCopies);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateDynamicViewportStateFunc) (VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroyDynamicViewportStateFunc) (VkDevice device, VkDynamicViewportState dynamicViewportState);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateDynamicRasterStateFunc) (VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroyDynamicRasterStateFunc) (VkDevice device, VkDynamicRasterState dynamicRasterState);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateDynamicColorBlendStateFunc) (VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroyDynamicColorBlendStateFunc) (VkDevice device, VkDynamicColorBlendState dynamicColorBlendState);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateDynamicDepthStencilStateFunc) (VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, VkDynamicDepthStencilState* pState);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroyDynamicDepthStencilStateFunc) (VkDevice device, VkDynamicDepthStencilState dynamicDepthStencilState);
+typedef VK_APICALL void (VK_APIENTRY* UpdateDescriptorSetsFunc) (VkDevice device, deUint32 writeCount, const VkWriteDescriptorSet* pDescriptorWrites, deUint32 copyCount, const VkCopyDescriptorSet* pDescriptorCopies);
typedef VK_APICALL VkResult (VK_APIENTRY* CreateFramebufferFunc) (VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroyFramebufferFunc) (VkDevice device, VkFramebuffer framebuffer);
+typedef VK_APICALL void (VK_APIENTRY* DestroyFramebufferFunc) (VkDevice device, VkFramebuffer framebuffer);
typedef VK_APICALL VkResult (VK_APIENTRY* CreateRenderPassFunc) (VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroyRenderPassFunc) (VkDevice device, VkRenderPass renderPass);
+typedef VK_APICALL void (VK_APIENTRY* DestroyRenderPassFunc) (VkDevice device, VkRenderPass renderPass);
typedef VK_APICALL VkResult (VK_APIENTRY* GetRenderAreaGranularityFunc) (VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
typedef VK_APICALL VkResult (VK_APIENTRY* CreateCommandPoolFunc) (VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroyCommandPoolFunc) (VkDevice device, VkCmdPool cmdPool);
+typedef VK_APICALL void (VK_APIENTRY* DestroyCommandPoolFunc) (VkDevice device, VkCmdPool cmdPool);
typedef VK_APICALL VkResult (VK_APIENTRY* ResetCommandPoolFunc) (VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags);
typedef VK_APICALL VkResult (VK_APIENTRY* CreateCommandBufferFunc) (VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroyCommandBufferFunc) (VkDevice device, VkCmdBuffer commandBuffer);
+typedef VK_APICALL void (VK_APIENTRY* DestroyCommandBufferFunc) (VkDevice device, VkCmdBuffer commandBuffer);
typedef VK_APICALL VkResult (VK_APIENTRY* BeginCommandBufferFunc) (VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo);
typedef VK_APICALL VkResult (VK_APIENTRY* EndCommandBufferFunc) (VkCmdBuffer cmdBuffer);
typedef VK_APICALL VkResult (VK_APIENTRY* ResetCommandBufferFunc) (VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags);
typedef VK_APICALL void (VK_APIENTRY* CmdBindPipelineFunc) (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
-typedef VK_APICALL void (VK_APIENTRY* CmdBindDynamicViewportStateFunc) (VkCmdBuffer cmdBuffer, VkDynamicViewportState dynamicViewportState);
-typedef VK_APICALL void (VK_APIENTRY* CmdBindDynamicRasterStateFunc) (VkCmdBuffer cmdBuffer, VkDynamicRasterState dynamicRasterState);
-typedef VK_APICALL void (VK_APIENTRY* CmdBindDynamicColorBlendStateFunc) (VkCmdBuffer cmdBuffer, VkDynamicColorBlendState dynamicColorBlendState);
-typedef VK_APICALL void (VK_APIENTRY* CmdBindDynamicDepthStencilStateFunc) (VkCmdBuffer cmdBuffer, VkDynamicDepthStencilState dynamicDepthStencilState);
+typedef VK_APICALL void (VK_APIENTRY* CmdSetViewportFunc) (VkCmdBuffer cmdBuffer, deUint32 viewportCount, const VkViewport* pViewports);
+typedef VK_APICALL void (VK_APIENTRY* CmdSetScissorFunc) (VkCmdBuffer cmdBuffer, deUint32 scissorCount, const VkRect2D* pScissors);
+typedef VK_APICALL void (VK_APIENTRY* CmdSetLineWidthFunc) (VkCmdBuffer cmdBuffer, float lineWidth);
+typedef VK_APICALL void (VK_APIENTRY* CmdSetDepthBiasFunc) (VkCmdBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias);
+typedef VK_APICALL void (VK_APIENTRY* CmdSetBlendConstantsFunc) (VkCmdBuffer cmdBuffer, const float blendConst);
+typedef VK_APICALL void (VK_APIENTRY* CmdSetDepthBoundsFunc) (VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds);
+typedef VK_APICALL void (VK_APIENTRY* CmdSetStencilCompareMaskFunc) (VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, deUint32 stencilCompareMask);
+typedef VK_APICALL void (VK_APIENTRY* CmdSetStencilWriteMaskFunc) (VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, deUint32 stencilWriteMask);
+typedef VK_APICALL void (VK_APIENTRY* CmdSetStencilReferenceFunc) (VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, deUint32 stencilReference);
typedef VK_APICALL void (VK_APIENTRY* CmdBindDescriptorSetsFunc) (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 firstSet, deUint32 setCount, const VkDescriptorSet* pDescriptorSets, deUint32 dynamicOffsetCount, const deUint32* pDynamicOffsets);
typedef VK_APICALL void (VK_APIENTRY* CmdBindIndexBufferFunc) (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
typedef VK_APICALL void (VK_APIENTRY* CmdBindVertexBuffersFunc) (VkCmdBuffer cmdBuffer, deUint32 startBinding, deUint32 bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
-typedef VK_APICALL void (VK_APIENTRY* CmdDrawFunc) (VkCmdBuffer cmdBuffer, deUint32 firstVertex, deUint32 vertexCount, deUint32 firstInstance, deUint32 instanceCount);
-typedef VK_APICALL void (VK_APIENTRY* CmdDrawIndexedFunc) (VkCmdBuffer cmdBuffer, deUint32 firstIndex, deUint32 indexCount, deInt32 vertexOffset, deUint32 firstInstance, deUint32 instanceCount);
+typedef VK_APICALL void (VK_APIENTRY* CmdDrawFunc) (VkCmdBuffer cmdBuffer, deUint32 vertexCount, deUint32 instanceCount, deUint32 firstVertex, deUint32 firstInstance);
+typedef VK_APICALL void (VK_APIENTRY* CmdDrawIndexedFunc) (VkCmdBuffer cmdBuffer, deUint32 indexCount, deUint32 instanceCount, deUint32 firstIndex, deInt32 vertexOffset, deUint32 firstInstance);
typedef VK_APICALL void (VK_APIENTRY* CmdDrawIndirectFunc) (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 count, deUint32 stride);
typedef VK_APICALL void (VK_APIENTRY* CmdDrawIndexedIndirectFunc) (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 count, deUint32 stride);
typedef VK_APICALL void (VK_APIENTRY* CmdDispatchFunc) (VkCmdBuffer cmdBuffer, deUint32 x, deUint32 y, deUint32 z);
typedef VK_APICALL void (VK_APIENTRY* CmdUpdateBufferFunc) (VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const deUint32* pData);
typedef VK_APICALL void (VK_APIENTRY* CmdFillBufferFunc) (VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, deUint32 data);
typedef VK_APICALL void (VK_APIENTRY* CmdClearColorImageFunc) (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, deUint32 rangeCount, const VkImageSubresourceRange* pRanges);
-typedef VK_APICALL void (VK_APIENTRY* CmdClearDepthStencilImageFunc) (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, deUint32 stencil, deUint32 rangeCount, const VkImageSubresourceRange* pRanges);
+typedef VK_APICALL void (VK_APIENTRY* CmdClearDepthStencilImageFunc) (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, deUint32 rangeCount, const VkImageSubresourceRange* pRanges);
typedef VK_APICALL void (VK_APIENTRY* CmdClearColorAttachmentFunc) (VkCmdBuffer cmdBuffer, deUint32 colorAttachment, VkImageLayout imageLayout, const VkClearColorValue* pColor, deUint32 rectCount, const VkRect3D* pRects);
-typedef VK_APICALL void (VK_APIENTRY* CmdClearDepthStencilAttachmentFunc) (VkCmdBuffer cmdBuffer, VkImageAspectFlags imageAspectMask, VkImageLayout imageLayout, float depth, deUint32 stencil, deUint32 rectCount, const VkRect3D* pRects);
+typedef VK_APICALL void (VK_APIENTRY* CmdClearDepthStencilAttachmentFunc) (VkCmdBuffer cmdBuffer, VkImageAspectFlags aspectMask, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, deUint32 rectCount, const VkRect3D* pRects);
typedef VK_APICALL void (VK_APIENTRY* CmdResolveImageFunc) (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageResolve* pRegions);
typedef VK_APICALL void (VK_APIENTRY* CmdSetEventFunc) (VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
typedef VK_APICALL void (VK_APIENTRY* CmdResetEventFunc) (VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
HANDLE_TYPE_QUERY_POOL,
HANDLE_TYPE_BUFFER_VIEW,
HANDLE_TYPE_IMAGE_VIEW,
- HANDLE_TYPE_ATTACHMENT_VIEW,
HANDLE_TYPE_SHADER_MODULE,
HANDLE_TYPE_SHADER,
HANDLE_TYPE_PIPELINE_CACHE,
HANDLE_TYPE_SAMPLER,
HANDLE_TYPE_DESCRIPTOR_POOL,
HANDLE_TYPE_DESCRIPTOR_SET,
- HANDLE_TYPE_DYNAMIC_VIEWPORT_STATE,
- HANDLE_TYPE_DYNAMIC_RASTER_STATE,
- HANDLE_TYPE_DYNAMIC_COLOR_BLEND_STATE,
- HANDLE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE,
HANDLE_TYPE_FRAMEBUFFER,
HANDLE_TYPE_CMD_POOL,
HANDLE_TYPE_LAST
case FMT_CASE(RGB, UNSIGNED_INT_999_E5_REV): return VK_FORMAT_R9G9B9E5_UFLOAT;
case FMT_CASE(D, UNORM_INT16): return VK_FORMAT_D16_UNORM;
- case FMT_CASE(D, UNORM_INT24): return VK_FORMAT_D24_UNORM;
+ case FMT_CASE(D, UNSIGNED_INT_24_8): return VK_FORMAT_D24_UNORM_X8;
case FMT_CASE(D, FLOAT): return VK_FORMAT_D32_SFLOAT;
case FMT_CASE(S, UNSIGNED_INT8): return VK_FORMAT_S8_UINT;
- case FMT_CASE(DS, FLOAT_UNSIGNED_INT_24_8_REV): return VK_FORMAT_D24_UNORM_S8_UINT;
+ case FMT_CASE(DS, UNSIGNED_INT_24_8): return VK_FORMAT_D24_UNORM_S8_UINT;
case FMT_CASE(BGRA, UNORM_SHORT_4444): return VK_FORMAT_B4G4R4A4_UNORM;
case FMT_CASE(BGRA, UNORM_SHORT_5551): return VK_FORMAT_B5G5R5A1_UNORM;
case VK_FORMAT_R9G9B9E5_UFLOAT: return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT_999_E5_REV);
case VK_FORMAT_D16_UNORM: return TextureFormat(TextureFormat::D, TextureFormat::UNORM_INT16);
- case VK_FORMAT_D24_UNORM: return TextureFormat(TextureFormat::D, TextureFormat::UNORM_INT24);
+ case VK_FORMAT_D24_UNORM_X8: return TextureFormat(TextureFormat::D, TextureFormat::UNSIGNED_INT_24_8);
case VK_FORMAT_D32_SFLOAT: return TextureFormat(TextureFormat::D, TextureFormat::FLOAT);
case VK_FORMAT_S8_UINT: return TextureFormat(TextureFormat::S, TextureFormat::UNSIGNED_INT8);
-
+
// \note There is no standard interleaved memory layout for DS formats; buffer-image copies
// will always operate on either D or S aspect only. See Khronos bug 12998
case VK_FORMAT_D16_UNORM_S8_UINT: return TextureFormat(TextureFormat::DS, TextureFormat::UNSIGNED_INT_16_8);
* be lost! Modify the generating script instead.
*/
m_vk.destroyDevice = (DestroyDeviceFunc) GET_PROC_ADDR("vkDestroyDevice");
-m_vk.getGlobalExtensionProperties = (GetGlobalExtensionPropertiesFunc) GET_PROC_ADDR("vkGetGlobalExtensionProperties");
-m_vk.getPhysicalDeviceExtensionProperties = (GetPhysicalDeviceExtensionPropertiesFunc) GET_PROC_ADDR("vkGetPhysicalDeviceExtensionProperties");
-m_vk.getGlobalLayerProperties = (GetGlobalLayerPropertiesFunc) GET_PROC_ADDR("vkGetGlobalLayerProperties");
-m_vk.getPhysicalDeviceLayerProperties = (GetPhysicalDeviceLayerPropertiesFunc) GET_PROC_ADDR("vkGetPhysicalDeviceLayerProperties");
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.getImageSubresourceLayout = (GetImageSubresourceLayoutFunc) GET_PROC_ADDR("vkGetImageSubresourceLayout");
m_vk.createImageView = (CreateImageViewFunc) GET_PROC_ADDR("vkCreateImageView");
m_vk.destroyImageView = (DestroyImageViewFunc) GET_PROC_ADDR("vkDestroyImageView");
-m_vk.createAttachmentView = (CreateAttachmentViewFunc) GET_PROC_ADDR("vkCreateAttachmentView");
-m_vk.destroyAttachmentView = (DestroyAttachmentViewFunc) GET_PROC_ADDR("vkDestroyAttachmentView");
m_vk.createShaderModule = (CreateShaderModuleFunc) GET_PROC_ADDR("vkCreateShaderModule");
m_vk.destroyShaderModule = (DestroyShaderModuleFunc) GET_PROC_ADDR("vkDestroyShaderModule");
m_vk.createShader = (CreateShaderFunc) GET_PROC_ADDR("vkCreateShader");
m_vk.allocDescriptorSets = (AllocDescriptorSetsFunc) GET_PROC_ADDR("vkAllocDescriptorSets");
m_vk.freeDescriptorSets = (FreeDescriptorSetsFunc) GET_PROC_ADDR("vkFreeDescriptorSets");
m_vk.updateDescriptorSets = (UpdateDescriptorSetsFunc) GET_PROC_ADDR("vkUpdateDescriptorSets");
-m_vk.createDynamicViewportState = (CreateDynamicViewportStateFunc) GET_PROC_ADDR("vkCreateDynamicViewportState");
-m_vk.destroyDynamicViewportState = (DestroyDynamicViewportStateFunc) GET_PROC_ADDR("vkDestroyDynamicViewportState");
-m_vk.createDynamicRasterState = (CreateDynamicRasterStateFunc) GET_PROC_ADDR("vkCreateDynamicRasterState");
-m_vk.destroyDynamicRasterState = (DestroyDynamicRasterStateFunc) GET_PROC_ADDR("vkDestroyDynamicRasterState");
-m_vk.createDynamicColorBlendState = (CreateDynamicColorBlendStateFunc) GET_PROC_ADDR("vkCreateDynamicColorBlendState");
-m_vk.destroyDynamicColorBlendState = (DestroyDynamicColorBlendStateFunc) GET_PROC_ADDR("vkDestroyDynamicColorBlendState");
-m_vk.createDynamicDepthStencilState = (CreateDynamicDepthStencilStateFunc) GET_PROC_ADDR("vkCreateDynamicDepthStencilState");
-m_vk.destroyDynamicDepthStencilState = (DestroyDynamicDepthStencilStateFunc) GET_PROC_ADDR("vkDestroyDynamicDepthStencilState");
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.endCommandBuffer = (EndCommandBufferFunc) GET_PROC_ADDR("vkEndCommandBuffer");
m_vk.resetCommandBuffer = (ResetCommandBufferFunc) GET_PROC_ADDR("vkResetCommandBuffer");
m_vk.cmdBindPipeline = (CmdBindPipelineFunc) GET_PROC_ADDR("vkCmdBindPipeline");
-m_vk.cmdBindDynamicViewportState = (CmdBindDynamicViewportStateFunc) GET_PROC_ADDR("vkCmdBindDynamicViewportState");
-m_vk.cmdBindDynamicRasterState = (CmdBindDynamicRasterStateFunc) GET_PROC_ADDR("vkCmdBindDynamicRasterState");
-m_vk.cmdBindDynamicColorBlendState = (CmdBindDynamicColorBlendStateFunc) GET_PROC_ADDR("vkCmdBindDynamicColorBlendState");
-m_vk.cmdBindDynamicDepthStencilState = (CmdBindDynamicDepthStencilStateFunc) GET_PROC_ADDR("vkCmdBindDynamicDepthStencilState");
+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.getPhysicalDeviceFeatures = (GetPhysicalDeviceFeaturesFunc) GET_PROC_ADDR("vkGetPhysicalDeviceFeatures");
m_vk.getPhysicalDeviceFormatProperties = (GetPhysicalDeviceFormatPropertiesFunc) GET_PROC_ADDR("vkGetPhysicalDeviceFormatProperties");
m_vk.getPhysicalDeviceImageFormatProperties = (GetPhysicalDeviceImageFormatPropertiesFunc) GET_PROC_ADDR("vkGetPhysicalDeviceImageFormatProperties");
-m_vk.getPhysicalDeviceLimits = (GetPhysicalDeviceLimitsFunc) GET_PROC_ADDR("vkGetPhysicalDeviceLimits");
m_vk.getPhysicalDeviceProperties = (GetPhysicalDevicePropertiesFunc) GET_PROC_ADDR("vkGetPhysicalDeviceProperties");
-m_vk.getPhysicalDeviceQueueCount = (GetPhysicalDeviceQueueCountFunc) GET_PROC_ADDR("vkGetPhysicalDeviceQueueCount");
-m_vk.getPhysicalDeviceQueueProperties = (GetPhysicalDeviceQueuePropertiesFunc) GET_PROC_ADDR("vkGetPhysicalDeviceQueueProperties");
+m_vk.getPhysicalDeviceQueueFamilyProperties = (GetPhysicalDeviceQueueFamilyPropertiesFunc) GET_PROC_ADDR("vkGetPhysicalDeviceQueueFamilyProperties");
m_vk.getPhysicalDeviceMemoryProperties = (GetPhysicalDeviceMemoryPropertiesFunc) GET_PROC_ADDR("vkGetPhysicalDeviceMemoryProperties");
m_vk.getDeviceProcAddr = (GetDeviceProcAddrFunc) GET_PROC_ADDR("vkGetDeviceProcAddr");
m_vk.createDevice = (CreateDeviceFunc) GET_PROC_ADDR("vkCreateDevice");
+m_vk.enumerateDeviceExtensionProperties = (EnumerateDeviceExtensionPropertiesFunc) GET_PROC_ADDR("vkEnumerateDeviceExtensionProperties");
+m_vk.enumerateDeviceLayerProperties = (EnumerateDeviceLayerPropertiesFunc) GET_PROC_ADDR("vkEnumerateDeviceLayerProperties");
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-m_vk.createInstance = (CreateInstanceFunc) GET_PROC_ADDR("vkCreateInstance");
-m_vk.getInstanceProcAddr = (GetInstanceProcAddrFunc) GET_PROC_ADDR("vkGetInstanceProcAddr");
+m_vk.createInstance = (CreateInstanceFunc) GET_PROC_ADDR("vkCreateInstance");
+m_vk.getInstanceProcAddr = (GetInstanceProcAddrFunc) GET_PROC_ADDR("vkGetInstanceProcAddr");
+m_vk.enumerateInstanceExtensionProperties = (EnumerateInstanceExtensionPropertiesFunc) GET_PROC_ADDR("vkEnumerateInstanceExtensionProperties");
+m_vk.enumerateInstanceLayerProperties = (EnumerateInstanceLayerPropertiesFunc) GET_PROC_ADDR("vkEnumerateInstanceLayerProperties");
* be lost! Modify the generating script instead.
*/
-VkResult InstanceDriver::destroyInstance (VkInstance instance) const
+void InstanceDriver::destroyInstance (VkInstance instance) const
{
- return m_vk.destroyInstance(instance);
+ m_vk.destroyInstance(instance);
}
VkResult InstanceDriver::enumeratePhysicalDevices (VkInstance instance, deUint32* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) const
return m_vk.getPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
}
-VkResult InstanceDriver::getPhysicalDeviceImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageFormatProperties* pImageFormatProperties) const
+VkResult InstanceDriver::getPhysicalDeviceImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) const
{
- return m_vk.getPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, pImageFormatProperties);
-}
-
-VkResult InstanceDriver::getPhysicalDeviceLimits (VkPhysicalDevice physicalDevice, VkPhysicalDeviceLimits* pLimits) const
-{
- return m_vk.getPhysicalDeviceLimits(physicalDevice, pLimits);
+ return m_vk.getPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
}
VkResult InstanceDriver::getPhysicalDeviceProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) const
return m_vk.getPhysicalDeviceProperties(physicalDevice, pProperties);
}
-VkResult InstanceDriver::getPhysicalDeviceQueueCount (VkPhysicalDevice physicalDevice, deUint32* pCount) const
-{
- return m_vk.getPhysicalDeviceQueueCount(physicalDevice, pCount);
-}
-
-VkResult InstanceDriver::getPhysicalDeviceQueueProperties (VkPhysicalDevice physicalDevice, deUint32 count, VkPhysicalDeviceQueueProperties* pQueueProperties) const
+VkResult InstanceDriver::getPhysicalDeviceQueueFamilyProperties (VkPhysicalDevice physicalDevice, deUint32* pCount, VkQueueFamilyProperties* pQueueFamilyProperties) const
{
- return m_vk.getPhysicalDeviceQueueProperties(physicalDevice, count, pQueueProperties);
+ return m_vk.getPhysicalDeviceQueueFamilyProperties(physicalDevice, pCount, pQueueFamilyProperties);
}
VkResult InstanceDriver::getPhysicalDeviceMemoryProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) const
{
return m_vk.createDevice(physicalDevice, pCreateInfo, pDevice);
}
+
+VkResult InstanceDriver::enumerateDeviceExtensionProperties (VkPhysicalDevice physicalDevice, const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties) const
+{
+ return m_vk.enumerateDeviceExtensionProperties(physicalDevice, pLayerName, pCount, pProperties);
+}
+
+VkResult InstanceDriver::enumerateDeviceLayerProperties (VkPhysicalDevice physicalDevice, deUint32* pCount, VkLayerProperties* pProperties) const
+{
+ return m_vk.enumerateDeviceLayerProperties(physicalDevice, pCount, pProperties);
+}
GetPhysicalDeviceFeaturesFunc getPhysicalDeviceFeatures;
GetPhysicalDeviceFormatPropertiesFunc getPhysicalDeviceFormatProperties;
GetPhysicalDeviceImageFormatPropertiesFunc getPhysicalDeviceImageFormatProperties;
-GetPhysicalDeviceLimitsFunc getPhysicalDeviceLimits;
GetPhysicalDevicePropertiesFunc getPhysicalDeviceProperties;
-GetPhysicalDeviceQueueCountFunc getPhysicalDeviceQueueCount;
-GetPhysicalDeviceQueuePropertiesFunc getPhysicalDeviceQueueProperties;
+GetPhysicalDeviceQueueFamilyPropertiesFunc getPhysicalDeviceQueueFamilyProperties;
GetPhysicalDeviceMemoryPropertiesFunc getPhysicalDeviceMemoryProperties;
GetDeviceProcAddrFunc getDeviceProcAddr;
CreateDeviceFunc createDevice;
+EnumerateDeviceExtensionPropertiesFunc enumerateDeviceExtensionProperties;
+EnumerateDeviceLayerPropertiesFunc enumerateDeviceLayerProperties;
const tcu::StaticFunctionLibrary m_functions;
};
-class DescriptorPool
-{
-public:
- DescriptorPool (VkDevice, VkDescriptorPoolUsage, deUint32, const VkDescriptorPoolCreateInfo*) {}
-};
-
class DescriptorSet
{
public:
VK_NULL_DEFINE_DEVICE_OBJ(QueryPool);
VK_NULL_DEFINE_DEVICE_OBJ(BufferView);
VK_NULL_DEFINE_DEVICE_OBJ(ImageView);
-VK_NULL_DEFINE_DEVICE_OBJ(AttachmentView);
VK_NULL_DEFINE_DEVICE_OBJ(ShaderModule);
VK_NULL_DEFINE_DEVICE_OBJ(Shader);
VK_NULL_DEFINE_DEVICE_OBJ(PipelineCache);
VK_NULL_DEFINE_DEVICE_OBJ(RenderPass);
VK_NULL_DEFINE_DEVICE_OBJ(DescriptorSetLayout);
VK_NULL_DEFINE_DEVICE_OBJ(Sampler);
-VK_NULL_DEFINE_DEVICE_OBJ(DynamicViewportState);
-VK_NULL_DEFINE_DEVICE_OBJ(DynamicRasterState);
-VK_NULL_DEFINE_DEVICE_OBJ(DynamicColorBlendState);
-VK_NULL_DEFINE_DEVICE_OBJ(DynamicDepthStencilState);
VK_NULL_DEFINE_DEVICE_OBJ(Framebuffer);
VK_NULL_DEFINE_DEVICE_OBJ(CmdPool);
+VK_NULL_DEFINE_DEVICE_OBJ(DescriptorPool);
extern "C"
{
return VK_SUCCESS;
}
-VkResult getPhysicalDeviceQueueCount (VkPhysicalDevice, deUint32* count)
+VkResult getPhysicalDeviceProperties (VkPhysicalDevice, VkPhysicalDeviceProperties* props)
{
- if (count)
- *count = 1u;
+ deMemset(props, 0, sizeof(VkPhysicalDeviceProperties));
- return VK_SUCCESS;
-}
+ props->apiVersion = VK_API_VERSION;
+ props->driverVersion = 1u;
+ props->deviceType = VK_PHYSICAL_DEVICE_TYPE_OTHER;
-VkResult getPhysicalDeviceProperties (VkPhysicalDevice, VkPhysicalDeviceProperties* props)
-{
- const VkPhysicalDeviceProperties defaultProps =
- {
- VK_API_VERSION, // deUint32 apiVersion;
- 1u, // deUint32 driverVersion;
- 0u, // deUint32 vendorId;
- 0u, // deUint32 deviceId;
- VK_PHYSICAL_DEVICE_TYPE_OTHER, // VkPhysicalDeviceType deviceType;
- "null", // char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME];
- { 0 } // deUint8 pipelineCacheUUID[VK_UUID_LENGTH];
- };
+ deMemcpy(props->deviceName, "null", 5);
- deMemcpy(props, &defaultProps, sizeof(defaultProps));
+ // \todo [2015-09-25 pyry] Fill in reasonable limits
return VK_SUCCESS;
}
-VkResult getPhysicalDeviceQueueProperties (VkPhysicalDevice, deUint32 count, VkPhysicalDeviceQueueProperties* props)
+VkResult getPhysicalDeviceQueueFamilyProperties (VkPhysicalDevice, deUint32* count, VkQueueFamilyProperties* props)
{
- if (count >= 1u)
+ if (props && *count >= 1u)
{
- deMemset(props, 0, sizeof(VkPhysicalDeviceQueueProperties));
+ deMemset(props, 0, sizeof(VkQueueFamilyProperties));
props->queueCount = 1u;
props->queueFlags = VK_QUEUE_GRAPHICS_BIT|VK_QUEUE_COMPUTE_BIT|VK_QUEUE_DMA_BIT;
props->supportsTimestamps = DE_TRUE;
}
+ *count = 1u;
+
return VK_SUCCESS;
}
props->memoryHeapCount = 1u;
props->memoryHeaps[0].size = 1ull << 31;
- props->memoryHeaps[0].flags = VK_MEMORY_HEAP_HOST_LOCAL;
+ props->memoryHeaps[0].flags = VK_MEMORY_HEAP_HOST_LOCAL_BIT;
return VK_SUCCESS;
}
return VK_SUCCESS;
}
-VkResult freeDescriptorSets (VkDevice, VkDescriptorPool, deUint32 count, const VkDescriptorSet* pDescriptorSets)
+void freeDescriptorSets (VkDevice, VkDescriptorPool, deUint32 count, const VkDescriptorSet* pDescriptorSets)
{
for (deUint32 ndx = 0; ndx < count; ++ndx)
{
// \note: delete cannot fail
delete reinterpret_cast<DescriptorSet*>((deUintptr)pDescriptorSets[ndx].getInternal());
}
-
- return VK_SUCCESS;
}
#include "vkNullDriverImpl.inl"
VK_NULL_RETURN(*pView = VkImageView((deUint64)(deUintptr)new ImageView(device, pCreateInfo)));
}
-VkResult createAttachmentView (VkDevice device, const VkAttachmentViewCreateInfo* pCreateInfo, VkAttachmentView* pView)
-{
- VK_NULL_RETURN(*pView = VkAttachmentView((deUint64)(deUintptr)new AttachmentView(device, pCreateInfo)));
-}
-
VkResult createShaderModule (VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule)
{
VK_NULL_RETURN(*pShaderModule = VkShaderModule((deUint64)(deUintptr)new ShaderModule(device, pCreateInfo)));
VK_NULL_RETURN(*pSetLayout = VkDescriptorSetLayout((deUint64)(deUintptr)new DescriptorSetLayout(device, pCreateInfo)));
}
-VkResult createDescriptorPool (VkDevice device, VkDescriptorPoolUsage poolUsage, deUint32 maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool)
-{
- VK_NULL_RETURN(*pDescriptorPool = VkDescriptorPool((deUint64)(deUintptr)new DescriptorPool(device, poolUsage, maxSets, pCreateInfo)));
-}
-
-VkResult createDynamicViewportState (VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState)
-{
- VK_NULL_RETURN(*pState = VkDynamicViewportState((deUint64)(deUintptr)new DynamicViewportState(device, pCreateInfo)));
-}
-
-VkResult createDynamicRasterState (VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState)
+VkResult createDescriptorPool (VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool)
{
- VK_NULL_RETURN(*pState = VkDynamicRasterState((deUint64)(deUintptr)new DynamicRasterState(device, pCreateInfo)));
-}
-
-VkResult createDynamicColorBlendState (VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState)
-{
- VK_NULL_RETURN(*pState = VkDynamicColorBlendState((deUint64)(deUintptr)new DynamicColorBlendState(device, pCreateInfo)));
-}
-
-VkResult createDynamicDepthStencilState (VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, VkDynamicDepthStencilState* pState)
-{
- VK_NULL_RETURN(*pState = VkDynamicDepthStencilState((deUint64)(deUintptr)new DynamicDepthStencilState(device, pCreateInfo)));
+ VK_NULL_RETURN(*pDescriptorPool = VkDescriptorPool((deUint64)(deUintptr)new DescriptorPool(device, pCreateInfo)));
}
VkResult createFramebuffer (VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer)
VK_NULL_RETURN(*pCmdBuffer = reinterpret_cast<VkCmdBuffer>(new CmdBuffer(device, pCreateInfo)));
}
-VkResult destroyInstance (VkInstance instance)
-{
- VK_NULL_RETURN(delete reinterpret_cast<Instance*>(instance));
-}
-
-VkResult destroyDevice (VkDevice device)
+void destroyInstance (VkInstance instance)
{
- VK_NULL_RETURN(delete reinterpret_cast<Device*>(device));
+ delete reinterpret_cast<Instance*>(instance);
}
-VkResult freeMemory (VkDevice device, VkDeviceMemory mem)
+void destroyDevice (VkDevice device)
{
- DE_UNREF(device);
- VK_NULL_RETURN(delete reinterpret_cast<DeviceMemory*>((deUintptr)mem.getInternal()));
-}
-
-VkResult destroyFence (VkDevice device, VkFence fence)
-{
- DE_UNREF(device);
- VK_NULL_RETURN(delete reinterpret_cast<Fence*>((deUintptr)fence.getInternal()));
-}
-
-VkResult destroySemaphore (VkDevice device, VkSemaphore semaphore)
-{
- DE_UNREF(device);
- VK_NULL_RETURN(delete reinterpret_cast<Semaphore*>((deUintptr)semaphore.getInternal()));
+ delete reinterpret_cast<Device*>(device);
}
-VkResult destroyEvent (VkDevice device, VkEvent event)
+void freeMemory (VkDevice device, VkDeviceMemory mem)
{
DE_UNREF(device);
- VK_NULL_RETURN(delete reinterpret_cast<Event*>((deUintptr)event.getInternal()));
+ delete reinterpret_cast<DeviceMemory*>((deUintptr)mem.getInternal());
}
-VkResult destroyQueryPool (VkDevice device, VkQueryPool queryPool)
+void destroyFence (VkDevice device, VkFence fence)
{
DE_UNREF(device);
- VK_NULL_RETURN(delete reinterpret_cast<QueryPool*>((deUintptr)queryPool.getInternal()));
+ delete reinterpret_cast<Fence*>((deUintptr)fence.getInternal());
}
-VkResult destroyBuffer (VkDevice device, VkBuffer buffer)
+void destroySemaphore (VkDevice device, VkSemaphore semaphore)
{
DE_UNREF(device);
- VK_NULL_RETURN(delete reinterpret_cast<Buffer*>((deUintptr)buffer.getInternal()));
+ delete reinterpret_cast<Semaphore*>((deUintptr)semaphore.getInternal());
}
-VkResult destroyBufferView (VkDevice device, VkBufferView bufferView)
+void destroyEvent (VkDevice device, VkEvent event)
{
DE_UNREF(device);
- VK_NULL_RETURN(delete reinterpret_cast<BufferView*>((deUintptr)bufferView.getInternal()));
+ delete reinterpret_cast<Event*>((deUintptr)event.getInternal());
}
-VkResult destroyImage (VkDevice device, VkImage image)
+void destroyQueryPool (VkDevice device, VkQueryPool queryPool)
{
DE_UNREF(device);
- VK_NULL_RETURN(delete reinterpret_cast<Image*>((deUintptr)image.getInternal()));
+ delete reinterpret_cast<QueryPool*>((deUintptr)queryPool.getInternal());
}
-VkResult destroyImageView (VkDevice device, VkImageView imageView)
+void destroyBuffer (VkDevice device, VkBuffer buffer)
{
DE_UNREF(device);
- VK_NULL_RETURN(delete reinterpret_cast<ImageView*>((deUintptr)imageView.getInternal()));
+ delete reinterpret_cast<Buffer*>((deUintptr)buffer.getInternal());
}
-VkResult destroyAttachmentView (VkDevice device, VkAttachmentView attachmentView)
+void destroyBufferView (VkDevice device, VkBufferView bufferView)
{
DE_UNREF(device);
- VK_NULL_RETURN(delete reinterpret_cast<AttachmentView*>((deUintptr)attachmentView.getInternal()));
+ delete reinterpret_cast<BufferView*>((deUintptr)bufferView.getInternal());
}
-VkResult destroyShaderModule (VkDevice device, VkShaderModule shaderModule)
+void destroyImage (VkDevice device, VkImage image)
{
DE_UNREF(device);
- VK_NULL_RETURN(delete reinterpret_cast<ShaderModule*>((deUintptr)shaderModule.getInternal()));
+ delete reinterpret_cast<Image*>((deUintptr)image.getInternal());
}
-VkResult destroyShader (VkDevice device, VkShader shader)
+void destroyImageView (VkDevice device, VkImageView imageView)
{
DE_UNREF(device);
- VK_NULL_RETURN(delete reinterpret_cast<Shader*>((deUintptr)shader.getInternal()));
+ delete reinterpret_cast<ImageView*>((deUintptr)imageView.getInternal());
}
-VkResult destroyPipelineCache (VkDevice device, VkPipelineCache pipelineCache)
+void destroyShaderModule (VkDevice device, VkShaderModule shaderModule)
{
DE_UNREF(device);
- VK_NULL_RETURN(delete reinterpret_cast<PipelineCache*>((deUintptr)pipelineCache.getInternal()));
+ delete reinterpret_cast<ShaderModule*>((deUintptr)shaderModule.getInternal());
}
-VkResult destroyPipeline (VkDevice device, VkPipeline pipeline)
+void destroyShader (VkDevice device, VkShader shader)
{
DE_UNREF(device);
- VK_NULL_RETURN(delete reinterpret_cast<Pipeline*>((deUintptr)pipeline.getInternal()));
+ delete reinterpret_cast<Shader*>((deUintptr)shader.getInternal());
}
-VkResult destroyPipelineLayout (VkDevice device, VkPipelineLayout pipelineLayout)
+void destroyPipelineCache (VkDevice device, VkPipelineCache pipelineCache)
{
DE_UNREF(device);
- VK_NULL_RETURN(delete reinterpret_cast<PipelineLayout*>((deUintptr)pipelineLayout.getInternal()));
+ delete reinterpret_cast<PipelineCache*>((deUintptr)pipelineCache.getInternal());
}
-VkResult destroySampler (VkDevice device, VkSampler sampler)
+void destroyPipeline (VkDevice device, VkPipeline pipeline)
{
DE_UNREF(device);
- VK_NULL_RETURN(delete reinterpret_cast<Sampler*>((deUintptr)sampler.getInternal()));
+ delete reinterpret_cast<Pipeline*>((deUintptr)pipeline.getInternal());
}
-VkResult destroyDescriptorSetLayout (VkDevice device, VkDescriptorSetLayout descriptorSetLayout)
+void destroyPipelineLayout (VkDevice device, VkPipelineLayout pipelineLayout)
{
DE_UNREF(device);
- VK_NULL_RETURN(delete reinterpret_cast<DescriptorSetLayout*>((deUintptr)descriptorSetLayout.getInternal()));
+ delete reinterpret_cast<PipelineLayout*>((deUintptr)pipelineLayout.getInternal());
}
-VkResult destroyDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool)
+void destroySampler (VkDevice device, VkSampler sampler)
{
DE_UNREF(device);
- VK_NULL_RETURN(delete reinterpret_cast<DescriptorPool*>((deUintptr)descriptorPool.getInternal()));
+ delete reinterpret_cast<Sampler*>((deUintptr)sampler.getInternal());
}
-VkResult destroyDynamicViewportState (VkDevice device, VkDynamicViewportState dynamicViewportState)
+void destroyDescriptorSetLayout (VkDevice device, VkDescriptorSetLayout descriptorSetLayout)
{
DE_UNREF(device);
- VK_NULL_RETURN(delete reinterpret_cast<DynamicViewportState*>((deUintptr)dynamicViewportState.getInternal()));
+ delete reinterpret_cast<DescriptorSetLayout*>((deUintptr)descriptorSetLayout.getInternal());
}
-VkResult destroyDynamicRasterState (VkDevice device, VkDynamicRasterState dynamicRasterState)
+void destroyDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool)
{
DE_UNREF(device);
- VK_NULL_RETURN(delete reinterpret_cast<DynamicRasterState*>((deUintptr)dynamicRasterState.getInternal()));
+ delete reinterpret_cast<DescriptorPool*>((deUintptr)descriptorPool.getInternal());
}
-VkResult destroyDynamicColorBlendState (VkDevice device, VkDynamicColorBlendState dynamicColorBlendState)
+void destroyFramebuffer (VkDevice device, VkFramebuffer framebuffer)
{
DE_UNREF(device);
- VK_NULL_RETURN(delete reinterpret_cast<DynamicColorBlendState*>((deUintptr)dynamicColorBlendState.getInternal()));
+ delete reinterpret_cast<Framebuffer*>((deUintptr)framebuffer.getInternal());
}
-VkResult destroyDynamicDepthStencilState (VkDevice device, VkDynamicDepthStencilState dynamicDepthStencilState)
+void destroyRenderPass (VkDevice device, VkRenderPass renderPass)
{
DE_UNREF(device);
- VK_NULL_RETURN(delete reinterpret_cast<DynamicDepthStencilState*>((deUintptr)dynamicDepthStencilState.getInternal()));
+ delete reinterpret_cast<RenderPass*>((deUintptr)renderPass.getInternal());
}
-VkResult destroyFramebuffer (VkDevice device, VkFramebuffer framebuffer)
+void destroyCommandPool (VkDevice device, VkCmdPool cmdPool)
{
DE_UNREF(device);
- VK_NULL_RETURN(delete reinterpret_cast<Framebuffer*>((deUintptr)framebuffer.getInternal()));
+ delete reinterpret_cast<CmdPool*>((deUintptr)cmdPool.getInternal());
}
-VkResult destroyRenderPass (VkDevice device, VkRenderPass renderPass)
+void destroyCommandBuffer (VkDevice device, VkCmdBuffer commandBuffer)
{
DE_UNREF(device);
- VK_NULL_RETURN(delete reinterpret_cast<RenderPass*>((deUintptr)renderPass.getInternal()));
-}
-
-VkResult destroyCommandPool (VkDevice device, VkCmdPool cmdPool)
-{
- DE_UNREF(device);
- VK_NULL_RETURN(delete reinterpret_cast<CmdPool*>((deUintptr)cmdPool.getInternal()));
-}
-
-VkResult destroyCommandBuffer (VkDevice device, VkCmdBuffer commandBuffer)
-{
- DE_UNREF(device);
- VK_NULL_RETURN(delete reinterpret_cast<CmdBuffer*>(commandBuffer));
+ delete reinterpret_cast<CmdBuffer*>(commandBuffer);
}
VkResult getPhysicalDeviceFeatures (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
return VK_SUCCESS;
}
-VkResult getPhysicalDeviceImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageFormatProperties* pImageFormatProperties)
+VkResult getPhysicalDeviceImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
{
DE_UNREF(physicalDevice);
DE_UNREF(format);
DE_UNREF(type);
DE_UNREF(tiling);
DE_UNREF(usage);
+ DE_UNREF(flags);
DE_UNREF(pImageFormatProperties);
return VK_SUCCESS;
}
-VkResult getPhysicalDeviceLimits (VkPhysicalDevice physicalDevice, VkPhysicalDeviceLimits* pLimits)
-{
- DE_UNREF(physicalDevice);
- DE_UNREF(pLimits);
- return VK_SUCCESS;
-}
-
-VkResult getGlobalExtensionProperties (const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties)
+VkResult enumerateInstanceExtensionProperties (const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties)
{
DE_UNREF(pLayerName);
DE_UNREF(pCount);
return VK_SUCCESS;
}
-VkResult getPhysicalDeviceExtensionProperties (VkPhysicalDevice physicalDevice, const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties)
+VkResult enumerateDeviceExtensionProperties (VkPhysicalDevice physicalDevice, const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties)
{
DE_UNREF(physicalDevice);
DE_UNREF(pLayerName);
return VK_SUCCESS;
}
-VkResult getGlobalLayerProperties (deUint32* pCount, VkLayerProperties* pProperties)
+VkResult enumerateInstanceLayerProperties (deUint32* pCount, VkLayerProperties* pProperties)
{
DE_UNREF(pCount);
DE_UNREF(pProperties);
return VK_SUCCESS;
}
-VkResult getPhysicalDeviceLayerProperties (VkPhysicalDevice physicalDevice, deUint32* pCount, VkLayerProperties* pProperties)
+VkResult enumerateDeviceLayerProperties (VkPhysicalDevice physicalDevice, deUint32* pCount, VkLayerProperties* pProperties)
{
DE_UNREF(physicalDevice);
DE_UNREF(pCount);
return VK_SUCCESS;
}
-VkResult unmapMemory (VkDevice device, VkDeviceMemory mem)
+void unmapMemory (VkDevice device, VkDeviceMemory mem)
{
DE_UNREF(device);
DE_UNREF(mem);
- return VK_SUCCESS;
}
VkResult flushMappedMemoryRanges (VkDevice device, deUint32 memRangeCount, const VkMappedMemoryRange* pMemRanges)
return VK_SUCCESS;
}
-VkResult updateDescriptorSets (VkDevice device, deUint32 writeCount, const VkWriteDescriptorSet* pDescriptorWrites, deUint32 copyCount, const VkCopyDescriptorSet* pDescriptorCopies)
+void updateDescriptorSets (VkDevice device, deUint32 writeCount, const VkWriteDescriptorSet* pDescriptorWrites, deUint32 copyCount, const VkCopyDescriptorSet* pDescriptorCopies)
{
DE_UNREF(device);
DE_UNREF(writeCount);
DE_UNREF(pDescriptorWrites);
DE_UNREF(copyCount);
DE_UNREF(pDescriptorCopies);
- return VK_SUCCESS;
}
VkResult getRenderAreaGranularity (VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
DE_UNREF(pipeline);
}
-void cmdBindDynamicViewportState (VkCmdBuffer cmdBuffer, VkDynamicViewportState dynamicViewportState)
+void cmdSetViewport (VkCmdBuffer cmdBuffer, deUint32 viewportCount, const VkViewport* pViewports)
+{
+ DE_UNREF(cmdBuffer);
+ DE_UNREF(viewportCount);
+ DE_UNREF(pViewports);
+}
+
+void cmdSetScissor (VkCmdBuffer cmdBuffer, deUint32 scissorCount, const VkRect2D* pScissors)
{
DE_UNREF(cmdBuffer);
- DE_UNREF(dynamicViewportState);
+ DE_UNREF(scissorCount);
+ DE_UNREF(pScissors);
}
-void cmdBindDynamicRasterState (VkCmdBuffer cmdBuffer, VkDynamicRasterState dynamicRasterState)
+void cmdSetLineWidth (VkCmdBuffer cmdBuffer, float lineWidth)
{
DE_UNREF(cmdBuffer);
- DE_UNREF(dynamicRasterState);
+ DE_UNREF(lineWidth);
}
-void cmdBindDynamicColorBlendState (VkCmdBuffer cmdBuffer, VkDynamicColorBlendState dynamicColorBlendState)
+void cmdSetDepthBias (VkCmdBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias)
{
DE_UNREF(cmdBuffer);
- DE_UNREF(dynamicColorBlendState);
+ DE_UNREF(depthBias);
+ DE_UNREF(depthBiasClamp);
+ DE_UNREF(slopeScaledDepthBias);
}
-void cmdBindDynamicDepthStencilState (VkCmdBuffer cmdBuffer, VkDynamicDepthStencilState dynamicDepthStencilState)
+void cmdSetBlendConstants (VkCmdBuffer cmdBuffer, const float blendConst)
{
DE_UNREF(cmdBuffer);
- DE_UNREF(dynamicDepthStencilState);
+ DE_UNREF(blendConst);
+}
+
+void cmdSetDepthBounds (VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds)
+{
+ DE_UNREF(cmdBuffer);
+ DE_UNREF(minDepthBounds);
+ DE_UNREF(maxDepthBounds);
+}
+
+void cmdSetStencilCompareMask (VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, deUint32 stencilCompareMask)
+{
+ DE_UNREF(cmdBuffer);
+ DE_UNREF(faceMask);
+ DE_UNREF(stencilCompareMask);
+}
+
+void cmdSetStencilWriteMask (VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, deUint32 stencilWriteMask)
+{
+ DE_UNREF(cmdBuffer);
+ DE_UNREF(faceMask);
+ DE_UNREF(stencilWriteMask);
+}
+
+void cmdSetStencilReference (VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, deUint32 stencilReference)
+{
+ DE_UNREF(cmdBuffer);
+ DE_UNREF(faceMask);
+ DE_UNREF(stencilReference);
}
void cmdBindDescriptorSets (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 firstSet, deUint32 setCount, const VkDescriptorSet* pDescriptorSets, deUint32 dynamicOffsetCount, const deUint32* pDynamicOffsets)
DE_UNREF(pOffsets);
}
-void cmdDraw (VkCmdBuffer cmdBuffer, deUint32 firstVertex, deUint32 vertexCount, deUint32 firstInstance, deUint32 instanceCount)
+void cmdDraw (VkCmdBuffer cmdBuffer, deUint32 vertexCount, deUint32 instanceCount, deUint32 firstVertex, deUint32 firstInstance)
{
DE_UNREF(cmdBuffer);
- DE_UNREF(firstVertex);
DE_UNREF(vertexCount);
- DE_UNREF(firstInstance);
DE_UNREF(instanceCount);
+ DE_UNREF(firstVertex);
+ DE_UNREF(firstInstance);
}
-void cmdDrawIndexed (VkCmdBuffer cmdBuffer, deUint32 firstIndex, deUint32 indexCount, deInt32 vertexOffset, deUint32 firstInstance, deUint32 instanceCount)
+void cmdDrawIndexed (VkCmdBuffer cmdBuffer, deUint32 indexCount, deUint32 instanceCount, deUint32 firstIndex, deInt32 vertexOffset, deUint32 firstInstance)
{
DE_UNREF(cmdBuffer);
- DE_UNREF(firstIndex);
DE_UNREF(indexCount);
+ DE_UNREF(instanceCount);
+ DE_UNREF(firstIndex);
DE_UNREF(vertexOffset);
DE_UNREF(firstInstance);
- DE_UNREF(instanceCount);
}
void cmdDrawIndirect (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 count, deUint32 stride)
DE_UNREF(pRanges);
}
-void cmdClearDepthStencilImage (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, deUint32 stencil, deUint32 rangeCount, const VkImageSubresourceRange* pRanges)
+void cmdClearDepthStencilImage (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, deUint32 rangeCount, const VkImageSubresourceRange* pRanges)
{
DE_UNREF(cmdBuffer);
DE_UNREF(image);
DE_UNREF(imageLayout);
- DE_UNREF(depth);
- DE_UNREF(stencil);
+ DE_UNREF(pDepthStencil);
DE_UNREF(rangeCount);
DE_UNREF(pRanges);
}
DE_UNREF(pRects);
}
-void cmdClearDepthStencilAttachment (VkCmdBuffer cmdBuffer, VkImageAspectFlags imageAspectMask, VkImageLayout imageLayout, float depth, deUint32 stencil, deUint32 rectCount, const VkRect3D* pRects)
+void cmdClearDepthStencilAttachment (VkCmdBuffer cmdBuffer, VkImageAspectFlags aspectMask, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, deUint32 rectCount, const VkRect3D* pRects)
{
DE_UNREF(cmdBuffer);
- DE_UNREF(imageAspectMask);
+ DE_UNREF(aspectMask);
DE_UNREF(imageLayout);
- DE_UNREF(depth);
- DE_UNREF(stencil);
+ DE_UNREF(pDepthStencil);
DE_UNREF(rectCount);
DE_UNREF(pRects);
}
static const tcu::StaticFunctionLibrary::Entry s_platformFunctions[] =
{
- VK_NULL_FUNC_ENTRY(vkCreateInstance, createInstance),
- VK_NULL_FUNC_ENTRY(vkGetInstanceProcAddr, getInstanceProcAddr),
+ VK_NULL_FUNC_ENTRY(vkCreateInstance, createInstance),
+ VK_NULL_FUNC_ENTRY(vkGetInstanceProcAddr, getInstanceProcAddr),
+ VK_NULL_FUNC_ENTRY(vkEnumerateInstanceExtensionProperties, enumerateInstanceExtensionProperties),
+ VK_NULL_FUNC_ENTRY(vkEnumerateInstanceLayerProperties, enumerateInstanceLayerProperties),
};
static const tcu::StaticFunctionLibrary::Entry s_instanceFunctions[] =
VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFeatures, getPhysicalDeviceFeatures),
VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFormatProperties, getPhysicalDeviceFormatProperties),
VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceImageFormatProperties, getPhysicalDeviceImageFormatProperties),
- VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceLimits, getPhysicalDeviceLimits),
VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceProperties, getPhysicalDeviceProperties),
- VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceQueueCount, getPhysicalDeviceQueueCount),
- VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceQueueProperties, getPhysicalDeviceQueueProperties),
+ VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceQueueFamilyProperties, getPhysicalDeviceQueueFamilyProperties),
VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceMemoryProperties, getPhysicalDeviceMemoryProperties),
VK_NULL_FUNC_ENTRY(vkGetDeviceProcAddr, getDeviceProcAddr),
VK_NULL_FUNC_ENTRY(vkCreateDevice, createDevice),
+ VK_NULL_FUNC_ENTRY(vkEnumerateDeviceExtensionProperties, enumerateDeviceExtensionProperties),
+ VK_NULL_FUNC_ENTRY(vkEnumerateDeviceLayerProperties, enumerateDeviceLayerProperties),
};
static const tcu::StaticFunctionLibrary::Entry s_deviceFunctions[] =
{
VK_NULL_FUNC_ENTRY(vkDestroyDevice, destroyDevice),
- VK_NULL_FUNC_ENTRY(vkGetGlobalExtensionProperties, getGlobalExtensionProperties),
- VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExtensionProperties, getPhysicalDeviceExtensionProperties),
- VK_NULL_FUNC_ENTRY(vkGetGlobalLayerProperties, getGlobalLayerProperties),
- VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceLayerProperties, getPhysicalDeviceLayerProperties),
VK_NULL_FUNC_ENTRY(vkGetDeviceQueue, getDeviceQueue),
VK_NULL_FUNC_ENTRY(vkQueueSubmit, queueSubmit),
VK_NULL_FUNC_ENTRY(vkQueueWaitIdle, queueWaitIdle),
VK_NULL_FUNC_ENTRY(vkGetImageSubresourceLayout, getImageSubresourceLayout),
VK_NULL_FUNC_ENTRY(vkCreateImageView, createImageView),
VK_NULL_FUNC_ENTRY(vkDestroyImageView, destroyImageView),
- VK_NULL_FUNC_ENTRY(vkCreateAttachmentView, createAttachmentView),
- VK_NULL_FUNC_ENTRY(vkDestroyAttachmentView, destroyAttachmentView),
VK_NULL_FUNC_ENTRY(vkCreateShaderModule, createShaderModule),
VK_NULL_FUNC_ENTRY(vkDestroyShaderModule, destroyShaderModule),
VK_NULL_FUNC_ENTRY(vkCreateShader, createShader),
VK_NULL_FUNC_ENTRY(vkAllocDescriptorSets, allocDescriptorSets),
VK_NULL_FUNC_ENTRY(vkFreeDescriptorSets, freeDescriptorSets),
VK_NULL_FUNC_ENTRY(vkUpdateDescriptorSets, updateDescriptorSets),
- VK_NULL_FUNC_ENTRY(vkCreateDynamicViewportState, createDynamicViewportState),
- VK_NULL_FUNC_ENTRY(vkDestroyDynamicViewportState, destroyDynamicViewportState),
- VK_NULL_FUNC_ENTRY(vkCreateDynamicRasterState, createDynamicRasterState),
- VK_NULL_FUNC_ENTRY(vkDestroyDynamicRasterState, destroyDynamicRasterState),
- VK_NULL_FUNC_ENTRY(vkCreateDynamicColorBlendState, createDynamicColorBlendState),
- VK_NULL_FUNC_ENTRY(vkDestroyDynamicColorBlendState, destroyDynamicColorBlendState),
- VK_NULL_FUNC_ENTRY(vkCreateDynamicDepthStencilState, createDynamicDepthStencilState),
- VK_NULL_FUNC_ENTRY(vkDestroyDynamicDepthStencilState, destroyDynamicDepthStencilState),
VK_NULL_FUNC_ENTRY(vkCreateFramebuffer, createFramebuffer),
VK_NULL_FUNC_ENTRY(vkDestroyFramebuffer, destroyFramebuffer),
VK_NULL_FUNC_ENTRY(vkCreateRenderPass, createRenderPass),
VK_NULL_FUNC_ENTRY(vkEndCommandBuffer, endCommandBuffer),
VK_NULL_FUNC_ENTRY(vkResetCommandBuffer, resetCommandBuffer),
VK_NULL_FUNC_ENTRY(vkCmdBindPipeline, cmdBindPipeline),
- VK_NULL_FUNC_ENTRY(vkCmdBindDynamicViewportState, cmdBindDynamicViewportState),
- VK_NULL_FUNC_ENTRY(vkCmdBindDynamicRasterState, cmdBindDynamicRasterState),
- VK_NULL_FUNC_ENTRY(vkCmdBindDynamicColorBlendState, cmdBindDynamicColorBlendState),
- VK_NULL_FUNC_ENTRY(vkCmdBindDynamicDepthStencilState, cmdBindDynamicDepthStencilState),
+ 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),
{
return m_vk.getInstanceProcAddr(instance, pName);
}
+
+VkResult PlatformDriver::enumerateInstanceExtensionProperties (const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties) const
+{
+ return m_vk.enumerateInstanceExtensionProperties(pLayerName, pCount, pProperties);
+}
+
+VkResult PlatformDriver::enumerateInstanceLayerProperties (deUint32* pCount, VkLayerProperties* pProperties) const
+{
+ return m_vk.enumerateInstanceLayerProperties(pCount, pProperties);
+}
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-CreateInstanceFunc createInstance;
-GetInstanceProcAddrFunc getInstanceProcAddr;
+CreateInstanceFunc createInstance;
+GetInstanceProcAddrFunc getInstanceProcAddr;
+EnumerateInstanceExtensionPropertiesFunc enumerateInstanceExtensionProperties;
+EnumerateInstanceLayerPropertiesFunc enumerateInstanceLayerProperties;
return devices;
}
-std::vector<VkPhysicalDeviceQueueProperties> getPhysicalDeviceQueueProperties (const InstanceInterface& vk, VkPhysicalDevice physicalDevice)
+std::vector<VkQueueFamilyProperties> getPhysicalDeviceQueueFamilyProperties (const InstanceInterface& vk, VkPhysicalDevice physicalDevice)
{
- deUint32 numQueues = 0;
- std::vector<VkPhysicalDeviceQueueProperties> properties;
+ deUint32 numQueues = 0;
+ std::vector<VkQueueFamilyProperties> properties;
- VK_CHECK(vk.getPhysicalDeviceQueueCount(physicalDevice, &numQueues));
+ VK_CHECK(vk.getPhysicalDeviceQueueFamilyProperties(physicalDevice, &numQueues, DE_NULL));
if (numQueues > 0)
{
properties.resize(numQueues);
- VK_CHECK(vk.getPhysicalDeviceQueueProperties(physicalDevice, numQueues, &properties[0]));
+ VK_CHECK(vk.getPhysicalDeviceQueueFamilyProperties(physicalDevice, &numQueues, &properties[0]));
+
+ if ((size_t)numQueues != properties.size())
+ TCU_FAIL("Returned queue family count changes between queries");
}
return properties;
namespace vk
{
-std::vector<VkPhysicalDevice> enumeratePhysicalDevices (const InstanceInterface& vk, VkInstance instance);
-std::vector<VkPhysicalDeviceQueueProperties> getPhysicalDeviceQueueProperties (const InstanceInterface& vk, VkPhysicalDevice physicalDevice);
-VkPhysicalDeviceMemoryProperties getPhysicalDeviceMemoryProperties (const InstanceInterface& vk, VkPhysicalDevice physicalDevice);
+std::vector<VkPhysicalDevice> enumeratePhysicalDevices (const InstanceInterface& vk, VkInstance instance);
+std::vector<VkQueueFamilyProperties> getPhysicalDeviceQueueFamilyProperties (const InstanceInterface& vk, VkPhysicalDevice physicalDevice);
+VkPhysicalDeviceMemoryProperties getPhysicalDeviceMemoryProperties (const InstanceInterface& vk, VkPhysicalDevice physicalDevice);
-VkMemoryRequirements getBufferMemoryRequirements (const DeviceInterface& vk, VkDevice device, VkBuffer buffer);
-VkMemoryRequirements getImageMemoryRequirements (const DeviceInterface& vk, VkDevice device, VkImage image);
+VkMemoryRequirements getBufferMemoryRequirements (const DeviceInterface& vk, VkDevice device, VkBuffer buffer);
+VkMemoryRequirements getImageMemoryRequirements (const DeviceInterface& vk, VkDevice device, VkImage image);
} // vk
: m_destroyInstance((DestroyInstanceFunc)DE_NULL)
{}
- void operator() (VkInstance obj) const { DE_TEST_ASSERT(m_destroyInstance(obj) == VK_SUCCESS); }
+ void operator() (VkInstance obj) const { m_destroyInstance(obj); }
private:
DestroyInstanceFunc m_destroyInstance;
: m_destroyDevice((DestroyDeviceFunc)DE_NULL)
{}
- void operator() (VkDevice obj) const { DE_TEST_ASSERT(m_destroyDevice(obj) == VK_SUCCESS); }
+ void operator() (VkDevice obj) const { m_destroyDevice(obj); }
private:
DestroyDeviceFunc m_destroyDevice;
, m_pool (DE_NULL)
{}
- void operator() (VkDescriptorSet obj) const { DE_TEST_ASSERT(m_deviceIface->freeDescriptorSets(m_device, m_pool, 1, &obj) == VK_SUCCESS); }
+ void operator() (VkDescriptorSet obj) const { m_deviceIface->freeDescriptorSets(m_device, m_pool, 1, &obj); }
private:
const DeviceInterface* m_deviceIface;
Move<VkDescriptorSet> allocDescriptorSet (const DeviceInterface& vk, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, VkDescriptorSetLayout layout)
{
- VkDescriptorSet descriptorSet = 0u;
- deUint32 numCreated = 0;
+ VkDescriptorSet descriptorSet = 0;
- VK_CHECK(vk.allocDescriptorSets(device, descriptorPool, setUsage, 1, &layout, &descriptorSet, &numCreated));
- if (numCreated != 1u)
- throw tcu::TestError("failed to allocate descriptor sets");
+ VK_CHECK(vk.allocDescriptorSets(device, descriptorPool, setUsage, 1, &layout, &descriptorSet));
return Move<VkDescriptorSet>(check<VkDescriptorSet>(descriptorSet), Deleter<VkDescriptorSet>(vk, device, descriptorPool));
}
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-Move<VkInstance> createInstance (const PlatformInterface& vk, const VkInstanceCreateInfo* pCreateInfo);
-Move<VkDevice> createDevice (const InstanceInterface& vk, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo);
-Move<VkDeviceMemory> allocMemory (const DeviceInterface& vk, VkDevice device, const VkMemoryAllocInfo* pAllocInfo);
-Move<VkFence> createFence (const DeviceInterface& vk, VkDevice device, const VkFenceCreateInfo* pCreateInfo);
-Move<VkSemaphore> createSemaphore (const DeviceInterface& vk, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo);
-Move<VkEvent> createEvent (const DeviceInterface& vk, VkDevice device, const VkEventCreateInfo* pCreateInfo);
-Move<VkQueryPool> createQueryPool (const DeviceInterface& vk, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo);
-Move<VkBuffer> createBuffer (const DeviceInterface& vk, VkDevice device, const VkBufferCreateInfo* pCreateInfo);
-Move<VkBufferView> createBufferView (const DeviceInterface& vk, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo);
-Move<VkImage> createImage (const DeviceInterface& vk, VkDevice device, const VkImageCreateInfo* pCreateInfo);
-Move<VkImageView> createImageView (const DeviceInterface& vk, VkDevice device, const VkImageViewCreateInfo* pCreateInfo);
-Move<VkAttachmentView> createAttachmentView (const DeviceInterface& vk, VkDevice device, const VkAttachmentViewCreateInfo* pCreateInfo);
-Move<VkShaderModule> createShaderModule (const DeviceInterface& vk, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo);
-Move<VkShader> createShader (const DeviceInterface& vk, VkDevice device, const VkShaderCreateInfo* pCreateInfo);
-Move<VkPipelineCache> createPipelineCache (const DeviceInterface& vk, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo);
-Move<VkPipelineLayout> createPipelineLayout (const DeviceInterface& vk, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo);
-Move<VkSampler> createSampler (const DeviceInterface& vk, VkDevice device, const VkSamplerCreateInfo* pCreateInfo);
-Move<VkDescriptorSetLayout> createDescriptorSetLayout (const DeviceInterface& vk, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo);
-Move<VkDescriptorPool> createDescriptorPool (const DeviceInterface& vk, VkDevice device, VkDescriptorPoolUsage poolUsage, deUint32 maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo);
-Move<VkDynamicViewportState> createDynamicViewportState (const DeviceInterface& vk, VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo);
-Move<VkDynamicRasterState> createDynamicRasterState (const DeviceInterface& vk, VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo);
-Move<VkDynamicColorBlendState> createDynamicColorBlendState (const DeviceInterface& vk, VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo);
-Move<VkDynamicDepthStencilState> createDynamicDepthStencilState (const DeviceInterface& vk, VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo);
-Move<VkFramebuffer> createFramebuffer (const DeviceInterface& vk, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo);
-Move<VkRenderPass> createRenderPass (const DeviceInterface& vk, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo);
-Move<VkCmdPool> createCommandPool (const DeviceInterface& vk, VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo);
-Move<VkCmdBuffer> createCommandBuffer (const DeviceInterface& vk, VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo);
+Move<VkInstance> createInstance (const PlatformInterface& vk, const VkInstanceCreateInfo* pCreateInfo);
+Move<VkDevice> createDevice (const InstanceInterface& vk, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo);
+Move<VkDeviceMemory> allocMemory (const DeviceInterface& vk, VkDevice device, const VkMemoryAllocInfo* pAllocInfo);
+Move<VkFence> createFence (const DeviceInterface& vk, VkDevice device, const VkFenceCreateInfo* pCreateInfo);
+Move<VkSemaphore> createSemaphore (const DeviceInterface& vk, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo);
+Move<VkEvent> createEvent (const DeviceInterface& vk, VkDevice device, const VkEventCreateInfo* pCreateInfo);
+Move<VkQueryPool> createQueryPool (const DeviceInterface& vk, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo);
+Move<VkBuffer> createBuffer (const DeviceInterface& vk, VkDevice device, const VkBufferCreateInfo* pCreateInfo);
+Move<VkBufferView> createBufferView (const DeviceInterface& vk, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo);
+Move<VkImage> createImage (const DeviceInterface& vk, VkDevice device, const VkImageCreateInfo* pCreateInfo);
+Move<VkImageView> createImageView (const DeviceInterface& vk, VkDevice device, const VkImageViewCreateInfo* pCreateInfo);
+Move<VkShaderModule> createShaderModule (const DeviceInterface& vk, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo);
+Move<VkShader> createShader (const DeviceInterface& vk, VkDevice device, const VkShaderCreateInfo* pCreateInfo);
+Move<VkPipelineCache> createPipelineCache (const DeviceInterface& vk, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo);
+Move<VkPipelineLayout> createPipelineLayout (const DeviceInterface& vk, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo);
+Move<VkSampler> createSampler (const DeviceInterface& vk, VkDevice device, const VkSamplerCreateInfo* pCreateInfo);
+Move<VkDescriptorSetLayout> createDescriptorSetLayout (const DeviceInterface& vk, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo);
+Move<VkDescriptorPool> createDescriptorPool (const DeviceInterface& vk, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo);
+Move<VkFramebuffer> createFramebuffer (const DeviceInterface& vk, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo);
+Move<VkRenderPass> createRenderPass (const DeviceInterface& vk, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo);
+Move<VkCmdPool> createCommandPool (const DeviceInterface& vk, VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo);
+Move<VkCmdBuffer> createCommandBuffer (const DeviceInterface& vk, VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo);
template<>
void Deleter<VkDeviceMemory>::operator() (VkDeviceMemory obj) const
{
- DE_TEST_ASSERT(m_deviceIface->freeMemory(m_device, obj) == VK_SUCCESS);
+ m_deviceIface->freeMemory(m_device, obj);
}
template<>
void Deleter<VkFence>::operator() (VkFence obj) const
{
- DE_TEST_ASSERT(m_deviceIface->destroyFence(m_device, obj) == VK_SUCCESS);
+ m_deviceIface->destroyFence(m_device, obj);
}
template<>
void Deleter<VkSemaphore>::operator() (VkSemaphore obj) const
{
- DE_TEST_ASSERT(m_deviceIface->destroySemaphore(m_device, obj) == VK_SUCCESS);
+ m_deviceIface->destroySemaphore(m_device, obj);
}
template<>
void Deleter<VkEvent>::operator() (VkEvent obj) const
{
- DE_TEST_ASSERT(m_deviceIface->destroyEvent(m_device, obj) == VK_SUCCESS);
+ m_deviceIface->destroyEvent(m_device, obj);
}
template<>
void Deleter<VkQueryPool>::operator() (VkQueryPool obj) const
{
- DE_TEST_ASSERT(m_deviceIface->destroyQueryPool(m_device, obj) == VK_SUCCESS);
+ m_deviceIface->destroyQueryPool(m_device, obj);
}
template<>
void Deleter<VkBuffer>::operator() (VkBuffer obj) const
{
- DE_TEST_ASSERT(m_deviceIface->destroyBuffer(m_device, obj) == VK_SUCCESS);
+ m_deviceIface->destroyBuffer(m_device, obj);
}
template<>
void Deleter<VkBufferView>::operator() (VkBufferView obj) const
{
- DE_TEST_ASSERT(m_deviceIface->destroyBufferView(m_device, obj) == VK_SUCCESS);
+ m_deviceIface->destroyBufferView(m_device, obj);
}
template<>
void Deleter<VkImage>::operator() (VkImage obj) const
{
- DE_TEST_ASSERT(m_deviceIface->destroyImage(m_device, obj) == VK_SUCCESS);
+ m_deviceIface->destroyImage(m_device, obj);
}
template<>
void Deleter<VkImageView>::operator() (VkImageView obj) const
{
- DE_TEST_ASSERT(m_deviceIface->destroyImageView(m_device, obj) == VK_SUCCESS);
-}
-
-template<>
-void Deleter<VkAttachmentView>::operator() (VkAttachmentView obj) const
-{
- DE_TEST_ASSERT(m_deviceIface->destroyAttachmentView(m_device, obj) == VK_SUCCESS);
+ m_deviceIface->destroyImageView(m_device, obj);
}
template<>
void Deleter<VkShaderModule>::operator() (VkShaderModule obj) const
{
- DE_TEST_ASSERT(m_deviceIface->destroyShaderModule(m_device, obj) == VK_SUCCESS);
+ m_deviceIface->destroyShaderModule(m_device, obj);
}
template<>
void Deleter<VkShader>::operator() (VkShader obj) const
{
- DE_TEST_ASSERT(m_deviceIface->destroyShader(m_device, obj) == VK_SUCCESS);
+ m_deviceIface->destroyShader(m_device, obj);
}
template<>
void Deleter<VkPipelineCache>::operator() (VkPipelineCache obj) const
{
- DE_TEST_ASSERT(m_deviceIface->destroyPipelineCache(m_device, obj) == VK_SUCCESS);
+ m_deviceIface->destroyPipelineCache(m_device, obj);
}
template<>
void Deleter<VkPipeline>::operator() (VkPipeline obj) const
{
- DE_TEST_ASSERT(m_deviceIface->destroyPipeline(m_device, obj) == VK_SUCCESS);
+ m_deviceIface->destroyPipeline(m_device, obj);
}
template<>
void Deleter<VkPipelineLayout>::operator() (VkPipelineLayout obj) const
{
- DE_TEST_ASSERT(m_deviceIface->destroyPipelineLayout(m_device, obj) == VK_SUCCESS);
+ m_deviceIface->destroyPipelineLayout(m_device, obj);
}
template<>
void Deleter<VkSampler>::operator() (VkSampler obj) const
{
- DE_TEST_ASSERT(m_deviceIface->destroySampler(m_device, obj) == VK_SUCCESS);
+ m_deviceIface->destroySampler(m_device, obj);
}
template<>
void Deleter<VkDescriptorSetLayout>::operator() (VkDescriptorSetLayout obj) const
{
- DE_TEST_ASSERT(m_deviceIface->destroyDescriptorSetLayout(m_device, obj) == VK_SUCCESS);
+ m_deviceIface->destroyDescriptorSetLayout(m_device, obj);
}
template<>
void Deleter<VkDescriptorPool>::operator() (VkDescriptorPool obj) const
{
- DE_TEST_ASSERT(m_deviceIface->destroyDescriptorPool(m_device, obj) == VK_SUCCESS);
-}
-
-template<>
-void Deleter<VkDynamicViewportState>::operator() (VkDynamicViewportState obj) const
-{
- DE_TEST_ASSERT(m_deviceIface->destroyDynamicViewportState(m_device, obj) == VK_SUCCESS);
-}
-
-template<>
-void Deleter<VkDynamicRasterState>::operator() (VkDynamicRasterState obj) const
-{
- DE_TEST_ASSERT(m_deviceIface->destroyDynamicRasterState(m_device, obj) == VK_SUCCESS);
-}
-
-template<>
-void Deleter<VkDynamicColorBlendState>::operator() (VkDynamicColorBlendState obj) const
-{
- DE_TEST_ASSERT(m_deviceIface->destroyDynamicColorBlendState(m_device, obj) == VK_SUCCESS);
-}
-
-template<>
-void Deleter<VkDynamicDepthStencilState>::operator() (VkDynamicDepthStencilState obj) const
-{
- DE_TEST_ASSERT(m_deviceIface->destroyDynamicDepthStencilState(m_device, obj) == VK_SUCCESS);
+ m_deviceIface->destroyDescriptorPool(m_device, obj);
}
template<>
void Deleter<VkFramebuffer>::operator() (VkFramebuffer obj) const
{
- DE_TEST_ASSERT(m_deviceIface->destroyFramebuffer(m_device, obj) == VK_SUCCESS);
+ m_deviceIface->destroyFramebuffer(m_device, obj);
}
template<>
void Deleter<VkRenderPass>::operator() (VkRenderPass obj) const
{
- DE_TEST_ASSERT(m_deviceIface->destroyRenderPass(m_device, obj) == VK_SUCCESS);
+ m_deviceIface->destroyRenderPass(m_device, obj);
}
template<>
void Deleter<VkCmdPool>::operator() (VkCmdPool obj) const
{
- DE_TEST_ASSERT(m_deviceIface->destroyCommandPool(m_device, obj) == VK_SUCCESS);
+ m_deviceIface->destroyCommandPool(m_device, obj);
}
template<>
void Deleter<VkCmdBuffer>::operator() (VkCmdBuffer obj) const
{
- DE_TEST_ASSERT(m_deviceIface->destroyCommandBuffer(m_device, obj) == VK_SUCCESS);
+ m_deviceIface->destroyCommandBuffer(m_device, obj);
}
} // refdetails
return Move<VkImageView>(check<VkImageView>(object), Deleter<VkImageView>(vk, device));
}
-Move<VkAttachmentView> createAttachmentView (const DeviceInterface& vk, VkDevice device, const VkAttachmentViewCreateInfo* pCreateInfo)
-{
- VkAttachmentView object = 0;
- VK_CHECK(vk.createAttachmentView(device, pCreateInfo, &object));
- return Move<VkAttachmentView>(check<VkAttachmentView>(object), Deleter<VkAttachmentView>(vk, device));
-}
-
Move<VkShaderModule> createShaderModule (const DeviceInterface& vk, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo)
{
VkShaderModule object = 0;
return Move<VkDescriptorSetLayout>(check<VkDescriptorSetLayout>(object), Deleter<VkDescriptorSetLayout>(vk, device));
}
-Move<VkDescriptorPool> createDescriptorPool (const DeviceInterface& vk, VkDevice device, VkDescriptorPoolUsage poolUsage, deUint32 maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo)
+Move<VkDescriptorPool> createDescriptorPool (const DeviceInterface& vk, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo)
{
VkDescriptorPool object = 0;
- VK_CHECK(vk.createDescriptorPool(device, poolUsage, maxSets, pCreateInfo, &object));
+ VK_CHECK(vk.createDescriptorPool(device, pCreateInfo, &object));
return Move<VkDescriptorPool>(check<VkDescriptorPool>(object), Deleter<VkDescriptorPool>(vk, device));
}
-Move<VkDynamicViewportState> createDynamicViewportState (const DeviceInterface& vk, VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo)
-{
- VkDynamicViewportState object = 0;
- VK_CHECK(vk.createDynamicViewportState(device, pCreateInfo, &object));
- return Move<VkDynamicViewportState>(check<VkDynamicViewportState>(object), Deleter<VkDynamicViewportState>(vk, device));
-}
-
-Move<VkDynamicRasterState> createDynamicRasterState (const DeviceInterface& vk, VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo)
-{
- VkDynamicRasterState object = 0;
- VK_CHECK(vk.createDynamicRasterState(device, pCreateInfo, &object));
- return Move<VkDynamicRasterState>(check<VkDynamicRasterState>(object), Deleter<VkDynamicRasterState>(vk, device));
-}
-
-Move<VkDynamicColorBlendState> createDynamicColorBlendState (const DeviceInterface& vk, VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo)
-{
- VkDynamicColorBlendState object = 0;
- VK_CHECK(vk.createDynamicColorBlendState(device, pCreateInfo, &object));
- return Move<VkDynamicColorBlendState>(check<VkDynamicColorBlendState>(object), Deleter<VkDynamicColorBlendState>(vk, device));
-}
-
-Move<VkDynamicDepthStencilState> createDynamicDepthStencilState (const DeviceInterface& vk, VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo)
-{
- VkDynamicDepthStencilState object = 0;
- VK_CHECK(vk.createDynamicDepthStencilState(device, pCreateInfo, &object));
- return Move<VkDynamicDepthStencilState>(check<VkDynamicDepthStencilState>(object), Deleter<VkDynamicDepthStencilState>(vk, device));
-}
-
Move<VkFramebuffer> createFramebuffer (const DeviceInterface& vk, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo)
{
VkFramebuffer object = 0;
const char* getImageAspectName (VkImageAspect value);
const char* getQueryTypeName (VkQueryType value);
const char* getSharingModeName (VkSharingMode value);
-const char* getBufferViewTypeName (VkBufferViewType value);
+const char* getImageLayoutName (VkImageLayout value);
const char* getImageViewTypeName (VkImageViewType value);
const char* getChannelSwizzleName (VkChannelSwizzle value);
const char* getShaderStageName (VkShaderStage value);
const char* getLogicOpName (VkLogicOp value);
const char* getBlendName (VkBlend value);
const char* getBlendOpName (VkBlendOp value);
+const char* getDynamicStateName (VkDynamicState value);
const char* getTexFilterName (VkTexFilter value);
const char* getTexMipmapModeName (VkTexMipmapMode value);
-const char* getTexAddressName (VkTexAddress value);
+const char* getTexAddressModeName (VkTexAddressMode value);
const char* getBorderColorName (VkBorderColor value);
const char* getDescriptorTypeName (VkDescriptorType value);
const char* getDescriptorPoolUsageName (VkDescriptorPoolUsage value);
const char* getDescriptorSetUsageName (VkDescriptorSetUsage value);
-const char* getImageLayoutName (VkImageLayout value);
const char* getAttachmentLoadOpName (VkAttachmentLoadOp value);
const char* getAttachmentStoreOpName (VkAttachmentStoreOp value);
const char* getPipelineBindPointName (VkPipelineBindPoint value);
inline tcu::Format::Enum<VkImageAspect> getImageAspectStr (VkImageAspect value) { return tcu::Format::Enum<VkImageAspect>(getImageAspectName, value); }
inline tcu::Format::Enum<VkQueryType> getQueryTypeStr (VkQueryType value) { return tcu::Format::Enum<VkQueryType>(getQueryTypeName, value); }
inline tcu::Format::Enum<VkSharingMode> getSharingModeStr (VkSharingMode value) { return tcu::Format::Enum<VkSharingMode>(getSharingModeName, value); }
-inline tcu::Format::Enum<VkBufferViewType> getBufferViewTypeStr (VkBufferViewType value) { return tcu::Format::Enum<VkBufferViewType>(getBufferViewTypeName, value); }
+inline tcu::Format::Enum<VkImageLayout> getImageLayoutStr (VkImageLayout value) { return tcu::Format::Enum<VkImageLayout>(getImageLayoutName, value); }
inline tcu::Format::Enum<VkImageViewType> getImageViewTypeStr (VkImageViewType value) { return tcu::Format::Enum<VkImageViewType>(getImageViewTypeName, value); }
inline tcu::Format::Enum<VkChannelSwizzle> getChannelSwizzleStr (VkChannelSwizzle value) { return tcu::Format::Enum<VkChannelSwizzle>(getChannelSwizzleName, value); }
inline tcu::Format::Enum<VkShaderStage> getShaderStageStr (VkShaderStage value) { return tcu::Format::Enum<VkShaderStage>(getShaderStageName, value); }
inline tcu::Format::Enum<VkLogicOp> getLogicOpStr (VkLogicOp value) { return tcu::Format::Enum<VkLogicOp>(getLogicOpName, value); }
inline tcu::Format::Enum<VkBlend> getBlendStr (VkBlend value) { return tcu::Format::Enum<VkBlend>(getBlendName, value); }
inline tcu::Format::Enum<VkBlendOp> getBlendOpStr (VkBlendOp value) { return tcu::Format::Enum<VkBlendOp>(getBlendOpName, value); }
+inline tcu::Format::Enum<VkDynamicState> getDynamicStateStr (VkDynamicState value) { return tcu::Format::Enum<VkDynamicState>(getDynamicStateName, value); }
inline tcu::Format::Enum<VkTexFilter> getTexFilterStr (VkTexFilter value) { return tcu::Format::Enum<VkTexFilter>(getTexFilterName, value); }
inline tcu::Format::Enum<VkTexMipmapMode> getTexMipmapModeStr (VkTexMipmapMode value) { return tcu::Format::Enum<VkTexMipmapMode>(getTexMipmapModeName, value); }
-inline tcu::Format::Enum<VkTexAddress> getTexAddressStr (VkTexAddress value) { return tcu::Format::Enum<VkTexAddress>(getTexAddressName, value); }
+inline tcu::Format::Enum<VkTexAddressMode> getTexAddressModeStr (VkTexAddressMode value) { return tcu::Format::Enum<VkTexAddressMode>(getTexAddressModeName, value); }
inline tcu::Format::Enum<VkBorderColor> getBorderColorStr (VkBorderColor value) { return tcu::Format::Enum<VkBorderColor>(getBorderColorName, value); }
inline tcu::Format::Enum<VkDescriptorType> getDescriptorTypeStr (VkDescriptorType value) { return tcu::Format::Enum<VkDescriptorType>(getDescriptorTypeName, value); }
inline tcu::Format::Enum<VkDescriptorPoolUsage> getDescriptorPoolUsageStr (VkDescriptorPoolUsage value) { return tcu::Format::Enum<VkDescriptorPoolUsage>(getDescriptorPoolUsageName, value); }
inline tcu::Format::Enum<VkDescriptorSetUsage> getDescriptorSetUsageStr (VkDescriptorSetUsage value) { return tcu::Format::Enum<VkDescriptorSetUsage>(getDescriptorSetUsageName, value); }
-inline tcu::Format::Enum<VkImageLayout> getImageLayoutStr (VkImageLayout value) { return tcu::Format::Enum<VkImageLayout>(getImageLayoutName, value); }
inline tcu::Format::Enum<VkAttachmentLoadOp> getAttachmentLoadOpStr (VkAttachmentLoadOp value) { return tcu::Format::Enum<VkAttachmentLoadOp>(getAttachmentLoadOpName, value); }
inline tcu::Format::Enum<VkAttachmentStoreOp> getAttachmentStoreOpStr (VkAttachmentStoreOp value) { return tcu::Format::Enum<VkAttachmentStoreOp>(getAttachmentStoreOpName, value); }
inline tcu::Format::Enum<VkPipelineBindPoint> getPipelineBindPointStr (VkPipelineBindPoint value) { return tcu::Format::Enum<VkPipelineBindPoint>(getPipelineBindPointName, value); }
inline std::ostream& operator<< (std::ostream& s, VkImageAspect value) { return s << getImageAspectStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkQueryType value) { return s << getQueryTypeStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkSharingMode value) { return s << getSharingModeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkBufferViewType value) { return s << getBufferViewTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkImageLayout value) { return s << getImageLayoutStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkImageViewType value) { return s << getImageViewTypeStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkChannelSwizzle value) { return s << getChannelSwizzleStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkShaderStage value) { return s << getShaderStageStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkLogicOp value) { return s << getLogicOpStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkBlend value) { return s << getBlendStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkBlendOp value) { return s << getBlendOpStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkDynamicState value) { return s << getDynamicStateStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkTexFilter value) { return s << getTexFilterStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkTexMipmapMode value) { return s << getTexMipmapModeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkTexAddress value) { return s << getTexAddressStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkTexAddressMode value) { return s << getTexAddressModeStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkBorderColor value) { return s << getBorderColorStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkDescriptorType value) { return s << getDescriptorTypeStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkDescriptorPoolUsage value) { return s << getDescriptorPoolUsageStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkDescriptorSetUsage value) { return s << getDescriptorSetUsageStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkImageLayout value) { return s << getImageLayoutStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkAttachmentLoadOp value) { return s << getAttachmentLoadOpStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkAttachmentStoreOp value) { return s << getAttachmentStoreOpStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkPipelineBindPoint value) { return s << getPipelineBindPointStr(value); }
tcu::Format::Bitfield<32> getFormatFeatureFlagsStr (VkFormatFeatureFlags value);
tcu::Format::Bitfield<32> getImageUsageFlagsStr (VkImageUsageFlags value);
+tcu::Format::Bitfield<32> getImageCreateFlagsStr (VkImageCreateFlags value);
+tcu::Format::Bitfield<32> getSampleCountFlagsStr (VkSampleCountFlags value);
tcu::Format::Bitfield<32> getQueueFlagsStr (VkQueueFlags value);
tcu::Format::Bitfield<32> getMemoryPropertyFlagsStr (VkMemoryPropertyFlags value);
tcu::Format::Bitfield<32> getMemoryHeapFlagsStr (VkMemoryHeapFlags value);
-tcu::Format::Bitfield<32> getDeviceCreateFlagsStr (VkDeviceCreateFlags value);
tcu::Format::Bitfield<32> getSparseImageFormatFlagsStr (VkSparseImageFormatFlags value);
tcu::Format::Bitfield<32> getSparseMemoryBindFlagsStr (VkSparseMemoryBindFlags value);
tcu::Format::Bitfield<32> getFenceCreateFlagsStr (VkFenceCreateFlags value);
tcu::Format::Bitfield<32> getQueryResultFlagsStr (VkQueryResultFlags value);
tcu::Format::Bitfield<32> getBufferUsageFlagsStr (VkBufferUsageFlags value);
tcu::Format::Bitfield<32> getBufferCreateFlagsStr (VkBufferCreateFlags value);
-tcu::Format::Bitfield<32> getImageCreateFlagsStr (VkImageCreateFlags value);
-tcu::Format::Bitfield<32> getAttachmentViewCreateFlagsStr (VkAttachmentViewCreateFlags value);
+tcu::Format::Bitfield<32> getImageAspectFlagsStr (VkImageAspectFlags value);
+tcu::Format::Bitfield<32> getImageViewCreateFlagsStr (VkImageViewCreateFlags value);
tcu::Format::Bitfield<32> getChannelFlagsStr (VkChannelFlags value);
tcu::Format::Bitfield<32> getPipelineCreateFlagsStr (VkPipelineCreateFlags value);
tcu::Format::Bitfield<32> getShaderStageFlagsStr (VkShaderStageFlags value);
+tcu::Format::Bitfield<32> getAttachmentDescriptionFlagsStr (VkAttachmentDescriptionFlags value);
tcu::Format::Bitfield<32> getSubpassDescriptionFlagsStr (VkSubpassDescriptionFlags value);
tcu::Format::Bitfield<32> getPipelineStageFlagsStr (VkPipelineStageFlags value);
tcu::Format::Bitfield<32> getMemoryOutputFlagsStr (VkMemoryOutputFlags value);
tcu::Format::Bitfield<32> getCmdPoolResetFlagsStr (VkCmdPoolResetFlags value);
tcu::Format::Bitfield<32> getCmdBufferOptimizeFlagsStr (VkCmdBufferOptimizeFlags value);
tcu::Format::Bitfield<32> getCmdBufferResetFlagsStr (VkCmdBufferResetFlags value);
-tcu::Format::Bitfield<32> getImageAspectFlagsStr (VkImageAspectFlags value);
+tcu::Format::Bitfield<32> getStencilFaceFlagsStr (VkStencilFaceFlags value);
tcu::Format::Bitfield<32> getQueryControlFlagsStr (VkQueryControlFlags value);
std::ostream& operator<< (std::ostream& s, const VkApplicationInfo& value);
std::ostream& operator<< (std::ostream& s, const VkInstanceCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceFeatures& value);
std::ostream& operator<< (std::ostream& s, const VkFormatProperties& value);
+std::ostream& operator<< (std::ostream& s, const VkExtent3D& value);
std::ostream& operator<< (std::ostream& s, const VkImageFormatProperties& value);
std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceLimits& value);
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceSparseProperties& value);
std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceProperties& value);
-std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceQueueProperties& value);
+std::ostream& operator<< (std::ostream& s, const VkQueueFamilyProperties& value);
std::ostream& operator<< (std::ostream& s, const VkMemoryType& value);
std::ostream& operator<< (std::ostream& s, const VkMemoryHeap& value);
std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceMemoryProperties& value);
std::ostream& operator<< (std::ostream& s, const VkMemoryAllocInfo& value);
std::ostream& operator<< (std::ostream& s, const VkMappedMemoryRange& value);
std::ostream& operator<< (std::ostream& s, const VkMemoryRequirements& value);
-std::ostream& operator<< (std::ostream& s, const VkExtent3D& value);
std::ostream& operator<< (std::ostream& s, const VkSparseImageFormatProperties& value);
std::ostream& operator<< (std::ostream& s, const VkSparseImageMemoryRequirements& value);
std::ostream& operator<< (std::ostream& s, const VkSparseMemoryBindInfo& value);
std::ostream& operator<< (std::ostream& s, const VkChannelMapping& value);
std::ostream& operator<< (std::ostream& s, const VkImageSubresourceRange& value);
std::ostream& operator<< (std::ostream& s, const VkImageViewCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkAttachmentViewCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkShaderModuleCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkShaderCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkPipelineCacheCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkPipelineVertexInputStateCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkPipelineInputAssemblyStateCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkPipelineTessellationStateCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkViewport& value);
+std::ostream& operator<< (std::ostream& s, const VkOffset2D& value);
+std::ostream& operator<< (std::ostream& s, const VkExtent2D& value);
+std::ostream& operator<< (std::ostream& s, const VkRect2D& value);
std::ostream& operator<< (std::ostream& s, const VkPipelineViewportStateCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkPipelineRasterStateCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkPipelineMultisampleStateCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkPipelineDepthStencilStateCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkPipelineColorBlendAttachmentState& value);
std::ostream& operator<< (std::ostream& s, const VkPipelineColorBlendStateCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkPipelineDynamicStateCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkGraphicsPipelineCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkComputePipelineCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkPushConstantRange& value);
std::ostream& operator<< (std::ostream& s, const VkDescriptorSetLayoutCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkDescriptorTypeCount& value);
std::ostream& operator<< (std::ostream& s, const VkDescriptorPoolCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkDescriptorBufferInfo& value);
std::ostream& operator<< (std::ostream& s, const VkDescriptorInfo& value);
std::ostream& operator<< (std::ostream& s, const VkWriteDescriptorSet& value);
std::ostream& operator<< (std::ostream& s, const VkCopyDescriptorSet& value);
-std::ostream& operator<< (std::ostream& s, const VkViewport& value);
-std::ostream& operator<< (std::ostream& s, const VkOffset2D& value);
-std::ostream& operator<< (std::ostream& s, const VkExtent2D& value);
-std::ostream& operator<< (std::ostream& s, const VkRect2D& value);
-std::ostream& operator<< (std::ostream& s, const VkDynamicViewportStateCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkDynamicRasterStateCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkDynamicColorBlendStateCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkDynamicDepthStencilStateCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkAttachmentBindInfo& value);
std::ostream& operator<< (std::ostream& s, const VkFramebufferCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkAttachmentDescription& value);
std::ostream& operator<< (std::ostream& s, const VkAttachmentReference& value);
std::ostream& operator<< (std::ostream& s, const VkCmdBufferCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkCmdBufferBeginInfo& value);
std::ostream& operator<< (std::ostream& s, const VkBufferCopy& value);
+std::ostream& operator<< (std::ostream& s, const VkImageSubresourceCopy& value);
std::ostream& operator<< (std::ostream& s, const VkImageCopy& value);
std::ostream& operator<< (std::ostream& s, const VkImageBlit& value);
std::ostream& operator<< (std::ostream& s, const VkBufferImageCopy& value);
std::ostream& operator<< (std::ostream& s, const VkClearColorValue& value);
+std::ostream& operator<< (std::ostream& s, const VkClearDepthStencilValue& value);
std::ostream& operator<< (std::ostream& s, const VkRect3D& value);
std::ostream& operator<< (std::ostream& s, const VkImageResolve& value);
-std::ostream& operator<< (std::ostream& s, const VkClearDepthStencilValue& value);
std::ostream& operator<< (std::ostream& s, const VkClearValue& value);
std::ostream& operator<< (std::ostream& s, const VkRenderPassBeginInfo& value);
std::ostream& operator<< (std::ostream& s, const VkBufferMemoryBarrier& value);
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-template<> const char* getTypeName<VkInstance> (void) { return "VkInstance"; }
-template<> const char* getTypeName<VkPhysicalDevice> (void) { return "VkPhysicalDevice"; }
-template<> const char* getTypeName<VkDevice> (void) { return "VkDevice"; }
-template<> const char* getTypeName<VkQueue> (void) { return "VkQueue"; }
-template<> const char* getTypeName<VkCmdBuffer> (void) { return "VkCmdBuffer"; }
-template<> const char* getTypeName<VkFence> (void) { return "VkFence"; }
-template<> const char* getTypeName<VkDeviceMemory> (void) { return "VkDeviceMemory"; }
-template<> const char* getTypeName<VkBuffer> (void) { return "VkBuffer"; }
-template<> const char* getTypeName<VkImage> (void) { return "VkImage"; }
-template<> const char* getTypeName<VkSemaphore> (void) { return "VkSemaphore"; }
-template<> const char* getTypeName<VkEvent> (void) { return "VkEvent"; }
-template<> const char* getTypeName<VkQueryPool> (void) { return "VkQueryPool"; }
-template<> const char* getTypeName<VkBufferView> (void) { return "VkBufferView"; }
-template<> const char* getTypeName<VkImageView> (void) { return "VkImageView"; }
-template<> const char* getTypeName<VkAttachmentView> (void) { return "VkAttachmentView"; }
-template<> const char* getTypeName<VkShaderModule> (void) { return "VkShaderModule"; }
-template<> const char* getTypeName<VkShader> (void) { return "VkShader"; }
-template<> const char* getTypeName<VkPipelineCache> (void) { return "VkPipelineCache"; }
-template<> const char* getTypeName<VkPipelineLayout> (void) { return "VkPipelineLayout"; }
-template<> const char* getTypeName<VkRenderPass> (void) { return "VkRenderPass"; }
-template<> const char* getTypeName<VkPipeline> (void) { return "VkPipeline"; }
-template<> const char* getTypeName<VkDescriptorSetLayout> (void) { return "VkDescriptorSetLayout"; }
-template<> const char* getTypeName<VkSampler> (void) { return "VkSampler"; }
-template<> const char* getTypeName<VkDescriptorPool> (void) { return "VkDescriptorPool"; }
-template<> const char* getTypeName<VkDescriptorSet> (void) { return "VkDescriptorSet"; }
-template<> const char* getTypeName<VkDynamicViewportState> (void) { return "VkDynamicViewportState"; }
-template<> const char* getTypeName<VkDynamicRasterState> (void) { return "VkDynamicRasterState"; }
-template<> const char* getTypeName<VkDynamicColorBlendState> (void) { return "VkDynamicColorBlendState"; }
-template<> const char* getTypeName<VkDynamicDepthStencilState> (void) { return "VkDynamicDepthStencilState"; }
-template<> const char* getTypeName<VkFramebuffer> (void) { return "VkFramebuffer"; }
-template<> const char* getTypeName<VkCmdPool> (void) { return "VkCmdPool"; }
+template<> const char* getTypeName<VkInstance> (void) { return "VkInstance"; }
+template<> const char* getTypeName<VkPhysicalDevice> (void) { return "VkPhysicalDevice"; }
+template<> const char* getTypeName<VkDevice> (void) { return "VkDevice"; }
+template<> const char* getTypeName<VkQueue> (void) { return "VkQueue"; }
+template<> const char* getTypeName<VkCmdBuffer> (void) { return "VkCmdBuffer"; }
+template<> const char* getTypeName<VkFence> (void) { return "VkFence"; }
+template<> const char* getTypeName<VkDeviceMemory> (void) { return "VkDeviceMemory"; }
+template<> const char* getTypeName<VkBuffer> (void) { return "VkBuffer"; }
+template<> const char* getTypeName<VkImage> (void) { return "VkImage"; }
+template<> const char* getTypeName<VkSemaphore> (void) { return "VkSemaphore"; }
+template<> const char* getTypeName<VkEvent> (void) { return "VkEvent"; }
+template<> const char* getTypeName<VkQueryPool> (void) { return "VkQueryPool"; }
+template<> const char* getTypeName<VkBufferView> (void) { return "VkBufferView"; }
+template<> const char* getTypeName<VkImageView> (void) { return "VkImageView"; }
+template<> const char* getTypeName<VkShaderModule> (void) { return "VkShaderModule"; }
+template<> const char* getTypeName<VkShader> (void) { return "VkShader"; }
+template<> const char* getTypeName<VkPipelineCache> (void) { return "VkPipelineCache"; }
+template<> const char* getTypeName<VkPipelineLayout> (void) { return "VkPipelineLayout"; }
+template<> const char* getTypeName<VkRenderPass> (void) { return "VkRenderPass"; }
+template<> const char* getTypeName<VkPipeline> (void) { return "VkPipeline"; }
+template<> const char* getTypeName<VkDescriptorSetLayout> (void) { return "VkDescriptorSetLayout"; }
+template<> const char* getTypeName<VkSampler> (void) { return "VkSampler"; }
+template<> const char* getTypeName<VkDescriptorPool> (void) { return "VkDescriptorPool"; }
+template<> const char* getTypeName<VkDescriptorSet> (void) { return "VkDescriptorSet"; }
+template<> const char* getTypeName<VkFramebuffer> (void) { return "VkFramebuffer"; }
+template<> const char* getTypeName<VkCmdPool> (void) { return "VkCmdPool"; }
const char* getResultName (VkResult value)
{
switch (value)
{
- case VK_SUCCESS: return "VK_SUCCESS";
- case VK_UNSUPPORTED: return "VK_UNSUPPORTED";
- case VK_NOT_READY: return "VK_NOT_READY";
- case VK_TIMEOUT: return "VK_TIMEOUT";
- case VK_EVENT_SET: return "VK_EVENT_SET";
- case VK_EVENT_RESET: return "VK_EVENT_RESET";
- case VK_INCOMPLETE: return "VK_INCOMPLETE";
- case VK_ERROR_UNKNOWN: return "VK_ERROR_UNKNOWN";
- case VK_ERROR_UNAVAILABLE: return "VK_ERROR_UNAVAILABLE";
- case VK_ERROR_INITIALIZATION_FAILED: return "VK_ERROR_INITIALIZATION_FAILED";
- case VK_ERROR_OUT_OF_HOST_MEMORY: return "VK_ERROR_OUT_OF_HOST_MEMORY";
- case VK_ERROR_OUT_OF_DEVICE_MEMORY: return "VK_ERROR_OUT_OF_DEVICE_MEMORY";
- case VK_ERROR_DEVICE_ALREADY_CREATED: return "VK_ERROR_DEVICE_ALREADY_CREATED";
- case VK_ERROR_DEVICE_LOST: return "VK_ERROR_DEVICE_LOST";
- case VK_ERROR_INVALID_POINTER: return "VK_ERROR_INVALID_POINTER";
- case VK_ERROR_INVALID_VALUE: return "VK_ERROR_INVALID_VALUE";
- case VK_ERROR_INVALID_HANDLE: return "VK_ERROR_INVALID_HANDLE";
- case VK_ERROR_INVALID_ORDINAL: return "VK_ERROR_INVALID_ORDINAL";
- case VK_ERROR_INVALID_MEMORY_SIZE: return "VK_ERROR_INVALID_MEMORY_SIZE";
- case VK_ERROR_INVALID_EXTENSION: return "VK_ERROR_INVALID_EXTENSION";
- case VK_ERROR_INVALID_FLAGS: return "VK_ERROR_INVALID_FLAGS";
- case VK_ERROR_INVALID_ALIGNMENT: return "VK_ERROR_INVALID_ALIGNMENT";
- case VK_ERROR_INVALID_FORMAT: return "VK_ERROR_INVALID_FORMAT";
- case VK_ERROR_INVALID_IMAGE: return "VK_ERROR_INVALID_IMAGE";
- case VK_ERROR_INVALID_DESCRIPTOR_SET_DATA: return "VK_ERROR_INVALID_DESCRIPTOR_SET_DATA";
- case VK_ERROR_INVALID_QUEUE_TYPE: return "VK_ERROR_INVALID_QUEUE_TYPE";
- case VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION: return "VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION";
- case VK_ERROR_BAD_SHADER_CODE: return "VK_ERROR_BAD_SHADER_CODE";
- case VK_ERROR_BAD_PIPELINE_DATA: return "VK_ERROR_BAD_PIPELINE_DATA";
- case VK_ERROR_NOT_MAPPABLE: return "VK_ERROR_NOT_MAPPABLE";
- case VK_ERROR_MEMORY_MAP_FAILED: return "VK_ERROR_MEMORY_MAP_FAILED";
- case VK_ERROR_MEMORY_UNMAP_FAILED: return "VK_ERROR_MEMORY_UNMAP_FAILED";
- case VK_ERROR_INCOMPATIBLE_DEVICE: return "VK_ERROR_INCOMPATIBLE_DEVICE";
- case VK_ERROR_INCOMPATIBLE_DRIVER: return "VK_ERROR_INCOMPATIBLE_DRIVER";
- case VK_ERROR_INCOMPLETE_COMMAND_BUFFER: return "VK_ERROR_INCOMPLETE_COMMAND_BUFFER";
- case VK_ERROR_BUILDING_COMMAND_BUFFER: return "VK_ERROR_BUILDING_COMMAND_BUFFER";
- case VK_ERROR_MEMORY_NOT_BOUND: return "VK_ERROR_MEMORY_NOT_BOUND";
- case VK_ERROR_INCOMPATIBLE_QUEUE: return "VK_ERROR_INCOMPATIBLE_QUEUE";
- case VK_ERROR_INVALID_LAYER: return "VK_ERROR_INVALID_LAYER";
- default: return DE_NULL;
+ case VK_SUCCESS: return "VK_SUCCESS";
+ case VK_UNSUPPORTED: return "VK_UNSUPPORTED";
+ case VK_NOT_READY: return "VK_NOT_READY";
+ case VK_TIMEOUT: return "VK_TIMEOUT";
+ case VK_EVENT_SET: return "VK_EVENT_SET";
+ case VK_EVENT_RESET: return "VK_EVENT_RESET";
+ case VK_INCOMPLETE: return "VK_INCOMPLETE";
+ case VK_ERROR_OUT_OF_HOST_MEMORY: return "VK_ERROR_OUT_OF_HOST_MEMORY";
+ case VK_ERROR_OUT_OF_DEVICE_MEMORY: return "VK_ERROR_OUT_OF_DEVICE_MEMORY";
+ case VK_ERROR_INITIALIZATION_FAILED: return "VK_ERROR_INITIALIZATION_FAILED";
+ case VK_ERROR_DEVICE_LOST: return "VK_ERROR_DEVICE_LOST";
+ case VK_ERROR_MEMORY_MAP_FAILED: return "VK_ERROR_MEMORY_MAP_FAILED";
+ case VK_ERROR_LAYER_NOT_PRESENT: return "VK_ERROR_LAYER_NOT_PRESENT";
+ case VK_ERROR_EXTENSION_NOT_PRESENT: return "VK_ERROR_EXTENSION_NOT_PRESENT";
+ case VK_ERROR_INCOMPATIBLE_DRIVER: return "VK_ERROR_INCOMPATIBLE_DRIVER";
+ default: return DE_NULL;
}
}
case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: return "VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO";
case VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO: return "VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO";
case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: return "VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO";
- case VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO: return "VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO";
case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: return "VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO";
case VK_STRUCTURE_TYPE_SHADER_CREATE_INFO: return "VK_STRUCTURE_TYPE_SHADER_CREATE_INFO";
case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: return "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO";
case VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO: return "VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO";
case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO: return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO";
- case VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO";
case VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO: return "VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO";
case VK_STRUCTURE_TYPE_EVENT_CREATE_INFO: return "VK_STRUCTURE_TYPE_EVENT_CREATE_INFO";
case VK_STRUCTURE_TYPE_FENCE_CREATE_INFO: return "VK_STRUCTURE_TYPE_FENCE_CREATE_INFO";
case VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY: return "VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY";
case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO: return "VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO";
case VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO: return "VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO: return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO";
default: return DE_NULL;
}
}
case VK_FORMAT_R11G11B10_UFLOAT: return "VK_FORMAT_R11G11B10_UFLOAT";
case VK_FORMAT_R9G9B9E5_UFLOAT: return "VK_FORMAT_R9G9B9E5_UFLOAT";
case VK_FORMAT_D16_UNORM: return "VK_FORMAT_D16_UNORM";
- case VK_FORMAT_D24_UNORM: return "VK_FORMAT_D24_UNORM";
+ case VK_FORMAT_D24_UNORM_X8: return "VK_FORMAT_D24_UNORM_X8";
case VK_FORMAT_D32_SFLOAT: return "VK_FORMAT_D32_SFLOAT";
case VK_FORMAT_S8_UINT: return "VK_FORMAT_S8_UINT";
case VK_FORMAT_D16_UNORM_S8_UINT: return "VK_FORMAT_D16_UNORM_S8_UINT";
}
}
-const char* getBufferViewTypeName (VkBufferViewType value)
+const char* getImageLayoutName (VkImageLayout value)
{
switch (value)
{
- case VK_BUFFER_VIEW_TYPE_RAW: return "VK_BUFFER_VIEW_TYPE_RAW";
- case VK_BUFFER_VIEW_TYPE_FORMATTED: return "VK_BUFFER_VIEW_TYPE_FORMATTED";
- default: return DE_NULL;
+ case VK_IMAGE_LAYOUT_UNDEFINED: return "VK_IMAGE_LAYOUT_UNDEFINED";
+ case VK_IMAGE_LAYOUT_GENERAL: return "VK_IMAGE_LAYOUT_GENERAL";
+ case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL: return "VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
+ case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL: return "VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
+ case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL: return "VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
+ case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL: return "VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
+ case VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL: return "VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL";
+ case VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL: return "VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL";
+ case VK_IMAGE_LAYOUT_PREINITIALIZED: return "VK_IMAGE_LAYOUT_PREINITIALIZED";
+ default: return DE_NULL;
}
}
}
}
+const char* getDynamicStateName (VkDynamicState value)
+{
+ switch (value)
+ {
+ case VK_DYNAMIC_STATE_VIEWPORT: return "VK_DYNAMIC_STATE_VIEWPORT";
+ case VK_DYNAMIC_STATE_SCISSOR: return "VK_DYNAMIC_STATE_SCISSOR";
+ case VK_DYNAMIC_STATE_LINE_WIDTH: return "VK_DYNAMIC_STATE_LINE_WIDTH";
+ case VK_DYNAMIC_STATE_DEPTH_BIAS: return "VK_DYNAMIC_STATE_DEPTH_BIAS";
+ case VK_DYNAMIC_STATE_BLEND_CONSTANTS: return "VK_DYNAMIC_STATE_BLEND_CONSTANTS";
+ case VK_DYNAMIC_STATE_DEPTH_BOUNDS: return "VK_DYNAMIC_STATE_DEPTH_BOUNDS";
+ case VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK: return "VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK";
+ case VK_DYNAMIC_STATE_STENCIL_WRITE_MASK: return "VK_DYNAMIC_STATE_STENCIL_WRITE_MASK";
+ case VK_DYNAMIC_STATE_STENCIL_REFERENCE: return "VK_DYNAMIC_STATE_STENCIL_REFERENCE";
+ default: return DE_NULL;
+ }
+}
+
const char* getTexFilterName (VkTexFilter value)
{
switch (value)
}
}
-const char* getTexAddressName (VkTexAddress value)
+const char* getTexAddressModeName (VkTexAddressMode value)
{
switch (value)
{
- case VK_TEX_ADDRESS_WRAP: return "VK_TEX_ADDRESS_WRAP";
- case VK_TEX_ADDRESS_MIRROR: return "VK_TEX_ADDRESS_MIRROR";
- case VK_TEX_ADDRESS_CLAMP: return "VK_TEX_ADDRESS_CLAMP";
- case VK_TEX_ADDRESS_MIRROR_ONCE: return "VK_TEX_ADDRESS_MIRROR_ONCE";
- case VK_TEX_ADDRESS_CLAMP_BORDER: return "VK_TEX_ADDRESS_CLAMP_BORDER";
- default: return DE_NULL;
+ case VK_TEX_ADDRESS_MODE_WRAP: return "VK_TEX_ADDRESS_MODE_WRAP";
+ case VK_TEX_ADDRESS_MODE_MIRROR: return "VK_TEX_ADDRESS_MODE_MIRROR";
+ case VK_TEX_ADDRESS_MODE_CLAMP: return "VK_TEX_ADDRESS_MODE_CLAMP";
+ case VK_TEX_ADDRESS_MODE_MIRROR_ONCE: return "VK_TEX_ADDRESS_MODE_MIRROR_ONCE";
+ case VK_TEX_ADDRESS_MODE_CLAMP_BORDER: return "VK_TEX_ADDRESS_MODE_CLAMP_BORDER";
+ default: return DE_NULL;
}
}
}
}
-const char* getImageLayoutName (VkImageLayout value)
-{
- switch (value)
- {
- case VK_IMAGE_LAYOUT_UNDEFINED: return "VK_IMAGE_LAYOUT_UNDEFINED";
- case VK_IMAGE_LAYOUT_GENERAL: return "VK_IMAGE_LAYOUT_GENERAL";
- case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL: return "VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
- case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL: return "VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
- case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL: return "VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
- case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL: return "VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
- case VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL: return "VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL";
- case VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL: return "VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL";
- default: return DE_NULL;
- }
-}
-
const char* getAttachmentLoadOpName (VkAttachmentLoadOp value)
{
switch (value)
tcu::Format::BitDesc(VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT, "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT"),
tcu::Format::BitDesc(VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT"),
tcu::Format::BitDesc(VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT, "VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT"),
- tcu::Format::BitDesc(VK_FORMAT_FEATURE_CONVERSION_BIT, "VK_FORMAT_FEATURE_CONVERSION_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_BLIT_SOURCE_BIT, "VK_FORMAT_FEATURE_BLIT_SOURCE_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_BLIT_DESTINATION_BIT, "VK_FORMAT_FEATURE_BLIT_DESTINATION_BIT"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_IMAGE_USAGE_GENERAL, "VK_IMAGE_USAGE_GENERAL"),
- tcu::Format::BitDesc(VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT, "VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT, "VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_USAGE_SAMPLED_BIT, "VK_IMAGE_USAGE_SAMPLED_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_USAGE_STORAGE_BIT, "VK_IMAGE_USAGE_STORAGE_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, "VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_USAGE_DEPTH_STENCIL_BIT, "VK_IMAGE_USAGE_DEPTH_STENCIL_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, "VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, "VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT, "VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT, "VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_USAGE_SAMPLED_BIT, "VK_IMAGE_USAGE_SAMPLED_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_USAGE_STORAGE_BIT, "VK_IMAGE_USAGE_STORAGE_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, "VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, "VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, "VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, "VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getImageCreateFlagsStr (VkImageCreateFlags value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_IMAGE_CREATE_SPARSE_BINDING_BIT, "VK_IMAGE_CREATE_SPARSE_BINDING_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, "VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, "VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, "VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getSampleCountFlagsStr (VkSampleCountFlags value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_SAMPLE_COUNT_1_BIT, "VK_SAMPLE_COUNT_1_BIT"),
+ tcu::Format::BitDesc(VK_SAMPLE_COUNT_2_BIT, "VK_SAMPLE_COUNT_2_BIT"),
+ tcu::Format::BitDesc(VK_SAMPLE_COUNT_4_BIT, "VK_SAMPLE_COUNT_4_BIT"),
+ tcu::Format::BitDesc(VK_SAMPLE_COUNT_8_BIT, "VK_SAMPLE_COUNT_8_BIT"),
+ tcu::Format::BitDesc(VK_SAMPLE_COUNT_16_BIT, "VK_SAMPLE_COUNT_16_BIT"),
+ tcu::Format::BitDesc(VK_SAMPLE_COUNT_32_BIT, "VK_SAMPLE_COUNT_32_BIT"),
+ tcu::Format::BitDesc(VK_SAMPLE_COUNT_64_BIT, "VK_SAMPLE_COUNT_64_BIT"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_MEMORY_HEAP_HOST_LOCAL, "VK_MEMORY_HEAP_HOST_LOCAL"),
- };
- return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
-}
-
-tcu::Format::Bitfield<32> getDeviceCreateFlagsStr (VkDeviceCreateFlags value)
-{
- static const tcu::Format::BitDesc s_desc[] =
- {
- tcu::Format::BitDesc(VK_DEVICE_CREATE_VALIDATION_BIT, "VK_DEVICE_CREATE_VALIDATION_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_HEAP_HOST_LOCAL_BIT, "VK_MEMORY_HEAP_HOST_LOCAL_BIT"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_BUFFER_USAGE_GENERAL, "VK_BUFFER_USAGE_GENERAL"),
tcu::Format::BitDesc(VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT, "VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT"),
tcu::Format::BitDesc(VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT, "VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT"),
tcu::Format::BitDesc(VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, "VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT"),
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_BUFFER_CREATE_SPARSE_BIT, "VK_BUFFER_CREATE_SPARSE_BIT"),
+ tcu::Format::BitDesc(VK_BUFFER_CREATE_SPARSE_BINDING_BIT, "VK_BUFFER_CREATE_SPARSE_BINDING_BIT"),
tcu::Format::BitDesc(VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, "VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT"),
tcu::Format::BitDesc(VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, "VK_BUFFER_CREATE_SPARSE_ALIASED_BIT"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
-tcu::Format::Bitfield<32> getImageCreateFlagsStr (VkImageCreateFlags value)
+tcu::Format::Bitfield<32> getImageAspectFlagsStr (VkImageAspectFlags value)
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_IMAGE_CREATE_SPARSE_BIT, "VK_IMAGE_CREATE_SPARSE_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, "VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_CREATE_INVARIANT_DATA_BIT, "VK_IMAGE_CREATE_INVARIANT_DATA_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, "VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, "VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_ASPECT_COLOR_BIT, "VK_IMAGE_ASPECT_COLOR_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_ASPECT_DEPTH_BIT, "VK_IMAGE_ASPECT_DEPTH_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_ASPECT_STENCIL_BIT, "VK_IMAGE_ASPECT_STENCIL_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_ASPECT_METADATA_BIT, "VK_IMAGE_ASPECT_METADATA_BIT"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
-tcu::Format::Bitfield<32> getAttachmentViewCreateFlagsStr (VkAttachmentViewCreateFlags value)
+tcu::Format::Bitfield<32> getImageViewCreateFlagsStr (VkImageViewCreateFlags value)
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_DEPTH_BIT, "VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_DEPTH_BIT"),
- tcu::Format::BitDesc(VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_STENCIL_BIT, "VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_STENCIL_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_VIEW_CREATE_READ_ONLY_DEPTH_BIT, "VK_IMAGE_VIEW_CREATE_READ_ONLY_DEPTH_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_VIEW_CREATE_READ_ONLY_STENCIL_BIT, "VK_IMAGE_VIEW_CREATE_READ_ONLY_STENCIL_BIT"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
+tcu::Format::Bitfield<32> getAttachmentDescriptionFlagsStr (VkAttachmentDescriptionFlags value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT, "VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
tcu::Format::Bitfield<32> getSubpassDescriptionFlagsStr (VkSubpassDescriptionFlags value)
{
static const tcu::Format::BitDesc s_desc[] =
tcu::Format::BitDesc(VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, "VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT"),
tcu::Format::BitDesc(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, "VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT"),
tcu::Format::BitDesc(VK_PIPELINE_STAGE_TRANSFER_BIT, "VK_PIPELINE_STAGE_TRANSFER_BIT"),
- tcu::Format::BitDesc(VK_PIPELINE_STAGE_TRANSITION_BIT, "VK_PIPELINE_STAGE_TRANSITION_BIT"),
tcu::Format::BitDesc(VK_PIPELINE_STAGE_HOST_BIT, "VK_PIPELINE_STAGE_HOST_BIT"),
tcu::Format::BitDesc(VK_PIPELINE_STAGE_ALL_GRAPHICS, "VK_PIPELINE_STAGE_ALL_GRAPHICS"),
tcu::Format::BitDesc(VK_PIPELINE_STAGE_ALL_GPU_COMMANDS, "VK_PIPELINE_STAGE_ALL_GPU_COMMANDS"),
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_CMD_POOL_RESET_RELEASE_RESOURCES, "VK_CMD_POOL_RESET_RELEASE_RESOURCES"),
+ tcu::Format::BitDesc(VK_CMD_POOL_RESET_RELEASE_RESOURCES_BIT, "VK_CMD_POOL_RESET_RELEASE_RESOURCES_BIT"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_CMD_BUFFER_RESET_RELEASE_RESOURCES, "VK_CMD_BUFFER_RESET_RELEASE_RESOURCES"),
+ tcu::Format::BitDesc(VK_CMD_BUFFER_RESET_RELEASE_RESOURCES_BIT, "VK_CMD_BUFFER_RESET_RELEASE_RESOURCES_BIT"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
-tcu::Format::Bitfield<32> getImageAspectFlagsStr (VkImageAspectFlags value)
+tcu::Format::Bitfield<32> getStencilFaceFlagsStr (VkStencilFaceFlags value)
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_IMAGE_ASPECT_COLOR_BIT, "VK_IMAGE_ASPECT_COLOR_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_ASPECT_DEPTH_BIT, "VK_IMAGE_ASPECT_DEPTH_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_ASPECT_STENCIL_BIT, "VK_IMAGE_ASPECT_STENCIL_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_ASPECT_METADATA_BIT, "VK_IMAGE_ASPECT_METADATA_BIT"),
+ tcu::Format::BitDesc(VK_STENCIL_FACE_NONE, "VK_STENCIL_FACE_NONE"),
+ tcu::Format::BitDesc(VK_STENCIL_FACE_FRONT_BIT, "VK_STENCIL_FACE_FRONT_BIT"),
+ tcu::Format::BitDesc(VK_STENCIL_FACE_BACK_BIT, "VK_STENCIL_FACE_BACK_BIT"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
s << "\tsampleRateShading = " << value.sampleRateShading << '\n';
s << "\tdualSourceBlend = " << value.dualSourceBlend << '\n';
s << "\tlogicOp = " << value.logicOp << '\n';
- s << "\tinstancedDrawIndirect = " << value.instancedDrawIndirect << '\n';
+ s << "\tmultiDrawIndirect = " << value.multiDrawIndirect << '\n';
s << "\tdepthClip = " << value.depthClip << '\n';
s << "\tdepthBiasClamp = " << value.depthBiasClamp << '\n';
s << "\tfillModeNonSolid = " << value.fillModeNonSolid << '\n';
s << "\ttextureCompressionETC2 = " << value.textureCompressionETC2 << '\n';
s << "\ttextureCompressionASTC_LDR = " << value.textureCompressionASTC_LDR << '\n';
s << "\ttextureCompressionBC = " << value.textureCompressionBC << '\n';
+ s << "\tocclusionQueryNonConservative = " << value.occlusionQueryNonConservative << '\n';
s << "\tpipelineStatisticsQuery = " << value.pipelineStatisticsQuery << '\n';
s << "\tvertexSideEffects = " << value.vertexSideEffects << '\n';
s << "\ttessellationSideEffects = " << value.tessellationSideEffects << '\n';
s << "\tfragmentSideEffects = " << value.fragmentSideEffects << '\n';
s << "\tshaderTessellationPointSize = " << value.shaderTessellationPointSize << '\n';
s << "\tshaderGeometryPointSize = " << value.shaderGeometryPointSize << '\n';
- s << "\tshaderTextureGatherExtended = " << value.shaderTextureGatherExtended << '\n';
+ s << "\tshaderImageGatherExtended = " << value.shaderImageGatherExtended << '\n';
s << "\tshaderStorageImageExtendedFormats = " << value.shaderStorageImageExtendedFormats << '\n';
s << "\tshaderStorageImageMultisample = " << value.shaderStorageImageMultisample << '\n';
- s << "\tshaderStorageBufferArrayConstantIndexing = " << value.shaderStorageBufferArrayConstantIndexing << '\n';
- s << "\tshaderStorageImageArrayConstantIndexing = " << value.shaderStorageImageArrayConstantIndexing << '\n';
s << "\tshaderUniformBufferArrayDynamicIndexing = " << value.shaderUniformBufferArrayDynamicIndexing << '\n';
s << "\tshaderSampledImageArrayDynamicIndexing = " << value.shaderSampledImageArrayDynamicIndexing << '\n';
s << "\tshaderStorageBufferArrayDynamicIndexing = " << value.shaderStorageBufferArrayDynamicIndexing << '\n';
s << "\tshaderCullDistance = " << value.shaderCullDistance << '\n';
s << "\tshaderFloat64 = " << value.shaderFloat64 << '\n';
s << "\tshaderInt64 = " << value.shaderInt64 << '\n';
- s << "\tshaderFloat16 = " << value.shaderFloat16 << '\n';
s << "\tshaderInt16 = " << value.shaderInt16 << '\n';
s << "\tshaderResourceResidency = " << value.shaderResourceResidency << '\n';
s << "\tshaderResourceMinLOD = " << value.shaderResourceMinLOD << '\n';
- s << "\tsparse = " << value.sparse << '\n';
+ s << "\talphaToOne = " << value.alphaToOne << '\n';
+ s << "\tsparseBinding = " << value.sparseBinding << '\n';
s << "\tsparseResidencyBuffer = " << value.sparseResidencyBuffer << '\n';
s << "\tsparseResidencyImage2D = " << value.sparseResidencyImage2D << '\n';
s << "\tsparseResidencyImage3D = " << value.sparseResidencyImage3D << '\n';
s << "\tsparseResidency4Samples = " << value.sparseResidency4Samples << '\n';
s << "\tsparseResidency8Samples = " << value.sparseResidency8Samples << '\n';
s << "\tsparseResidency16Samples = " << value.sparseResidency16Samples << '\n';
- s << "\tsparseResidencyStandard2DBlockShape = " << value.sparseResidencyStandard2DBlockShape << '\n';
- s << "\tsparseResidencyStandard2DMSBlockShape = " << value.sparseResidencyStandard2DMSBlockShape << '\n';
- s << "\tsparseResidencyStandard3DBlockShape = " << value.sparseResidencyStandard3DBlockShape << '\n';
- s << "\tsparseResidencyAlignedMipSize = " << value.sparseResidencyAlignedMipSize << '\n';
- s << "\tsparseResidencyNonResident = " << value.sparseResidencyNonResident << '\n';
- s << "\tsparseResidencyNonResidentStrict = " << value.sparseResidencyNonResidentStrict << '\n';
s << "\tsparseResidencyAliased = " << value.sparseResidencyAliased << '\n';
s << '}';
return s;
s << "VkFormatProperties = {\n";
s << "\tlinearTilingFeatures = " << getFormatFeatureFlagsStr(value.linearTilingFeatures) << '\n';
s << "\toptimalTilingFeatures = " << getFormatFeatureFlagsStr(value.optimalTilingFeatures) << '\n';
+ s << "\tbufferFeatures = " << getFormatFeatureFlagsStr(value.bufferFeatures) << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkExtent3D& value)
+{
+ s << "VkExtent3D = {\n";
+ s << "\twidth = " << value.width << '\n';
+ s << "\theight = " << value.height << '\n';
+ s << "\tdepth = " << value.depth << '\n';
s << '}';
return s;
}
std::ostream& operator<< (std::ostream& s, const VkImageFormatProperties& value)
{
s << "VkImageFormatProperties = {\n";
+ s << "\tmaxExtent = " << value.maxExtent << '\n';
+ s << "\tmaxMipLevels = " << value.maxMipLevels << '\n';
+ s << "\tmaxArraySize = " << value.maxArraySize << '\n';
+ s << "\tsampleCounts = " << getSampleCountFlagsStr(value.sampleCounts) << '\n';
s << "\tmaxResourceSize = " << value.maxResourceSize << '\n';
- s << "\tmaxSamples = " << value.maxSamples << '\n';
s << '}';
return s;
}
s << "\tmaxImageDimension3D = " << value.maxImageDimension3D << '\n';
s << "\tmaxImageDimensionCube = " << value.maxImageDimensionCube << '\n';
s << "\tmaxImageArrayLayers = " << value.maxImageArrayLayers << '\n';
+ s << "\tsampleCounts = " << getSampleCountFlagsStr(value.sampleCounts) << '\n';
s << "\tmaxTexelBufferSize = " << value.maxTexelBufferSize << '\n';
s << "\tmaxUniformBufferSize = " << value.maxUniformBufferSize << '\n';
s << "\tmaxStorageBufferSize = " << value.maxStorageBufferSize << '\n';
s << "\tmaxPushConstantsSize = " << value.maxPushConstantsSize << '\n';
s << "\tmaxMemoryAllocationCount = " << value.maxMemoryAllocationCount << '\n';
s << "\tbufferImageGranularity = " << value.bufferImageGranularity << '\n';
+ s << "\tsparseAddressSpaceSize = " << value.sparseAddressSpaceSize << '\n';
s << "\tmaxBoundDescriptorSets = " << value.maxBoundDescriptorSets << '\n';
s << "\tmaxDescriptorSets = " << value.maxDescriptorSets << '\n';
s << "\tmaxPerStageDescriptorSamplers = " << value.maxPerStageDescriptorSamplers << '\n';
s << "\tmaxPerStageDescriptorStorageImages = " << value.maxPerStageDescriptorStorageImages << '\n';
s << "\tmaxDescriptorSetSamplers = " << value.maxDescriptorSetSamplers << '\n';
s << "\tmaxDescriptorSetUniformBuffers = " << value.maxDescriptorSetUniformBuffers << '\n';
+ s << "\tmaxDescriptorSetUniformBuffersDynamic = " << value.maxDescriptorSetUniformBuffersDynamic << '\n';
s << "\tmaxDescriptorSetStorageBuffers = " << value.maxDescriptorSetStorageBuffers << '\n';
+ s << "\tmaxDescriptorSetStorageBuffersDynamic = " << value.maxDescriptorSetStorageBuffersDynamic << '\n';
s << "\tmaxDescriptorSetSampledImages = " << value.maxDescriptorSetSampledImages << '\n';
s << "\tmaxDescriptorSetStorageImages = " << value.maxDescriptorSetStorageImages << '\n';
s << "\tmaxVertexInputAttributes = " << value.maxVertexInputAttributes << '\n';
+ s << "\tmaxVertexInputBindings = " << value.maxVertexInputBindings << '\n';
s << "\tmaxVertexInputAttributeOffset = " << value.maxVertexInputAttributeOffset << '\n';
s << "\tmaxVertexInputBindingStride = " << value.maxVertexInputBindingStride << '\n';
s << "\tmaxVertexOutputComponents = " << value.maxVertexOutputComponents << '\n';
s << "\tmaxSamplerLodBias = " << value.maxSamplerLodBias << '\n';
s << "\tmaxSamplerAnisotropy = " << value.maxSamplerAnisotropy << '\n';
s << "\tmaxViewports = " << value.maxViewports << '\n';
- s << "\tmaxDynamicViewportStates = " << value.maxDynamicViewportStates << '\n';
s << "\tmaxViewportDimensions = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.maxViewportDimensions), DE_ARRAY_END(value.maxViewportDimensions)) << '\n';
s << "\tviewportBoundsRange = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.viewportBoundsRange), DE_ARRAY_END(value.viewportBoundsRange)) << '\n';
s << "\tviewportSubPixelBits = " << value.viewportSubPixelBits << '\n';
return s;
}
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceSparseProperties& value)
+{
+ s << "VkPhysicalDeviceSparseProperties = {\n";
+ s << "\tresidencyStandard2DBlockShape = " << value.residencyStandard2DBlockShape << '\n';
+ s << "\tresidencyStandard2DMSBlockShape = " << value.residencyStandard2DMSBlockShape << '\n';
+ s << "\tresidencyStandard3DBlockShape = " << value.residencyStandard3DBlockShape << '\n';
+ s << "\tresidencyAlignedMipSize = " << value.residencyAlignedMipSize << '\n';
+ s << "\tresidencyNonResident = " << value.residencyNonResident << '\n';
+ s << "\tresidencyNonResidentStrict = " << value.residencyNonResidentStrict << '\n';
+ s << '}';
+ return s;
+}
+
std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceProperties& value)
{
s << "VkPhysicalDeviceProperties = {\n";
s << "\tdeviceId = " << value.deviceId << '\n';
s << "\tdeviceType = " << value.deviceType << '\n';
s << "\tdeviceName = " << (const char*)value.deviceName << '\n';
- s << "\tpipelineCacheUUID = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.pipelineCacheUUID), DE_ARRAY_END(value.pipelineCacheUUID)) << '\n';
+ s << "\tpipelineCacheUUID = " << '\n' << tcu::formatArray(tcu::Format::HexIterator<deUint8>(DE_ARRAY_BEGIN(value.pipelineCacheUUID)), tcu::Format::HexIterator<deUint8>(DE_ARRAY_END(value.pipelineCacheUUID))) << '\n';
+ s << "\tlimits = " << value.limits << '\n';
+ s << "\tsparseProperties = " << value.sparseProperties << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceQueueProperties& value)
+std::ostream& operator<< (std::ostream& s, const VkQueueFamilyProperties& value)
{
- s << "VkPhysicalDeviceQueueProperties = {\n";
+ s << "VkQueueFamilyProperties = {\n";
s << "\tqueueFlags = " << getQueueFlagsStr(value.queueFlags) << '\n';
s << "\tqueueCount = " << value.queueCount << '\n';
s << "\tsupportsTimestamps = " << value.supportsTimestamps << '\n';
std::ostream& operator<< (std::ostream& s, const VkDeviceQueueCreateInfo& value)
{
s << "VkDeviceQueueCreateInfo = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
s << "\tqueueFamilyIndex = " << value.queueFamilyIndex << '\n';
s << "\tqueueCount = " << value.queueCount << '\n';
s << '}';
s << "\textensionCount = " << value.extensionCount << '\n';
s << "\tppEnabledExtensionNames = " << value.ppEnabledExtensionNames << '\n';
s << "\tpEnabledFeatures = " << value.pEnabledFeatures << '\n';
- s << "\tflags = " << getDeviceCreateFlagsStr(value.flags) << '\n';
s << '}';
return s;
}
std::ostream& operator<< (std::ostream& s, const VkLayerProperties& value)
{
s << "VkLayerProperties = {\n";
- s << "\tlayerName = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.layerName), DE_ARRAY_END(value.layerName)) << '\n';
+ s << "\tlayerName = " << (const char*)value.layerName << '\n';
s << "\tspecVersion = " << value.specVersion << '\n';
s << "\timplVersion = " << value.implVersion << '\n';
- s << "\tdescription = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.description), DE_ARRAY_END(value.description)) << '\n';
+ s << "\tdescription = " << (const char*)value.description << '\n';
s << '}';
return s;
}
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkExtent3D& value)
-{
- s << "VkExtent3D = {\n";
- s << "\twidth = " << value.width << '\n';
- s << "\theight = " << value.height << '\n';
- s << "\tdepth = " << value.depth << '\n';
- s << '}';
- return s;
-}
-
std::ostream& operator<< (std::ostream& s, const VkSparseImageFormatProperties& value)
{
s << "VkSparseImageFormatProperties = {\n";
s << "VkImageSubresource = {\n";
s << "\taspect = " << value.aspect << '\n';
s << "\tmipLevel = " << value.mipLevel << '\n';
- s << "\tarraySlice = " << value.arraySlice << '\n';
+ s << "\tarrayLayer = " << value.arrayLayer << '\n';
s << '}';
return s;
}
s << "\tsType = " << value.sType << '\n';
s << "\tpNext = " << value.pNext << '\n';
s << "\tbuffer = " << value.buffer << '\n';
- s << "\tviewType = " << value.viewType << '\n';
s << "\tformat = " << value.format << '\n';
s << "\toffset = " << value.offset << '\n';
s << "\trange = " << value.range << '\n';
s << "\tsharingMode = " << value.sharingMode << '\n';
s << "\tqueueFamilyCount = " << value.queueFamilyCount << '\n';
s << "\tpQueueFamilyIndices = " << value.pQueueFamilyIndices << '\n';
+ s << "\tinitialLayout = " << value.initialLayout << '\n';
s << '}';
return s;
}
std::ostream& operator<< (std::ostream& s, const VkImageSubresourceRange& value)
{
s << "VkImageSubresourceRange = {\n";
- s << "\taspect = " << value.aspect << '\n';
+ s << "\taspectMask = " << getImageAspectFlagsStr(value.aspectMask) << '\n';
s << "\tbaseMipLevel = " << value.baseMipLevel << '\n';
s << "\tmipLevels = " << value.mipLevels << '\n';
- s << "\tbaseArraySlice = " << value.baseArraySlice << '\n';
+ s << "\tbaseArrayLayer = " << value.baseArrayLayer << '\n';
s << "\tarraySize = " << value.arraySize << '\n';
s << '}';
return s;
s << "\tformat = " << value.format << '\n';
s << "\tchannels = " << value.channels << '\n';
s << "\tsubresourceRange = " << value.subresourceRange << '\n';
- s << '}';
- return s;
-}
-
-std::ostream& operator<< (std::ostream& s, const VkAttachmentViewCreateInfo& value)
-{
- s << "VkAttachmentViewCreateInfo = {\n";
- s << "\tsType = " << value.sType << '\n';
- s << "\tpNext = " << value.pNext << '\n';
- s << "\timage = " << value.image << '\n';
- s << "\tformat = " << value.format << '\n';
- s << "\tmipLevel = " << value.mipLevel << '\n';
- s << "\tbaseArraySlice = " << value.baseArraySlice << '\n';
- s << "\tarraySize = " << value.arraySize << '\n';
- s << "\tflags = " << getAttachmentViewCreateFlagsStr(value.flags) << '\n';
+ s << "\tflags = " << getImageViewCreateFlagsStr(value.flags) << '\n';
s << '}';
return s;
}
s << "\tmodule = " << value.module << '\n';
s << "\tpName = " << getCharPtrStr(value.pName) << '\n';
s << "\tflags = " << value.flags << '\n';
+ s << "\tstage = " << value.stage << '\n';
s << '}';
return s;
}
return s;
}
+std::ostream& operator<< (std::ostream& s, const VkViewport& value)
+{
+ s << "VkViewport = {\n";
+ s << "\toriginX = " << value.originX << '\n';
+ s << "\toriginY = " << value.originY << '\n';
+ s << "\twidth = " << value.width << '\n';
+ s << "\theight = " << value.height << '\n';
+ s << "\tminDepth = " << value.minDepth << '\n';
+ s << "\tmaxDepth = " << value.maxDepth << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkOffset2D& value)
+{
+ s << "VkOffset2D = {\n";
+ s << "\tx = " << value.x << '\n';
+ s << "\ty = " << value.y << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkExtent2D& value)
+{
+ s << "VkExtent2D = {\n";
+ s << "\twidth = " << value.width << '\n';
+ s << "\theight = " << value.height << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkRect2D& value)
+{
+ s << "VkRect2D = {\n";
+ s << "\toffset = " << value.offset << '\n';
+ s << "\textent = " << value.extent << '\n';
+ s << '}';
+ return s;
+}
+
std::ostream& operator<< (std::ostream& s, const VkPipelineViewportStateCreateInfo& value)
{
s << "VkPipelineViewportStateCreateInfo = {\n";
s << "\tsType = " << value.sType << '\n';
s << "\tpNext = " << value.pNext << '\n';
s << "\tviewportCount = " << value.viewportCount << '\n';
+ s << "\tpViewports = " << value.pViewports << '\n';
+ s << "\tscissorCount = " << value.scissorCount << '\n';
+ s << "\tpScissors = " << value.pScissors << '\n';
s << '}';
return s;
}
s << "\tfillMode = " << value.fillMode << '\n';
s << "\tcullMode = " << value.cullMode << '\n';
s << "\tfrontFace = " << value.frontFace << '\n';
+ s << "\tdepthBiasEnable = " << value.depthBiasEnable << '\n';
+ s << "\tdepthBias = " << value.depthBias << '\n';
+ s << "\tdepthBiasClamp = " << value.depthBiasClamp << '\n';
+ s << "\tslopeScaledDepthBias = " << value.slopeScaledDepthBias << '\n';
+ s << "\tlineWidth = " << value.lineWidth << '\n';
s << '}';
return s;
}
s << "\trasterSamples = " << value.rasterSamples << '\n';
s << "\tsampleShadingEnable = " << value.sampleShadingEnable << '\n';
s << "\tminSampleShading = " << value.minSampleShading << '\n';
- s << "\tsampleMask = " << value.sampleMask << '\n';
+ s << "\tpSampleMask = " << value.pSampleMask << '\n';
s << '}';
return s;
}
s << "\tstencilPassOp = " << value.stencilPassOp << '\n';
s << "\tstencilDepthFailOp = " << value.stencilDepthFailOp << '\n';
s << "\tstencilCompareOp = " << value.stencilCompareOp << '\n';
+ s << "\tstencilCompareMask = " << value.stencilCompareMask << '\n';
+ s << "\tstencilWriteMask = " << value.stencilWriteMask << '\n';
+ s << "\tstencilReference = " << value.stencilReference << '\n';
s << '}';
return s;
}
s << "\tdepthTestEnable = " << value.depthTestEnable << '\n';
s << "\tdepthWriteEnable = " << value.depthWriteEnable << '\n';
s << "\tdepthCompareOp = " << value.depthCompareOp << '\n';
- s << "\tdepthBoundsEnable = " << value.depthBoundsEnable << '\n';
+ s << "\tdepthBoundsTestEnable = " << value.depthBoundsTestEnable << '\n';
s << "\tstencilTestEnable = " << value.stencilTestEnable << '\n';
s << "\tfront = " << value.front << '\n';
s << "\tback = " << value.back << '\n';
+ s << "\tminDepthBounds = " << value.minDepthBounds << '\n';
+ s << "\tmaxDepthBounds = " << value.maxDepthBounds << '\n';
s << '}';
return s;
}
s << "\tsType = " << value.sType << '\n';
s << "\tpNext = " << value.pNext << '\n';
s << "\talphaToCoverageEnable = " << value.alphaToCoverageEnable << '\n';
+ s << "\talphaToOneEnable = " << value.alphaToOneEnable << '\n';
s << "\tlogicOpEnable = " << value.logicOpEnable << '\n';
s << "\tlogicOp = " << value.logicOp << '\n';
s << "\tattachmentCount = " << value.attachmentCount << '\n';
s << "\tpAttachments = " << value.pAttachments << '\n';
+ s << "\tblendConst = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.blendConst), DE_ARRAY_END(value.blendConst)) << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPipelineDynamicStateCreateInfo& value)
+{
+ s << "VkPipelineDynamicStateCreateInfo = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tdynamicStateCount = " << value.dynamicStateCount << '\n';
+ s << "\tpDynamicStates = " << value.pDynamicStates << '\n';
s << '}';
return s;
}
s << "\tpMultisampleState = " << value.pMultisampleState << '\n';
s << "\tpDepthStencilState = " << value.pDepthStencilState << '\n';
s << "\tpColorBlendState = " << value.pColorBlendState << '\n';
+ s << "\tpDynamicState = " << value.pDynamicState << '\n';
s << "\tflags = " << getPipelineCreateFlagsStr(value.flags) << '\n';
s << "\tlayout = " << value.layout << '\n';
s << "\trenderPass = " << value.renderPass << '\n';
s << "VkComputePipelineCreateInfo = {\n";
s << "\tsType = " << value.sType << '\n';
s << "\tpNext = " << value.pNext << '\n';
- s << "\tcs = " << value.cs << '\n';
+ s << "\tstage = " << value.stage << '\n';
s << "\tflags = " << getPipelineCreateFlagsStr(value.flags) << '\n';
s << "\tlayout = " << value.layout << '\n';
s << "\tbasePipelineHandle = " << value.basePipelineHandle << '\n';
s << "\tmagFilter = " << value.magFilter << '\n';
s << "\tminFilter = " << value.minFilter << '\n';
s << "\tmipMode = " << value.mipMode << '\n';
- s << "\taddressU = " << value.addressU << '\n';
- s << "\taddressV = " << value.addressV << '\n';
- s << "\taddressW = " << value.addressW << '\n';
+ s << "\taddressModeU = " << value.addressModeU << '\n';
+ s << "\taddressModeV = " << value.addressModeV << '\n';
+ s << "\taddressModeW = " << value.addressModeW << '\n';
s << "\tmipLodBias = " << value.mipLodBias << '\n';
s << "\tmaxAnisotropy = " << value.maxAnisotropy << '\n';
s << "\tcompareEnable = " << value.compareEnable << '\n';
s << "\tminLod = " << value.minLod << '\n';
s << "\tmaxLod = " << value.maxLod << '\n';
s << "\tborderColor = " << value.borderColor << '\n';
+ s << "\tunnormalizedCoordinates = " << value.unnormalizedCoordinates << '\n';
s << '}';
return s;
}
s << "VkDescriptorPoolCreateInfo = {\n";
s << "\tsType = " << value.sType << '\n';
s << "\tpNext = " << value.pNext << '\n';
+ s << "\tpoolUsage = " << value.poolUsage << '\n';
+ s << "\tmaxSets = " << value.maxSets << '\n';
s << "\tcount = " << value.count << '\n';
s << "\tpTypeCount = " << value.pTypeCount << '\n';
s << '}';
return s;
}
+std::ostream& operator<< (std::ostream& s, const VkDescriptorBufferInfo& value)
+{
+ s << "VkDescriptorBufferInfo = {\n";
+ s << "\tbuffer = " << value.buffer << '\n';
+ s << "\toffset = " << value.offset << '\n';
+ s << "\trange = " << value.range << '\n';
+ s << '}';
+ return s;
+}
+
std::ostream& operator<< (std::ostream& s, const VkDescriptorInfo& value)
{
s << "VkDescriptorInfo = {\n";
s << "\tbufferView = " << value.bufferView << '\n';
s << "\tsampler = " << value.sampler << '\n';
s << "\timageView = " << value.imageView << '\n';
- s << "\tattachmentView = " << value.attachmentView << '\n';
s << "\timageLayout = " << value.imageLayout << '\n';
+ s << "\tbufferInfo = " << value.bufferInfo << '\n';
s << '}';
return s;
}
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkViewport& value)
-{
- s << "VkViewport = {\n";
- s << "\toriginX = " << value.originX << '\n';
- s << "\toriginY = " << value.originY << '\n';
- s << "\twidth = " << value.width << '\n';
- s << "\theight = " << value.height << '\n';
- s << "\tminDepth = " << value.minDepth << '\n';
- s << "\tmaxDepth = " << value.maxDepth << '\n';
- s << '}';
- return s;
-}
-
-std::ostream& operator<< (std::ostream& s, const VkOffset2D& value)
-{
- s << "VkOffset2D = {\n";
- s << "\tx = " << value.x << '\n';
- s << "\ty = " << value.y << '\n';
- s << '}';
- return s;
-}
-
-std::ostream& operator<< (std::ostream& s, const VkExtent2D& value)
-{
- s << "VkExtent2D = {\n";
- s << "\twidth = " << value.width << '\n';
- s << "\theight = " << value.height << '\n';
- s << '}';
- return s;
-}
-
-std::ostream& operator<< (std::ostream& s, const VkRect2D& value)
-{
- s << "VkRect2D = {\n";
- s << "\toffset = " << value.offset << '\n';
- s << "\textent = " << value.extent << '\n';
- s << '}';
- return s;
-}
-
-std::ostream& operator<< (std::ostream& s, const VkDynamicViewportStateCreateInfo& value)
-{
- s << "VkDynamicViewportStateCreateInfo = {\n";
- s << "\tsType = " << value.sType << '\n';
- s << "\tpNext = " << value.pNext << '\n';
- s << "\tviewportAndScissorCount = " << value.viewportAndScissorCount << '\n';
- s << "\tpViewports = " << value.pViewports << '\n';
- s << "\tpScissors = " << value.pScissors << '\n';
- s << '}';
- return s;
-}
-
-std::ostream& operator<< (std::ostream& s, const VkDynamicRasterStateCreateInfo& value)
-{
- s << "VkDynamicRasterStateCreateInfo = {\n";
- s << "\tsType = " << value.sType << '\n';
- s << "\tpNext = " << value.pNext << '\n';
- s << "\tdepthBias = " << value.depthBias << '\n';
- s << "\tdepthBiasClamp = " << value.depthBiasClamp << '\n';
- s << "\tslopeScaledDepthBias = " << value.slopeScaledDepthBias << '\n';
- s << "\tlineWidth = " << value.lineWidth << '\n';
- s << '}';
- return s;
-}
-
-std::ostream& operator<< (std::ostream& s, const VkDynamicColorBlendStateCreateInfo& value)
-{
- s << "VkDynamicColorBlendStateCreateInfo = {\n";
- s << "\tsType = " << value.sType << '\n';
- s << "\tpNext = " << value.pNext << '\n';
- s << "\tblendConst = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.blendConst), DE_ARRAY_END(value.blendConst)) << '\n';
- s << '}';
- return s;
-}
-
-std::ostream& operator<< (std::ostream& s, const VkDynamicDepthStencilStateCreateInfo& value)
-{
- s << "VkDynamicDepthStencilStateCreateInfo = {\n";
- s << "\tsType = " << value.sType << '\n';
- s << "\tpNext = " << value.pNext << '\n';
- s << "\tminDepthBounds = " << value.minDepthBounds << '\n';
- s << "\tmaxDepthBounds = " << value.maxDepthBounds << '\n';
- s << "\tstencilReadMask = " << value.stencilReadMask << '\n';
- s << "\tstencilWriteMask = " << value.stencilWriteMask << '\n';
- s << "\tstencilFrontRef = " << value.stencilFrontRef << '\n';
- s << "\tstencilBackRef = " << value.stencilBackRef << '\n';
- s << '}';
- return s;
-}
-
-std::ostream& operator<< (std::ostream& s, const VkAttachmentBindInfo& value)
-{
- s << "VkAttachmentBindInfo = {\n";
- s << "\tview = " << value.view << '\n';
- s << "\tlayout = " << value.layout << '\n';
- s << '}';
- return s;
-}
-
std::ostream& operator<< (std::ostream& s, const VkFramebufferCreateInfo& value)
{
s << "VkFramebufferCreateInfo = {\n";
s << "\tstencilStoreOp = " << value.stencilStoreOp << '\n';
s << "\tinitialLayout = " << value.initialLayout << '\n';
s << "\tfinalLayout = " << value.finalLayout << '\n';
+ s << "\tflags = " << getAttachmentDescriptionFlagsStr(value.flags) << '\n';
s << '}';
return s;
}
s << "\tpipelineBindPoint = " << value.pipelineBindPoint << '\n';
s << "\tflags = " << getSubpassDescriptionFlagsStr(value.flags) << '\n';
s << "\tinputCount = " << value.inputCount << '\n';
- s << "\tinputAttachments = " << value.inputAttachments << '\n';
+ s << "\tpInputAttachments = " << value.pInputAttachments << '\n';
s << "\tcolorCount = " << value.colorCount << '\n';
- s << "\tcolorAttachments = " << value.colorAttachments << '\n';
- s << "\tresolveAttachments = " << value.resolveAttachments << '\n';
+ s << "\tpColorAttachments = " << value.pColorAttachments << '\n';
+ s << "\tpResolveAttachments = " << value.pResolveAttachments << '\n';
s << "\tdepthStencilAttachment = " << value.depthStencilAttachment << '\n';
s << "\tpreserveCount = " << value.preserveCount << '\n';
- s << "\tpreserveAttachments = " << value.preserveAttachments << '\n';
+ s << "\tpPreserveAttachments = " << value.pPreserveAttachments << '\n';
s << '}';
return s;
}
s << "\tpNext = " << value.pNext << '\n';
s << "\tflags = " << getCmdBufferOptimizeFlagsStr(value.flags) << '\n';
s << "\trenderPass = " << value.renderPass << '\n';
+ s << "\tsubpass = " << value.subpass << '\n';
s << "\tframebuffer = " << value.framebuffer << '\n';
s << '}';
return s;
return s;
}
+std::ostream& operator<< (std::ostream& s, const VkImageSubresourceCopy& value)
+{
+ s << "VkImageSubresourceCopy = {\n";
+ s << "\taspect = " << value.aspect << '\n';
+ s << "\tmipLevel = " << value.mipLevel << '\n';
+ s << "\tarrayLayer = " << value.arrayLayer << '\n';
+ s << "\tarraySize = " << value.arraySize << '\n';
+ s << '}';
+ return s;
+}
+
std::ostream& operator<< (std::ostream& s, const VkImageCopy& value)
{
s << "VkImageCopy = {\n";
std::ostream& operator<< (std::ostream& s, const VkClearColorValue& value)
{
s << "VkClearColorValue = {\n";
- s << "\tf32 = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.f32), DE_ARRAY_END(value.f32)) << '\n';
- s << "\ts32 = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.s32), DE_ARRAY_END(value.s32)) << '\n';
- s << "\tu32 = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.u32), DE_ARRAY_END(value.u32)) << '\n';
+ s << "\tfloat32 = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.float32), DE_ARRAY_END(value.float32)) << '\n';
+ s << "\tint32 = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.int32), DE_ARRAY_END(value.int32)) << '\n';
+ s << "\tuint32 = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.uint32), DE_ARRAY_END(value.uint32)) << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkClearDepthStencilValue& value)
+{
+ s << "VkClearDepthStencilValue = {\n";
+ s << "\tdepth = " << value.depth << '\n';
+ s << "\tstencil = " << value.stencil << '\n';
s << '}';
return s;
}
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkClearDepthStencilValue& value)
-{
- s << "VkClearDepthStencilValue = {\n";
- s << "\tdepth = " << value.depth << '\n';
- s << "\tstencil = " << value.stencil << '\n';
- s << '}';
- return s;
-}
-
std::ostream& operator<< (std::ostream& s, const VkClearValue& value)
{
s << "VkClearValue = {\n";
s << "\tcolor = " << value.color << '\n';
- s << "\tds = " << value.ds << '\n';
+ s << "\tdepthStencil = " << value.depthStencil << '\n';
s << '}';
return s;
}
s << "\trenderPass = " << value.renderPass << '\n';
s << "\tframebuffer = " << value.framebuffer << '\n';
s << "\trenderArea = " << value.renderArea << '\n';
- s << "\tattachmentCount = " << value.attachmentCount << '\n';
- s << "\tpAttachmentClearValues = " << value.pAttachmentClearValues << '\n';
+ s << "\tclearValueCount = " << value.clearValueCount << '\n';
+ s << "\tpClearValues = " << value.pClearValues << '\n';
s << '}';
return s;
}
VkBool32 sampleRateShading;
VkBool32 dualSourceBlend;
VkBool32 logicOp;
- VkBool32 instancedDrawIndirect;
+ VkBool32 multiDrawIndirect;
VkBool32 depthClip;
VkBool32 depthBiasClamp;
VkBool32 fillModeNonSolid;
VkBool32 textureCompressionETC2;
VkBool32 textureCompressionASTC_LDR;
VkBool32 textureCompressionBC;
+ VkBool32 occlusionQueryNonConservative;
VkBool32 pipelineStatisticsQuery;
VkBool32 vertexSideEffects;
VkBool32 tessellationSideEffects;
VkBool32 fragmentSideEffects;
VkBool32 shaderTessellationPointSize;
VkBool32 shaderGeometryPointSize;
- VkBool32 shaderTextureGatherExtended;
+ VkBool32 shaderImageGatherExtended;
VkBool32 shaderStorageImageExtendedFormats;
VkBool32 shaderStorageImageMultisample;
- VkBool32 shaderStorageBufferArrayConstantIndexing;
- VkBool32 shaderStorageImageArrayConstantIndexing;
VkBool32 shaderUniformBufferArrayDynamicIndexing;
VkBool32 shaderSampledImageArrayDynamicIndexing;
VkBool32 shaderStorageBufferArrayDynamicIndexing;
VkBool32 shaderCullDistance;
VkBool32 shaderFloat64;
VkBool32 shaderInt64;
- VkBool32 shaderFloat16;
VkBool32 shaderInt16;
VkBool32 shaderResourceResidency;
VkBool32 shaderResourceMinLOD;
- VkBool32 sparse;
+ VkBool32 alphaToOne;
+ VkBool32 sparseBinding;
VkBool32 sparseResidencyBuffer;
VkBool32 sparseResidencyImage2D;
VkBool32 sparseResidencyImage3D;
VkBool32 sparseResidency4Samples;
VkBool32 sparseResidency8Samples;
VkBool32 sparseResidency16Samples;
- VkBool32 sparseResidencyStandard2DBlockShape;
- VkBool32 sparseResidencyStandard2DMSBlockShape;
- VkBool32 sparseResidencyStandard3DBlockShape;
- VkBool32 sparseResidencyAlignedMipSize;
- VkBool32 sparseResidencyNonResident;
- VkBool32 sparseResidencyNonResidentStrict;
VkBool32 sparseResidencyAliased;
};
{
VkFormatFeatureFlags linearTilingFeatures;
VkFormatFeatureFlags optimalTilingFeatures;
+ VkFormatFeatureFlags bufferFeatures;
+};
+
+struct VkExtent3D
+{
+ deInt32 width;
+ deInt32 height;
+ deInt32 depth;
};
struct VkImageFormatProperties
{
- deUint64 maxResourceSize;
- deUint32 maxSamples;
+ VkExtent3D maxExtent;
+ deUint32 maxMipLevels;
+ deUint32 maxArraySize;
+ VkSampleCountFlags sampleCounts;
+ VkDeviceSize maxResourceSize;
};
struct VkPhysicalDeviceLimits
{
- deUint32 maxImageDimension1D;
- deUint32 maxImageDimension2D;
- deUint32 maxImageDimension3D;
- deUint32 maxImageDimensionCube;
- deUint32 maxImageArrayLayers;
- deUint32 maxTexelBufferSize;
- deUint32 maxUniformBufferSize;
- deUint32 maxStorageBufferSize;
- deUint32 maxPushConstantsSize;
- deUint32 maxMemoryAllocationCount;
- VkDeviceSize bufferImageGranularity;
- deUint32 maxBoundDescriptorSets;
- deUint32 maxDescriptorSets;
- deUint32 maxPerStageDescriptorSamplers;
- deUint32 maxPerStageDescriptorUniformBuffers;
- deUint32 maxPerStageDescriptorStorageBuffers;
- deUint32 maxPerStageDescriptorSampledImages;
- deUint32 maxPerStageDescriptorStorageImages;
- deUint32 maxDescriptorSetSamplers;
- deUint32 maxDescriptorSetUniformBuffers;
- deUint32 maxDescriptorSetStorageBuffers;
- deUint32 maxDescriptorSetSampledImages;
- deUint32 maxDescriptorSetStorageImages;
- deUint32 maxVertexInputAttributes;
- deUint32 maxVertexInputAttributeOffset;
- deUint32 maxVertexInputBindingStride;
- deUint32 maxVertexOutputComponents;
- deUint32 maxTessGenLevel;
- deUint32 maxTessPatchSize;
- deUint32 maxTessControlPerVertexInputComponents;
- deUint32 maxTessControlPerVertexOutputComponents;
- deUint32 maxTessControlPerPatchOutputComponents;
- deUint32 maxTessControlTotalOutputComponents;
- deUint32 maxTessEvaluationInputComponents;
- deUint32 maxTessEvaluationOutputComponents;
- deUint32 maxGeometryShaderInvocations;
- deUint32 maxGeometryInputComponents;
- deUint32 maxGeometryOutputComponents;
- deUint32 maxGeometryOutputVertices;
- deUint32 maxGeometryTotalOutputComponents;
- deUint32 maxFragmentInputComponents;
- deUint32 maxFragmentOutputBuffers;
- deUint32 maxFragmentDualSourceBuffers;
- deUint32 maxFragmentCombinedOutputResources;
- deUint32 maxComputeSharedMemorySize;
- deUint32 maxComputeWorkGroupCount[3];
- deUint32 maxComputeWorkGroupInvocations;
- deUint32 maxComputeWorkGroupSize[3];
- deUint32 subPixelPrecisionBits;
- deUint32 subTexelPrecisionBits;
- deUint32 mipmapPrecisionBits;
- deUint32 maxDrawIndexedIndexValue;
- deUint32 maxDrawIndirectInstanceCount;
- VkBool32 primitiveRestartForPatches;
- float maxSamplerLodBias;
- float maxSamplerAnisotropy;
- deUint32 maxViewports;
- deUint32 maxDynamicViewportStates;
- deUint32 maxViewportDimensions[2];
- float viewportBoundsRange[2];
- deUint32 viewportSubPixelBits;
- deUint32 minMemoryMapAlignment;
- deUint32 minTexelBufferOffsetAlignment;
- deUint32 minUniformBufferOffsetAlignment;
- deUint32 minStorageBufferOffsetAlignment;
- deUint32 minTexelOffset;
- deUint32 maxTexelOffset;
- deUint32 minTexelGatherOffset;
- deUint32 maxTexelGatherOffset;
- float minInterpolationOffset;
- float maxInterpolationOffset;
- deUint32 subPixelInterpolationOffsetBits;
- deUint32 maxFramebufferWidth;
- deUint32 maxFramebufferHeight;
- deUint32 maxFramebufferLayers;
- deUint32 maxFramebufferColorSamples;
- deUint32 maxFramebufferDepthSamples;
- deUint32 maxFramebufferStencilSamples;
- deUint32 maxColorAttachments;
- deUint32 maxSampledImageColorSamples;
- deUint32 maxSampledImageDepthSamples;
- deUint32 maxSampledImageIntegerSamples;
- deUint32 maxStorageImageSamples;
- deUint32 maxSampleMaskWords;
- deUint64 timestampFrequency;
- deUint32 maxClipDistances;
- deUint32 maxCullDistances;
- deUint32 maxCombinedClipAndCullDistances;
- float pointSizeRange[2];
- float lineWidthRange[2];
- float pointSizeGranularity;
- float lineWidthGranularity;
+ deUint32 maxImageDimension1D;
+ deUint32 maxImageDimension2D;
+ deUint32 maxImageDimension3D;
+ deUint32 maxImageDimensionCube;
+ deUint32 maxImageArrayLayers;
+ VkSampleCountFlags sampleCounts;
+ deUint32 maxTexelBufferSize;
+ deUint32 maxUniformBufferSize;
+ deUint32 maxStorageBufferSize;
+ deUint32 maxPushConstantsSize;
+ deUint32 maxMemoryAllocationCount;
+ VkDeviceSize bufferImageGranularity;
+ VkDeviceSize sparseAddressSpaceSize;
+ deUint32 maxBoundDescriptorSets;
+ deUint32 maxDescriptorSets;
+ deUint32 maxPerStageDescriptorSamplers;
+ deUint32 maxPerStageDescriptorUniformBuffers;
+ deUint32 maxPerStageDescriptorStorageBuffers;
+ deUint32 maxPerStageDescriptorSampledImages;
+ deUint32 maxPerStageDescriptorStorageImages;
+ deUint32 maxDescriptorSetSamplers;
+ deUint32 maxDescriptorSetUniformBuffers;
+ deUint32 maxDescriptorSetUniformBuffersDynamic;
+ deUint32 maxDescriptorSetStorageBuffers;
+ deUint32 maxDescriptorSetStorageBuffersDynamic;
+ deUint32 maxDescriptorSetSampledImages;
+ deUint32 maxDescriptorSetStorageImages;
+ deUint32 maxVertexInputAttributes;
+ deUint32 maxVertexInputBindings;
+ deUint32 maxVertexInputAttributeOffset;
+ deUint32 maxVertexInputBindingStride;
+ deUint32 maxVertexOutputComponents;
+ deUint32 maxTessGenLevel;
+ deUint32 maxTessPatchSize;
+ deUint32 maxTessControlPerVertexInputComponents;
+ deUint32 maxTessControlPerVertexOutputComponents;
+ deUint32 maxTessControlPerPatchOutputComponents;
+ deUint32 maxTessControlTotalOutputComponents;
+ deUint32 maxTessEvaluationInputComponents;
+ deUint32 maxTessEvaluationOutputComponents;
+ deUint32 maxGeometryShaderInvocations;
+ deUint32 maxGeometryInputComponents;
+ deUint32 maxGeometryOutputComponents;
+ deUint32 maxGeometryOutputVertices;
+ deUint32 maxGeometryTotalOutputComponents;
+ deUint32 maxFragmentInputComponents;
+ deUint32 maxFragmentOutputBuffers;
+ deUint32 maxFragmentDualSourceBuffers;
+ deUint32 maxFragmentCombinedOutputResources;
+ deUint32 maxComputeSharedMemorySize;
+ deUint32 maxComputeWorkGroupCount[3];
+ deUint32 maxComputeWorkGroupInvocations;
+ deUint32 maxComputeWorkGroupSize[3];
+ deUint32 subPixelPrecisionBits;
+ deUint32 subTexelPrecisionBits;
+ deUint32 mipmapPrecisionBits;
+ deUint32 maxDrawIndexedIndexValue;
+ deUint32 maxDrawIndirectInstanceCount;
+ VkBool32 primitiveRestartForPatches;
+ float maxSamplerLodBias;
+ float maxSamplerAnisotropy;
+ deUint32 maxViewports;
+ deUint32 maxViewportDimensions[2];
+ float viewportBoundsRange[2];
+ deUint32 viewportSubPixelBits;
+ deUint32 minMemoryMapAlignment;
+ deUint32 minTexelBufferOffsetAlignment;
+ deUint32 minUniformBufferOffsetAlignment;
+ deUint32 minStorageBufferOffsetAlignment;
+ deUint32 minTexelOffset;
+ deUint32 maxTexelOffset;
+ deUint32 minTexelGatherOffset;
+ deUint32 maxTexelGatherOffset;
+ float minInterpolationOffset;
+ float maxInterpolationOffset;
+ deUint32 subPixelInterpolationOffsetBits;
+ deUint32 maxFramebufferWidth;
+ deUint32 maxFramebufferHeight;
+ deUint32 maxFramebufferLayers;
+ deUint32 maxFramebufferColorSamples;
+ deUint32 maxFramebufferDepthSamples;
+ deUint32 maxFramebufferStencilSamples;
+ deUint32 maxColorAttachments;
+ deUint32 maxSampledImageColorSamples;
+ deUint32 maxSampledImageDepthSamples;
+ deUint32 maxSampledImageIntegerSamples;
+ deUint32 maxStorageImageSamples;
+ deUint32 maxSampleMaskWords;
+ deUint64 timestampFrequency;
+ deUint32 maxClipDistances;
+ deUint32 maxCullDistances;
+ deUint32 maxCombinedClipAndCullDistances;
+ float pointSizeRange[2];
+ float lineWidthRange[2];
+ float pointSizeGranularity;
+ float lineWidthGranularity;
+};
+
+struct VkPhysicalDeviceSparseProperties
+{
+ VkBool32 residencyStandard2DBlockShape;
+ VkBool32 residencyStandard2DMSBlockShape;
+ VkBool32 residencyStandard3DBlockShape;
+ VkBool32 residencyAlignedMipSize;
+ VkBool32 residencyNonResident;
+ VkBool32 residencyNonResidentStrict;
};
struct VkPhysicalDeviceProperties
{
- deUint32 apiVersion;
- deUint32 driverVersion;
- deUint32 vendorId;
- deUint32 deviceId;
- VkPhysicalDeviceType deviceType;
- char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME];
- deUint8 pipelineCacheUUID[VK_UUID_LENGTH];
+ deUint32 apiVersion;
+ deUint32 driverVersion;
+ deUint32 vendorId;
+ deUint32 deviceId;
+ VkPhysicalDeviceType deviceType;
+ char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME];
+ deUint8 pipelineCacheUUID[VK_UUID_LENGTH];
+ VkPhysicalDeviceLimits limits;
+ VkPhysicalDeviceSparseProperties sparseProperties;
};
-struct VkPhysicalDeviceQueueProperties
+struct VkQueueFamilyProperties
{
VkQueueFlags queueFlags;
deUint32 queueCount;
struct VkDeviceQueueCreateInfo
{
- deUint32 queueFamilyIndex;
- deUint32 queueCount;
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 queueFamilyIndex;
+ deUint32 queueCount;
};
struct VkDeviceCreateInfo
deUint32 extensionCount;
const char*const* ppEnabledExtensionNames;
const VkPhysicalDeviceFeatures* pEnabledFeatures;
- VkDeviceCreateFlags flags;
};
struct VkExtensionProperties
deUint32 memoryTypeBits;
};
-struct VkExtent3D
-{
- deInt32 width;
- deInt32 height;
- deInt32 depth;
-};
-
struct VkSparseImageFormatProperties
{
VkImageAspect aspect;
{
VkImageAspect aspect;
deUint32 mipLevel;
- deUint32 arraySlice;
+ deUint32 arrayLayer;
};
struct VkOffset3D
struct VkBufferViewCreateInfo
{
- VkStructureType sType;
- const void* pNext;
- VkBuffer buffer;
- VkBufferViewType viewType;
- VkFormat format;
- VkDeviceSize offset;
- VkDeviceSize range;
+ VkStructureType sType;
+ const void* pNext;
+ VkBuffer buffer;
+ VkFormat format;
+ VkDeviceSize offset;
+ VkDeviceSize range;
};
struct VkImageCreateInfo
VkSharingMode sharingMode;
deUint32 queueFamilyCount;
const deUint32* pQueueFamilyIndices;
+ VkImageLayout initialLayout;
};
struct VkSubresourceLayout
struct VkImageSubresourceRange
{
- VkImageAspect aspect;
- deUint32 baseMipLevel;
- deUint32 mipLevels;
- deUint32 baseArraySlice;
- deUint32 arraySize;
+ VkImageAspectFlags aspectMask;
+ deUint32 baseMipLevel;
+ deUint32 mipLevels;
+ deUint32 baseArrayLayer;
+ deUint32 arraySize;
};
struct VkImageViewCreateInfo
VkFormat format;
VkChannelMapping channels;
VkImageSubresourceRange subresourceRange;
-};
-
-struct VkAttachmentViewCreateInfo
-{
- VkStructureType sType;
- const void* pNext;
- VkImage image;
- VkFormat format;
- deUint32 mipLevel;
- deUint32 baseArraySlice;
- deUint32 arraySize;
- VkAttachmentViewCreateFlags flags;
+ VkImageViewCreateFlags flags;
};
struct VkShaderModuleCreateInfo
VkShaderModule module;
const char* pName;
VkShaderCreateFlags flags;
+ VkShaderStage stage;
};
struct VkPipelineCacheCreateInfo
deUint32 patchControlPoints;
};
+struct VkViewport
+{
+ float originX;
+ float originY;
+ float width;
+ float height;
+ float minDepth;
+ float maxDepth;
+};
+
+struct VkOffset2D
+{
+ deInt32 x;
+ deInt32 y;
+};
+
+struct VkExtent2D
+{
+ deInt32 width;
+ deInt32 height;
+};
+
+struct VkRect2D
+{
+ VkOffset2D offset;
+ VkExtent2D extent;
+};
+
struct VkPipelineViewportStateCreateInfo
{
- VkStructureType sType;
- const void* pNext;
- deUint32 viewportCount;
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 viewportCount;
+ const VkViewport* pViewports;
+ deUint32 scissorCount;
+ const VkRect2D* pScissors;
};
struct VkPipelineRasterStateCreateInfo
VkFillMode fillMode;
VkCullMode cullMode;
VkFrontFace frontFace;
+ VkBool32 depthBiasEnable;
+ float depthBias;
+ float depthBiasClamp;
+ float slopeScaledDepthBias;
+ float lineWidth;
};
struct VkPipelineMultisampleStateCreateInfo
{
- VkStructureType sType;
- const void* pNext;
- deUint32 rasterSamples;
- VkBool32 sampleShadingEnable;
- float minSampleShading;
- VkSampleMask sampleMask;
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 rasterSamples;
+ VkBool32 sampleShadingEnable;
+ float minSampleShading;
+ const VkSampleMask* pSampleMask;
};
struct VkStencilOpState
VkStencilOp stencilPassOp;
VkStencilOp stencilDepthFailOp;
VkCompareOp stencilCompareOp;
+ deUint32 stencilCompareMask;
+ deUint32 stencilWriteMask;
+ deUint32 stencilReference;
};
struct VkPipelineDepthStencilStateCreateInfo
VkBool32 depthTestEnable;
VkBool32 depthWriteEnable;
VkCompareOp depthCompareOp;
- VkBool32 depthBoundsEnable;
+ VkBool32 depthBoundsTestEnable;
VkBool32 stencilTestEnable;
VkStencilOpState front;
VkStencilOpState back;
+ float minDepthBounds;
+ float maxDepthBounds;
};
struct VkPipelineColorBlendAttachmentState
VkStructureType sType;
const void* pNext;
VkBool32 alphaToCoverageEnable;
+ VkBool32 alphaToOneEnable;
VkBool32 logicOpEnable;
VkLogicOp logicOp;
deUint32 attachmentCount;
const VkPipelineColorBlendAttachmentState* pAttachments;
+ float blendConst[4];
+};
+
+struct VkPipelineDynamicStateCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 dynamicStateCount;
+ const VkDynamicState* pDynamicStates;
};
struct VkGraphicsPipelineCreateInfo
const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
+ const VkPipelineDynamicStateCreateInfo* pDynamicState;
VkPipelineCreateFlags flags;
VkPipelineLayout layout;
VkRenderPass renderPass;
{
VkStructureType sType;
const void* pNext;
- VkPipelineShaderStageCreateInfo cs;
+ VkPipelineShaderStageCreateInfo stage;
VkPipelineCreateFlags flags;
VkPipelineLayout layout;
VkPipeline basePipelineHandle;
struct VkSamplerCreateInfo
{
- VkStructureType sType;
- const void* pNext;
- VkTexFilter magFilter;
- VkTexFilter minFilter;
- VkTexMipmapMode mipMode;
- VkTexAddress addressU;
- VkTexAddress addressV;
- VkTexAddress addressW;
- float mipLodBias;
- float maxAnisotropy;
- VkBool32 compareEnable;
- VkCompareOp compareOp;
- float minLod;
- float maxLod;
- VkBorderColor borderColor;
+ VkStructureType sType;
+ const void* pNext;
+ VkTexFilter magFilter;
+ VkTexFilter minFilter;
+ VkTexMipmapMode mipMode;
+ VkTexAddressMode addressModeU;
+ VkTexAddressMode addressModeV;
+ VkTexAddressMode addressModeW;
+ float mipLodBias;
+ float maxAnisotropy;
+ VkBool32 compareEnable;
+ VkCompareOp compareOp;
+ float minLod;
+ float maxLod;
+ VkBorderColor borderColor;
+ VkBool32 unnormalizedCoordinates;
};
struct VkDescriptorSetLayoutBinding
{
VkStructureType sType;
const void* pNext;
+ VkDescriptorPoolUsage poolUsage;
+ deUint32 maxSets;
deUint32 count;
const VkDescriptorTypeCount* pTypeCount;
};
+struct VkDescriptorBufferInfo
+{
+ VkBuffer buffer;
+ VkDeviceSize offset;
+ VkDeviceSize range;
+};
+
struct VkDescriptorInfo
{
- VkBufferView bufferView;
- VkSampler sampler;
- VkImageView imageView;
- VkAttachmentView attachmentView;
- VkImageLayout imageLayout;
+ VkBufferView bufferView;
+ VkSampler sampler;
+ VkImageView imageView;
+ VkImageLayout imageLayout;
+ VkDescriptorBufferInfo bufferInfo;
};
struct VkWriteDescriptorSet
deUint32 count;
};
-struct VkViewport
-{
- float originX;
- float originY;
- float width;
- float height;
- float minDepth;
- float maxDepth;
-};
-
-struct VkOffset2D
-{
- deInt32 x;
- deInt32 y;
-};
-
-struct VkExtent2D
-{
- deInt32 width;
- deInt32 height;
-};
-
-struct VkRect2D
-{
- VkOffset2D offset;
- VkExtent2D extent;
-};
-
-struct VkDynamicViewportStateCreateInfo
+struct VkFramebufferCreateInfo
{
VkStructureType sType;
const void* pNext;
- deUint32 viewportAndScissorCount;
- const VkViewport* pViewports;
- const VkRect2D* pScissors;
-};
-
-struct VkDynamicRasterStateCreateInfo
-{
- VkStructureType sType;
- const void* pNext;
- float depthBias;
- float depthBiasClamp;
- float slopeScaledDepthBias;
- float lineWidth;
-};
-
-struct VkDynamicColorBlendStateCreateInfo
-{
- VkStructureType sType;
- const void* pNext;
- float blendConst[4];
-};
-
-struct VkDynamicDepthStencilStateCreateInfo
-{
- VkStructureType sType;
- const void* pNext;
- float minDepthBounds;
- float maxDepthBounds;
- deUint32 stencilReadMask;
- deUint32 stencilWriteMask;
- deUint32 stencilFrontRef;
- deUint32 stencilBackRef;
-};
-
-struct VkAttachmentBindInfo
-{
- VkAttachmentView view;
- VkImageLayout layout;
-};
-
-struct VkFramebufferCreateInfo
-{
- VkStructureType sType;
- const void* pNext;
- VkRenderPass renderPass;
- deUint32 attachmentCount;
- const VkAttachmentBindInfo* pAttachments;
- deUint32 width;
- deUint32 height;
- deUint32 layers;
+ VkRenderPass renderPass;
+ deUint32 attachmentCount;
+ const VkImageView* pAttachments;
+ deUint32 width;
+ deUint32 height;
+ deUint32 layers;
};
struct VkAttachmentDescription
{
- VkStructureType sType;
- const void* pNext;
- VkFormat format;
- deUint32 samples;
- VkAttachmentLoadOp loadOp;
- VkAttachmentStoreOp storeOp;
- VkAttachmentLoadOp stencilLoadOp;
- VkAttachmentStoreOp stencilStoreOp;
- VkImageLayout initialLayout;
- VkImageLayout finalLayout;
+ VkStructureType sType;
+ const void* pNext;
+ VkFormat format;
+ deUint32 samples;
+ VkAttachmentLoadOp loadOp;
+ VkAttachmentStoreOp storeOp;
+ VkAttachmentLoadOp stencilLoadOp;
+ VkAttachmentStoreOp stencilStoreOp;
+ VkImageLayout initialLayout;
+ VkImageLayout finalLayout;
+ VkAttachmentDescriptionFlags flags;
};
struct VkAttachmentReference
VkPipelineBindPoint pipelineBindPoint;
VkSubpassDescriptionFlags flags;
deUint32 inputCount;
- const VkAttachmentReference* inputAttachments;
+ const VkAttachmentReference* pInputAttachments;
deUint32 colorCount;
- const VkAttachmentReference* colorAttachments;
- const VkAttachmentReference* resolveAttachments;
+ const VkAttachmentReference* pColorAttachments;
+ const VkAttachmentReference* pResolveAttachments;
VkAttachmentReference depthStencilAttachment;
deUint32 preserveCount;
- const VkAttachmentReference* preserveAttachments;
+ const VkAttachmentReference* pPreserveAttachments;
};
struct VkSubpassDependency
const void* pNext;
VkCmdBufferOptimizeFlags flags;
VkRenderPass renderPass;
+ deUint32 subpass;
VkFramebuffer framebuffer;
};
VkDeviceSize copySize;
};
+struct VkImageSubresourceCopy
+{
+ VkImageAspect aspect;
+ deUint32 mipLevel;
+ deUint32 arrayLayer;
+ deUint32 arraySize;
+};
+
struct VkImageCopy
{
- VkImageSubresource srcSubresource;
- VkOffset3D srcOffset;
- VkImageSubresource destSubresource;
- VkOffset3D destOffset;
- VkExtent3D extent;
+ VkImageSubresourceCopy srcSubresource;
+ VkOffset3D srcOffset;
+ VkImageSubresourceCopy destSubresource;
+ VkOffset3D destOffset;
+ VkExtent3D extent;
};
struct VkImageBlit
{
- VkImageSubresource srcSubresource;
- VkOffset3D srcOffset;
- VkExtent3D srcExtent;
- VkImageSubresource destSubresource;
- VkOffset3D destOffset;
- VkExtent3D destExtent;
+ VkImageSubresourceCopy srcSubresource;
+ VkOffset3D srcOffset;
+ VkExtent3D srcExtent;
+ VkImageSubresourceCopy destSubresource;
+ VkOffset3D destOffset;
+ VkExtent3D destExtent;
};
struct VkBufferImageCopy
{
- VkDeviceSize bufferOffset;
- deUint32 bufferRowLength;
- deUint32 bufferImageHeight;
- VkImageSubresource imageSubresource;
- VkOffset3D imageOffset;
- VkExtent3D imageExtent;
+ VkDeviceSize bufferOffset;
+ deUint32 bufferRowLength;
+ deUint32 bufferImageHeight;
+ VkImageSubresourceCopy imageSubresource;
+ VkOffset3D imageOffset;
+ VkExtent3D imageExtent;
};
union VkClearColorValue
{
- float f32[4];
- deInt32 s32[4];
- deUint32 u32[4];
+ float float32[4];
+ deInt32 int32[4];
+ deUint32 uint32[4];
+};
+
+struct VkClearDepthStencilValue
+{
+ float depth;
+ deUint32 stencil;
};
struct VkRect3D
struct VkImageResolve
{
- VkImageSubresource srcSubresource;
- VkOffset3D srcOffset;
- VkImageSubresource destSubresource;
- VkOffset3D destOffset;
- VkExtent3D extent;
-};
-
-struct VkClearDepthStencilValue
-{
- float depth;
- deUint32 stencil;
+ VkImageSubresourceCopy srcSubresource;
+ VkOffset3D srcOffset;
+ VkImageSubresourceCopy destSubresource;
+ VkOffset3D destOffset;
+ VkExtent3D extent;
};
union VkClearValue
{
VkClearColorValue color;
- VkClearDepthStencilValue ds;
+ VkClearDepthStencilValue depthStencil;
};
struct VkRenderPassBeginInfo
VkRenderPass renderPass;
VkFramebuffer framebuffer;
VkRect2D renderArea;
- deUint32 attachmentCount;
- const VkClearValue* pAttachmentClearValues;
+ deUint32 clearValueCount;
+ const VkClearValue* pClearValues;
};
struct VkBufferMemoryBarrier
inline VkClearValue makeClearValueColorF32 (float r, float g, float b, float a)
{
VkClearValue v;
- v.color.f32[0] = r;
- v.color.f32[1] = g;
- v.color.f32[2] = b;
- v.color.f32[3] = a;
+ v.color.float32[0] = r;
+ v.color.float32[1] = g;
+ v.color.float32[2] = b;
+ v.color.float32[3] = a;
return v;
}
return res;
}
-inline VkPhysicalDeviceQueueProperties makePhysicalDeviceQueueProperties (VkQueueFlags queueFlags, deUint32 queueCount, VkBool32 supportsTimestamps)
-{
- VkPhysicalDeviceQueueProperties res;
- res.queueFlags = queueFlags;
- res.queueCount = queueCount;
- res.supportsTimestamps = supportsTimestamps;
- return res;
-}
-
-inline VkDeviceQueueCreateInfo makeDeviceQueueCreateInfo (deUint32 queueFamilyIndex, deUint32 queueCount)
+inline VkExtent3D makeExtent3D (deInt32 width, deInt32 height, deInt32 depth)
{
- VkDeviceQueueCreateInfo res;
- res.queueFamilyIndex = queueFamilyIndex;
- res.queueCount = queueCount;
+ VkExtent3D res;
+ res.width = width;
+ res.height = height;
+ res.depth = depth;
return res;
}
return res;
}
-inline VkExtent3D makeExtent3D (deInt32 width, deInt32 height, deInt32 depth)
-{
- VkExtent3D res;
- res.width = width;
- res.height = height;
- res.depth = depth;
- return res;
-}
-
inline VkSparseMemoryBindInfo makeSparseMemoryBindInfo (VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceSize memOffset, VkDeviceMemory mem, VkSparseMemoryBindFlags flags)
{
VkSparseMemoryBindInfo res;
return res;
}
-inline VkImageSubresource makeImageSubresource (VkImageAspect aspect, deUint32 mipLevel, deUint32 arraySlice)
+inline VkImageSubresource makeImageSubresource (VkImageAspect aspect, deUint32 mipLevel, deUint32 arrayLayer)
{
VkImageSubresource res;
res.aspect = aspect;
res.mipLevel = mipLevel;
- res.arraySlice = arraySlice;
+ res.arrayLayer = arrayLayer;
return res;
}
return res;
}
-inline VkImageSubresourceRange makeImageSubresourceRange (VkImageAspect aspect, deUint32 baseMipLevel, deUint32 mipLevels, deUint32 baseArraySlice, deUint32 arraySize)
+inline VkImageSubresourceRange makeImageSubresourceRange (VkImageAspectFlags aspectMask, deUint32 baseMipLevel, deUint32 mipLevels, deUint32 baseArrayLayer, deUint32 arraySize)
{
VkImageSubresourceRange res;
- res.aspect = aspect;
+ res.aspectMask = aspectMask;
res.baseMipLevel = baseMipLevel;
res.mipLevels = mipLevels;
- res.baseArraySlice = baseArraySlice;
+ res.baseArrayLayer = baseArrayLayer;
res.arraySize = arraySize;
return res;
}
return res;
}
-inline VkStencilOpState makeStencilOpState (VkStencilOp stencilFailOp, VkStencilOp stencilPassOp, VkStencilOp stencilDepthFailOp, VkCompareOp stencilCompareOp)
+inline VkViewport makeViewport (float originX, float originY, float width, float height, float minDepth, float maxDepth)
+{
+ VkViewport res;
+ res.originX = originX;
+ res.originY = originY;
+ res.width = width;
+ res.height = height;
+ res.minDepth = minDepth;
+ res.maxDepth = maxDepth;
+ return res;
+}
+
+inline VkOffset2D makeOffset2D (deInt32 x, deInt32 y)
+{
+ VkOffset2D res;
+ res.x = x;
+ res.y = y;
+ return res;
+}
+
+inline VkExtent2D makeExtent2D (deInt32 width, deInt32 height)
+{
+ VkExtent2D res;
+ res.width = width;
+ res.height = height;
+ return res;
+}
+
+inline VkStencilOpState makeStencilOpState (VkStencilOp stencilFailOp, VkStencilOp stencilPassOp, VkStencilOp stencilDepthFailOp, VkCompareOp stencilCompareOp, deUint32 stencilCompareMask, deUint32 stencilWriteMask, deUint32 stencilReference)
{
VkStencilOpState res;
res.stencilFailOp = stencilFailOp;
res.stencilPassOp = stencilPassOp;
res.stencilDepthFailOp = stencilDepthFailOp;
res.stencilCompareOp = stencilCompareOp;
+ res.stencilCompareMask = stencilCompareMask;
+ res.stencilWriteMask = stencilWriteMask;
+ res.stencilReference = stencilReference;
return res;
}
return res;
}
-inline VkDescriptorInfo makeDescriptorInfo (VkBufferView bufferView, VkSampler sampler, VkImageView imageView, VkAttachmentView attachmentView, VkImageLayout imageLayout)
-{
- VkDescriptorInfo res;
- res.bufferView = bufferView;
- res.sampler = sampler;
- res.imageView = imageView;
- res.attachmentView = attachmentView;
- res.imageLayout = imageLayout;
- return res;
-}
-
-inline VkViewport makeViewport (float originX, float originY, float width, float height, float minDepth, float maxDepth)
-{
- VkViewport res;
- res.originX = originX;
- res.originY = originY;
- res.width = width;
- res.height = height;
- res.minDepth = minDepth;
- res.maxDepth = maxDepth;
- return res;
-}
-
-inline VkOffset2D makeOffset2D (deInt32 x, deInt32 y)
-{
- VkOffset2D res;
- res.x = x;
- res.y = y;
- return res;
-}
-
-inline VkExtent2D makeExtent2D (deInt32 width, deInt32 height)
+inline VkDescriptorBufferInfo makeDescriptorBufferInfo (VkBuffer buffer, VkDeviceSize offset, VkDeviceSize range)
{
- VkExtent2D res;
- res.width = width;
- res.height = height;
- return res;
-}
-
-inline VkAttachmentBindInfo makeAttachmentBindInfo (VkAttachmentView view, VkImageLayout layout)
-{
- VkAttachmentBindInfo res;
- res.view = view;
- res.layout = layout;
+ VkDescriptorBufferInfo res;
+ res.buffer = buffer;
+ res.offset = offset;
+ res.range = range;
return res;
}
return res;
}
+inline VkImageSubresourceCopy makeImageSubresourceCopy (VkImageAspect aspect, deUint32 mipLevel, deUint32 arrayLayer, deUint32 arraySize)
+{
+ VkImageSubresourceCopy res;
+ res.aspect = aspect;
+ res.mipLevel = mipLevel;
+ res.arrayLayer = arrayLayer;
+ res.arraySize = arraySize;
+ return res;
+}
+
inline VkClearDepthStencilValue makeClearDepthStencilValue (float depth, deUint32 stencil)
{
VkClearDepthStencilValue res;
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-virtual VkResult destroyDevice (VkDevice device) const = 0;
-virtual VkResult getGlobalExtensionProperties (const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties) const = 0;
-virtual VkResult getPhysicalDeviceExtensionProperties (VkPhysicalDevice physicalDevice, const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties) const = 0;
-virtual VkResult getGlobalLayerProperties (deUint32* pCount, VkLayerProperties* pProperties) const = 0;
-virtual VkResult getPhysicalDeviceLayerProperties (VkPhysicalDevice physicalDevice, deUint32* pCount, VkLayerProperties* pProperties) const = 0;
+virtual void destroyDevice (VkDevice device) const = 0;
virtual VkResult getDeviceQueue (VkDevice device, deUint32 queueFamilyIndex, deUint32 queueIndex, VkQueue* pQueue) const = 0;
virtual VkResult queueSubmit (VkQueue queue, deUint32 cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence) const = 0;
virtual VkResult queueWaitIdle (VkQueue queue) const = 0;
virtual VkResult deviceWaitIdle (VkDevice device) const = 0;
virtual VkResult allocMemory (VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem) const = 0;
-virtual VkResult freeMemory (VkDevice device, VkDeviceMemory mem) const = 0;
+virtual void freeMemory (VkDevice device, VkDeviceMemory mem) const = 0;
virtual VkResult mapMemory (VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) const = 0;
-virtual VkResult unmapMemory (VkDevice device, VkDeviceMemory mem) const = 0;
+virtual void unmapMemory (VkDevice device, VkDeviceMemory mem) const = 0;
virtual VkResult flushMappedMemoryRanges (VkDevice device, deUint32 memRangeCount, const VkMappedMemoryRange* pMemRanges) const = 0;
virtual VkResult invalidateMappedMemoryRanges (VkDevice device, deUint32 memRangeCount, const VkMappedMemoryRange* pMemRanges) const = 0;
virtual VkResult getDeviceMemoryCommitment (VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) const = 0;
virtual VkResult queueBindSparseImageOpaqueMemory (VkQueue queue, VkImage image, deUint32 numBindings, const VkSparseMemoryBindInfo* pBindInfo) const = 0;
virtual VkResult queueBindSparseImageMemory (VkQueue queue, VkImage image, deUint32 numBindings, const VkSparseImageMemoryBindInfo* pBindInfo) const = 0;
virtual VkResult createFence (VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence) const = 0;
-virtual VkResult destroyFence (VkDevice device, VkFence fence) const = 0;
+virtual void destroyFence (VkDevice device, VkFence fence) const = 0;
virtual VkResult resetFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences) const = 0;
virtual VkResult getFenceStatus (VkDevice device, VkFence fence) const = 0;
virtual VkResult waitForFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences, VkBool32 waitAll, deUint64 timeout) const = 0;
virtual VkResult createSemaphore (VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore) const = 0;
-virtual VkResult destroySemaphore (VkDevice device, VkSemaphore semaphore) const = 0;
+virtual void destroySemaphore (VkDevice device, VkSemaphore semaphore) const = 0;
virtual VkResult queueSignalSemaphore (VkQueue queue, VkSemaphore semaphore) const = 0;
virtual VkResult queueWaitSemaphore (VkQueue queue, VkSemaphore semaphore) const = 0;
virtual VkResult createEvent (VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent) const = 0;
-virtual VkResult destroyEvent (VkDevice device, VkEvent event) const = 0;
+virtual void destroyEvent (VkDevice device, VkEvent event) const = 0;
virtual VkResult getEventStatus (VkDevice device, VkEvent event) const = 0;
virtual VkResult setEvent (VkDevice device, VkEvent event) const = 0;
virtual VkResult resetEvent (VkDevice device, VkEvent event) const = 0;
virtual VkResult createQueryPool (VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool) const = 0;
-virtual VkResult destroyQueryPool (VkDevice device, VkQueryPool queryPool) const = 0;
+virtual void destroyQueryPool (VkDevice device, VkQueryPool queryPool) const = 0;
virtual VkResult getQueryPoolResults (VkDevice device, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, deUintptr* pDataSize, void* pData, VkQueryResultFlags flags) const = 0;
virtual VkResult createBuffer (VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer) const = 0;
-virtual VkResult destroyBuffer (VkDevice device, VkBuffer buffer) const = 0;
+virtual void destroyBuffer (VkDevice device, VkBuffer buffer) const = 0;
virtual VkResult createBufferView (VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView) const = 0;
-virtual VkResult destroyBufferView (VkDevice device, VkBufferView bufferView) const = 0;
+virtual void destroyBufferView (VkDevice device, VkBufferView bufferView) const = 0;
virtual VkResult createImage (VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage) const = 0;
-virtual VkResult destroyImage (VkDevice device, VkImage image) const = 0;
+virtual void destroyImage (VkDevice device, VkImage image) const = 0;
virtual VkResult getImageSubresourceLayout (VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) const = 0;
virtual VkResult createImageView (VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView) const = 0;
-virtual VkResult destroyImageView (VkDevice device, VkImageView imageView) const = 0;
-virtual VkResult createAttachmentView (VkDevice device, const VkAttachmentViewCreateInfo* pCreateInfo, VkAttachmentView* pView) const = 0;
-virtual VkResult destroyAttachmentView (VkDevice device, VkAttachmentView attachmentView) const = 0;
+virtual void destroyImageView (VkDevice device, VkImageView imageView) const = 0;
virtual VkResult createShaderModule (VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule) const = 0;
-virtual VkResult destroyShaderModule (VkDevice device, VkShaderModule shaderModule) const = 0;
+virtual void destroyShaderModule (VkDevice device, VkShaderModule shaderModule) const = 0;
virtual VkResult createShader (VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader) const = 0;
-virtual VkResult destroyShader (VkDevice device, VkShader shader) const = 0;
+virtual void destroyShader (VkDevice device, VkShader shader) const = 0;
virtual VkResult createPipelineCache (VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache) const = 0;
-virtual VkResult destroyPipelineCache (VkDevice device, VkPipelineCache pipelineCache) const = 0;
+virtual void destroyPipelineCache (VkDevice device, VkPipelineCache pipelineCache) const = 0;
virtual deUintptr getPipelineCacheSize (VkDevice device, VkPipelineCache pipelineCache) const = 0;
virtual VkResult getPipelineCacheData (VkDevice device, VkPipelineCache pipelineCache, void* pData) const = 0;
virtual VkResult mergePipelineCaches (VkDevice device, VkPipelineCache destCache, deUint32 srcCacheCount, const VkPipelineCache* pSrcCaches) const = 0;
virtual VkResult createGraphicsPipelines (VkDevice device, VkPipelineCache pipelineCache, deUint32 count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines) const = 0;
virtual VkResult createComputePipelines (VkDevice device, VkPipelineCache pipelineCache, deUint32 count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines) const = 0;
-virtual VkResult destroyPipeline (VkDevice device, VkPipeline pipeline) const = 0;
+virtual void destroyPipeline (VkDevice device, VkPipeline pipeline) const = 0;
virtual VkResult createPipelineLayout (VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout) const = 0;
-virtual VkResult destroyPipelineLayout (VkDevice device, VkPipelineLayout pipelineLayout) const = 0;
+virtual void destroyPipelineLayout (VkDevice device, VkPipelineLayout pipelineLayout) const = 0;
virtual VkResult createSampler (VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) const = 0;
-virtual VkResult destroySampler (VkDevice device, VkSampler sampler) const = 0;
+virtual void destroySampler (VkDevice device, VkSampler sampler) const = 0;
virtual VkResult createDescriptorSetLayout (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout) const = 0;
-virtual VkResult destroyDescriptorSetLayout (VkDevice device, VkDescriptorSetLayout descriptorSetLayout) const = 0;
-virtual VkResult createDescriptorPool (VkDevice device, VkDescriptorPoolUsage poolUsage, deUint32 maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) const = 0;
-virtual VkResult destroyDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool) const = 0;
+virtual void destroyDescriptorSetLayout (VkDevice device, VkDescriptorSetLayout descriptorSetLayout) const = 0;
+virtual VkResult createDescriptorPool (VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) const = 0;
+virtual void destroyDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool) const = 0;
virtual VkResult resetDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool) const = 0;
-virtual VkResult allocDescriptorSets (VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, deUint32 count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, deUint32* pCount) const = 0;
+virtual VkResult allocDescriptorSets (VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, deUint32 count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets) const = 0;
virtual VkResult freeDescriptorSets (VkDevice device, VkDescriptorPool descriptorPool, deUint32 count, const VkDescriptorSet* pDescriptorSets) const = 0;
-virtual VkResult updateDescriptorSets (VkDevice device, deUint32 writeCount, const VkWriteDescriptorSet* pDescriptorWrites, deUint32 copyCount, const VkCopyDescriptorSet* pDescriptorCopies) const = 0;
-virtual VkResult createDynamicViewportState (VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState) const = 0;
-virtual VkResult destroyDynamicViewportState (VkDevice device, VkDynamicViewportState dynamicViewportState) const = 0;
-virtual VkResult createDynamicRasterState (VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState) const = 0;
-virtual VkResult destroyDynamicRasterState (VkDevice device, VkDynamicRasterState dynamicRasterState) const = 0;
-virtual VkResult createDynamicColorBlendState (VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState) const = 0;
-virtual VkResult destroyDynamicColorBlendState (VkDevice device, VkDynamicColorBlendState dynamicColorBlendState) const = 0;
-virtual VkResult createDynamicDepthStencilState (VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, VkDynamicDepthStencilState* pState) const = 0;
-virtual VkResult destroyDynamicDepthStencilState (VkDevice device, VkDynamicDepthStencilState dynamicDepthStencilState) const = 0;
+virtual void updateDescriptorSets (VkDevice device, deUint32 writeCount, const VkWriteDescriptorSet* pDescriptorWrites, deUint32 copyCount, const VkCopyDescriptorSet* pDescriptorCopies) const = 0;
virtual VkResult createFramebuffer (VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer) const = 0;
-virtual VkResult destroyFramebuffer (VkDevice device, VkFramebuffer framebuffer) const = 0;
+virtual void destroyFramebuffer (VkDevice device, VkFramebuffer framebuffer) const = 0;
virtual VkResult createRenderPass (VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass) const = 0;
-virtual VkResult destroyRenderPass (VkDevice device, VkRenderPass renderPass) const = 0;
+virtual void destroyRenderPass (VkDevice device, VkRenderPass renderPass) const = 0;
virtual VkResult getRenderAreaGranularity (VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) const = 0;
virtual VkResult createCommandPool (VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool) const = 0;
-virtual VkResult destroyCommandPool (VkDevice device, VkCmdPool cmdPool) const = 0;
+virtual void destroyCommandPool (VkDevice device, VkCmdPool cmdPool) const = 0;
virtual VkResult resetCommandPool (VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags) const = 0;
virtual VkResult createCommandBuffer (VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer) const = 0;
-virtual VkResult destroyCommandBuffer (VkDevice device, VkCmdBuffer commandBuffer) const = 0;
+virtual void destroyCommandBuffer (VkDevice device, VkCmdBuffer commandBuffer) const = 0;
virtual VkResult beginCommandBuffer (VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) const = 0;
virtual VkResult endCommandBuffer (VkCmdBuffer cmdBuffer) const = 0;
virtual VkResult resetCommandBuffer (VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags) const = 0;
virtual void cmdBindPipeline (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) const = 0;
-virtual void cmdBindDynamicViewportState (VkCmdBuffer cmdBuffer, VkDynamicViewportState dynamicViewportState) const = 0;
-virtual void cmdBindDynamicRasterState (VkCmdBuffer cmdBuffer, VkDynamicRasterState dynamicRasterState) const = 0;
-virtual void cmdBindDynamicColorBlendState (VkCmdBuffer cmdBuffer, VkDynamicColorBlendState dynamicColorBlendState) const = 0;
-virtual void cmdBindDynamicDepthStencilState (VkCmdBuffer cmdBuffer, VkDynamicDepthStencilState dynamicDepthStencilState) const = 0;
+virtual void cmdSetViewport (VkCmdBuffer cmdBuffer, deUint32 viewportCount, const VkViewport* pViewports) const = 0;
+virtual void cmdSetScissor (VkCmdBuffer cmdBuffer, deUint32 scissorCount, const VkRect2D* pScissors) const = 0;
+virtual void cmdSetLineWidth (VkCmdBuffer cmdBuffer, float lineWidth) const = 0;
+virtual void cmdSetDepthBias (VkCmdBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias) const = 0;
+virtual void cmdSetBlendConstants (VkCmdBuffer cmdBuffer, const float blendConst) const = 0;
+virtual void cmdSetDepthBounds (VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds) const = 0;
+virtual void cmdSetStencilCompareMask (VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, deUint32 stencilCompareMask) const = 0;
+virtual void cmdSetStencilWriteMask (VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, deUint32 stencilWriteMask) const = 0;
+virtual void cmdSetStencilReference (VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, deUint32 stencilReference) const = 0;
virtual void cmdBindDescriptorSets (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 firstSet, deUint32 setCount, const VkDescriptorSet* pDescriptorSets, deUint32 dynamicOffsetCount, const deUint32* pDynamicOffsets) const = 0;
virtual void cmdBindIndexBuffer (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) const = 0;
virtual void cmdBindVertexBuffers (VkCmdBuffer cmdBuffer, deUint32 startBinding, deUint32 bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) const = 0;
-virtual void cmdDraw (VkCmdBuffer cmdBuffer, deUint32 firstVertex, deUint32 vertexCount, deUint32 firstInstance, deUint32 instanceCount) const = 0;
-virtual void cmdDrawIndexed (VkCmdBuffer cmdBuffer, deUint32 firstIndex, deUint32 indexCount, deInt32 vertexOffset, deUint32 firstInstance, deUint32 instanceCount) const = 0;
+virtual void cmdDraw (VkCmdBuffer cmdBuffer, deUint32 vertexCount, deUint32 instanceCount, deUint32 firstVertex, deUint32 firstInstance) const = 0;
+virtual void cmdDrawIndexed (VkCmdBuffer cmdBuffer, deUint32 indexCount, deUint32 instanceCount, deUint32 firstIndex, deInt32 vertexOffset, deUint32 firstInstance) const = 0;
virtual void cmdDrawIndirect (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 count, deUint32 stride) const = 0;
virtual void cmdDrawIndexedIndirect (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 count, deUint32 stride) const = 0;
virtual void cmdDispatch (VkCmdBuffer cmdBuffer, deUint32 x, deUint32 y, deUint32 z) const = 0;
virtual void cmdUpdateBuffer (VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const deUint32* pData) const = 0;
virtual void cmdFillBuffer (VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, deUint32 data) const = 0;
virtual void cmdClearColorImage (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, deUint32 rangeCount, const VkImageSubresourceRange* pRanges) const = 0;
-virtual void cmdClearDepthStencilImage (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, deUint32 stencil, deUint32 rangeCount, const VkImageSubresourceRange* pRanges) const = 0;
+virtual void cmdClearDepthStencilImage (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, deUint32 rangeCount, const VkImageSubresourceRange* pRanges) const = 0;
virtual void cmdClearColorAttachment (VkCmdBuffer cmdBuffer, deUint32 colorAttachment, VkImageLayout imageLayout, const VkClearColorValue* pColor, deUint32 rectCount, const VkRect3D* pRects) const = 0;
-virtual void cmdClearDepthStencilAttachment (VkCmdBuffer cmdBuffer, VkImageAspectFlags imageAspectMask, VkImageLayout imageLayout, float depth, deUint32 stencil, deUint32 rectCount, const VkRect3D* pRects) const = 0;
+virtual void cmdClearDepthStencilAttachment (VkCmdBuffer cmdBuffer, VkImageAspectFlags aspectMask, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, deUint32 rectCount, const VkRect3D* pRects) const = 0;
virtual void cmdResolveImage (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageResolve* pRegions) const = 0;
virtual void cmdSetEvent (VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) const = 0;
virtual void cmdResetEvent (VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) const = 0;
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-virtual VkResult destroyInstance (VkInstance instance) const = 0;
+virtual void destroyInstance (VkInstance instance) const = 0;
virtual VkResult enumeratePhysicalDevices (VkInstance instance, deUint32* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) const = 0;
virtual VkResult getPhysicalDeviceFeatures (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) const = 0;
virtual VkResult getPhysicalDeviceFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) const = 0;
-virtual VkResult getPhysicalDeviceImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageFormatProperties* pImageFormatProperties) const = 0;
-virtual VkResult getPhysicalDeviceLimits (VkPhysicalDevice physicalDevice, VkPhysicalDeviceLimits* pLimits) const = 0;
+virtual VkResult getPhysicalDeviceImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) const = 0;
virtual VkResult getPhysicalDeviceProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) const = 0;
-virtual VkResult getPhysicalDeviceQueueCount (VkPhysicalDevice physicalDevice, deUint32* pCount) const = 0;
-virtual VkResult getPhysicalDeviceQueueProperties (VkPhysicalDevice physicalDevice, deUint32 count, VkPhysicalDeviceQueueProperties* pQueueProperties) const = 0;
+virtual VkResult getPhysicalDeviceQueueFamilyProperties (VkPhysicalDevice physicalDevice, deUint32* pCount, VkQueueFamilyProperties* pQueueFamilyProperties) const = 0;
virtual VkResult getPhysicalDeviceMemoryProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) const = 0;
virtual PFN_vkVoidFunction getDeviceProcAddr (VkDevice device, const char* pName) const = 0;
virtual VkResult createDevice (VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) const = 0;
+virtual VkResult enumerateDeviceExtensionProperties (VkPhysicalDevice physicalDevice, const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties) const = 0;
+virtual VkResult enumerateDeviceLayerProperties (VkPhysicalDevice physicalDevice, deUint32* pCount, VkLayerProperties* pProperties) const = 0;
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-virtual VkResult createInstance (const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance) const = 0;
-virtual PFN_vkVoidFunction getInstanceProcAddr (VkInstance instance, const char* pName) const = 0;
+virtual VkResult createInstance (const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance) const = 0;
+virtual PFN_vkVoidFunction getInstanceProcAddr (VkInstance instance, const char* pName) const = 0;
+virtual VkResult enumerateInstanceExtensionProperties (const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties) const = 0;
+virtual VkResult enumerateInstanceLayerProperties (deUint32* pCount, VkLayerProperties* pProperties) const = 0;
PLATFORM_FUNCTIONS = [
"vkCreateInstance",
- "vkGetInstanceProcAddr"
+ "vkGetInstanceProcAddr",
+ "vkEnumerateInstanceExtensionProperties",
+ "vkEnumerateInstanceLayerProperties",
]
INSTANCE_FUNCTIONS = [
"vkDestroyInstance",
"vkGetPhysicalDeviceImageFormatProperties",
"vkGetPhysicalDeviceLimits",
"vkGetPhysicalDeviceProperties",
- "vkGetPhysicalDeviceQueueCount",
- "vkGetPhysicalDeviceQueueProperties",
+ "vkGetPhysicalDeviceQueueFamilyProperties",
"vkGetPhysicalDeviceMemoryProperties",
+ "vkEnumerateDeviceExtensionProperties",
+ "vkEnumerateDeviceLayerProperties",
"vkCreateDevice",
- "vkGetDeviceProcAddr"
+ "vkGetDeviceProcAddr",
]
DEFINITIONS = [
"VK_MAX_DESCRIPTION",
"VK_FALSE",
"VK_TRUE",
- "VK_ATTACHMENT_UNUSED"
+ "VK_ATTACHMENT_UNUSED",
]
class Handle:
for member in type.members:
memberName = member.name
valFmt = None
- newLine = ""
+ newLine = ""
if member.type in bitfieldTypeNames:
valFmt = "get%sStr(value.%s)" % (member.type[2:], member.name)
elif member.type == "const char*" or member.type == "char*":
valFmt = "getCharPtrStr(value.%s)" % member.name
elif '[' in member.name:
baseName = member.name[:member.name.find('[')]
- if baseName == "extName" or baseName == "deviceName":
+ if baseName in ["extName", "deviceName", "layerName", "description"]:
valFmt = "(const char*)value.%s" % baseName
+ elif member.type == 'char' or member.type == 'deUint8':
+ newLine = "'\\n' << "
+ valFmt = "tcu::formatArray(tcu::Format::HexIterator<%s>(DE_ARRAY_BEGIN(value.%s)), tcu::Format::HexIterator<%s>(DE_ARRAY_END(value.%s)))" % (member.type, baseName, member.type, baseName)
else:
newLine = "'\\n' << "
valFmt = "tcu::formatArray(DE_ARRAY_BEGIN(value.%s), DE_ARRAY_END(value.%s))" % (baseName, baseName)
yield "template<>"
yield "void Deleter<%s>::operator() (%s obj) const" % (objectType, objectType)
yield "{"
- yield "\tDE_TEST_ASSERT(m_deviceIface->%s(m_device, obj) == VK_SUCCESS);" % (getInterfaceName(function))
+ yield "\tm_deviceIface->%s(m_device, obj);" % (getInterfaceName(function))
yield "}"
yield ""
"vkGetDeviceProcAddr",
"vkEnumeratePhysicalDevices",
"vkGetPhysicalDeviceProperties",
- "vkGetPhysicalDeviceQueueCount",
- "vkGetPhysicalDeviceQueueProperties",
+ "vkGetPhysicalDeviceQueueFamilyProperties",
"vkGetPhysicalDeviceMemoryProperties",
"vkGetBufferMemoryRequirements",
"vkGetImageMemoryRequirements",
yield "\tDE_UNREF(%s);" % arg.name
if getHandle(function.arguments[-1].type).type == Handle.TYPE_NONDISP:
- yield "\tVK_NULL_RETURN(delete reinterpret_cast<%s*>((deUintptr)%s.getInternal()));" % (function.arguments[-1].type[2:], function.arguments[-1].name)
+ yield "\tdelete reinterpret_cast<%s*>((deUintptr)%s.getInternal());" % (function.arguments[-1].type[2:], function.arguments[-1].name)
else:
- yield "\tVK_NULL_RETURN(delete reinterpret_cast<%s*>(%s));" % (function.arguments[-1].type[2:], function.arguments[-1].name)
+ yield "\tdelete reinterpret_cast<%s*>(%s);" % (function.arguments[-1].type[2:], function.arguments[-1].name)
yield "}"
yield ""
const char* engineNames[] = { "engineName", DE_NULL, "", "engine. name", "engine\"(name)", "eng~!@#$%^&*()_+name", "engine\nName", "engine\r\nName" };
const deUint32 appVersions[] = { 0, 1, (deUint32)-1 };
const deUint32 engineVersions[] = { 0, 1, (deUint32)-1 };
- const PlatformInterface& platformInterface = context.getPlatformInterface();
+ const PlatformInterface& platformInterface = context.getPlatformInterface();
vector<VkApplicationInfo> appInfos;
// test over appName
{
tcu::TestLog& log = context.getTestContext().getLog();
const PlatformInterface& platformInterface = context.getPlatformInterface();
- const char* enabledExtensions[] = {"VK_UNSUPPORTED_EXTENSION", "THIS_IS_NOT_AN_EXTENSION"};
+ const char* enabledExtensions[] = {"VK_UNSUPPORTED_EXTENSION", "THIS_IS_NOT_AN_EXTENSION"};
const VkApplicationInfo appInfo =
{
VK_STRUCTURE_TYPE_APPLICATION_INFO, // VkStructureType sType;
const deUint32 queueIndex = 0;
VkDeviceQueueCreateInfo deviceQueueCreateInfo =
{
+ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
+ DE_NULL,
queueFamilyIndex, //queueFamilyIndex;
queueCount //queueCount;
};
0, //extensionCount;
DE_NULL, //ppEnabledExtensionNames;
DE_NULL, //pEnabledFeatures;
- VK_DEVICE_CREATE_VALIDATION_BIT, //flags;
};
const Unique<VkDevice> device (createDevice(instanceDriver, physicalDevice, &deviceCreateInfo));
const DeviceDriver deviceDriver (instanceDriver, device.get());
- VkQueue queue;
+ VkQueue queue;
VK_CHECK(deviceDriver.getDeviceQueue(device.get(), queueFamilyIndex, queueIndex, &queue));
VK_CHECK(deviceDriver.queueWaitIdle(queue));
const deUint32 queueIndex = 0;
const VkDeviceQueueCreateInfo deviceQueueCreateInfo =
{
+ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
+ DE_NULL,
queueFamilyIndex, //queueFamilyIndex;
queueCount //queueCount;
};
0, //extensionCount;
DE_NULL, //ppEnabledExtensionNames;
DE_NULL, //pEnabledFeatures;
- VK_DEVICE_CREATE_VALIDATION_BIT, //flags;
};
- VkResult result;
vector<VkDevice> devices(numDevices, (VkDevice)DE_NULL);
try
{
for (int deviceNdx = 0; deviceNdx < numDevices; deviceNdx++)
{
- result = instanceDriver.createDevice(physicalDevice, &deviceCreateInfo, &devices[deviceNdx]);
+ const VkResult result = instanceDriver.createDevice(physicalDevice, &deviceCreateInfo, &devices[deviceNdx]);
if (result != VK_SUCCESS)
{
if (devices[deviceNdx] != (VkDevice)DE_NULL)
{
DeviceDriver deviceDriver(instanceDriver, devices[deviceNdx]);
- result = deviceDriver.destroyDevice(devices[deviceNdx]);
+ deviceDriver.destroyDevice(devices[deviceNdx]);
}
}
if (devices[deviceNdx] != (VkDevice)DE_NULL)
{
DeviceDriver deviceDriver(instanceDriver, devices[deviceNdx]);
- result = deviceDriver.destroyDevice(devices[deviceNdx]);
-
- if (result != VK_SUCCESS)
- resultCollector.fail("Failed to destroy Device No. " + de::toString(deviceNdx) + ", Error Code: " + de::toString(result));
+ deviceDriver.destroyDevice(devices[deviceNdx]);
}
}
const VkPhysicalDevice physicalDevice = chooseDevice(instanceDriver, instance.get(), context.getTestContext().getCommandLine());
const VkDeviceQueueCreateInfo deviceQueueCreateInfo =
{
+ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
+ DE_NULL,
0, //queueFamiliIndex;
1, //queueCount;
};
DE_LENGTH_OF_ARRAY(enabledExtensions), //extensionCount;
enabledExtensions, //ppEnabledExtensionNames;
DE_NULL, //pEnabledFeatures;
- VK_DEVICE_CREATE_VALIDATION_BIT, //flags;
};
try
tcu::TestStatus createDeviceWithVariousQueueCountsTest (Context& context)
{
- tcu::TestLog& log = context.getTestContext().getLog();
- const int queueCountDiff = 1;
- const PlatformInterface& platformInterface = context.getPlatformInterface();
- const Unique<VkInstance> instance (createDefaultInstance(platformInterface));
- const InstanceDriver instanceDriver (platformInterface, instance.get());
- const VkPhysicalDevice physicalDevice = chooseDevice(instanceDriver, instance.get(), context.getTestContext().getCommandLine());
- const vector<VkPhysicalDeviceQueueProperties> physicalDeviceQueueProperties = getPhysicalDeviceQueueProperties(instanceDriver, physicalDevice);
- vector<VkDeviceQueueCreateInfo> deviceQueueCreateInfos;
- VkResult result;
-
- for (deUint32 queueFamilyNdx = 0; queueFamilyNdx < (deUint32)physicalDeviceQueueProperties.size(); queueFamilyNdx++)
+ tcu::TestLog& log = context.getTestContext().getLog();
+ const int queueCountDiff = 1;
+ const PlatformInterface& platformInterface = context.getPlatformInterface();
+ const Unique<VkInstance> instance (createDefaultInstance(platformInterface));
+ const InstanceDriver instanceDriver (platformInterface, instance.get());
+ const VkPhysicalDevice physicalDevice = chooseDevice(instanceDriver, instance.get(), context.getTestContext().getCommandLine());
+ const vector<VkQueueFamilyProperties> queueFamilyProperties = getPhysicalDeviceQueueFamilyProperties(instanceDriver, physicalDevice);
+ vector<VkDeviceQueueCreateInfo> deviceQueueCreateInfos;
+ VkResult result;
+
+ for (deUint32 queueFamilyNdx = 0; queueFamilyNdx < (deUint32)queueFamilyProperties.size(); queueFamilyNdx++)
{
- const deUint32 maxQueueCount = physicalDeviceQueueProperties[queueFamilyNdx].queueCount;
+ const deUint32 maxQueueCount = queueFamilyProperties[queueFamilyNdx].queueCount;
for (deUint32 queueCount = 1; queueCount <= maxQueueCount; queueCount += queueCountDiff)
{
const VkDeviceQueueCreateInfo queueCreateInfo =
{
+ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
+ DE_NULL,
queueFamilyNdx,
queueCount
};
0, //extensionCount;
DE_NULL, //ppEnabledExtensionNames;
DE_NULL, //pEnabledFeatures;
- VK_DEVICE_CREATE_VALIDATION_BIT, //flags;
};
const Unique<VkDevice> device (createDevice(instanceDriver, physicalDevice, &deviceCreateInfo));
const DeviceDriver deviceDriver (instanceDriver, device.get());
const deUint32 queueFamilyIndex = deviceCreateInfo.pRequestedQueues->queueFamilyIndex;
- const deUint32 queueCount = deviceCreateInfo.pRequestedQueues->queueCount;
+ const deUint32 queueCount = deviceCreateInfo.pRequestedQueues->queueCount;
for (deUint32 queueIndex = 0; queueIndex < queueCount; queueIndex++)
{
{
const struct VkSamplerCreateInfo samplerInfo =
{
- VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- VK_TEX_FILTER_NEAREST, // VkTexFilter magFilter;
- VK_TEX_FILTER_NEAREST, // VkTexFilter minFilter;
- VK_TEX_MIPMAP_MODE_BASE, // VkTexMipmapMode mipMode;
- VK_TEX_ADDRESS_CLAMP, // VkTexAddress addressU;
- VK_TEX_ADDRESS_CLAMP, // VkTexAddress addressV;
- VK_TEX_ADDRESS_CLAMP, // VkTexAddress addressW;
- 0.0f, // float mipLodBias;
- 0.0f, // float maxAnisotropy;
- DE_FALSE, // VkBool32 compareEnable;
- VK_COMPARE_OP_ALWAYS, // VkCompareOp compareOp;
- 0.0f, // float minLod;
- 0.0f, // float maxLod;
- VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, // VkBorderColor borderColor;
+ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ VK_TEX_FILTER_NEAREST, // VkTexFilter magFilter;
+ VK_TEX_FILTER_NEAREST, // VkTexFilter minFilter;
+ VK_TEX_MIPMAP_MODE_BASE, // VkTexMipmapMode mipMode;
+ VK_TEX_ADDRESS_MODE_CLAMP, // VkTexAddressMode addressU;
+ VK_TEX_ADDRESS_MODE_CLAMP, // VkTexAddressMode addressV;
+ VK_TEX_ADDRESS_MODE_CLAMP, // VkTexAddressMode addressW;
+ 0.0f, // float mipLodBias;
+ 0.0f, // float maxAnisotropy;
+ DE_FALSE, // VkBool32 compareEnable;
+ VK_COMPARE_OP_ALWAYS, // VkCompareOp compareOp;
+ 0.0f, // float minLod;
+ 0.0f, // float maxLod;
+ VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, // VkBorderColor borderColor;
+ VK_FALSE, // VKBool32 unnormalizedCoords;
};
Move<VkSampler> tmpSampler = createSampler(vk, vkDevice, &samplerInfo);
VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1u, // deUint32 queueFamilyCount;
&queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
+ VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
};
const Unique<VkImage> image (createImage(vk, vkDevice, &imageParams));
const VkAttachmentDescription colorAttDesc =
{
- VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- VK_FORMAT_R8G8B8A8_UNORM, // VkFormat format;
- 1u, // deUint32 samples;
- VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
- VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
- VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
- VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
- VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout;
- VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout finalLayout;
+ VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ VK_FORMAT_R8G8B8A8_UNORM, // VkFormat format;
+ 1u, // deUint32 samples;
+ VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
+ VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
+ VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
+ VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
+ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout;
+ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout finalLayout;
+ 0u, // VkAttachmentDescriptionFlags flags;
};
const VkAttachmentReference colorAttRef =
{
VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint;
0u, // VkSubpassDescriptionFlags flags;
0u, // deUint32 inputCount;
- DE_NULL, // const VkAttachmentReference* inputAttachments;
+ DE_NULL, // const VkAttachmentReference* pInputAttachments;
1u, // deUint32 colorCount;
- &colorAttRef, // const VkAttachmentReference* colorAttachments;
- DE_NULL, // const VkAttachmentReference* resolveAttachments;
+ &colorAttRef, // const VkAttachmentReference* pColorAttachments;
+ DE_NULL, // const VkAttachmentReference* pResolveAttachments;
{ VK_NO_ATTACHMENT, VK_IMAGE_LAYOUT_GENERAL }, // VkAttachmentReference depthStencilAttachment;
0u, // deUint32 preserveCount;
- DE_NULL, // const VkAttachmentReference* preserveAttachments;
+ DE_NULL, // const VkAttachmentReference* pPreserveAttachments;
};
const VkRenderPassCreateInfo renderPassParams =
};
const Unique<VkRenderPass> renderPass (createRenderPass(vk, vkDevice, &renderPassParams));
- const VkAttachmentViewCreateInfo colorAttViewParams =
+ const VkImageViewCreateInfo colorAttViewParams =
{
- VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, // VkStructureType sType;
+ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
*image, // VkImage image;
+ VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType;
VK_FORMAT_R8G8B8A8_UNORM, // VkFormat format;
- 0u, // deUint32 mipLevel;
- 0u, // deUint32 baseArraySlice;
- 1u, // deUint32 arraySize;
- 0u, // VkAttachmentViewCreateFlags flags;
+ {
+ VK_CHANNEL_SWIZZLE_R,
+ VK_CHANNEL_SWIZZLE_G,
+ VK_CHANNEL_SWIZZLE_B,
+ VK_CHANNEL_SWIZZLE_A
+ }, // VkChannelMapping channels;
+ {
+ VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
+ 0u, // deUint32 baseMipLevel;
+ 1u, // deUint32 mipLevels;
+ 0u, // deUint32 baseArrayLayer;
+ 1u, // deUint32 arraySize;
+ }, // VkImageSubresourceRange subresourceRange;
+ 0u, // VkImageViewCreateFlags flags;
};
- const Unique<VkAttachmentView> colorAttView (createAttachmentView(vk, vkDevice, &colorAttViewParams));
+ const Unique<VkImageView> colorAttView (createImageView(vk, vkDevice, &colorAttViewParams));
const Unique<VkShaderModule> vertShaderModule (createShaderModule(vk, vkDevice, context.getBinaryCollection().get("vert"), 0));
const VkShaderCreateInfo vertShaderParams =
*vertShaderModule, // VkShaderModule module;
"main", // const char* pName;
0u, // VkShaderCreateFlags flags;
+ VK_SHADER_STAGE_VERTEX, // VkShaderStage stage;
};
const Unique<VkShader> vertShader (createShader(vk, vkDevice, &vertShaderParams));
const Unique<VkShaderModule> fragShaderModule (createShaderModule(vk, vkDevice, context.getBinaryCollection().get("frag"), 0));
*fragShaderModule, // VkShaderModule module;
"main", // const char* pName;
0u, // VkShaderCreateFlags flags;
+ VK_SHADER_STAGE_FRAGMENT, // VkShaderStage stage;
};
const Unique<VkShader> fragShader (createShader(vk, vkDevice, &fragShaderParams));
DE_FALSE, // deUint32 depthTestEnable;
DE_FALSE, // deUint32 depthWriteEnable;
VK_COMPARE_OP_ALWAYS, // VkCompareOp depthCompareOp;
- DE_FALSE, // deUint32 depthBoundsEnable;
+ DE_FALSE, // deUint32 depthBoundsTestEnable;
DE_FALSE, // deUint32 stencilTestEnable;
{
VK_STENCIL_OP_KEEP, // VkStencilOp stencilFailOp;
VK_STENCIL_OP_KEEP, // VkStencilOp stencilPassOp;
VK_STENCIL_OP_KEEP, // VkStencilOp stencilDepthFailOp;
VK_COMPARE_OP_ALWAYS, // VkCompareOp stencilCompareOp;
+ 0u, // deUint32 stencilCompareMask;
+ 0u, // deUint32 stencilWriteMask;
+ 0u, // deUint32 stencilReference;
}, // VkStencilOpState front;
{
VK_STENCIL_OP_KEEP, // VkStencilOp stencilFailOp;
VK_STENCIL_OP_KEEP, // VkStencilOp stencilPassOp;
VK_STENCIL_OP_KEEP, // VkStencilOp stencilDepthFailOp;
VK_COMPARE_OP_ALWAYS, // VkCompareOp stencilCompareOp;
- } // VkStencilOpState back;
+ 0u, // deUint32 stencilCompareMask;
+ 0u, // deUint32 stencilWriteMask;
+ 0u, // deUint32 stencilReference;
+ }, // VkStencilOpState back;
+ -1.0f, // float minDepthBounds;
+ +1.0f, // float maxDepthBounds;
+ };
+ const VkViewport viewport0 =
+ {
+ 0.0f, // float originX;
+ 0.0f, // float originY;
+ (float)renderSize.x(), // float width;
+ (float)renderSize.y(), // float height;
+ 0.0f, // float minDepth;
+ 1.0f, // float maxDepth;
+ };
+ const VkRect2D scissor0 =
+ {
+ {
+ 0u, // deInt32 x;
+ 0u, // deInt32 y;
+ }, // VkOffset2D offset;
+ {
+ renderSize.x(), // deInt32 width;
+ renderSize.y(), // deInt32 height;
+ }, // VkExtent2D extent;
};
const VkPipelineViewportStateCreateInfo viewportParams =
{
VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
1u, // deUint32 viewportCount;
+ &viewport0,
+ 1u,
+ &scissor0
};
+ const VkSampleMask sampleMask = ~0u;
const VkPipelineMultisampleStateCreateInfo multisampleParams =
{
VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
1u, // deUint32 rasterSamples;
DE_FALSE, // deUint32 sampleShadingEnable;
0.0f, // float minSampleShading;
- ~0u, // VkSampleMask sampleMask;
+ &sampleMask, // VkSampleMask sampleMask;
};
const VkPipelineRasterStateCreateInfo rasterParams =
{
- VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- DE_TRUE, // deUint32 depthClipEnable;
- DE_FALSE, // deUint32 rasterizerDiscardEnable;
- VK_FILL_MODE_SOLID, // VkFillMode fillMode;
- VK_CULL_MODE_NONE, // VkCullMode cullMode;
- VK_FRONT_FACE_CCW, // VkFrontFace frontFace;
+ VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ DE_TRUE, // deUint32 depthClipEnable;
+ DE_FALSE, // deUint32 rasterizerDiscardEnable;
+ VK_FILL_MODE_SOLID, // VkFillMode fillMode;
+ VK_CULL_MODE_NONE, // VkCullMode cullMode;
+ VK_FRONT_FACE_CCW, // VkFrontFace frontFace;
+ VK_FALSE, // VkBool32 depthBiasEnable;
+ 0.0f, // float depthBias;
+ 0.0f, // float depthBiasClamp;
+ 0.0f, // float slopeScaledDepthBias;
+ 1.0f, // float lineWidth;
};
const VkPipelineInputAssemblyStateCreateInfo inputAssemblyParams =
{
VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
DE_FALSE, // VkBool32 alphaToCoverageEnable;
+ DE_FALSE, // VkBool32 alphaToOneEnable;
DE_FALSE, // VkBool32 logicOpEnable;
VK_LOGIC_OP_COPY, // VkLogicOp logicOp;
1u, // deUint32 attachmentCount;
&attBlendParams, // const VkPipelineColorBlendAttachmentState* pAttachments;
+ { 0.0f, 0.0f, 0.0f, 0.0f }, // float blendConst[4];
+ };
+ const VkPipelineDynamicStateCreateInfo dynamicStateInfo =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // deUint32 dynamicStateCount;
+ DE_NULL // const VkDynamicState* pDynamicStates;
};
const VkGraphicsPipelineCreateInfo pipelineParams =
{
&multisampleParams, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
&depthStencilParams, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
&blendParams, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
+ &dynamicStateInfo, // const VkPipelineDynamicStateCreateInfo* pDynamicState;
0u, // VkPipelineCreateFlags flags;
*pipelineLayout, // VkPipelineLayout layout;
*renderPass, // VkRenderPass renderPass;
const Unique<VkPipeline> pipeline (createGraphicsPipeline(vk, vkDevice, DE_NULL, &pipelineParams));
// Framebuffer
- const VkAttachmentBindInfo colorBinding0 =
- {
- *colorAttView, // VkColorAttachmentView view;
- VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout layout;
- };
const VkFramebufferCreateInfo framebufferParams =
{
- VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- *renderPass, // VkRenderPass renderPass;
- 1u, // deUint32 attachmentCount;
- &colorBinding0, // const VkAttachmentBindInfo* pAttachments;
- (deUint32)renderSize.x(), // deUint32 width;
- (deUint32)renderSize.y(), // deUint32 height;
- 1u, // deUint32 layers;
- };
- const Unique<VkFramebuffer> framebuffer (createFramebuffer(vk, vkDevice, &framebufferParams));
-
- // Viewport state
- const VkViewport viewport0 =
- {
- 0.0f, // float originX;
- 0.0f, // float originY;
- (float)renderSize.x(), // float width;
- (float)renderSize.y(), // float height;
- 0.0f, // float minDepth;
- 1.0f, // float maxDepth;
- };
- const VkRect2D scissor0 =
- {
- {
- 0u, // deInt32 x;
- 0u, // deInt32 y;
- }, // VkOffset2D offset;
- {
- renderSize.x(), // deInt32 width;
- renderSize.y(), // deInt32 height;
- }, // VkExtent2D extent;
- };
- const VkDynamicViewportStateCreateInfo dynViewportStateParams =
- {
- VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType;
+ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
- 1u, // deUint32 viewportAndScissorCount;
- &viewport0, // const VkViewport* pViewports;
- &scissor0, // const VkRect* pScissors;
- };
- const Unique<VkDynamicViewportState> dynViewportState (createDynamicViewportState(vk, vkDevice, &dynViewportStateParams));
-
- const VkDynamicRasterStateCreateInfo dynRasterStateParams =
- {
- VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0.0f, // float depthBias;
- 0.0f, // float depthBiasClamp;
- 0.0f, // float slopeScaledDepthBias;
- 1.0f, // float lineWidth;
+ *renderPass, // VkRenderPass renderPass;
+ 1u, // deUint32 attachmentCount;
+ &*colorAttView, // const VkImageView* pAttachments;
+ (deUint32)renderSize.x(), // deUint32 width;
+ (deUint32)renderSize.y(), // deUint32 height;
+ 1u, // deUint32 layers;
};
- const Unique<VkDynamicRasterState> dynRasterState (createDynamicRasterState(vk, vkDevice, &dynRasterStateParams));
-
- const VkDynamicDepthStencilStateCreateInfo dynDepthStencilParams =
- {
- VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0.0f, // float minDepthBounds;
- 1.0f, // float maxDepthBounds;
- 0u, // deUint32 stencilReadMask;
- 0u, // deUint32 stencilWriteMask;
- 0u, // deUint32 stencilFrontRef;
- 0u, // deUint32 stencilBackRef;
- };
- const Unique<VkDynamicDepthStencilState> dynDepthStencilState (createDynamicDepthStencilState(vk, vkDevice, &dynDepthStencilParams));
+ const Unique<VkFramebuffer> framebuffer (createFramebuffer(vk, vkDevice, &framebufferParams));
const VkCmdPoolCreateInfo cmdPoolParams =
{
DE_NULL, // const void* pNext;
0u, // VkCmdBufferOptimizeFlags flags;
DE_NULL, // VkRenderPass renderPass;
+ 0u, // deUint32 subpass;
DE_NULL, // VkFramebuffer framebuffer;
};
queueFamilyIndex, // deUint32 destQueueFamilyIndex;
*image, // VkImage image;
{
- VK_IMAGE_ASPECT_COLOR, // VkImageAspect aspect;
+ VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspect aspect;
0u, // deUint32 baseMipLevel;
1u, // deUint32 mipLevels;
0u, // deUint32 baseArraySlice;
*renderPass, // VkRenderPass renderPass;
*framebuffer, // VkFramebuffer framebuffer;
{ { 0, 0 }, { renderSize.x(), renderSize.y() } }, // VkRect2D renderArea;
- 1u, // deUint32 attachmentCount;
- &clearValue, // const VkClearValue* pAttachmentClearValues;
+ 1u, // deUint32 clearValueCount;
+ &clearValue, // const VkClearValue* pClearValues;
};
vk.cmdBeginRenderPass(*cmdBuf, &passBeginParams, VK_RENDER_PASS_CONTENTS_INLINE);
}
- vk.cmdBindDynamicViewportState(*cmdBuf, *dynViewportState);
- vk.cmdBindDynamicRasterState(*cmdBuf, *dynRasterState);
- vk.cmdBindDynamicDepthStencilState(*cmdBuf, *dynDepthStencilState);
vk.cmdBindPipeline(*cmdBuf, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
{
const VkDeviceSize bindingOffset = 0;
vk.cmdBindVertexBuffers(*cmdBuf, 0u, 1u, &vertexBuffer.get(), &bindingOffset);
}
- vk.cmdDraw(*cmdBuf, 0u, 3u, 0u, 1u);
+ vk.cmdDraw(*cmdBuf, 3u, 1u, 0u, 0u);
vk.cmdEndRenderPass(*cmdBuf);
{
queueFamilyIndex, // deUint32 destQueueFamilyIndex;
*image, // VkImage image;
{
- VK_IMAGE_ASPECT_COLOR, // VkImageAspect aspect;
- 0u, // deUint32 baseMipLevel;
- 1u, // deUint32 mipLevels;
- 0u, // deUint32 baseArraySlice;
- 1u, // deUint32 arraySize;
+ VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
+ 0u, // deUint32 baseMipLevel;
+ 1u, // deUint32 mipLevels;
+ 0u, // deUint32 baseArraySlice;
+ 1u, // deUint32 arraySize;
} // VkImageSubresourceRange subresourceRange;
};
const void* barriers[] = { &renderFinishBarrier };
{
const VkBufferImageCopy copyParams =
{
- (VkDeviceSize)0u, // VkDeviceSize bufferOffset;
- (deUint32)renderSize.x(), // deUint32 bufferRowLength;
- (deUint32)renderSize.y(), // deUint32 bufferImageHeight;
+ (VkDeviceSize)0u, // VkDeviceSize bufferOffset;
+ (deUint32)renderSize.x(), // deUint32 bufferRowLength;
+ (deUint32)renderSize.y(), // deUint32 bufferImageHeight;
{
- VK_IMAGE_ASPECT_COLOR, // VkImageAspect aspect;
- 0u, // deUint32 mipLevel;
- 0u, // deUint32 arraySlice;
- }, // VkImageSubresource imageSubresource;
- { 0u, 0u, 0u }, // VkOffset3D imageOffset;
- { renderSize.x(), renderSize.y(), 1u } // VkExtent3D imageExtent;
+ VK_IMAGE_ASPECT_COLOR, // VkImageAspect aspect;
+ 0u, // deUint32 mipLevel;
+ 0u, // deUint32 arrayLayer;
+ 1u, // deUint32 arraySize;
+ }, // VkImageSubresourceCopy imageSubresource;
+ { 0u, 0u, 0u }, // VkOffset3D imageOffset;
+ { renderSize.x(), renderSize.y(), 1u } // VkExtent3D imageExtent;
};
vk.cmdCopyImageToBuffer(*cmdBuf, *image, VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL, *readImageBuffer, 1u, ©Params);
}
}
}
-vk::VkTexAddress mapToVkTexAddress (tcu::Sampler::WrapMode mode)
+vk::VkTexAddressMode mapToVkTexAddressMode (tcu::Sampler::WrapMode mode)
{
switch (mode)
{
- case tcu::Sampler::CLAMP_TO_EDGE: return vk::VK_TEX_ADDRESS_CLAMP;
- case tcu::Sampler::CLAMP_TO_BORDER: return vk::VK_TEX_ADDRESS_CLAMP_BORDER;
- case tcu::Sampler::REPEAT_GL: return vk::VK_TEX_ADDRESS_WRAP;
- case tcu::Sampler::MIRRORED_REPEAT_GL: return vk::VK_TEX_ADDRESS_MIRROR;
+ case tcu::Sampler::CLAMP_TO_EDGE: return vk::VK_TEX_ADDRESS_MODE_CLAMP;
+ case tcu::Sampler::CLAMP_TO_BORDER: return vk::VK_TEX_ADDRESS_MODE_CLAMP_BORDER;
+ case tcu::Sampler::REPEAT_GL: return vk::VK_TEX_ADDRESS_MODE_WRAP;
+ case tcu::Sampler::MIRRORED_REPEAT_GL: return vk::VK_TEX_ADDRESS_MODE_MIRROR;
default:
DE_FATAL("Illegal wrap mode");
- return (vk::VkTexAddress)0;
+ return (vk::VkTexAddressMode)0;
}
}
{
vk::VK_IMAGE_ASPECT_COLOR, // aspect
(deUint32)level, // mipLevel
- (deUint32)sliceNdx // arraySlice
+ (deUint32)sliceNdx, // arrayLayer
+ 1u, // arraySize
}, // imageSubresource
{
0,
return allocation;
}
+vk::VkDescriptorInfo createDescriptorInfo (vk::VkBuffer buffer, vk::VkDeviceSize offset, vk::VkDeviceSize range)
+{
+ const vk::VkDescriptorInfo resultInfo =
+ {
+ 0, // bufferView
+ 0, // sampler
+ 0, // imageView
+ (vk::VkImageLayout)0, // imageLayout
+ { buffer, offset, range } // bufferInfo
+ };
+ return resultInfo;
+}
+
vk::VkDescriptorInfo createDescriptorInfo (vk::VkBufferView bufferView)
{
const vk::VkDescriptorInfo resultInfo =
{
- bufferView, // bufferView
- 0, // sampler
- 0, // imageView
- 0, // attachmentView
- (vk::VkImageLayout)0, // imageLayout
+ bufferView, // bufferView
+ 0, // sampler
+ 0, // imageView
+ (vk::VkImageLayout)0, // imageLayout
+ { (vk::VkBuffer)0, 0, 0 } // bufferInfo
};
return resultInfo;
}
{
const vk::VkDescriptorInfo resultInfo =
{
- 0, // bufferView
- sampler, // sampler
- 0, // imageView
- 0, // attachmentView
- (vk::VkImageLayout)0, // imageLayout
+ 0, // bufferView
+ sampler, // sampler
+ 0, // imageView
+ (vk::VkImageLayout)0, // imageLayout
+ { (vk::VkBuffer)0, 0, 0 } // bufferInfo
};
return resultInfo;
}
{
const vk::VkDescriptorInfo resultInfo =
{
- 0, // bufferView
- 0, // sampler
- imageView, // imageView
- 0, // attachmentView
- layout, // imageLayout
+ 0, // bufferView
+ 0, // sampler
+ imageView, // imageView
+ layout, // imageLayout
+ { (vk::VkBuffer)0, 0, 0 } // bufferInfo
};
return resultInfo;
}
{
const vk::VkDescriptorInfo resultInfo =
{
- 0, // bufferView
- sampler, // sampler
- imageView, // imageView
- 0, // attachmentView
- layout, // imageLayout
+ 0, // bufferView
+ sampler, // sampler
+ imageView, // imageView
+ layout, // imageLayout
+ { (vk::VkBuffer)0, 0, 0 } // bufferInfo
};
return resultInfo;
}
{
vk::VkClearValue retVal;
- retVal.color.f32[0] = color.x();
- retVal.color.f32[1] = color.y();
- retVal.color.f32[2] = color.z();
- retVal.color.f32[3] = color.w();
+ retVal.color.float32[0] = color.x();
+ retVal.color.float32[1] = color.y();
+ retVal.color.float32[2] = color.z();
+ retVal.color.float32[3] = color.w();
return retVal;
};
const tcu::UVec2& size,
de::MovePtr<vk::Allocation>* outAllocation);
- static vk::Move<vk::VkAttachmentView> createColorAttachmentView (const vk::DeviceInterface& vki,
+ static vk::Move<vk::VkImageView> createColorAttachmentView (const vk::DeviceInterface& vki,
vk::VkDevice device,
const tcu::TextureFormat& format,
vk::VkImage image);
static vk::Move<vk::VkFramebuffer> createFramebuffer (const vk::DeviceInterface& vki,
vk::VkDevice device,
vk::VkRenderPass renderpass,
- vk::VkAttachmentView colorAttachmentView,
+ vk::VkImageView colorAttachmentView,
const tcu::UVec2& size);
static vk::Move<vk::VkCmdPool> createCommandPool (const vk::DeviceInterface& vki,
vk::Allocator& m_allocator;
de::MovePtr<vk::Allocation> m_colorAttachmentMemory;
const vk::Unique<vk::VkImage> m_colorAttachmentImage;
- const vk::Unique<vk::VkAttachmentView> m_colorAttachmentView;
+ const vk::Unique<vk::VkImageView> m_colorAttachmentView;
const vk::Unique<vk::VkRenderPass> m_renderPass;
const vk::Unique<vk::VkFramebuffer> m_framebuffer;
const vk::Unique<vk::VkCmdPool> m_cmdPool;
vk::VK_SHARING_MODE_EXCLUSIVE, // sharingMode
0u, // queueFamilyCount
DE_NULL, // pQueueFamilyIndices
+ vk::VK_IMAGE_LAYOUT_UNDEFINED, // initialLayout
};
vk::Move<vk::VkImage> image (vk::createImage(vki, device, &imageInfo));
return image;
}
-vk::Move<vk::VkAttachmentView> SingleTargetRenderInstance::createColorAttachmentView (const vk::DeviceInterface& vki,
- vk::VkDevice device,
- const tcu::TextureFormat& format,
- vk::VkImage image)
+vk::Move<vk::VkImageView> SingleTargetRenderInstance::createColorAttachmentView (const vk::DeviceInterface& vki,
+ vk::VkDevice device,
+ const tcu::TextureFormat& format,
+ vk::VkImage image)
{
- const vk::VkAttachmentViewCreateInfo createInfo =
+ const vk::VkImageViewCreateInfo createInfo =
{
- vk::VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO,
+ vk::VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
DE_NULL,
image, // image
+ vk::VK_IMAGE_VIEW_TYPE_2D, // viewType
mapToVkTextureFormat(format), // format
- 0u, // mipLevel
- 0u, // baseArraySlice
- 1u, // arraySize
+ { vk::VK_CHANNEL_SWIZZLE_R, vk::VK_CHANNEL_SWIZZLE_G, vk::VK_CHANNEL_SWIZZLE_B, vk::VK_CHANNEL_SWIZZLE_A },
+ {
+ vk::VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
+ 0u, // baseMipLevel
+ 1u, // mipLevels
+ 0u, // baseArrayLayer
+ 1u, // arraySize
+ },
0u, // flags
};
- return vk::createAttachmentView(vki, device, &createInfo);
+ return vk::createImageView(vki, device, &createInfo);
}
vk::Move<vk::VkRenderPass> SingleTargetRenderInstance::createRenderPass (const vk::DeviceInterface& vki,
vk::VK_ATTACHMENT_STORE_OP_DONT_CARE, // stencilStoreOp
vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // initialLayout
vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // finalLayout
+ 0u, // flags
};
const vk::VkAttachmentReference colorAttachment =
{
0u, // inputCount
DE_NULL, // inputAttachments
1u, // colorCount
- &colorAttachment, // colorAttachments
- DE_NULL, // resolveAttachments
+ &colorAttachment, // pColorAttachments
+ DE_NULL, // pResolveAttachments
depthStencilAttachment, // depthStencilAttachment
0u, // preserveCount
- DE_NULL // preserveAttachments
+ DE_NULL // pPreserveAttachments
};
const vk::VkRenderPassCreateInfo renderPassCreateInfo =
{
vk::Move<vk::VkFramebuffer> SingleTargetRenderInstance::createFramebuffer (const vk::DeviceInterface& vki,
vk::VkDevice device,
vk::VkRenderPass renderpass,
- vk::VkAttachmentView colorAttachmentView,
+ vk::VkImageView colorAttachmentView,
const tcu::UVec2& size)
{
- const vk::VkAttachmentBindInfo colorAttachment =
- {
- colorAttachmentView, // view;
- vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // layout;
- };
const vk::VkFramebufferCreateInfo framebufferCreateInfo =
{
vk::VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
DE_NULL,
renderpass, // renderPass
1u, // attachmentCount
- &colorAttachment, // pAttachments
+ &colorAttachmentView, // pAttachments
size.x(), // width
size.y(), // height
1, // layers
const vk::Unique<vk::VkBuffer> buffer (vk::createBuffer(m_vki, m_device, &bufferCreateInfo));
const vk::VkImageSubresourceRange fullSubrange =
{
- vk::VK_IMAGE_ASPECT_COLOR, // aspect
+ vk::VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
0u, // baseMipLevel
1u, // mipLevels
0u, // baseArraySlice
DE_NULL,
vk::VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT | vk::VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT, // flags
(vk::VkRenderPass)0u, // renderPass
+ 0u, // subpass
(vk::VkFramebuffer)0u, // framebuffer
};
- const vk::VkImageSubresource firstSlice =
+ const vk::VkImageSubresourceCopy firstSlice =
{
vk::VK_IMAGE_ASPECT_COLOR, // aspect
0, // mipLevel
- 0, // arraySlice
+ 0, // arrayLayer
+ 1, // arraySize
};
const vk::VkBufferImageCopy copyRegion =
{
// transition to VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
const vk::VkImageSubresourceRange fullSubrange =
{
- vk::VK_IMAGE_ASPECT_COLOR, // aspect
+ vk::VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
0u, // baseMipLevel
1u, // mipLevels
0u, // baseArraySlice
DE_NULL,
vk::VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT | vk::VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT, // flags
(vk::VkRenderPass)0u, // renderPass
- (vk::VkFramebuffer)0u, // framebuffer
+ 0u, // subpass
+ (vk::VkFramebuffer)0u, // framebuffer
};
const vk::Unique<vk::VkCmdBuffer> cmd (vk::createCommandBuffer(m_vki, m_device, &cmdBufCreateInfo));
DE_NULL,
*module, // module
"main", // pName
- 0u // flags
+ 0u, // flags
+ stage
};
vk::Move<vk::VkShader> shader = vk::createShader(vki, device, &createInfo);
DE_NULL,
3u, // patchControlPoints
};
+ const vk::VkViewport viewport =
+ {
+ 0.0f, // originX
+ 0.0f, // originY
+ float(m_targetSize.x()), // width
+ float(m_targetSize.y()), // height
+ 0.0f, // minDepth
+ 1.0f, // maxDepth
+ };
+ const vk::VkRect2D renderArea =
+ {
+ { 0, 0 }, // offset
+ { (deInt32)m_targetSize.x(), (deInt32)m_targetSize.y() }, // extent
+ };
const vk::VkPipelineViewportStateCreateInfo vpState =
{
vk::VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
DE_NULL,
1u, // viewportCount
+ &viewport,
+ 1u,
+ &renderArea,
};
const vk::VkPipelineRasterStateCreateInfo rsState =
{
vk::VK_FILL_MODE_SOLID, // fillMode
vk::VK_CULL_MODE_NONE, // cullMode
vk::VK_FRONT_FACE_CCW, // frontFace
+ vk::VK_FALSE, // depthBiasEnable
+ 0.0f, // depthBias
+ 0.0f, // depthBiasClamp
+ 0.0f, // slopeScaledDepthBias
+ 1.0f, // lineWidth
};
+ const vk::VkSampleMask sampleMask = 0x01u;
const vk::VkPipelineMultisampleStateCreateInfo msState =
{
vk::VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
1u, // rasterSamples
vk::VK_FALSE, // sampleShadingEnable
0.0f, // minSampleShading
- 0x01u // sampleMask
+ &sampleMask // sampleMask
};
const vk::VkPipelineDepthStencilStateCreateInfo dsState =
{
vk::VK_FALSE, // depthTestEnable
vk::VK_FALSE, // depthWriteEnable
vk::VK_COMPARE_OP_ALWAYS, // depthCompareOp
- vk::VK_FALSE, // depthBoundsEnable
+ vk::VK_FALSE, // depthBoundsTestEnable
vk::VK_FALSE, // stencilTestEnable
- { vk::VK_STENCIL_OP_KEEP, vk::VK_STENCIL_OP_KEEP, vk::VK_STENCIL_OP_KEEP, vk::VK_COMPARE_OP_ALWAYS }, // front
- { vk::VK_STENCIL_OP_KEEP, vk::VK_STENCIL_OP_KEEP, vk::VK_STENCIL_OP_KEEP, vk::VK_COMPARE_OP_ALWAYS }, // back
+ { vk::VK_STENCIL_OP_KEEP, vk::VK_STENCIL_OP_KEEP, vk::VK_STENCIL_OP_KEEP, vk::VK_COMPARE_OP_ALWAYS, 0u, 0u, 0u }, // front
+ { vk::VK_STENCIL_OP_KEEP, vk::VK_STENCIL_OP_KEEP, vk::VK_STENCIL_OP_KEEP, vk::VK_COMPARE_OP_ALWAYS, 0u, 0u, 0u }, // back
+ -1.0f, // minDepthBounds
+ +1.0f, // maxDepthBounds
};
const vk::VkPipelineColorBlendAttachmentState cbAttachment =
{
vk::VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
DE_NULL,
vk::VK_FALSE, // alphaToCoverageEnable
+ vk::VK_FALSE, // alphaToOneEnable
vk::VK_FALSE, // logicOpEnable
vk::VK_LOGIC_OP_CLEAR, // logicOp
1u, // attachmentCount
&cbAttachment, // pAttachments
+ { 0.0f, 0.0f, 0.0f, 0.0f }, // blendConst
+ };
+ const vk::VkPipelineDynamicStateCreateInfo dynState =
+ {
+ vk::VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
+ DE_NULL,
+ 0u, // dynamicStateCount
+ DE_NULL, // pDynamicStates
};
const vk::VkGraphicsPipelineCreateInfo createInfo =
{
&msState, // pMultisampleState
&dsState, // pDepthStencilState
&cbState, // pColorBlendState
+ &dynState, // pDynamicState
0u, // flags
pipelineLayout, // layout
*m_renderPass, // renderPass
void SingleCmdRenderInstance::renderToTarget (void)
{
- const vk::VkViewport viewport =
- {
- 0.0f, // originX
- 0.0f, // originY
- float(m_targetSize.x()), // width
- float(m_targetSize.y()), // height
- 0.0f, // minDepth
- 1.0f, // maxDepth
- };
const vk::VkRect2D renderArea =
{
{ 0, 0 }, // offset
{ (deInt32)m_targetSize.x(), (deInt32)m_targetSize.y() }, // extent
};
- const vk::VkDynamicViewportStateCreateInfo viewportStateCreateInfo =
- {
- vk::VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO,
- DE_NULL,
- 1, // viewportAndScissorCount
- &viewport, // pViewports
- &renderArea, // pScissors
- };
- const vk::VkDynamicRasterStateCreateInfo rasterStateCreateInfo =
- {
- vk::VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO,
- DE_NULL,
- 0.0f, // depthBias
- 0.0f, // depthBiasClamp
- 0.0f, // slopeScaledDepthBias
- 1.0f, // lineWidth
- };
- const vk::VkDynamicColorBlendStateCreateInfo colorBlendStateCreateInfo =
- {
- vk::VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO,
- DE_NULL,
- { 0.0f, 0.0f, 0.0f, 0.0f }, // blendConst
- };
- const vk::VkDynamicDepthStencilStateCreateInfo depthStencilStateCreateInfo =
- {
- vk::VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO,
- DE_NULL,
- 0.0f, // minDepthBounds
- 1.0f, // maxDepthBounds
- 0u, // stencilReadMask
- 0u, // stencilWriteMask
- 0u, // stencilFrontRef
- 0u, // stencilBackRef
- };
const vk::VkCmdBufferCreateInfo mainCmdBufCreateInfo =
{
vk::VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO,
DE_NULL,
vk::VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT | vk::VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT, // flags
(vk::VkRenderPass)0u, // renderPass
+ 0u, // subpass
(vk::VkFramebuffer)0u, // framebuffer
};
const vk::VkCmdBufferCreateInfo passCmdBufCreateInfo =
DE_NULL,
vk::VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT | vk::VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT, // flags
(vk::VkRenderPass)*m_renderPass, // renderPass
+ 0u, // subpass
(vk::VkFramebuffer)*m_framebuffer, // framebuffer
};
const vk::VkFenceCreateInfo fenceCreateInfo =
{
vk::VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
DE_NULL,
- *m_renderPass, // renderPass
+ *m_renderPass, // renderPass
*m_framebuffer, // framebuffer
renderArea, // renderArea
- 1u, // attachmentCount
- &clearValue, // pAttachmentClearValues
+ 1u, // clearValueCount
+ &clearValue, // pClearValues
};
const vk::VkPipelineLayout pipelineLayout (getPipelineLayout());
const vk::Unique<vk::VkPipeline> pipeline (createPipeline(pipelineLayout));
const vk::Unique<vk::VkCmdBuffer> mainCmd (vk::createCommandBuffer(m_vki, m_device, &mainCmdBufCreateInfo));
const vk::Unique<vk::VkCmdBuffer> passCmd ((m_isPrimaryCmdBuf) ? (vk::Move<vk::VkCmdBuffer>()) : (vk::createCommandBuffer(m_vki, m_device, &passCmdBufCreateInfo)));
- const vk::Unique<vk::VkDynamicViewportState> dynamicVpState (vk::createDynamicViewportState(m_vki, m_device, &viewportStateCreateInfo));
- const vk::Unique<vk::VkDynamicRasterState> dynamicRsState (vk::createDynamicRasterState(m_vki, m_device, &rasterStateCreateInfo));
- const vk::Unique<vk::VkDynamicColorBlendState> dynamicCbState (vk::createDynamicColorBlendState(m_vki, m_device, &colorBlendStateCreateInfo));
- const vk::Unique<vk::VkDynamicDepthStencilState> dynamicDsState (vk::createDynamicDepthStencilState(m_vki, m_device, &depthStencilStateCreateInfo));
const vk::Unique<vk::VkFence> fence (vk::createFence(m_vki, m_device, &fenceCreateInfo));
const deUint64 infiniteTimeout = ~(deUint64)0u;
const vk::VkRenderPassContents passContents = (m_isPrimaryCmdBuf) ? (vk::VK_RENDER_PASS_CONTENTS_INLINE) : (vk::VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS);
if (m_isPrimaryCmdBuf)
{
- m_vki.cmdBindDynamicViewportState(*mainCmd, *dynamicVpState);
- m_vki.cmdBindDynamicRasterState(*mainCmd, *dynamicRsState);
- m_vki.cmdBindDynamicColorBlendState(*mainCmd, *dynamicCbState);
- m_vki.cmdBindDynamicDepthStencilState(*mainCmd, *dynamicDsState);
m_vki.cmdBindPipeline(*mainCmd, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
writeDrawCmdBuffer(*mainCmd);
}
else
{
VK_CHECK(m_vki.beginCommandBuffer(*passCmd, &passCmdBufBeginInfo));
- m_vki.cmdBindDynamicViewportState(*passCmd, *dynamicVpState);
- m_vki.cmdBindDynamicRasterState(*passCmd, *dynamicRsState);
- m_vki.cmdBindDynamicColorBlendState(*passCmd, *dynamicCbState);
- m_vki.cmdBindDynamicDepthStencilState(*passCmd, *dynamicDsState);
m_vki.cmdBindPipeline(*passCmd, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
writeDrawCmdBuffer(*passCmd);
VK_CHECK(m_vki.endCommandBuffer(*passCmd));
deUint32 bufferSize,
de::MovePtr<vk::Allocation>* outMemory);
- static vk::Move<vk::VkBufferView> createBufferView (const vk::DeviceInterface& vki,
- vk::VkDevice device,
- vk::VkBuffer buffer,
- deUint32 offset);
-
static vk::Move<vk::VkDescriptorPool> createDescriptorPool (const vk::DeviceInterface& vki,
vk::VkDevice device,
vk::VkDescriptorType descriptorType,
vk::VkDescriptorPool descriptorPool,
vk::VkDescriptorType descriptorType,
ShaderInputInterface shaderInterface,
- vk::VkBufferView bufferViewA,
- vk::VkBufferView bufferViewB);
+ vk::VkBuffer sourceBufferA,
+ const deUint32 viewOffsetA,
+ vk::VkBuffer sourceBufferB,
+ const deUint32 viewOffsetB);
- static vk::Move<vk::VkPipelineLayout> createPipelineLayout (const vk::DeviceInterface& vki,
+ static vk::Move<vk::VkPipelineLayout> createPipelineLayout (const vk::DeviceInterface& vki,
vk::VkDevice device,
vk::VkDescriptorSetLayout descriptorSetLayout);
de::MovePtr<vk::Allocation> m_bufferMemoryB;
const vk::Unique<vk::VkBuffer> m_sourceBufferA;
const vk::Unique<vk::VkBuffer> m_sourceBufferB;
- const vk::Unique<vk::VkBufferView> m_bufferViewA;
- const vk::Unique<vk::VkBufferView> m_bufferViewB;
const vk::Unique<vk::VkDescriptorPool> m_descriptorPool;
const vk::Unique<vk::VkDescriptorSetLayout> m_descriptorSetLayout;
const vk::Unique<vk::VkDescriptorSet> m_descriptorSet;
, m_sourceBufferB ((getInterfaceNumResources(m_shaderInterface) == 1u)
? vk::Move<vk::VkBuffer>()
: createSourceBuffer(m_vki, m_device, m_allocator, m_descriptorType, m_effectiveOffsetB, m_bufferSizeB, &m_bufferMemoryB))
- , m_bufferViewA (createBufferView(m_vki, m_device, *m_sourceBufferA, m_viewOffsetA))
- , m_bufferViewB ((getInterfaceNumResources(m_shaderInterface) == 1u)
- ? vk::Move<vk::VkBufferView>()
- : createBufferView(m_vki, m_device, *m_sourceBufferB, m_viewOffsetB))
, m_descriptorPool (createDescriptorPool(m_vki, m_device, m_descriptorType, m_shaderInterface))
, m_descriptorSetLayout (createDescriptorSetLayout(m_vki, m_device, m_descriptorType, m_shaderInterface, m_stageFlags))
- , m_descriptorSet (createDescriptorSet(m_vki, m_device, *m_descriptorSetLayout, *m_descriptorPool, m_descriptorType, m_shaderInterface, *m_bufferViewA, *m_bufferViewB))
+ , m_descriptorSet (createDescriptorSet(m_vki, m_device, *m_descriptorSetLayout, *m_descriptorPool, m_descriptorType, m_shaderInterface, *m_sourceBufferA, m_viewOffsetA, *m_sourceBufferB, m_viewOffsetB))
, m_pipelineLayout (createPipelineLayout(m_vki, m_device, *m_descriptorSetLayout))
{
if (m_setDynamicOffset)
return buffer;
}
-vk::Move<vk::VkBufferView> BufferRenderInstance::createBufferView (const vk::DeviceInterface& vki,
- vk::VkDevice device,
- vk::VkBuffer buffer,
- deUint32 offset)
-{
- const vk::VkBufferViewCreateInfo createInfo =
- {
- vk::VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,
- DE_NULL,
- buffer, // buffer
- vk::VK_BUFFER_VIEW_TYPE_RAW, // viewType
- vk::VK_FORMAT_UNDEFINED, // format
- (vk::VkDeviceSize)offset, // offset
- (vk::VkDeviceSize)BUFFER_DATA_SIZE // range
- };
- return vk::createBufferView(vki, device, &createInfo);
-}
-
vk::Move<vk::VkDescriptorPool> BufferRenderInstance::createDescriptorPool (const vk::DeviceInterface& vki,
vk::VkDevice device,
vk::VkDescriptorType descriptorType,
vk::VkDescriptorPool descriptorPool,
vk::VkDescriptorType descriptorType,
ShaderInputInterface shaderInterface,
- vk::VkBufferView viewA,
- vk::VkBufferView viewB)
+ vk::VkBuffer bufferA,
+ deUint32 offsetA,
+ vk::VkBuffer bufferB,
+ deUint32 offsetB)
{
const vk::VkDescriptorInfo bufferInfos[2] =
{
- createDescriptorInfo(viewA),
- createDescriptorInfo(viewB),
+ createDescriptorInfo(bufferA, (vk::VkDeviceSize)offsetA, (vk::VkDeviceSize)BUFFER_DATA_SIZE),
+ createDescriptorInfo(bufferB, (vk::VkDeviceSize)offsetB, (vk::VkDeviceSize)BUFFER_DATA_SIZE),
};
vk::Move<vk::VkDescriptorSet> descriptorSet = allocDescriptorSet(vki, device, descriptorPool, vk::VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, descriptorSetLayout);
m_vki.cmdBindDescriptorSets(cmd, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, getPipelineLayout(), 0, 1, &m_descriptorSet.get(), numOffsets, dynamicOffsetPtr);
m_vki.cmdPipelineBarrier(cmd, 0u, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS, vk::VK_FALSE, numMemoryBarriers, memoryBarriers);
- m_vki.cmdDraw(cmd, 0, 6 * 4, 0, 1); // render four quads (two separate triangles)
+ m_vki.cmdDraw(cmd, 6 * 4, 1, 0, 0); // render four quads (two separate triangles)
}
tcu::TestStatus BufferRenderInstance::verifyResultImage (const tcu::ConstPixelBufferAccess& result) const
void readResultContentsTo (tcu::Vec4 (*results)[4]) const;
inline vk::VkBuffer getBuffer (void) const { return *m_buffer; }
- inline vk::VkBufferView getBufferView (void) const { return *m_bufferView; }
inline const void* getResultReadBarrier (void) const { return &m_bufferBarrier; }
private:
- static vk::Move<vk::VkBuffer> createResultBuffer (const vk::DeviceInterface& vki,
+ static vk::Move<vk::VkBuffer> createResultBuffer (const vk::DeviceInterface& vki,
vk::VkDevice device,
vk::Allocator& allocator,
de::MovePtr<vk::Allocation>* outAllocation);
- static vk::Move<vk::VkBufferView> createResultBufferView (const vk::DeviceInterface& vki,
- vk::VkDevice device,
- vk::VkBuffer buffer);
-
static vk::VkBufferMemoryBarrier createResultBufferBarrier (vk::VkBuffer buffer);
const vk::DeviceInterface& m_vki;
de::MovePtr<vk::Allocation> m_bufferMem;
const vk::Unique<vk::VkBuffer> m_buffer;
- const vk::Unique<vk::VkBufferView> m_bufferView;
const vk::VkBufferMemoryBarrier m_bufferBarrier;
};
, m_device (device)
, m_bufferMem (DE_NULL)
, m_buffer (createResultBuffer(m_vki, m_device, allocator, &m_bufferMem))
- , m_bufferView (createResultBufferView(m_vki, m_device, *m_buffer))
, m_bufferBarrier (createResultBufferBarrier(*m_buffer))
{
}
return buffer;
}
-vk::Move<vk::VkBufferView> ComputeInstanceResultBuffer::createResultBufferView (const vk::DeviceInterface& vki,
- vk::VkDevice device,
- vk::VkBuffer buffer)
-{
- const vk::VkBufferViewCreateInfo createInfo =
- {
- vk::VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,
- DE_NULL,
- buffer, // buffer
- vk::VK_BUFFER_VIEW_TYPE_RAW, // viewType
- vk::VK_FORMAT_UNDEFINED, // format
- (vk::VkDeviceSize)0u, // offset
- (vk::VkDeviceSize)DATA_SIZE // range
- };
- return vk::createBufferView(vki, device, &createInfo);
-}
-
vk::VkBufferMemoryBarrier ComputeInstanceResultBuffer::createResultBufferBarrier (vk::VkBuffer buffer)
{
const vk::VkBufferMemoryBarrier bufferBarrier =
DE_NULL,
*computeModule, // module
"main", // pName
- 0u // flags
+ 0u, // flags
+ vk::VK_SHADER_STAGE_COMPUTE
};
const vk::Unique<vk::VkShader> computeShader (vk::createShader(vki, device, &shaderCreateInfo));
const vk::VkPipelineShaderStageCreateInfo cs =
DE_NULL,
vk::VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT | vk::VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT, // flags
(vk::VkRenderPass)0u, // renderPass
+ 0u, // subpass
(vk::VkFramebuffer)0u, // framebuffer
};
vk::Move<vk::VkBufferView> createBufferView (vk::VkBuffer buffer, deUint32 offset) const;
vk::Move<vk::VkDescriptorSetLayout> createDescriptorSetLayout (void) const;
vk::Move<vk::VkDescriptorPool> createDescriptorPool (void) const;
- vk::Move<vk::VkDescriptorSet> createDescriptorSet (vk::VkDescriptorPool pool, vk::VkDescriptorSetLayout layout, vk::VkBufferView viewA, vk::VkBufferView viewB, vk::VkBufferView viewRes) const;
+ vk::Move<vk::VkDescriptorSet> createDescriptorSet (vk::VkDescriptorPool pool, vk::VkDescriptorSetLayout layout, vk::VkBuffer viewA, deUint32 offsetA, vk::VkBuffer viewB, deUint32 offsetB, vk::VkBuffer resBuf) const;
tcu::TestStatus iterate (void);
void logTestPlan (void) const;
return buffer;
}
-vk::Move<vk::VkBufferView> BufferComputeInstance::createBufferView (vk::VkBuffer buffer, deUint32 offset) const
-{
- const vk::VkBufferViewCreateInfo createInfo =
- {
- vk::VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,
- DE_NULL,
- buffer, // buffer
- vk::VK_BUFFER_VIEW_TYPE_RAW, // viewType
- vk::VK_FORMAT_UNDEFINED, // format
- (vk::VkDeviceSize)offset, // offset
- (vk::VkDeviceSize)sizeof(tcu::Vec4[2]) // range
- };
- return vk::createBufferView(m_vki, m_device, &createInfo);
-}
-
vk::Move<vk::VkDescriptorSetLayout> BufferComputeInstance::createDescriptorSetLayout (void) const
{
vk::DescriptorSetLayoutBuilder builder;
.build(m_vki, m_device, vk::VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT, 1);
}
-vk::Move<vk::VkDescriptorSet> BufferComputeInstance::createDescriptorSet (vk::VkDescriptorPool pool, vk::VkDescriptorSetLayout layout, vk::VkBufferView viewA, vk::VkBufferView viewB, vk::VkBufferView viewRes) const
+vk::Move<vk::VkDescriptorSet> BufferComputeInstance::createDescriptorSet (vk::VkDescriptorPool pool, vk::VkDescriptorSetLayout layout, vk::VkBuffer viewA, deUint32 offsetA, vk::VkBuffer viewB, deUint32 offsetB, vk::VkBuffer resBuf) const
{
- const vk::VkDescriptorInfo resultInfo = createDescriptorInfo(viewRes);
+ const vk::VkDescriptorInfo resultInfo = createDescriptorInfo(resBuf, 0u, (vk::VkDeviceSize)ComputeInstanceResultBuffer::DATA_SIZE);
const vk::VkDescriptorInfo bufferInfos[2] =
{
- createDescriptorInfo(viewA),
- createDescriptorInfo(viewB),
+ createDescriptorInfo(viewA, (vk::VkDeviceSize)offsetA, (vk::VkDeviceSize)sizeof(tcu::Vec4[2])),
+ createDescriptorInfo(viewB, (vk::VkDeviceSize)offsetB, (vk::VkDeviceSize)sizeof(tcu::Vec4[2])),
};
vk::Move<vk::VkDescriptorSet> descriptorSet = allocDescriptorSet(m_vki, m_device, pool, vk::VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, layout);
de::MovePtr<vk::Allocation> bufferMemA;
const vk::Unique<vk::VkBuffer> bufferA (createColorDataBuffer(dataOffsetA, bufferSizeA, colorA1, colorA2, &bufferMemA));
- const vk::Unique<vk::VkBufferView> bufferViewA (createBufferView(*bufferA, viewOffsetA));
de::MovePtr<vk::Allocation> bufferMemB;
const vk::Unique<vk::VkBuffer> bufferB ((getInterfaceNumResources(m_shaderInterface) == 1u)
? (vk::Move<vk::VkBuffer>())
: (createColorDataBuffer(dataOffsetB, bufferSizeB, colorB1, colorB2, &bufferMemB)));
- const vk::Unique<vk::VkBufferView> bufferViewB ((getInterfaceNumResources(m_shaderInterface) == 1u)
- ? (vk::Move<vk::VkBufferView>())
- : (createBufferView(*bufferB, viewOffsetB)));
const vk::Unique<vk::VkDescriptorSetLayout> descriptorSetLayout (createDescriptorSetLayout());
const vk::Unique<vk::VkDescriptorPool> descriptorPool (createDescriptorPool());
- const vk::Unique<vk::VkDescriptorSet> descriptorSet (createDescriptorSet(*descriptorPool, *descriptorSetLayout, *bufferViewA, *bufferViewB, m_result.getBufferView()));
+ const vk::Unique<vk::VkDescriptorSet> descriptorSet (createDescriptorSet(*descriptorPool, *descriptorSetLayout, *bufferA, viewOffsetA, *bufferB, viewOffsetB, m_result.getBuffer()));
const ComputePipeline pipeline (m_vki, m_device, m_context.getBinaryCollection(), 1, &descriptorSetLayout.get());
const vk::VkMemoryInputFlags inputBit = (isUniformBuffer) ? (vk::VK_MEMORY_INPUT_UNIFORM_READ_BIT) : (vk::VK_MEMORY_INPUT_SHADER_READ_BIT);
deUint32 baseArraySlice);
private:
- static vk::Move<vk::VkImage> createImage (const vk::DeviceInterface& vki,
+ static vk::Move<vk::VkImage> createImage (const vk::DeviceInterface& vki,
vk::VkDevice device,
vk::Allocator& allocator,
vk::VkDescriptorType descriptorType,
const tcu::TextureLevelPyramid& sourceImage,
de::MovePtr<vk::Allocation>* outAllocation);
- static vk::Move<vk::VkImageView> createImageView (const vk::DeviceInterface& vki,
+ static vk::Move<vk::VkImageView> createImageView (const vk::DeviceInterface& vki,
vk::VkDevice device,
vk::VkImageViewType viewType,
const tcu::TextureLevelPyramid& sourceImage,
deUint32 queueFamilyIndex,
vk::VkQueue queue,
vk::Allocator& allocator,
- vk::VkImage image,
+ vk::VkImage image,
const tcu::TextureLevelPyramid& data);
protected:
vk::VK_SHARING_MODE_EXCLUSIVE, // sharingMode
0u, // queueFamilyCount
DE_NULL, // pQueueFamilyIndices
+ vk::VK_IMAGE_LAYOUT_UNDEFINED, // initialLayout
};
vk::Move<vk::VkImage> image (vk::createImage(vki, device, &createInfo));
const vk::VkImageSubresourceRange resourceRange =
{
- vk::VK_IMAGE_ASPECT_COLOR, // aspect
+ vk::VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
baseMipLevel, // baseMipLevel
sourceImage.getNumLevels() - baseMipLevel, // mipLevels
viewTypeBaseSlice, // baseArraySlice
vk::VK_CHANNEL_SWIZZLE_A
}, // channels
resourceRange, // subresourceRange
+ 0u, // flags
};
return vk::createImageView(vki, device, &createInfo);
}
for (int level = 0; level < numLevels; ++level)
{
const int width = IMAGE_SIZE >> level;
- const int height = (m_viewType == vk::VK_IMAGE_VIEW_TYPE_1D || m_viewType == vk::VK_IMAGE_VIEW_TYPE_1D_ARRAY) ? (ARRAY_SIZE)
+ const int height = (m_viewType == vk::VK_IMAGE_VIEW_TYPE_1D || m_viewType == vk::VK_IMAGE_VIEW_TYPE_1D_ARRAY) ? (ARRAY_SIZE)
: (IMAGE_SIZE >> level);
const int depth = (m_viewType == vk::VK_IMAGE_VIEW_TYPE_1D || m_viewType == vk::VK_IMAGE_VIEW_TYPE_1D_ARRAY) ? (1)
: (m_viewType == vk::VK_IMAGE_VIEW_TYPE_2D || m_viewType == vk::VK_IMAGE_VIEW_TYPE_2D_ARRAY) ? (ARRAY_SIZE)
};
const vk::VkImageSubresourceRange fullSubrange =
{
- vk::VK_IMAGE_ASPECT_COLOR, // aspect
+ vk::VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
0u, // baseMipLevel
(deUint32)data.getNumLevels(), // mipLevels
0u, // baseArraySlice
DE_NULL,
vk::VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT | vk::VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT, // flags
(vk::VkRenderPass)0u, // renderPass
+ 0u, // subpass
(vk::VkFramebuffer)0u, // framebuffer
};
ShaderInputInterface shaderInterface,
vk::VkShaderStageFlags stageFlags);
- static vk::Move<vk::VkPipelineLayout> createPipelineLayout (const vk::DeviceInterface& vki,
+ static vk::Move<vk::VkPipelineLayout> createPipelineLayout (const vk::DeviceInterface& vki,
vk::VkDevice device,
vk::VkDescriptorSetLayout descriptorSetLayout);
void ImageFetchRenderInstance::writeDrawCmdBuffer (vk::VkCmdBuffer cmd) const
{
m_vki.cmdBindDescriptorSets(cmd, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, getPipelineLayout(), 0, 1, &m_descriptorSet.get(), 0, DE_NULL);
- m_vki.cmdDraw(cmd, 0, 6 * 4, 0, 1); // render four quads (two separate triangles)
+ m_vki.cmdDraw(cmd, 6 * 4, 1, 0, 0); // render four quads (two separate triangles)
}
tcu::TestStatus ImageFetchRenderInstance::verifyResultImage (const tcu::ConstPixelBufferAccess& result) const
vk::Move<vk::VkDescriptorSet> ImageFetchComputeInstance::createDescriptorSet (vk::VkDescriptorPool pool, vk::VkDescriptorSetLayout layout) const
{
- const vk::VkDescriptorInfo resultInfo = createDescriptorInfo(m_result.getBufferView());
+ const vk::VkDescriptorInfo resultInfo = createDescriptorInfo(m_result.getBuffer(), 0u, (vk::VkDeviceSize)ComputeInstanceResultBuffer::DATA_SIZE);
const vk::VkDescriptorInfo imageInfos[2] =
{
createDescriptorInfo(m_images.getImageViewA(), vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL),
mapMagFilterToVkTexFilter(sampler.magFilter), // magFilter
mapMinFilterToVkTexFilter(sampler.minFilter), // minFilter
mapMinFilterToVkTexMipmapMode(sampler.minFilter), // mipMode
- mapToVkTexAddress(sampler.wrapS), // addressU
- mapToVkTexAddress(sampler.wrapT), // addressV
- mapToVkTexAddress(sampler.wrapR), // addressW
+ mapToVkTexAddressMode(sampler.wrapS), // addressU
+ mapToVkTexAddressMode(sampler.wrapT), // addressV
+ mapToVkTexAddressMode(sampler.wrapR), // addressW
0.0f, // mipLodBias
1, // maxAnisotropy
(compareEnabled) ? (vk::VkBool32)(vk::VK_TRUE) : (vk::VkBool32)(vk::VK_FALSE), // compareEnable
0.0f, // minLod
0.0f, // maxLod
borderColor, // borderColor
+ vk::VK_FALSE, // unnormalizedCoords
};
return vk::createSampler(vki, device, &createInfo);
}
vk::VkShaderStageFlags stageFlags,
const ImageSampleInstanceImages& images);
- static vk::Move<vk::VkPipelineLayout> createPipelineLayout (const vk::DeviceInterface& vki,
+ static vk::Move<vk::VkPipelineLayout> createPipelineLayout (const vk::DeviceInterface& vki,
vk::VkDevice device,
vk::VkDescriptorSetLayout descriptorSetLayout);
const vk::VkImageViewType m_viewType;
const deUint32 m_baseMipLevel;
const deUint32 m_baseArraySlice;
-
+
const ImageSampleInstanceImages m_images;
const vk::Unique<vk::VkDescriptorSetLayout> m_descriptorSetLayout;
const vk::Unique<vk::VkPipelineLayout> m_pipelineLayout;
void ImageSampleRenderInstance::writeDrawCmdBuffer (vk::VkCmdBuffer cmd) const
{
m_vki.cmdBindDescriptorSets(cmd, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, getPipelineLayout(), 0u, 1u, &m_descriptorSet.get(), 0u, DE_NULL);
- m_vki.cmdDraw(cmd, 0u, 6u * 4u, 0u, 1u); // render four quads (two separate triangles)
+ m_vki.cmdDraw(cmd, 6u * 4u, 1u, 0u, 0u); // render four quads (two separate triangles)
}
tcu::TestStatus ImageSampleRenderInstance::verifyResultImage (const tcu::ConstPixelBufferAccess& result) const
void ImageSampleComputeInstance::writeSamplerDescriptorSet (vk::VkDescriptorSet descriptorSet) const
{
- const vk::VkDescriptorInfo resultInfo = createDescriptorInfo(m_result.getBufferView());
+ const vk::VkDescriptorInfo resultInfo = createDescriptorInfo(m_result.getBuffer(), 0u, (vk::VkDeviceSize)ComputeInstanceResultBuffer::DATA_SIZE);
const vk::VkDescriptorInfo imageInfo = createDescriptorInfo(m_images.getImageViewA(), vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
const vk::VkDescriptorInfo samplersInfos[2] =
{
void ImageSampleComputeInstance::writeImageSamplerDescriptorSet (vk::VkDescriptorSet descriptorSet) const
{
- const vk::VkDescriptorInfo resultInfo = createDescriptorInfo(m_result.getBufferView());
+ const vk::VkDescriptorInfo resultInfo = createDescriptorInfo(m_result.getBuffer(), 0u, (vk::VkDeviceSize)ComputeInstanceResultBuffer::DATA_SIZE);
const vk::VkSampler samplers[2] =
{
(m_isImmutableSampler) ? (0) : (m_images.getSamplerA()),
vk::VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,
DE_NULL,
buffer, // buffer
- vk::VK_BUFFER_VIEW_TYPE_FORMATTED, // viewType
mapToVkTextureFormat(textureFormat), // format
(vk::VkDeviceSize)offset, // offset
(vk::VkDeviceSize)VIEW_DATA_SIZE // range
ShaderInputInterface shaderInterface,
vk::VkShaderStageFlags stageFlags);
- static vk::Move<vk::VkPipelineLayout> createPipelineLayout (const vk::DeviceInterface& vki,
+ static vk::Move<vk::VkPipelineLayout> createPipelineLayout (const vk::DeviceInterface& vki,
vk::VkDevice device,
vk::VkDescriptorSetLayout descriptorSetLayout);
void TexelBufferRenderInstance::writeDrawCmdBuffer (vk::VkCmdBuffer cmd) const
{
m_vki.cmdBindDescriptorSets(cmd, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, getPipelineLayout(), 0, 1, &m_descriptorSet.get(), 0, DE_NULL);
- m_vki.cmdDraw(cmd, 0, 6 * 4, 0, 1); // render four quads (two separate triangles)
+ m_vki.cmdDraw(cmd, 6 * 4, 1, 0, 0); // render four quads (two separate triangles)
}
tcu::TestStatus TexelBufferRenderInstance::verifyResultImage (const tcu::ConstPixelBufferAccess& result) const
vk::Move<vk::VkDescriptorSet> TexelBufferComputeInstance::createDescriptorSet (vk::VkDescriptorPool pool, vk::VkDescriptorSetLayout layout) const
{
- const vk::VkDescriptorInfo resultInfo = createDescriptorInfo(m_result.getBufferView());
+ const vk::VkDescriptorInfo resultInfo = createDescriptorInfo(m_result.getBuffer(), 0u, (vk::VkDeviceSize)ComputeInstanceResultBuffer::DATA_SIZE);
const vk::VkDescriptorInfo texelBufferInfos[2] =
{
createDescriptorInfo(m_texelBuffers.getBufferViewA()),
if (isDepthStencilFormat(clearFormat))
{
const VkClearDepthStencilValue dsValue = defaultClearDepthStencilValue();
- clearValue.ds.stencil = dsValue.stencil;
- clearValue.ds.depth = dsValue.depth;
+ clearValue.depthStencil.stencil = dsValue.stencil;
+ clearValue.depthStencil.depth = dsValue.depth;
}
else
{
if (isUintFormat(clearFormat))
{
const tcu::UVec4 defaultColor = defaultClearColorUint(tcuClearFormat);
- clearValue.color.u32[0] = defaultColor.x();
- clearValue.color.u32[1] = defaultColor.y();
- clearValue.color.u32[2] = defaultColor.z();
- clearValue.color.u32[3] = defaultColor.w();
+ clearValue.color.uint32[0] = defaultColor.x();
+ clearValue.color.uint32[1] = defaultColor.y();
+ clearValue.color.uint32[2] = defaultColor.z();
+ clearValue.color.uint32[3] = defaultColor.w();
}
else if (isIntFormat(clearFormat))
{
const tcu::IVec4 defaultColor = defaultClearColorInt(tcuClearFormat);
- clearValue.color.s32[0] = defaultColor.x();
- clearValue.color.s32[1] = defaultColor.y();
- clearValue.color.s32[2] = defaultColor.z();
- clearValue.color.s32[3] = defaultColor.w();
+ clearValue.color.int32[0] = defaultColor.x();
+ clearValue.color.int32[1] = defaultColor.y();
+ clearValue.color.int32[2] = defaultColor.z();
+ clearValue.color.int32[3] = defaultColor.w();
}
else
{
const tcu::Vec4 defaultColor = defaultClearColorFloat(tcuClearFormat);
- clearValue.color.f32[0] = defaultColor.x();
- clearValue.color.f32[1] = defaultColor.y();
- clearValue.color.f32[2] = defaultColor.z();
- clearValue.color.f32[3] = defaultColor.w();
+ clearValue.color.float32[0] = defaultColor.x();
+ clearValue.color.float32[1] = defaultColor.y();
+ clearValue.color.float32[2] = defaultColor.z();
+ clearValue.color.float32[3] = defaultColor.w();
}
}
de::MovePtr<Allocation> m_colorImageAlloc;
Move<VkImage> m_depthImage;
de::MovePtr<Allocation> m_depthImageAlloc;
- Move<VkAttachmentView> m_colorAttachmentView;
- Move<VkAttachmentView> m_depthAttachmentView;
+ Move<VkImageView> m_colorAttachmentView;
+ Move<VkImageView> m_depthAttachmentView;
Move<VkRenderPass> m_renderPass;
Move<VkFramebuffer> m_framebuffer;
Move<VkCmdPool> m_cmdPool;
Move<VkCmdBuffer> m_cmdBuffer;
- Move<VkDynamicViewportState> m_viewportState;
- Move<VkDynamicRasterState> m_rasterState;
- Move<VkDynamicColorBlendState> m_colorBlendState;
- Move<VkDynamicDepthStencilState> m_depthStencilState;
-
Move<VkFence> m_fence;
};
const VkDevice vkDevice = context.getDevice();
const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
SimpleAllocator memAlloc (vk, vkDevice, getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice()));
+ const VkChannelMapping channelMappingRGBA = { VK_CHANNEL_SWIZZLE_R, VK_CHANNEL_SWIZZLE_G, VK_CHANNEL_SWIZZLE_B, VK_CHANNEL_SWIZZLE_A };
// Copy depth operators
deMemcpy(m_depthCompareOps, depthCompareOps, sizeof(VkCompareOp) * DepthTest::QUAD_COUNT);
0u, // VkImageCreateFlags flags;
VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1u, // deUint32 queueFamilyCount;
- &queueFamilyIndex // const deUint32* pQueueFamilyIndices;
+ &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
+ VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
};
m_colorImage = createImage(vk, vkDevice, &colorImageParams);
1u, // deUint32 arraySize;
1u, // deUint32 samples;
VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
- VK_IMAGE_USAGE_DEPTH_STENCIL_BIT, // VkImageUsageFlags usage;
+ VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, // VkImageUsageFlags usage;
0u, // VkImageCreateFlags flags;
VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1u, // deUint32 queueFamilyCount;
- &queueFamilyIndex // const deUint32* pQueueFamilyIndices;
+ &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
+ VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
};
m_depthImage = createImage(vk, vkDevice, &depthImageParams);
// Create color attachment view
{
- const VkAttachmentViewCreateInfo colorAttachmentViewParams =
+ const VkImageViewCreateInfo colorAttachmentViewParams =
{
- VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // constvoid* pNext;
- *m_colorImage, // VkImage image;
- m_colorFormat, // VkFormat format;
- 0u, // deUint32 mipLevel;
- 0u, // deUint32 baseArraySlice;
- 1u, // deUint32 arraySize;
- 0u // VkAttachmentViewCreateFlags flags;
+ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ *m_colorImage, // VkImage image;
+ VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType;
+ m_colorFormat, // VkFormat format;
+ channelMappingRGBA, // VkChannelMapping channels;
+ { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u }, // VkImageSubresourceRange subresourceRange;
+ 0u // VkImageViewCreateFlags flags;
};
- m_colorAttachmentView = createAttachmentView(vk, vkDevice, &colorAttachmentViewParams);
+ m_colorAttachmentView = createImageView(vk, vkDevice, &colorAttachmentViewParams);
}
// Create depth attachment view
{
- const VkAttachmentViewCreateInfo depthAttachmentViewParams =
+ const VkImageViewCreateInfo depthAttachmentViewParams =
{
- VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // constvoid* pNext;
- *m_depthImage, // VkImage image;
- m_depthFormat, // VkFormat format;
- 0u, // deUint32 mipLevel;
- 0u, // deUint32 baseArraySlice;
- 1u, // deUint32 arraySize;
- 0u // VkAttachmentViewCreateFlags flags;
+ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ *m_depthImage, // VkImage image;
+ VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType;
+ m_depthFormat, // VkFormat format;
+ channelMappingRGBA, // VkChannelMapping channels;
+ { VK_IMAGE_ASPECT_DEPTH_BIT, 0u, 1u, 0u, 1u }, // VkImageSubresourceRange subresourceRange;
+ 0u // VkImageViewCreateFlags flags;
};
- m_depthAttachmentView = createAttachmentView(vk, vkDevice, &depthAttachmentViewParams);
+ m_depthAttachmentView = createImageView(vk, vkDevice, &depthAttachmentViewParams);
}
// Create render pass
{
const VkAttachmentDescription colorAttachmentDescription =
{
- VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- m_colorFormat, // VkFormat format;
- 1u, // deUint32 samples;
- VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
- VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
- VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
- VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
- VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout;
- VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout;
+ VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ m_colorFormat, // VkFormat format;
+ 1u, // deUint32 samples;
+ VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
+ VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
+ VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
+ VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
+ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout;
+ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout finalLayout;
+ 0u, // VkAttachmentDescriptionFlags flags;
};
const VkAttachmentDescription depthAttachmentDescription =
{
- VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- m_depthFormat, // VkFormat format;
- 1u, // deUint32 samples;
- VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
- VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp storeOp;
- VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
- VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
- VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout;
- VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout;
+ VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ m_depthFormat, // VkFormat format;
+ 1u, // deUint32 samples;
+ VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
+ VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp storeOp;
+ VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
+ VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
+ VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout;
+ VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, // VkImageLayout finalLayout;
+ 0u, // VkAttachmentDescriptionFlags flags;
};
const VkAttachmentDescription attachments[2] =
const VkSubpassDescription subpassDescription =
{
- VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION, // VkStructureType sType;
- DE_NULL, // constvoid* pNext;
- VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint;
- 0u, // VkSubpassDescriptionFlags flags;
- 0u, // deUint32 inputCount;
- DE_NULL, // constVkAttachmentReference* inputAttachments;
- 1u, // deUint32 colorCount;
- &colorAttachmentReference, // constVkAttachmentReference* colorAttachments;
- DE_NULL, // constVkAttachmentReference* resolveAttachments;
- depthAttachmentReference, // VkAttachmentReference depthStencilAttachment;
- 0u, // deUint32 preserveCount;
- DE_NULL // constVkAttachmentReference* preserveAttachments;
+ VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint;
+ 0u, // VkSubpassDescriptionFlags flags;
+ 0u, // deUint32 inputCount;
+ DE_NULL, // const VkAttachmentReference* pInputAttachments;
+ 1u, // deUint32 colorCount;
+ &colorAttachmentReference, // const VkAttachmentReference* pColorAttachments;
+ DE_NULL, // const VkAttachmentReference* pResolveAttachments;
+ depthAttachmentReference, // VkAttachmentReference depthStencilAttachment;
+ 0u, // deUint32 preserveCount;
+ DE_NULL // const VkAttachmentReference* pPreserveAttachments;
};
const VkRenderPassCreateInfo renderPassParams =
// Create framebuffer
{
- const VkAttachmentBindInfo attachmentBindInfos[2] =
+ const VkImageView attachmentBindInfos[2] =
{
- { *m_colorAttachmentView, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL },
- { *m_depthAttachmentView, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL }
+ *m_colorAttachmentView,
+ *m_depthAttachmentView,
};
const VkFramebufferCreateInfo framebufferParams =
DE_NULL, // const void* pNext;
*m_renderPass, // VkRenderPass renderPass;
2u, // deUint32 attachmentCount;
- attachmentBindInfos, // const VkAttachmentBindInfo* pAttachments;
+ attachmentBindInfos, // const VkImageView* pAttachments;
(deUint32)m_renderSize.x(), // deUint32 width;
(deUint32)m_renderSize.y(), // deUint32 height;
1u // deUint32 layers;
DE_NULL, // const void* pNext;
*m_vertexShaderModule, // VkShaderModule module;
"main", // const char* pName;
- 0u // VkShaderCreateFlags flags;
+ 0u, // VkShaderCreateFlags flags;
+ VK_SHADER_STAGE_VERTEX, // VkShaderStage stage;
};
const VkShaderCreateInfo fragmentShaderParams =
DE_NULL, // const void* pNext;
*m_fragmentShaderModule, // VkShaderModule module;
"main", // const char* pName;
- 0u // VkShaderCreateFlags flags;
+ 0u, // VkShaderCreateFlags flags;
+ VK_SHADER_STAGE_FRAGMENT, // VkShaderStage stage;
};
m_vertexShader = createShader(vk, vkDevice, &vertexShaderParams);
const VkVertexInputAttributeDescription vertexInputAttributeDescriptions[2] =
{
{
- 0u, // deUint32 location;
- 0u, // deUint32 binding;
- VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format;
- 0u // deUint32 offsetInBytes;
+ 0u, // deUint32 location;
+ 0u, // deUint32 binding;
+ VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format;
+ 0u // deUint32 offsetInBytes;
},
{
1u, // deUint32 location;
false // VkBool32 primitiveRestartEnable;
};
+ const VkViewport viewport =
+ {
+ 0.0f, // float originX;
+ 0.0f, // float originY;
+ (float)m_renderSize.x(), // float width;
+ (float)m_renderSize.y(), // float height;
+ 0.0f, // float minDepth;
+ 1.0f // float maxDepth;
+ };
+ const VkRect2D scissor =
+ {
+ { 0, 0 }, // VkOffset2D offset;
+ { m_renderSize.x(), m_renderSize.y() } // VkExtent2D extent;
+ };
const VkPipelineViewportStateCreateInfo viewportStateParams =
{
- VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 1u // deUint32 viewportCount;
+ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 1u, // deUint32 viewportCount;
+ &viewport, // const VkViewport* pViewports;
+ 1u, // deUint32 scissorCount;
+ &scissor // const VkRect2D* pScissors;
};
const VkPipelineRasterStateCreateInfo rasterStateParams =
false, // VkBool32 rasterizerDiscardEnable;
VK_FILL_MODE_SOLID, // VkFillMode fillMode;
VK_CULL_MODE_NONE, // VkCullMode cullMode;
- VK_FRONT_FACE_CCW // VkFrontFace frontFace;
+ VK_FRONT_FACE_CCW, // VkFrontFace frontFace;
+ VK_FALSE, // VkBool32 depthBiasEnable;
+ 0.0f, // float depthBias;
+ 0.0f, // float depthBiasClamp;
+ 0.0f, // float slopeScaledDepthBias;
+ 1.0f, // float lineWidth;
};
const VkPipelineColorBlendAttachmentState colorBlendAttachmentState =
VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
false, // VkBool32 alphaToCoverageEnable;
+ false, // VkBool32 alphaToOneEnable;
false, // VkBool32 logicOpEnable;
VK_LOGIC_OP_COPY, // VkLogicOp logicOp;
1u, // deUint32 attachmentCount;
- &colorBlendAttachmentState // const VkPipelineColorBlendAttachmentState* pAttachments;
+ &colorBlendAttachmentState, // const VkPipelineColorBlendAttachmentState* pAttachments;
+ { 0.0f, 0.0f, 0.0f, 0.0f }, // float blendConst[4];
};
- const VkPipelineMultisampleStateCreateInfo multisampleStateParams =
+ const VkPipelineMultisampleStateCreateInfo multisampleStateParams =
{
- VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 1u, // deUint32 rasterSamples;
- false, // VkBool32 sampleShadingEnable;
- 0.0f, // float minSampleShading;
- ~((VkSampleMask)0) // VkSampleMask sampleMask;
+ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 1u, // deUint32 rasterSamples;
+ false, // VkBool32 sampleShadingEnable;
+ 0.0f, // float minSampleShading;
+ DE_NULL // const VkSampleMask* pSampleMask;
+ };
+
+ const VkPipelineDynamicStateCreateInfo dynamicStateParams =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // deUint32 dynamicStateCount;
+ DE_NULL // const VkDynamicState* pDynamicStates;
};
VkPipelineDepthStencilStateCreateInfo depthStencilStateParams =
true, // VkBool32 depthTestEnable;
true, // VkBool32 depthWriteEnable;
VK_COMPARE_OP_LESS, // VkCompareOp depthCompareOp;
- false, // VkBool32 depthBoundsEnable;
+ false, // VkBool32 depthBoundsTestEnable;
false, // VkBool32 stencilTestEnable;
// VkStencilOpState front;
{
VK_STENCIL_OP_KEEP, // VkStencilOp stencilFailOp;
VK_STENCIL_OP_KEEP, // VkStencilOp stencilPassOp;
VK_STENCIL_OP_KEEP, // VkStencilOp stencilDepthFailOp;
- VK_COMPARE_OP_NEVER // VkCompareOp stencilCompareOp;
+ VK_COMPARE_OP_NEVER, // VkCompareOp stencilCompareOp;
+ 0u, // deUint32 stencilCompareMask;
+ 0u, // deUint32 stencilWriteMask;
+ 0u, // deUint32 stencilReference;
},
// VkStencilOpState back;
{
VK_STENCIL_OP_KEEP, // VkStencilOp stencilFailOp;
VK_STENCIL_OP_KEEP, // VkStencilOp stencilPassOp;
VK_STENCIL_OP_KEEP, // VkStencilOp stencilDepthFailOp;
- VK_COMPARE_OP_NEVER // VkCompareOp stencilCompareOp;
- }
+ VK_COMPARE_OP_NEVER, // VkCompareOp stencilCompareOp;
+ 0u, // deUint32 stencilCompareMask;
+ 0u, // deUint32 stencilWriteMask;
+ 0u, // deUint32 stencilReference;
+ },
+ -1.0f, // float minDepthBounds;
+ +1.0f, // float maxDepthBounds;
};
const VkGraphicsPipelineCreateInfo graphicsPipelineParams =
&multisampleStateParams, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
&depthStencilStateParams, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
&colorBlendStateParams, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
+ &dynamicStateParams, // const VkPipelineDynamicStateCreateInfo* pDynamicState;
0u, // VkPipelineCreateFlags flags;
*m_pipelineLayout, // VkPipelineLayout layout;
*m_renderPass, // VkRenderPass renderPass;
}
}
- // Create dynamic states
- {
- const VkViewport viewport =
- {
- 0.0f, // float originX;
- 0.0f, // float originY;
- (float)m_renderSize.x(), // float width;
- (float)m_renderSize.y(), // float height;
- 0.0f, // float minDepth;
- 1.0f // float maxDepth;
- };
-
- const VkRect2D scissor =
- {
- { 0, 0 }, // VkOffset2D offset;
- { m_renderSize.x(), m_renderSize.y() } // VkExtent2D extent;
- };
-
- const VkDynamicViewportStateCreateInfo viewportStateParams =
- {
- VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 1, // deUint32 viewportAndScissorCount;
- &viewport, // const VkViewport* pViewports;
- &scissor // const VkRect2D* pScissors;
- };
-
- const VkDynamicRasterStateCreateInfo rasterStateParams =
- {
- VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0.0f, // float depthBias;
- 0.0f, // float depthBiasClamp;
- 0.0f, // float slopeScaledDepthBias;
- 1.0f, // float lineWidth;
- };
-
- const VkDynamicColorBlendStateCreateInfo colorBlendStateParams =
- {
- VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- { 0.0f, 0.0f, 0.0f, 0.0f } // float blendConst[4];
- };
-
- const VkDynamicDepthStencilStateCreateInfo depthStencilStateParams =
- {
- VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0.0f, // float minDepthBounds;
- 1.0f, // float maxDepthBounds;
- 0x0, // deUint32 stencilReadMask;
- 0x0, // deUint32 stencilWriteMask;
- 0x0, // deUint32 stencilFrontRef;
- 0x0 // deUint32 stencilBackRef;
- };
-
- m_viewportState = createDynamicViewportState(vk, vkDevice, &viewportStateParams);
- m_rasterState = createDynamicRasterState(vk, vkDevice, &rasterStateParams);
- m_colorBlendState = createDynamicColorBlendState(vk, vkDevice, &colorBlendStateParams);
- m_depthStencilState = createDynamicDepthStencilState(vk, vkDevice, &depthStencilStateParams);
- }
-
// Create vertex buffer
{
const VkBufferCreateInfo vertexBufferParams =
DE_NULL, // const void* pNext;
0u, // VkCmdBufferOptimizeFlags flags;
DE_NULL, // VkRenderPass renderPass;
+ 0u, // deUint32 subpass;
DE_NULL // VkFramebuffer framebuffer;
};
DE_NULL, // const void* pNext;
*m_renderPass, // VkRenderPass renderPass;
*m_framebuffer, // VkFramebuffer framebuffer;
- { { 0, 0 }, { m_renderSize.x(), m_renderSize.y()} }, // VkRect2D renderArea;
- 2, // deUint32 attachmentCount;
- attachmentClearValues // const VkClearValue* pAttachmentClearValues;
+ { { 0, 0 }, { m_renderSize.x(), m_renderSize.y() } }, // VkRect2D renderArea;
+ 2, // deUint32 clearValueCount;
+ attachmentClearValues // const VkClearValue* pClearValues;
};
m_cmdBuffer = createCommandBuffer(vk, vkDevice, &cmdBufferParams);
VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
vk.cmdBeginRenderPass(*m_cmdBuffer, &renderPassBeginInfo, VK_RENDER_PASS_CONTENTS_INLINE);
- vk.cmdBindDynamicViewportState(*m_cmdBuffer, *m_viewportState);
- vk.cmdBindDynamicRasterState(*m_cmdBuffer, *m_rasterState);
- vk.cmdBindDynamicColorBlendState(*m_cmdBuffer, *m_colorBlendState);
- vk.cmdBindDynamicDepthStencilState(*m_cmdBuffer, *m_depthStencilState);
-
const VkDeviceSize quadOffset = (m_vertices.size() / DepthTest::QUAD_COUNT) * sizeof(Vertex4RGBA);
for (int quadNdx = 0; quadNdx < DepthTest::QUAD_COUNT; quadNdx++)
vk.cmdBindPipeline(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_graphicsPipelines[quadNdx]);
vk.cmdBindVertexBuffers(*m_cmdBuffer, 0, 1, &m_vertexBuffer.get(), &vertexBufferOffset);
- vk.cmdDraw(*m_cmdBuffer, 0, (deUint32)(m_vertices.size() / DepthTest::QUAD_COUNT), 0, 1);
+ vk.cmdDraw(*m_cmdBuffer, (deUint32)(m_vertices.size() / DepthTest::QUAD_COUNT), 1, 0, 0);
}
vk.cmdEndRenderPass(*m_cmdBuffer);
const VkFormat depthFormats[] =
{
VK_FORMAT_D16_UNORM,
- VK_FORMAT_D24_UNORM,
+ VK_FORMAT_D24_UNORM_X8,
VK_FORMAT_D32_SFLOAT,
VK_FORMAT_D16_UNORM_S8_UINT,
VK_FORMAT_D24_UNORM_S8_UINT,
VK_FORMAT_D16_UNORM);
// Sets where at least one of the formats must be supported
- const VkFormat depthOnlyFormats[] = { VK_FORMAT_D24_UNORM, VK_FORMAT_D32_SFLOAT };
+ const VkFormat depthOnlyFormats[] = { VK_FORMAT_D24_UNORM_X8, VK_FORMAT_D32_SFLOAT };
const VkFormat depthStencilFormats[] = { VK_FORMAT_D24_UNORM_S8_UINT, VK_FORMAT_D32_SFLOAT_S8_UINT };
addFunctionCase(formatFeaturesTests.get(),
"support_d24_unorm_or_d32_sfloat",
- "Tests if any of VK_FORMAT_D24_UNORM or VK_FORMAT_D32_SFLOAT are supported as depth/stencil attachment format",
+ "Tests if any of VK_FORMAT_D24_UNORM_X8 or VK_FORMAT_D32_SFLOAT are supported as depth/stencil attachment format",
testSupportsAtLeastOneDepthStencilFormat,
std::vector<VkFormat>(depthOnlyFormats, depthOnlyFormats + DE_LENGTH_OF_ARRAY(depthOnlyFormats)));
VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
image, // VkImage image;
{ // VkImageSubresourceRange subresourceRange;
- VK_IMAGE_ASPECT_COLOR, // VkImageAspect aspect;
- 0u, // deUint32 baseMipLevel;
- 1u, // deUint32 mipLevels;
- 0u, // deUint32 baseArraySlice;
- 1u // deUint32 arraySize;
+ VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
+ 0u, // deUint32 baseMipLevel;
+ 1u, // deUint32 mipLevels;
+ 0u, // deUint32 baseArraySlice;
+ 1u // deUint32 arraySize;
}
};
DE_NULL, // const void* pNext;
VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT | VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT, // VkCmdBufferOptimizeFlags flags;
DE_NULL, // VkRenderPass renderPass;
+ 0u, // deUint32 subpass;
DE_NULL // VkFramebuffer framebuffer;
};
const VkBufferImageCopy copyRegion =
{
- 0u, // VkDeviceSize bufferOffset;
- (deUint32)renderSize.x(), // deUint32 bufferRowLength;
- (deUint32)renderSize.y(), // deUint32 bufferImageHeight;
- { VK_IMAGE_ASPECT_COLOR, 0u, 0u }, // VkImageSubresource imageSubresource;
- { 0, 0, 0 }, // VkOffset3D imageOffset;
- { renderSize.x(), renderSize.y(), 1 } // VkExtent3D imageExtent;
+ 0u, // VkDeviceSize bufferOffset;
+ (deUint32)renderSize.x(), // deUint32 bufferRowLength;
+ (deUint32)renderSize.y(), // deUint32 bufferImageHeight;
+ { VK_IMAGE_ASPECT_COLOR, 0u, 0u, 1u }, // VkImageSubresourceCopy imageSubresource;
+ { 0, 0, 0 }, // VkOffset3D imageOffset;
+ { renderSize.x(), renderSize.y(), 1 } // VkExtent3D imageExtent;
};
VK_CHECK(vk.beginCommandBuffer(*cmdBuffer, &cmdBufferBeginInfo));
tcu::TestStatus queueProperties (Context& context)
{
- TestLog& log = context.getTestContext().getLog();
- const vector<VkPhysicalDeviceQueueProperties> queueProperties = getPhysicalDeviceQueueProperties(context.getInstanceInterface(), context.getPhysicalDevice());
+ TestLog& log = context.getTestContext().getLog();
+ const vector<VkQueueFamilyProperties> queueProperties = getPhysicalDeviceQueueFamilyProperties(context.getInstanceInterface(), context.getPhysicalDevice());
log << TestLog::Message << "device = " << context.getPhysicalDevice() << TestLog::EndMessage;
static deUint32 findQueueFamilyIndexWithCaps (const InstanceInterface& vkInstance, VkPhysicalDevice physicalDevice, VkQueueFlags requiredCaps)
{
- const vector<VkPhysicalDeviceQueueProperties> queueProps = getPhysicalDeviceQueueProperties(vkInstance, physicalDevice);
+ const vector<VkQueueFamilyProperties> queueProps = getPhysicalDeviceQueueFamilyProperties(vkInstance, physicalDevice);
for (size_t queueNdx = 0; queueNdx < queueProps.size(); queueNdx++)
{
TCU_THROW(NotSupportedError, "No matching queue found");
}
+// \todo [2015-09-28 pyry] Refactor using Move<>
+
struct DeviceCreateInfoHelper
{
VkPhysicalDeviceFeatures enabledFeatures;
// * Enable all supported by default, and expose that to test cases
// * More limited enabled set could be used for verifying that tests behave correctly
+ queueInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+ queueInfo.pNext = DE_NULL;
queueInfo.queueFamilyIndex = queueIndex;
queueInfo.queueCount = 1u;
deviceInfo.extensionCount = 0u;
deviceInfo.ppEnabledExtensionNames = DE_NULL;
deviceInfo.pEnabledFeatures = &enabledFeatures;
- deviceInfo.flags = 0u;
}
};
projects / platform / upstream / VK-GL-CTS.git / commitdiff