framework/randomshaders
framework/egl
framework/egl/wrapper
+ framework/vulkan
)
if (DE_OS_IS_ANDROID OR DE_OS_IS_IOS)
# EGL utilities
add_subdirectory(egl)
+# Vulkan utilities
+add_subdirectory(vulkan)
+
if (IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/randomshaders)
add_subdirectory(randomshaders)
endif ()
const glu::Platform& Platform::getGLPlatform (void) const
{
- throw tcu::NotSupportedError("OpenGL (ES) is not supported", DE_NULL, __FILE__, __LINE__);
+ TCU_THROW(NotSupportedError, "OpenGL (ES) is not supported");
}
const eglu::Platform& Platform::getEGLPlatform (void) const
{
- throw tcu::NotSupportedError("EGL is not supported", DE_NULL, __FILE__, __LINE__);
+ TCU_THROW(NotSupportedError, "EGL is not supported");
+}
+
+const vk::Platform& Platform::getVulkanPlatform (void) const
+{
+ TCU_THROW(NotSupportedError, "Vulkan is not supported");
}
} // tcu
class Platform;
}
+namespace vk
+{
+class Platform;
+}
+
namespace tcu
{
* \return Reference to EGL platform interface.
*//*--------------------------------------------------------------------*/
virtual const eglu::Platform& getEGLPlatform (void) const;
+
+ virtual const vk::Platform& getVulkanPlatform (void) const;
};
} // tcu
target_link_libraries(tcutil-platform eglutil eglwrapper)
endif ()
+target_link_libraries(tcutil-platform vkutil)
+
# X11 libraries
if (DEQP_USE_X11)
find_package(X11 REQUIRED)
return new NativeDisplay();
}
+// Vulkan
+
+static vk::GetProcAddrFunc loadGetProcAddr (const de::DynamicLibrary& library)
+{
+ const vk::GetProcAddrFunc getProc = (vk::GetProcAddrFunc)library.getFunction("vkGetProcAddr");
+
+ if (!getProc)
+ TCU_THROW(InternalError, "Failed to load vkGetProcAddr");
+
+ return getProc;
+}
+
+class VulkanLibrary : public vk::Library
+{
+public:
+ VulkanLibrary (void)
+ : m_library ("libvulkan.so")
+ , m_driver (loadGetProcAddr(m_library))
+ {
+ }
+
+ const vk::PlatformInterface& getPlatformInterface (void) const
+ {
+ return m_driver;
+ }
+
+private:
+ const de::DynamicLibrary m_library;
+ const vk::PlatformDriver m_driver;
+};
+
// Platform
Platform::Platform (void)
return true;
}
+vk::Library* Platform::createLibrary (void) const
+{
+ return new VulkanLibrary();
+}
+
} // Android
} // tcu
#include "tcuPlatform.hpp"
#include "egluPlatform.hpp"
#include "gluPlatform.hpp"
+#include "vkPlatform.hpp"
#include "tcuAndroidWindow.hpp"
namespace tcu
namespace Android
{
-class Platform : public tcu::Platform, private eglu::Platform, private glu::Platform
+class Platform : public tcu::Platform, private eglu::Platform, private glu::Platform, private vk::Platform
{
public:
Platform (void);
virtual const glu::Platform& getGLPlatform (void) const { return static_cast<const glu::Platform&>(*this); }
virtual const eglu::Platform& getEGLPlatform (void) const { return static_cast<const eglu::Platform&>(*this); }
+ virtual const vk::Platform& getVulkanPlatform (void) const { return static_cast<const vk::Platform&>(*this); }
WindowRegistry& getWindowRegistry (void) { return m_windowRegistry; }
+ vk::Library* createLibrary (void) const;
+
private:
WindowRegistry m_windowRegistry;
};
namespace tcu
{
+static vk::GetProcAddrFunc loadGetProcAddr (const de::DynamicLibrary& library)
+{
+ const vk::GetProcAddrFunc getProc = (vk::GetProcAddrFunc)library.getFunction("vkGetProcAddr");
+
+ if (!getProc)
+ TCU_THROW(InternalError, "Failed to load vkGetProcAddr");
+
+ return getProc;
+}
+
+class VulkanLibrary : public vk::Library
+{
+public:
+ VulkanLibrary (void)
+ : m_library ("vulkan.dll")
+ , m_driver (loadGetProcAddr(m_library))
+ {
+ }
+
+ const vk::PlatformInterface& getPlatformInterface (void) const
+ {
+ return m_driver;
+ }
+
+private:
+ const de::DynamicLibrary m_library;
+ const vk::PlatformDriver m_driver;
+};
+
Win32Platform::Win32Platform (void)
: m_instance(GetModuleHandle(NULL))
{
return true;
}
+vk::Library* Win32Platform::createLibrary (void) const
+{
+ return new VulkanLibrary();
+}
+
} // tcu
// Create platform
#include "tcuDefs.hpp"
#include "tcuPlatform.hpp"
#include "gluPlatform.hpp"
+#include "vkPlatform.hpp"
#include "tcuWin32API.h"
#if defined(DEQP_SUPPORT_EGL)
namespace tcu
{
-class Win32Platform : public tcu::Platform, private glu::Platform
+class Win32Platform : public tcu::Platform, private glu::Platform, private vk::Platform
#if defined(DEQP_SUPPORT_EGL)
, private eglu::Platform
#endif
const eglu::Platform& getEGLPlatform (void) const { return static_cast<const eglu::Platform&>(*this); }
#endif
+ const vk::Platform& getVulkanPlatform (void) const { return static_cast<const vk::Platform&>(*this); }
+
private:
+ vk::Library* createLibrary (void) const;
+
HINSTANCE m_instance;
};
--- /dev/null
+# vk - Vulkan utilites
+
+set(VKUTIL_SRCS
+ vkDefs.cpp
+ vkDefs.hpp
+ vkRef.cpp
+ vkRef.hpp
+ vkPlatform.cpp
+ vkPlatform.hpp
+ vkPrograms.cpp
+ vkPrograms.hpp
+ vkStrUtil.cpp
+ vkStrUtil.hpp
+ )
+
+set(VKUTIL_LIBS
+ tcutil
+ )
+
+add_library(vkutil STATIC ${VKUTIL_SRCS})
+target_link_libraries(vkutil ${VKUTIL_LIBS})
--- /dev/null
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * be lost! Modify the generating script instead.
+ */
+#define VK_API_VERSION VK_MAKE_VERSION(0, 90, 0)
+#define VK_MAX_PHYSICAL_DEVICE_NAME 256
+#define VK_MAX_EXTENSION_NAME 256
+
+VK_DEFINE_BASE_HANDLE (VkObject);
+VK_DEFINE_DISP_SUBCLASS_HANDLE (VkInstance, VkObject);
+VK_DEFINE_DISP_SUBCLASS_HANDLE (VkPhysicalDevice, VkObject);
+VK_DEFINE_DISP_SUBCLASS_HANDLE (VkDevice, VkObject);
+VK_DEFINE_DISP_SUBCLASS_HANDLE (VkQueue, VkObject);
+VK_DEFINE_DISP_SUBCLASS_HANDLE (VkCmdBuffer, VkObject);
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkNonDispatchable, VkObject);
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkDeviceMemory, VkNonDispatchable);
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkBuffer, VkNonDispatchable);
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkBufferView, VkNonDispatchable);
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkImage, VkNonDispatchable);
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkImageView, VkNonDispatchable);
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkColorAttachmentView, VkNonDispatchable);
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkDepthStencilView, VkNonDispatchable);
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkShader, VkNonDispatchable);
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkPipeline, VkNonDispatchable);
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkPipelineLayout, VkNonDispatchable);
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkSampler, VkNonDispatchable);
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkDescriptorSet, VkNonDispatchable);
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkDescriptorSetLayout, VkNonDispatchable);
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkDescriptorPool, VkNonDispatchable);
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkDynamicStateObject, VkNonDispatchable);
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkDynamicVpState, VkDynamicStateObject);
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkDynamicRsState, VkDynamicStateObject);
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkDynamicCbState, VkDynamicStateObject);
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkDynamicDsState, VkDynamicStateObject);
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkFence, VkNonDispatchable);
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkSemaphore, VkNonDispatchable);
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkEvent, VkNonDispatchable);
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkQueryPool, VkNonDispatchable);
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkFramebuffer, VkNonDispatchable);
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkRenderPass, VkNonDispatchable);
+
+enum VkMemoryPriority
+{
+ VK_MEMORY_PRIORITY_UNUSED = 0x00000000,
+ VK_MEMORY_PRIORITY_VERY_LOW = 0x00000001,
+ VK_MEMORY_PRIORITY_LOW = 0x00000002,
+ VK_MEMORY_PRIORITY_NORMAL = 0x00000003,
+ VK_MEMORY_PRIORITY_HIGH = 0x00000004,
+ VK_MEMORY_PRIORITY_VERY_HIGH = 0x00000005,
+};
+
+enum VkImageLayout
+{
+ VK_IMAGE_LAYOUT_UNDEFINED = 0x00000000,
+ VK_IMAGE_LAYOUT_GENERAL = 0x00000001,
+ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 0x00000002,
+ VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 0x00000003,
+ VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 0x00000004,
+ VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 0x00000005,
+ VK_IMAGE_LAYOUT_CLEAR_OPTIMAL = 0x00000006,
+ VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL = 0x00000007,
+ VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 0x00000008,
+};
+
+enum VkPipeEvent
+{
+ VK_PIPE_EVENT_TOP_OF_PIPE = 0x00000001,
+ VK_PIPE_EVENT_VERTEX_PROCESSING_COMPLETE = 0x00000002,
+ VK_PIPE_EVENT_LOCAL_FRAGMENT_PROCESSING_COMPLETE = 0x00000003,
+ VK_PIPE_EVENT_FRAGMENT_PROCESSING_COMPLETE = 0x00000004,
+ VK_PIPE_EVENT_GRAPHICS_PIPELINE_COMPLETE = 0x00000005,
+ VK_PIPE_EVENT_COMPUTE_PIPELINE_COMPLETE = 0x00000006,
+ VK_PIPE_EVENT_TRANSFER_COMPLETE = 0x00000007,
+ VK_PIPE_EVENT_COMMANDS_COMPLETE = 0x00000008,
+};
+
+enum VkWaitEvent
+{
+ VK_WAIT_EVENT_TOP_OF_PIPE = 0x00000001,
+ VK_WAIT_EVENT_BEFORE_RASTERIZATION = 0x00000002,
+};
+
+enum VkAttachmentLoadOp
+{
+ VK_ATTACHMENT_LOAD_OP_LOAD = 0x00000000,
+ VK_ATTACHMENT_LOAD_OP_CLEAR = 0x00000001,
+ VK_ATTACHMENT_LOAD_OP_DONT_CARE = 0x00000002,
+};
+
+enum VkAttachmentStoreOp
+{
+ VK_ATTACHMENT_STORE_OP_STORE = 0x00000000,
+ VK_ATTACHMENT_STORE_OP_RESOLVE_MSAA = 0x00000001,
+ VK_ATTACHMENT_STORE_OP_DONT_CARE = 0x00000002,
+};
+
+enum VkImageType
+{
+ VK_IMAGE_TYPE_1D = 0x00000000,
+ VK_IMAGE_TYPE_2D = 0x00000001,
+ VK_IMAGE_TYPE_3D = 0x00000002,
+};
+
+enum VkImageTiling
+{
+ VK_IMAGE_TILING_LINEAR = 0x00000000,
+ VK_IMAGE_TILING_OPTIMAL = 0x00000001,
+};
+
+enum VkImageViewType
+{
+ VK_IMAGE_VIEW_TYPE_1D = 0x00000000,
+ VK_IMAGE_VIEW_TYPE_2D = 0x00000001,
+ VK_IMAGE_VIEW_TYPE_3D = 0x00000002,
+ VK_IMAGE_VIEW_TYPE_CUBE = 0x00000003,
+};
+
+enum VkImageAspect
+{
+ VK_IMAGE_ASPECT_COLOR = 0x00000000,
+ VK_IMAGE_ASPECT_DEPTH = 0x00000001,
+ VK_IMAGE_ASPECT_STENCIL = 0x00000002,
+};
+
+enum VkBufferViewType
+{
+ VK_BUFFER_VIEW_TYPE_RAW = 0x00000000,
+ VK_BUFFER_VIEW_TYPE_FORMATTED = 0x00000001,
+};
+
+enum VkChannelSwizzle
+{
+ VK_CHANNEL_SWIZZLE_ZERO = 0x00000000,
+ VK_CHANNEL_SWIZZLE_ONE = 0x00000001,
+ VK_CHANNEL_SWIZZLE_R = 0x00000002,
+ VK_CHANNEL_SWIZZLE_G = 0x00000003,
+ VK_CHANNEL_SWIZZLE_B = 0x00000004,
+ VK_CHANNEL_SWIZZLE_A = 0x00000005,
+};
+
+enum VkDescriptorType
+{
+ VK_DESCRIPTOR_TYPE_SAMPLER = 0x00000000,
+ VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 0x00000001,
+ VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 0x00000002,
+ VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 0x00000003,
+ VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 0x00000004,
+ VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 0x00000005,
+ VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 0x00000006,
+ VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 0x00000007,
+ VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 0x00000008,
+ VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 0x00000009,
+};
+
+enum VkDescriptorPoolUsage
+{
+ VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT = 0x00000000,
+ VK_DESCRIPTOR_POOL_USAGE_DYNAMIC = 0x00000001,
+};
+
+enum VkDescriptorUpdateMode
+{
+ VK_DESCRIPTOR_UPDATE_MODE_COPY = 0x00000000,
+ VK_DESCRIPTOR_UPDATE_MODE_FASTEST = 0x00000001,
+};
+
+enum VkDescriptorSetUsage
+{
+ VK_DESCRIPTOR_SET_USAGE_ONE_SHOT = 0x00000000,
+ VK_DESCRIPTOR_SET_USAGE_STATIC = 0x00000001,
+};
+
+enum VkQueryType
+{
+ VK_QUERY_TYPE_OCCLUSION = 0x00000000,
+ VK_QUERY_TYPE_PIPELINE_STATISTICS = 0x00000001,
+};
+
+enum VkTimestampType
+{
+ VK_TIMESTAMP_TYPE_TOP = 0x00000000,
+ VK_TIMESTAMP_TYPE_BOTTOM = 0x00000001,
+};
+
+enum VkBorderColor
+{
+ VK_BORDER_COLOR_OPAQUE_WHITE = 0x00000000,
+ VK_BORDER_COLOR_TRANSPARENT_BLACK = 0x00000001,
+ VK_BORDER_COLOR_OPAQUE_BLACK = 0x00000002,
+};
+
+enum VkPipelineBindPoint
+{
+ VK_PIPELINE_BIND_POINT_COMPUTE = 0x00000000,
+ VK_PIPELINE_BIND_POINT_GRAPHICS = 0x00000001,
+};
+
+enum VkStateBindPoint
+{
+ VK_STATE_BIND_POINT_VIEWPORT = 0x00000000,
+ VK_STATE_BIND_POINT_RASTER = 0x00000001,
+ VK_STATE_BIND_POINT_COLOR_BLEND = 0x00000002,
+ VK_STATE_BIND_POINT_DEPTH_STENCIL = 0x00000003,
+};
+
+enum VkPrimitiveTopology
+{
+ VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0x00000000,
+ VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 0x00000001,
+ VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 0x00000002,
+ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 0x00000003,
+ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 0x00000004,
+ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 0x00000005,
+ VK_PRIMITIVE_TOPOLOGY_LINE_LIST_ADJ = 0x00000006,
+ VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_ADJ = 0x00000007,
+ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_ADJ = 0x00000008,
+ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_ADJ = 0x00000009,
+ VK_PRIMITIVE_TOPOLOGY_PATCH = 0x0000000a,
+};
+
+enum VkIndexType
+{
+ VK_INDEX_TYPE_UINT8 = 0x00000000,
+ VK_INDEX_TYPE_UINT16 = 0x00000001,
+ VK_INDEX_TYPE_UINT32 = 0x00000002,
+};
+
+enum VkTexFilter
+{
+ VK_TEX_FILTER_NEAREST = 0x00000000,
+ VK_TEX_FILTER_LINEAR = 0x00000001,
+};
+
+enum VkTexMipmapMode
+{
+ VK_TEX_MIPMAP_MODE_BASE = 0x00000000,
+ VK_TEX_MIPMAP_MODE_NEAREST = 0x00000001,
+ VK_TEX_MIPMAP_MODE_LINEAR = 0x00000002,
+};
+
+enum VkTexAddress
+{
+ VK_TEX_ADDRESS_WRAP = 0x00000000,
+ VK_TEX_ADDRESS_MIRROR = 0x00000001,
+ VK_TEX_ADDRESS_CLAMP = 0x00000002,
+ VK_TEX_ADDRESS_MIRROR_ONCE = 0x00000003,
+ VK_TEX_ADDRESS_CLAMP_BORDER = 0x00000004,
+};
+
+enum VkCompareOp
+{
+ VK_COMPARE_OP_NEVER = 0x00000000,
+ VK_COMPARE_OP_LESS = 0x00000001,
+ VK_COMPARE_OP_EQUAL = 0x00000002,
+ VK_COMPARE_OP_LESS_EQUAL = 0x00000003,
+ VK_COMPARE_OP_GREATER = 0x00000004,
+ VK_COMPARE_OP_NOT_EQUAL = 0x00000005,
+ VK_COMPARE_OP_GREATER_EQUAL = 0x00000006,
+ VK_COMPARE_OP_ALWAYS = 0x00000007,
+};
+
+enum VkFillMode
+{
+ VK_FILL_MODE_POINTS = 0x00000000,
+ VK_FILL_MODE_WIREFRAME = 0x00000001,
+ VK_FILL_MODE_SOLID = 0x00000002,
+};
+
+enum VkCullMode
+{
+ VK_CULL_MODE_NONE = 0x00000000,
+ VK_CULL_MODE_FRONT = 0x00000001,
+ VK_CULL_MODE_BACK = 0x00000002,
+ VK_CULL_MODE_FRONT_AND_BACK = 0x00000003,
+};
+
+enum VkFrontFace
+{
+ VK_FRONT_FACE_CCW = 0x00000000,
+ VK_FRONT_FACE_CW = 0x00000001,
+};
+
+enum VkProvokingVertex
+{
+ VK_PROVOKING_VERTEX_FIRST = 0x00000000,
+ VK_PROVOKING_VERTEX_LAST = 0x00000001,
+};
+
+enum VkCoordinateOrigin
+{
+ VK_COORDINATE_ORIGIN_UPPER_LEFT = 0x00000000,
+ VK_COORDINATE_ORIGIN_LOWER_LEFT = 0x00000001,
+};
+
+enum VkDepthMode
+{
+ VK_DEPTH_MODE_ZERO_TO_ONE = 0x00000000,
+ VK_DEPTH_MODE_NEGATIVE_ONE_TO_ONE = 0x00000001,
+};
+
+enum VkBlend
+{
+ VK_BLEND_ZERO = 0x00000000,
+ VK_BLEND_ONE = 0x00000001,
+ VK_BLEND_SRC_COLOR = 0x00000002,
+ VK_BLEND_ONE_MINUS_SRC_COLOR = 0x00000003,
+ VK_BLEND_DEST_COLOR = 0x00000004,
+ VK_BLEND_ONE_MINUS_DEST_COLOR = 0x00000005,
+ VK_BLEND_SRC_ALPHA = 0x00000006,
+ VK_BLEND_ONE_MINUS_SRC_ALPHA = 0x00000007,
+ VK_BLEND_DEST_ALPHA = 0x00000008,
+ VK_BLEND_ONE_MINUS_DEST_ALPHA = 0x00000009,
+ VK_BLEND_CONSTANT_COLOR = 0x0000000a,
+ VK_BLEND_ONE_MINUS_CONSTANT_COLOR = 0x0000000b,
+ VK_BLEND_CONSTANT_ALPHA = 0x0000000c,
+ VK_BLEND_ONE_MINUS_CONSTANT_ALPHA = 0x0000000d,
+ VK_BLEND_SRC_ALPHA_SATURATE = 0x0000000e,
+ VK_BLEND_SRC1_COLOR = 0x0000000f,
+ VK_BLEND_ONE_MINUS_SRC1_COLOR = 0x00000010,
+ VK_BLEND_SRC1_ALPHA = 0x00000011,
+ VK_BLEND_ONE_MINUS_SRC1_ALPHA = 0x00000012,
+};
+
+enum VkBlendOp
+{
+ VK_BLEND_OP_ADD = 0x00000000,
+ VK_BLEND_OP_SUBTRACT = 0x00000001,
+ VK_BLEND_OP_REVERSE_SUBTRACT = 0x00000002,
+ VK_BLEND_OP_MIN = 0x00000003,
+ VK_BLEND_OP_MAX = 0x00000004,
+};
+
+enum VkStencilOp
+{
+ VK_STENCIL_OP_KEEP = 0x00000000,
+ VK_STENCIL_OP_ZERO = 0x00000001,
+ VK_STENCIL_OP_REPLACE = 0x00000002,
+ VK_STENCIL_OP_INC_CLAMP = 0x00000003,
+ VK_STENCIL_OP_DEC_CLAMP = 0x00000004,
+ VK_STENCIL_OP_INVERT = 0x00000005,
+ VK_STENCIL_OP_INC_WRAP = 0x00000006,
+ VK_STENCIL_OP_DEC_WRAP = 0x00000007,
+};
+
+enum VkLogicOp
+{
+ VK_LOGIC_OP_COPY = 0x00000000,
+ VK_LOGIC_OP_CLEAR = 0x00000001,
+ VK_LOGIC_OP_AND = 0x00000002,
+ VK_LOGIC_OP_AND_REVERSE = 0x00000003,
+ VK_LOGIC_OP_AND_INVERTED = 0x00000004,
+ VK_LOGIC_OP_NOOP = 0x00000005,
+ VK_LOGIC_OP_XOR = 0x00000006,
+ VK_LOGIC_OP_OR = 0x00000007,
+ VK_LOGIC_OP_NOR = 0x00000008,
+ VK_LOGIC_OP_EQUIV = 0x00000009,
+ VK_LOGIC_OP_INVERT = 0x0000000a,
+ VK_LOGIC_OP_OR_REVERSE = 0x0000000b,
+ VK_LOGIC_OP_COPY_INVERTED = 0x0000000c,
+ VK_LOGIC_OP_OR_INVERTED = 0x0000000d,
+ VK_LOGIC_OP_NAND = 0x0000000e,
+ VK_LOGIC_OP_SET = 0x0000000f,
+};
+
+enum VkSystemAllocType
+{
+ VK_SYSTEM_ALLOC_TYPE_API_OBJECT = 0x00000000,
+ VK_SYSTEM_ALLOC_TYPE_INTERNAL = 0x00000001,
+ VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP = 0x00000002,
+ VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER = 0x00000003,
+ VK_SYSTEM_ALLOC_TYPE_DEBUG = 0x00000004,
+};
+
+enum VkPhysicalDeviceType
+{
+ VK_PHYSICAL_DEVICE_TYPE_OTHER = 0x00000000,
+ VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 0x00000001,
+ VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 0x00000002,
+ VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 0x00000003,
+ VK_PHYSICAL_DEVICE_TYPE_CPU = 0x00000004,
+};
+
+enum VkPhysicalDeviceInfoType
+{
+ VK_PHYSICAL_DEVICE_INFO_TYPE_PROPERTIES = 0x00000000,
+ VK_PHYSICAL_DEVICE_INFO_TYPE_PERFORMANCE = 0x00000001,
+ VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PROPERTIES = 0x00000002,
+ VK_PHYSICAL_DEVICE_INFO_TYPE_MEMORY_PROPERTIES = 0x00000003,
+};
+
+enum VkExtensionInfoType
+{
+ VK_EXTENSION_INFO_TYPE_COUNT = 0x00000000,
+ VK_EXTENSION_INFO_TYPE_PROPERTIES = 0x00000001,
+};
+
+enum VkFormatInfoType
+{
+ VK_FORMAT_INFO_TYPE_PROPERTIES = 0x00000000,
+};
+
+enum VkSubresourceInfoType
+{
+ VK_SUBRESOURCE_INFO_TYPE_LAYOUT = 0x00000000,
+};
+
+enum VkObjectInfoType
+{
+ VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT = 0x00000000,
+ VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS = 0x00000001,
+};
+
+enum VkVertexInputStepRate
+{
+ VK_VERTEX_INPUT_STEP_RATE_VERTEX = 0x0,
+ VK_VERTEX_INPUT_STEP_RATE_INSTANCE = 0x1,
+ VK_VERTEX_INPUT_STEP_RATE_DRAW = 0x2,
+};
+
+enum VkFormat
+{
+ VK_FORMAT_UNDEFINED = 0x00000000,
+ VK_FORMAT_R4G4_UNORM = 0x00000001,
+ VK_FORMAT_R4G4_USCALED = 0x00000002,
+ VK_FORMAT_R4G4B4A4_UNORM = 0x00000003,
+ VK_FORMAT_R4G4B4A4_USCALED = 0x00000004,
+ VK_FORMAT_R5G6B5_UNORM = 0x00000005,
+ VK_FORMAT_R5G6B5_USCALED = 0x00000006,
+ VK_FORMAT_R5G5B5A1_UNORM = 0x00000007,
+ VK_FORMAT_R5G5B5A1_USCALED = 0x00000008,
+ VK_FORMAT_R8_UNORM = 0x00000009,
+ VK_FORMAT_R8_SNORM = 0x0000000A,
+ VK_FORMAT_R8_USCALED = 0x0000000B,
+ VK_FORMAT_R8_SSCALED = 0x0000000C,
+ VK_FORMAT_R8_UINT = 0x0000000D,
+ VK_FORMAT_R8_SINT = 0x0000000E,
+ VK_FORMAT_R8_SRGB = 0x0000000F,
+ VK_FORMAT_R8G8_UNORM = 0x00000010,
+ VK_FORMAT_R8G8_SNORM = 0x00000011,
+ VK_FORMAT_R8G8_USCALED = 0x00000012,
+ VK_FORMAT_R8G8_SSCALED = 0x00000013,
+ VK_FORMAT_R8G8_UINT = 0x00000014,
+ VK_FORMAT_R8G8_SINT = 0x00000015,
+ VK_FORMAT_R8G8_SRGB = 0x00000016,
+ VK_FORMAT_R8G8B8_UNORM = 0x00000017,
+ VK_FORMAT_R8G8B8_SNORM = 0x00000018,
+ VK_FORMAT_R8G8B8_USCALED = 0x00000019,
+ VK_FORMAT_R8G8B8_SSCALED = 0x0000001A,
+ VK_FORMAT_R8G8B8_UINT = 0x0000001B,
+ VK_FORMAT_R8G8B8_SINT = 0x0000001C,
+ VK_FORMAT_R8G8B8_SRGB = 0x0000001D,
+ VK_FORMAT_R8G8B8A8_UNORM = 0x0000001E,
+ VK_FORMAT_R8G8B8A8_SNORM = 0x0000001F,
+ VK_FORMAT_R8G8B8A8_USCALED = 0x00000020,
+ VK_FORMAT_R8G8B8A8_SSCALED = 0x00000021,
+ VK_FORMAT_R8G8B8A8_UINT = 0x00000022,
+ VK_FORMAT_R8G8B8A8_SINT = 0x00000023,
+ VK_FORMAT_R8G8B8A8_SRGB = 0x00000024,
+ VK_FORMAT_R10G10B10A2_UNORM = 0x00000025,
+ VK_FORMAT_R10G10B10A2_SNORM = 0x00000026,
+ VK_FORMAT_R10G10B10A2_USCALED = 0x00000027,
+ VK_FORMAT_R10G10B10A2_SSCALED = 0x00000028,
+ VK_FORMAT_R10G10B10A2_UINT = 0x00000029,
+ VK_FORMAT_R10G10B10A2_SINT = 0x0000002A,
+ VK_FORMAT_R16_UNORM = 0x0000002B,
+ VK_FORMAT_R16_SNORM = 0x0000002C,
+ VK_FORMAT_R16_USCALED = 0x0000002D,
+ VK_FORMAT_R16_SSCALED = 0x0000002E,
+ VK_FORMAT_R16_UINT = 0x0000002F,
+ VK_FORMAT_R16_SINT = 0x00000030,
+ VK_FORMAT_R16_SFLOAT = 0x00000031,
+ VK_FORMAT_R16G16_UNORM = 0x00000032,
+ VK_FORMAT_R16G16_SNORM = 0x00000033,
+ VK_FORMAT_R16G16_USCALED = 0x00000034,
+ VK_FORMAT_R16G16_SSCALED = 0x00000035,
+ VK_FORMAT_R16G16_UINT = 0x00000036,
+ VK_FORMAT_R16G16_SINT = 0x00000037,
+ VK_FORMAT_R16G16_SFLOAT = 0x00000038,
+ VK_FORMAT_R16G16B16_UNORM = 0x00000039,
+ VK_FORMAT_R16G16B16_SNORM = 0x0000003A,
+ VK_FORMAT_R16G16B16_USCALED = 0x0000003B,
+ VK_FORMAT_R16G16B16_SSCALED = 0x0000003C,
+ VK_FORMAT_R16G16B16_UINT = 0x0000003D,
+ VK_FORMAT_R16G16B16_SINT = 0x0000003E,
+ VK_FORMAT_R16G16B16_SFLOAT = 0x0000003F,
+ VK_FORMAT_R16G16B16A16_UNORM = 0x00000040,
+ VK_FORMAT_R16G16B16A16_SNORM = 0x00000041,
+ VK_FORMAT_R16G16B16A16_USCALED = 0x00000042,
+ VK_FORMAT_R16G16B16A16_SSCALED = 0x00000043,
+ VK_FORMAT_R16G16B16A16_UINT = 0x00000044,
+ VK_FORMAT_R16G16B16A16_SINT = 0x00000045,
+ VK_FORMAT_R16G16B16A16_SFLOAT = 0x00000046,
+ VK_FORMAT_R32_UINT = 0x00000047,
+ VK_FORMAT_R32_SINT = 0x00000048,
+ VK_FORMAT_R32_SFLOAT = 0x00000049,
+ VK_FORMAT_R32G32_UINT = 0x0000004A,
+ VK_FORMAT_R32G32_SINT = 0x0000004B,
+ VK_FORMAT_R32G32_SFLOAT = 0x0000004C,
+ VK_FORMAT_R32G32B32_UINT = 0x0000004D,
+ VK_FORMAT_R32G32B32_SINT = 0x0000004E,
+ VK_FORMAT_R32G32B32_SFLOAT = 0x0000004F,
+ VK_FORMAT_R32G32B32A32_UINT = 0x00000050,
+ VK_FORMAT_R32G32B32A32_SINT = 0x00000051,
+ VK_FORMAT_R32G32B32A32_SFLOAT = 0x00000052,
+ VK_FORMAT_R64_SFLOAT = 0x00000053,
+ VK_FORMAT_R64G64_SFLOAT = 0x00000054,
+ VK_FORMAT_R64G64B64_SFLOAT = 0x00000055,
+ VK_FORMAT_R64G64B64A64_SFLOAT = 0x00000056,
+ VK_FORMAT_R11G11B10_UFLOAT = 0x00000057,
+ VK_FORMAT_R9G9B9E5_UFLOAT = 0x00000058,
+ VK_FORMAT_D16_UNORM = 0x00000059,
+ VK_FORMAT_D24_UNORM = 0x0000005A,
+ VK_FORMAT_D32_SFLOAT = 0x0000005B,
+ VK_FORMAT_S8_UINT = 0x0000005C,
+ VK_FORMAT_D16_UNORM_S8_UINT = 0x0000005D,
+ VK_FORMAT_D24_UNORM_S8_UINT = 0x0000005E,
+ VK_FORMAT_D32_SFLOAT_S8_UINT = 0x0000005F,
+ VK_FORMAT_BC1_RGB_UNORM = 0x00000060,
+ VK_FORMAT_BC1_RGB_SRGB = 0x00000061,
+ VK_FORMAT_BC1_RGBA_UNORM = 0x00000062,
+ VK_FORMAT_BC1_RGBA_SRGB = 0x00000063,
+ VK_FORMAT_BC2_UNORM = 0x00000064,
+ VK_FORMAT_BC2_SRGB = 0x00000065,
+ VK_FORMAT_BC3_UNORM = 0x00000066,
+ VK_FORMAT_BC3_SRGB = 0x00000067,
+ VK_FORMAT_BC4_UNORM = 0x00000068,
+ VK_FORMAT_BC4_SNORM = 0x00000069,
+ VK_FORMAT_BC5_UNORM = 0x0000006A,
+ VK_FORMAT_BC5_SNORM = 0x0000006B,
+ VK_FORMAT_BC6H_UFLOAT = 0x0000006C,
+ VK_FORMAT_BC6H_SFLOAT = 0x0000006D,
+ VK_FORMAT_BC7_UNORM = 0x0000006E,
+ VK_FORMAT_BC7_SRGB = 0x0000006F,
+ VK_FORMAT_ETC2_R8G8B8_UNORM = 0x00000070,
+ VK_FORMAT_ETC2_R8G8B8_SRGB = 0x00000071,
+ VK_FORMAT_ETC2_R8G8B8A1_UNORM = 0x00000072,
+ VK_FORMAT_ETC2_R8G8B8A1_SRGB = 0x00000073,
+ VK_FORMAT_ETC2_R8G8B8A8_UNORM = 0x00000074,
+ VK_FORMAT_ETC2_R8G8B8A8_SRGB = 0x00000075,
+ VK_FORMAT_EAC_R11_UNORM = 0x00000076,
+ VK_FORMAT_EAC_R11_SNORM = 0x00000077,
+ VK_FORMAT_EAC_R11G11_UNORM = 0x00000078,
+ VK_FORMAT_EAC_R11G11_SNORM = 0x00000079,
+ VK_FORMAT_ASTC_4x4_UNORM = 0x0000007A,
+ VK_FORMAT_ASTC_4x4_SRGB = 0x0000007B,
+ VK_FORMAT_ASTC_5x4_UNORM = 0x0000007C,
+ VK_FORMAT_ASTC_5x4_SRGB = 0x0000007D,
+ VK_FORMAT_ASTC_5x5_UNORM = 0x0000007E,
+ VK_FORMAT_ASTC_5x5_SRGB = 0x0000007F,
+ VK_FORMAT_ASTC_6x5_UNORM = 0x00000080,
+ VK_FORMAT_ASTC_6x5_SRGB = 0x00000081,
+ VK_FORMAT_ASTC_6x6_UNORM = 0x00000082,
+ VK_FORMAT_ASTC_6x6_SRGB = 0x00000083,
+ VK_FORMAT_ASTC_8x5_UNORM = 0x00000084,
+ VK_FORMAT_ASTC_8x5_SRGB = 0x00000085,
+ VK_FORMAT_ASTC_8x6_UNORM = 0x00000086,
+ VK_FORMAT_ASTC_8x6_SRGB = 0x00000087,
+ VK_FORMAT_ASTC_8x8_UNORM = 0x00000088,
+ VK_FORMAT_ASTC_8x8_SRGB = 0x00000089,
+ VK_FORMAT_ASTC_10x5_UNORM = 0x0000008A,
+ VK_FORMAT_ASTC_10x5_SRGB = 0x0000008B,
+ VK_FORMAT_ASTC_10x6_UNORM = 0x0000008C,
+ VK_FORMAT_ASTC_10x6_SRGB = 0x0000008D,
+ VK_FORMAT_ASTC_10x8_UNORM = 0x0000008E,
+ VK_FORMAT_ASTC_10x8_SRGB = 0x0000008F,
+ VK_FORMAT_ASTC_10x10_UNORM = 0x00000090,
+ VK_FORMAT_ASTC_10x10_SRGB = 0x00000091,
+ VK_FORMAT_ASTC_12x10_UNORM = 0x00000092,
+ VK_FORMAT_ASTC_12x10_SRGB = 0x00000093,
+ VK_FORMAT_ASTC_12x12_UNORM = 0x00000094,
+ VK_FORMAT_ASTC_12x12_SRGB = 0x00000095,
+ VK_FORMAT_B4G4R4A4_UNORM = 0x00000096,
+ VK_FORMAT_B5G5R5A1_UNORM = 0x00000097,
+ VK_FORMAT_B5G6R5_UNORM = 0x00000098,
+ VK_FORMAT_B5G6R5_USCALED = 0x00000099,
+ VK_FORMAT_B8G8R8_UNORM = 0x0000009A,
+ VK_FORMAT_B8G8R8_SNORM = 0x0000009B,
+ VK_FORMAT_B8G8R8_USCALED = 0x0000009C,
+ VK_FORMAT_B8G8R8_SSCALED = 0x0000009D,
+ VK_FORMAT_B8G8R8_UINT = 0x0000009E,
+ VK_FORMAT_B8G8R8_SINT = 0x0000009F,
+ VK_FORMAT_B8G8R8_SRGB = 0x000000A0,
+ VK_FORMAT_B8G8R8A8_UNORM = 0x000000A1,
+ VK_FORMAT_B8G8R8A8_SNORM = 0x000000A2,
+ VK_FORMAT_B8G8R8A8_USCALED = 0x000000A3,
+ VK_FORMAT_B8G8R8A8_SSCALED = 0x000000A4,
+ VK_FORMAT_B8G8R8A8_UINT = 0x000000A5,
+ VK_FORMAT_B8G8R8A8_SINT = 0x000000A6,
+ VK_FORMAT_B8G8R8A8_SRGB = 0x000000A7,
+ VK_FORMAT_B10G10R10A2_UNORM = 0x000000A8,
+ VK_FORMAT_B10G10R10A2_SNORM = 0x000000A9,
+ VK_FORMAT_B10G10R10A2_USCALED = 0x000000AA,
+ VK_FORMAT_B10G10R10A2_SSCALED = 0x000000AB,
+ VK_FORMAT_B10G10R10A2_UINT = 0x000000AC,
+ VK_FORMAT_B10G10R10A2_SINT = 0x000000AD,
+};
+
+enum VkShaderStage
+{
+ VK_SHADER_STAGE_VERTEX = 0,
+ VK_SHADER_STAGE_TESS_CONTROL = 1,
+ VK_SHADER_STAGE_TESS_EVALUATION = 2,
+ VK_SHADER_STAGE_GEOMETRY = 3,
+ VK_SHADER_STAGE_FRAGMENT = 4,
+ VK_SHADER_STAGE_COMPUTE = 5,
+};
+
+enum VkStructureType
+{
+ VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
+ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1,
+ VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 2,
+ VK_STRUCTURE_TYPE_MEMORY_OPEN_INFO = 3,
+ VK_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO = 4,
+ VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO = 5,
+ VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO = 6,
+ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 7,
+ VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO = 8,
+ VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO = 9,
+ VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 10,
+ VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 11,
+ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 12,
+ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 13,
+ VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO = 14,
+ VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO = 15,
+ VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO = 16,
+ VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO = 17,
+ VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 18,
+ VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 19,
+ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 20,
+ VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 21,
+ VK_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO = 22,
+ VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 23,
+ VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 24,
+ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 25,
+ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO = 26,
+ VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO = 27,
+ VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO = 28,
+ VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO = 29,
+ VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO = 30,
+ VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO = 31,
+ VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO = 32,
+ VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO = 33,
+ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 34,
+ VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 35,
+ VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 36,
+ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37,
+ VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 38,
+ VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO = 39,
+ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 40,
+ VK_STRUCTURE_TYPE_LAYER_CREATE_INFO = 41,
+ VK_STRUCTURE_TYPE_MEMORY_BARRIER = 42,
+ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 43,
+ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 44,
+ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 45,
+ VK_STRUCTURE_TYPE_UPDATE_SAMPLERS = 46,
+ VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES = 47,
+ VK_STRUCTURE_TYPE_UPDATE_IMAGES = 48,
+ VK_STRUCTURE_TYPE_UPDATE_BUFFERS = 49,
+ VK_STRUCTURE_TYPE_UPDATE_AS_COPY = 50,
+ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 51,
+ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 52,
+};
+
+enum VkObjectType
+{
+ VK_OBJECT_TYPE_INSTANCE = 0,
+ VK_OBJECT_TYPE_PHYSICAL_DEVICE = 1,
+ VK_OBJECT_TYPE_DEVICE = 2,
+ VK_OBJECT_TYPE_QUEUE = 3,
+ VK_OBJECT_TYPE_COMMAND_BUFFER = 4,
+ VK_OBJECT_TYPE_DEVICE_MEMORY = 5,
+ VK_OBJECT_TYPE_BUFFER = 6,
+ VK_OBJECT_TYPE_BUFFER_VIEW = 7,
+ VK_OBJECT_TYPE_IMAGE = 8,
+ VK_OBJECT_TYPE_IMAGE_VIEW = 9,
+ VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW = 10,
+ VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW = 11,
+ VK_OBJECT_TYPE_SHADER = 12,
+ VK_OBJECT_TYPE_PIPELINE = 13,
+ VK_OBJECT_TYPE_PIPELINE_LAYOUT = 14,
+ VK_OBJECT_TYPE_SAMPLER = 15,
+ VK_OBJECT_TYPE_DESCRIPTOR_SET = 16,
+ VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 17,
+ VK_OBJECT_TYPE_DESCRIPTOR_POOL = 18,
+ VK_OBJECT_TYPE_DYNAMIC_VP_STATE = 19,
+ VK_OBJECT_TYPE_DYNAMIC_RS_STATE = 20,
+ VK_OBJECT_TYPE_DYNAMIC_CB_STATE = 21,
+ VK_OBJECT_TYPE_DYNAMIC_DS_STATE = 22,
+ VK_OBJECT_TYPE_FENCE = 23,
+ VK_OBJECT_TYPE_SEMAPHORE = 24,
+ VK_OBJECT_TYPE_EVENT = 25,
+ VK_OBJECT_TYPE_QUERY_POOL = 26,
+ VK_OBJECT_TYPE_FRAMEBUFFER = 27,
+ VK_OBJECT_TYPE_RENDER_PASS = 28,
+};
+
+enum VkResult
+{
+ VK_SUCCESS = 0x0000000,
+ VK_UNSUPPORTED = 0x0000001,
+ VK_NOT_READY = 0x0000002,
+ VK_TIMEOUT = 0x0000003,
+ VK_EVENT_SET = 0x0000004,
+ VK_EVENT_RESET = 0x0000005,
+ VK_ERROR_UNKNOWN = -(0x00000001),
+ VK_ERROR_UNAVAILABLE = -(0x00000002),
+ VK_ERROR_INITIALIZATION_FAILED = -(0x00000003),
+ VK_ERROR_OUT_OF_HOST_MEMORY = -(0x00000004),
+ VK_ERROR_OUT_OF_DEVICE_MEMORY = -(0x00000005),
+ VK_ERROR_DEVICE_ALREADY_CREATED = -(0x00000006),
+ VK_ERROR_DEVICE_LOST = -(0x00000007),
+ VK_ERROR_INVALID_POINTER = -(0x00000008),
+ VK_ERROR_INVALID_VALUE = -(0x00000009),
+ VK_ERROR_INVALID_HANDLE = -(0x0000000A),
+ VK_ERROR_INVALID_ORDINAL = -(0x0000000B),
+ VK_ERROR_INVALID_MEMORY_SIZE = -(0x0000000C),
+ VK_ERROR_INVALID_EXTENSION = -(0x0000000D),
+ VK_ERROR_INVALID_FLAGS = -(0x0000000E),
+ VK_ERROR_INVALID_ALIGNMENT = -(0x0000000F),
+ VK_ERROR_INVALID_FORMAT = -(0x00000010),
+ VK_ERROR_INVALID_IMAGE = -(0x00000011),
+ VK_ERROR_INVALID_DESCRIPTOR_SET_DATA = -(0x00000012),
+ VK_ERROR_INVALID_QUEUE_TYPE = -(0x00000013),
+ VK_ERROR_INVALID_OBJECT_TYPE = -(0x00000014),
+ VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION = -(0x00000015),
+ VK_ERROR_BAD_SHADER_CODE = -(0x00000016),
+ VK_ERROR_BAD_PIPELINE_DATA = -(0x00000017),
+ VK_ERROR_TOO_MANY_MEMORY_REFERENCES = -(0x00000018),
+ VK_ERROR_NOT_MAPPABLE = -(0x00000019),
+ VK_ERROR_MEMORY_MAP_FAILED = -(0x0000001A),
+ VK_ERROR_MEMORY_UNMAP_FAILED = -(0x0000001B),
+ VK_ERROR_INCOMPATIBLE_DEVICE = -(0x0000001C),
+ VK_ERROR_INCOMPATIBLE_DRIVER = -(0x0000001D),
+ VK_ERROR_INCOMPLETE_COMMAND_BUFFER = -(0x0000001E),
+ VK_ERROR_BUILDING_COMMAND_BUFFER = -(0x0000001F),
+ VK_ERROR_MEMORY_NOT_BOUND = -(0x00000020),
+ VK_ERROR_INCOMPATIBLE_QUEUE = -(0x00000021),
+ VK_ERROR_NOT_SHAREABLE = -(0x00000022),
+};
+
+enum VkDeviceCreateFlagBits
+{
+ VK_DEVICE_CREATE_VALIDATION_BIT = VK_BIT(0),
+ VK_DEVICE_CREATE_MULTI_DEVICE_IQ_MATCH_BIT = VK_BIT(1),
+};
+typedef deUint32 VkDeviceCreateFlags;
+
+enum VkQueueFlagBits
+{
+ VK_QUEUE_GRAPHICS_BIT = VK_BIT(0),
+ VK_QUEUE_COMPUTE_BIT = VK_BIT(1),
+ VK_QUEUE_DMA_BIT = VK_BIT(2),
+ VK_QUEUE_MEMMGR_BIT = VK_BIT(3),
+ VK_QUEUE_EXTENDED_BIT = VK_BIT(30),
+};
+typedef deUint32 VkQueueFlags;
+
+enum VkMemoryPropertyFlagBits
+{
+ VK_MEMORY_PROPERTY_DEVICE_ONLY = 0,
+ VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = VK_BIT(0),
+ VK_MEMORY_PROPERTY_HOST_DEVICE_COHERENT_BIT = VK_BIT(1),
+ VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT = VK_BIT(2),
+ VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT = VK_BIT(3),
+ VK_MEMORY_PROPERTY_PREFER_HOST_LOCAL = VK_BIT(4),
+ VK_MEMORY_PROPERTY_SHAREABLE_BIT = VK_BIT(5),
+};
+typedef deUint32 VkMemoryPropertyFlags;
+
+enum VkMemoryOutputFlagBits
+{
+ VK_MEMORY_OUTPUT_CPU_WRITE_BIT = VK_BIT(0),
+ VK_MEMORY_OUTPUT_SHADER_WRITE_BIT = VK_BIT(1),
+ VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT = VK_BIT(2),
+ VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT = VK_BIT(3),
+ VK_MEMORY_OUTPUT_TRANSFER_BIT = VK_BIT(4),
+};
+typedef deUint32 VkMemoryOutputFlags;
+
+enum VkMemoryInputFlagBits
+{
+ VK_MEMORY_INPUT_CPU_READ_BIT = VK_BIT(0),
+ VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT = VK_BIT(1),
+ VK_MEMORY_INPUT_INDEX_FETCH_BIT = VK_BIT(2),
+ VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT = VK_BIT(3),
+ VK_MEMORY_INPUT_UNIFORM_READ_BIT = VK_BIT(4),
+ VK_MEMORY_INPUT_SHADER_READ_BIT = VK_BIT(5),
+ VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT = VK_BIT(6),
+ VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT = VK_BIT(7),
+ VK_MEMORY_INPUT_TRANSFER_BIT = VK_BIT(8),
+};
+typedef deUint32 VkMemoryInputFlags;
+
+enum VkBufferUsageFlagBits
+{
+ VK_BUFFER_USAGE_GENERAL = 0,
+ VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = VK_BIT(0),
+ VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT = VK_BIT(1),
+ VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = VK_BIT(2),
+ VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = VK_BIT(3),
+ VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = VK_BIT(4),
+ VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = VK_BIT(5),
+ VK_BUFFER_USAGE_INDEX_BUFFER_BIT = VK_BIT(6),
+ VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = VK_BIT(7),
+ VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = VK_BIT(8),
+};
+typedef deUint32 VkBufferUsageFlags;
+
+enum VkBufferCreateFlagBits
+{
+ VK_BUFFER_CREATE_SHAREABLE_BIT = VK_BIT(0),
+ VK_BUFFER_CREATE_SPARSE_BIT = VK_BIT(1),
+};
+typedef deUint32 VkBufferCreateFlags;
+
+enum VkShaderStageFlagBits
+{
+ VK_SHADER_STAGE_VERTEX_BIT = VK_BIT(0),
+ VK_SHADER_STAGE_TESS_CONTROL_BIT = VK_BIT(1),
+ VK_SHADER_STAGE_TESS_EVALUATION_BIT = VK_BIT(2),
+ VK_SHADER_STAGE_GEOMETRY_BIT = VK_BIT(3),
+ VK_SHADER_STAGE_FRAGMENT_BIT = VK_BIT(4),
+ VK_SHADER_STAGE_COMPUTE_BIT = VK_BIT(5),
+ VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
+};
+typedef deUint32 VkShaderStageFlags;
+
+enum VkImageUsageFlagBits
+{
+ VK_IMAGE_USAGE_GENERAL = 0,
+ VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = VK_BIT(0),
+ VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT = VK_BIT(1),
+ VK_IMAGE_USAGE_SAMPLED_BIT = VK_BIT(2),
+ VK_IMAGE_USAGE_STORAGE_BIT = VK_BIT(3),
+ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = VK_BIT(4),
+ VK_IMAGE_USAGE_DEPTH_STENCIL_BIT = VK_BIT(5),
+ VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = VK_BIT(6),
+};
+typedef deUint32 VkImageUsageFlags;
+
+enum VkImageCreateFlagBits
+{
+ VK_IMAGE_CREATE_INVARIANT_DATA_BIT = VK_BIT(0),
+ VK_IMAGE_CREATE_CLONEABLE_BIT = VK_BIT(1),
+ VK_IMAGE_CREATE_SHAREABLE_BIT = VK_BIT(2),
+ VK_IMAGE_CREATE_SPARSE_BIT = VK_BIT(3),
+ VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = VK_BIT(4),
+ VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = VK_BIT(5),
+};
+typedef deUint32 VkImageCreateFlags;
+
+enum VkDepthStencilViewCreateFlagBits
+{
+ VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT = VK_BIT(0),
+ VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT = VK_BIT(1),
+};
+typedef deUint32 VkDepthStencilViewCreateFlags;
+
+enum VkPipelineCreateFlagBits
+{
+ VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = VK_BIT(0),
+ VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = VK_BIT(1),
+};
+typedef deUint32 VkPipelineCreateFlags;
+
+enum VkChannelFlagBits
+{
+ VK_CHANNEL_R_BIT = VK_BIT(0),
+ VK_CHANNEL_G_BIT = VK_BIT(1),
+ VK_CHANNEL_B_BIT = VK_BIT(2),
+ VK_CHANNEL_A_BIT = VK_BIT(3),
+};
+typedef deUint32 VkChannelFlags;
+
+enum VkFenceCreateFlagBits
+{
+ VK_FENCE_CREATE_SIGNALED_BIT = VK_BIT(0),
+};
+typedef deUint32 VkFenceCreateFlags;
+
+enum VkSemaphoreCreateFlagBits
+{
+ VK_SEMAPHORE_CREATE_SHAREABLE_BIT = VK_BIT(0),
+};
+typedef deUint32 VkSemaphoreCreateFlags;
+
+enum VkFormatFeatureFlagBits
+{
+ VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = VK_BIT(0),
+ VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = VK_BIT(1),
+ VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = VK_BIT(2),
+ VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = VK_BIT(3),
+ VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = VK_BIT(4),
+ VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = VK_BIT(5),
+ VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = VK_BIT(6),
+ VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = VK_BIT(7),
+ VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = VK_BIT(8),
+ VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = VK_BIT(9),
+ VK_FORMAT_FEATURE_CONVERSION_BIT = VK_BIT(10),
+};
+typedef deUint32 VkFormatFeatureFlags;
+
+enum VkQueryControlFlagBits
+{
+ VK_QUERY_CONTROL_CONSERVATIVE_BIT = VK_BIT(0),
+};
+typedef deUint32 VkQueryControlFlags;
+
+enum VkQueryResultFlagBits
+{
+ VK_QUERY_RESULT_32_BIT = 0,
+ VK_QUERY_RESULT_64_BIT = VK_BIT(0),
+ VK_QUERY_RESULT_NO_WAIT_BIT = 0,
+ VK_QUERY_RESULT_WAIT_BIT = VK_BIT(1),
+ VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = VK_BIT(2),
+ VK_QUERY_RESULT_PARTIAL_BIT = VK_BIT(3),
+};
+typedef deUint32 VkQueryResultFlags;
+
+enum VkPhysicalDeviceCompatibilityFlagBits
+{
+ VK_PHYSICAL_DEVICE_COMPATIBILITY_FEATURES_BIT = VK_BIT(0),
+ VK_PHYSICAL_DEVICE_COMPATIBILITY_IQ_MATCH_BIT = VK_BIT(1),
+ VK_PHYSICAL_DEVICE_COMPATIBILITY_PEER_TRANSFER_BIT = VK_BIT(2),
+ VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_MEMORY_BIT = VK_BIT(3),
+ VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_SYNC_BIT = VK_BIT(4),
+ VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_DEVICE0_DISPLAY_BIT = VK_BIT(5),
+ VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_DEVICE1_DISPLAY_BIT = VK_BIT(6),
+};
+typedef deUint32 VkPhysicalDeviceCompatibilityFlags;
+
+enum VkCmdBufferOptimizeFlagBits
+{
+ VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT = VK_BIT(0),
+ VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = VK_BIT(1),
+ VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = VK_BIT(2),
+ VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = VK_BIT(3),
+};
+typedef deUint32 VkCmdBufferOptimizeFlags;
+
+enum VkQueryPipelineStatisticFlagBits
+{
+ VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT = VK_BIT(0),
+ VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT = VK_BIT(1),
+ VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT = VK_BIT(2),
+ VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT = VK_BIT(3),
+ VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT = VK_BIT(4),
+ VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT = VK_BIT(5),
+ VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT = VK_BIT(6),
+ VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT = VK_BIT(7),
+ VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT = VK_BIT(8),
+ VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT = VK_BIT(9),
+ VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT = VK_BIT(10),
+};
+typedef deUint32 VkQueryPipelineStatisticFlags;
+
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkObject);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkInstance);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkPhysicalDevice);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkDevice);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkQueue);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkCmdBuffer);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkNonDispatchable);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkDeviceMemory);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkBuffer);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkBufferView);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkImage);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkImageView);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkColorAttachmentView);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkDepthStencilView);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkShader);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkPipeline);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkPipelineLayout);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkSampler);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkDescriptorSet);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkDescriptorSetLayout);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkDescriptorPool);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkDynamicStateObject);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkDynamicVpState);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkDynamicRsState);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkDynamicCbState);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkDynamicDsState);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkFence);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkSemaphore);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkEvent);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkQueryPool);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkFramebuffer);
+VK_DEFINE_HANDLE_TYPE_TRAITS(VkRenderPass);
--- /dev/null
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * be lost! Modify the generating script instead.
+ */
+virtual VkResult getPhysicalDeviceInfo (VkPhysicalDevice physicalDevice, VkPhysicalDeviceInfoType infoType, deUintptr* pDataSize, void* pData) const;
+virtual VkResult createDevice (VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) const;
+virtual VkResult destroyDevice (VkDevice device) const;
+virtual VkResult getGlobalExtensionInfo (VkExtensionInfoType infoType, deUint32 extensionIndex, deUintptr* pDataSize, void* pData) const;
+virtual VkResult getPhysicalDeviceExtensionInfo (VkPhysicalDevice physicalDevice, VkExtensionInfoType infoType, deUint32 extensionIndex, deUintptr* pDataSize, void* pData) const;
+virtual VkResult enumerateLayers (VkPhysicalDevice physicalDevice, deUintptr maxStringSize, deUintptr* pLayerCount, char* const* pOutLayers, void* pReserved) const;
+virtual VkResult getDeviceQueue (VkDevice device, deUint32 queueNodeIndex, deUint32 queueIndex, VkQueue* pQueue) const;
+virtual VkResult queueSubmit (VkQueue queue, deUint32 cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence) const;
+virtual VkResult queueAddMemReferences (VkQueue queue, deUint32 count, const VkDeviceMemory* pMems) const;
+virtual VkResult queueRemoveMemReferences (VkQueue queue, deUint32 count, const VkDeviceMemory* pMems) 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 VkResult setMemoryPriority (VkDevice device, VkDeviceMemory mem, VkMemoryPriority priority) 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 VkResult flushMappedMemory (VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size) const;
+virtual VkResult pinSystemMemory (VkDevice device, const void* pSysMem, deUintptr memSize, VkDeviceMemory* pMem) const;
+virtual VkResult getMultiDeviceCompatibility (VkPhysicalDevice physicalDevice0, VkPhysicalDevice physicalDevice1, VkPhysicalDeviceCompatibilityInfo* pInfo) const;
+virtual VkResult openSharedMemory (VkDevice device, const VkMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem) const;
+virtual VkResult openSharedSemaphore (VkDevice device, const VkSemaphoreOpenInfo* pOpenInfo, VkSemaphore* pSemaphore) const;
+virtual VkResult openPeerMemory (VkDevice device, const VkPeerMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem) const;
+virtual VkResult openPeerImage (VkDevice device, const VkPeerImageOpenInfo* pOpenInfo, VkImage* pImage, VkDeviceMemory* pMem) const;
+virtual VkResult destroyObject (VkDevice device, VkObjectType objType, VkObject object) const;
+virtual VkResult getObjectInfo (VkDevice device, VkObjectType objType, VkObject object, VkObjectInfoType infoType, deUintptr* pDataSize, void* pData) const;
+virtual VkResult queueBindObjectMemory (VkQueue queue, VkObjectType objType, VkObject object, deUint32 allocationIdx, VkDeviceMemory mem, VkDeviceSize memOffset) const;
+virtual VkResult queueBindObjectMemoryRange (VkQueue queue, VkObjectType objType, VkObject object, deUint32 allocationIdx, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset) const;
+virtual VkResult queueBindImageMemoryRange (VkQueue queue, VkImage image, deUint32 allocationIdx, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset) const;
+virtual VkResult createFence (VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence) const;
+virtual VkResult resetFences (VkDevice device, deUint32 fenceCount, VkFence* pFences) const;
+virtual VkResult getFenceStatus (VkDevice device, VkFence fence) const;
+virtual VkResult waitForFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences, deUint32 waitAll, deUint64 timeout) const;
+virtual VkResult createSemaphore (VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore) 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 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 getQueryPoolResults (VkDevice device, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, deUintptr* pDataSize, void* pData, VkQueryResultFlags flags) const;
+virtual VkResult getFormatInfo (VkDevice device, VkFormat format, VkFormatInfoType infoType, deUintptr* pDataSize, void* pData) const;
+virtual VkResult createBuffer (VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer) const;
+virtual VkResult createBufferView (VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView) const;
+virtual VkResult createImage (VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage) const;
+virtual VkResult getImageSubresourceInfo (VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceInfoType infoType, deUintptr* pDataSize, void* pData) const;
+virtual VkResult createImageView (VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView) const;
+virtual VkResult createColorAttachmentView (VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo, VkColorAttachmentView* pView) const;
+virtual VkResult createDepthStencilView (VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo, VkDepthStencilView* pView) const;
+virtual VkResult createShader (VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader) const;
+virtual VkResult createGraphicsPipeline (VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) const;
+virtual VkResult createGraphicsPipelineDerivative (VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline basePipeline, VkPipeline* pPipeline) const;
+virtual VkResult createComputePipeline (VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) const;
+virtual VkResult storePipeline (VkDevice device, VkPipeline pipeline, deUintptr* pDataSize, void* pData) const;
+virtual VkResult loadPipeline (VkDevice device, deUintptr dataSize, const void* pData, VkPipeline* pPipeline) const;
+virtual VkResult loadPipelineDerivative (VkDevice device, deUintptr dataSize, const void* pData, VkPipeline basePipeline, VkPipeline* pPipeline) const;
+virtual VkResult createPipelineLayout (VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout) const;
+virtual VkResult createSampler (VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) const;
+virtual VkResult createDescriptorSetLayout (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout) const;
+virtual VkResult beginDescriptorPoolUpdate (VkDevice device, VkDescriptorUpdateMode updateMode) const;
+virtual VkResult endDescriptorPoolUpdate (VkDevice device, VkCmdBuffer cmd) const;
+virtual VkResult createDescriptorPool (VkDevice device, VkDescriptorPoolUsage poolUsage, deUint32 maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) 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 void clearDescriptorSets (VkDevice device, VkDescriptorPool descriptorPool, deUint32 count, const VkDescriptorSet* pDescriptorSets) const;
+virtual void updateDescriptors (VkDevice device, VkDescriptorSet descriptorSet, deUint32 updateCount, const void** ppUpdateArray) const;
+virtual VkResult createDynamicViewportState (VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpState* pState) const;
+virtual VkResult createDynamicRasterState (VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsState* pState) const;
+virtual VkResult createDynamicColorBlendState (VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbState* pState) const;
+virtual VkResult createDynamicDepthStencilState (VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsState* pState) const;
+virtual VkResult createCommandBuffer (VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer) const;
+virtual VkResult beginCommandBuffer (VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) const;
+virtual VkResult endCommandBuffer (VkCmdBuffer cmdBuffer) const;
+virtual VkResult resetCommandBuffer (VkCmdBuffer cmdBuffer) const;
+virtual void cmdBindPipeline (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) const;
+virtual void cmdBindDynamicStateObject (VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject dynamicState) const;
+virtual void cmdBindDescriptorSets (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, 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 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 cmdDispatchIndirect (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset) const;
+virtual void cmdCopyBuffer (VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, deUint32 regionCount, const VkBufferCopy* pRegions) const;
+virtual void cmdCopyImage (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageCopy* pRegions) const;
+virtual void cmdBlitImage (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageBlit* pRegions) const;
+virtual void cmdCopyBufferToImage (VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkBufferImageCopy* pRegions) const;
+virtual void cmdCopyImageToBuffer (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, deUint32 regionCount, const VkBufferImageCopy* pRegions) const;
+virtual void cmdCloneImageData (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout) 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, VkClearColor color, deUint32 rangeCount, const VkImageSubresourceRange* pRanges) const;
+virtual void cmdClearDepthStencil (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, deUint32 stencil, deUint32 rangeCount, const VkImageSubresourceRange* pRanges) 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, VkPipeEvent pipeEvent) const;
+virtual void cmdResetEvent (VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent) const;
+virtual void cmdWaitEvents (VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, deUint32 eventCount, const VkEvent* pEvents, deUint32 memBarrierCount, const void** ppMemBarriers) const;
+virtual void cmdPipelineBarrier (VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, deUint32 pipeEventCount, const VkPipeEvent* pPipeEvents, deUint32 memBarrierCount, const void** ppMemBarriers) const;
+virtual void cmdBeginQuery (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 slot, VkQueryControlFlags flags) const;
+virtual void cmdEndQuery (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 slot) const;
+virtual void cmdResetQueryPool (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount) const;
+virtual void cmdWriteTimestamp (VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset) const;
+virtual void cmdCopyQueryPoolResults (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags) const;
+virtual void cmdInitAtomicCounters (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 startCounter, deUint32 counterCount, const deUint32* pData) const;
+virtual void cmdLoadAtomicCounters (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 startCounter, deUint32 counterCount, VkBuffer srcBuffer, VkDeviceSize srcOffset) const;
+virtual void cmdSaveAtomicCounters (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 startCounter, deUint32 counterCount, VkBuffer destBuffer, VkDeviceSize destOffset) const;
+virtual VkResult createFramebuffer (VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer) const;
+virtual VkResult createRenderPass (VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass) const;
+virtual void cmdBeginRenderPass (VkCmdBuffer cmdBuffer, const VkRenderPassBegin* pRenderPassBegin) const;
+virtual void cmdEndRenderPass (VkCmdBuffer cmdBuffer, VkRenderPass renderPass) const;
--- /dev/null
+/* 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 VkResult destroyInstance (VkInstance instance) const;
+virtual VkResult enumeratePhysicalDevices (VkInstance instance, deUint32* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) const;
+virtual FunctionPtr getProcAddr (VkPhysicalDevice physicalDevice, const char* pName) const;
--- /dev/null
+/*-------------------------------------------------------------------------
+ * drawElements Quality Program Vulkan Utilities
+ * -----------------------------------------------
+ *
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Vulkan utilites.
+ *//*--------------------------------------------------------------------*/
+
+#include "vkDefs.hpp"
+#include "vkStrUtil.hpp"
+
+#include <sstream>
+
+DE_STATIC_ASSERT(sizeof(vk::VkImageType) == sizeof(deUint32));
+DE_STATIC_ASSERT(sizeof(vk::VkResult) == sizeof(deUint32));
+
+namespace vk
+{
+
+static bool isOutOfMemoryError (VkResult result)
+{
+ return result == VK_ERROR_OUT_OF_DEVICE_MEMORY ||
+ result == VK_ERROR_OUT_OF_HOST_MEMORY;
+}
+
+Error::Error (VkResult error, const char* message, const char* expr, const char* file, int line)
+ : tcu::TestError (message, expr, file, line)
+ , m_error (error)
+{
+}
+
+Error::Error (VkResult error, const std::string& message)
+ : tcu::TestError (message)
+ , m_error (error)
+{
+}
+
+Error::~Error (void) throw()
+{
+}
+
+OutOfMemoryError::OutOfMemoryError (VkResult error, const char* message, const char* expr, const char* file, int line)
+ : tcu::ResourceError(message, expr, file, line)
+ , m_error (error)
+{
+ DE_ASSERT(isOutOfMemoryError(error));
+}
+
+OutOfMemoryError::OutOfMemoryError (VkResult error, const std::string& message)
+ : tcu::ResourceError(message)
+ , m_error (error)
+{
+ DE_ASSERT(isOutOfMemoryError(error));
+}
+
+OutOfMemoryError::~OutOfMemoryError (void) throw()
+{
+}
+
+void checkResult (VkResult result, const char* msg, const char* file, int line)
+{
+ if (result != VK_SUCCESS)
+ {
+ std::ostringstream msgStr;
+ if (msg)
+ msgStr << msg << ": ";
+
+ msgStr << getResultStr(result);
+
+ if (isOutOfMemoryError(result))
+ throw OutOfMemoryError(result, msgStr.str().c_str(), DE_NULL, file, line);
+ else if (result == VK_UNSUPPORTED)
+ throw tcu::NotSupportedError(msgStr.str().c_str(), DE_NULL, file, line);
+ else
+ throw Error(result, msgStr.str().c_str(), DE_NULL, file, line);
+ }
+}
+
+ApiVersion unpackVersion (deUint32 version)
+{
+ return ApiVersion((version & 0xFFC00000) >> 22,
+ (version & 0x003FF000) >> 12,
+ version & 0x00000FFF);
+}
+
+deUint32 pack (const ApiVersion& version)
+{
+ DE_ASSERT((version.major & ~0x3FF) == 0);
+ DE_ASSERT((version.minor & ~0x3FF) == 0);
+ DE_ASSERT((version.patch & ~0xFFF) == 0);
+
+ return (version.major << 22) | (version.minor << 12) | version.patch;
+}
+
+#include "vkGetObjectTypeImpl.inl"
+
+} // vk
--- /dev/null
+#ifndef _VKDEFS_HPP
+#define _VKDEFS_HPP
+/*-------------------------------------------------------------------------
+ * drawElements Quality Program Vulkan Utilities
+ * -----------------------------------------------
+ *
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Vulkan utilites.
+ *//*--------------------------------------------------------------------*/
+
+#include "tcuDefs.hpp"
+
+#if (DE_OS == DE_OS_ANDROID)
+# include <sys/cdefs.h>
+# if !defined(__NDK_FPABI__)
+# define __NDK_FPABI__
+# endif
+# define VK_APICALL __NDK_FPABI__
+#else
+# define VK_APICALL
+#endif
+
+#if (DE_OS == DE_OS_WIN32) && (_MSC_VER >= 800) || defined(_STDCALL_SUPPORTED)
+# define VK_APIENTRY __stdcall
+#else
+# define VK_APIENTRY
+#endif
+
+#define VK_DEFINE_HANDLE_TYPE_TRAITS(HANDLE) \
+ struct HANDLE##T { private: HANDLE##T (void); }; \
+ template<> \
+ struct Traits<HANDLE##T> \
+ { \
+ typedef HANDLE Type; \
+ }
+
+#if (DE_PTR_SIZE == 8)
+# define VK_DEFINE_PTR_HANDLE(HANDLE) \
+ struct HANDLE##_s { private: HANDLE##_s (void); }; \
+ typedef HANDLE##_s* HANDLE
+
+# define VK_DEFINE_PTR_SUBCLASS_HANDLE(HANDLE, PARENT) \
+ struct HANDLE##_s : public PARENT##_s { private: HANDLE##_s (void); }; \
+ typedef HANDLE##_s* HANDLE
+
+# define VK_DEFINE_BASE_HANDLE(HANDLE) VK_DEFINE_PTR_HANDLE(HANDLE)
+# define VK_DEFINE_DISP_SUBCLASS_HANDLE(HANDLE, PARENT) VK_DEFINE_PTR_SUBCLASS_HANDLE(HANDLE, PARENT)
+# define VK_DEFINE_NONDISP_SUBCLASS_HANDLE(HANDLE, PARENT) VK_DEFINE_PTR_SUBCLASS_HANDLE(HANDLE, PARENT)
+#else
+# define VK_DEFINE_BASE_HANDLE(HANDLE) typedef deUint64 HANDLE
+# define VK_DEFINE_DISP_SUBCLASS_HANDLE(HANDLE, PARENT) typedef deUintptr HANDLE
+# define VK_DEFINE_NONDISP_SUBCLASS_HANDLE(HANDLE, PARENT) typedef deUint64 HANDLE
+#endif
+
+#define VK_MAKE_VERSION(MAJOR, MINOR, PATCH) ((MAJOR << 22) | (MINOR << 12) | PATCH)
+#define VK_BIT(NUM) (1<<NUM)
+
+#define VK_CHECK(EXPR) vk::checkResult((EXPR), #EXPR, __FILE__, __LINE__)
+#define VK_CHECK_MSG(EXPR, MSG) vk::checkResult((EXPR), MSG, __FILE__, __LINE__)
+
+/*--------------------------------------------------------------------*//*!
+ * \brief Vulkan utilities
+ *//*--------------------------------------------------------------------*/
+namespace vk
+{
+
+typedef deUint64 VkDeviceSize;
+typedef deUint32 VkSampleMask;
+
+typedef deUint32 VkShaderCreateFlags; // Reserved
+typedef deUint32 VkEventCreateFlags; // Reserved
+typedef deUint32 VkCmdBufferCreateFlags; // Reserved
+typedef deUint32 VkMemoryMapFlags; // \todo [2015-05-08 pyry] Reserved? Not documented
+
+template<typename T> struct Traits;
+
+#include "vkBasicTypes.inl"
+
+typedef VK_APICALL void (VK_APIENTRY* FunctionPtr) (void);
+
+typedef VK_APICALL void* (VK_APIENTRY* PFN_vkAllocFunction) (void* pUserData, deUintptr size, deUintptr alignment, VkSystemAllocType allocType);
+typedef VK_APICALL void (VK_APIENTRY* PFN_vkFreeFunction) (void* pUserData, void* pMem);
+
+union VkClearColorValue
+{
+ float floatColor[4];
+ deUint32 rawColor[4];
+};
+
+#include "vkStructTypes.inl"
+
+class PlatformInterface
+{
+public:
+#include "vkVirtualPlatformInterface.inl"
+};
+
+class DeviceInterface
+{
+public:
+#include "vkVirtualDeviceInterface.inl"
+};
+
+struct ApiVersion
+{
+ deUint32 major;
+ deUint32 minor;
+ deUint32 patch;
+
+ ApiVersion (deUint32 major_,
+ deUint32 minor_,
+ deUint32 patch_)
+ : major (major_)
+ , minor (minor_)
+ , patch (patch_)
+ {
+ }
+};
+
+class Error : public tcu::TestError
+{
+public:
+ Error (VkResult error, const char* message, const char* expr, const char* file, int line);
+ Error (VkResult error, const std::string& message);
+ virtual ~Error (void) throw();
+
+ VkResult getError (void) const { return m_error; }
+
+private:
+ const VkResult m_error;
+};
+
+class OutOfMemoryError : public tcu::ResourceError
+{
+public:
+ OutOfMemoryError (VkResult error, const char* message, const char* expr, const char* file, int line);
+ OutOfMemoryError (VkResult error, const std::string& message);
+ virtual ~OutOfMemoryError (void) throw();
+
+ VkResult getError (void) const { return m_error; }
+
+private:
+ const VkResult m_error;
+};
+
+ApiVersion unpackVersion (deUint32 version);
+deUint32 pack (const ApiVersion& version);
+
+void checkResult (VkResult result, const char* message, const char* file, int line);
+
+//! Map Vk{Object}T to VK_OBJECT_TYPE_{OBJECT}. Defined for leaf objects only.
+template<typename T>
+VkObjectType getObjectType (void);
+
+} // vk
+
+#endif // _VKDEFS_HPP
--- /dev/null
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * be lost! Modify the generating script instead.
+ */
+
+VkResult DeviceDriver::getPhysicalDeviceInfo (VkPhysicalDevice physicalDevice, VkPhysicalDeviceInfoType infoType, deUintptr* pDataSize, void* pData) const
+{
+ return m_vk.getPhysicalDeviceInfo(physicalDevice, infoType, pDataSize, pData);
+}
+
+VkResult DeviceDriver::createDevice (VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) const
+{
+ return m_vk.createDevice(physicalDevice, pCreateInfo, pDevice);
+}
+
+VkResult DeviceDriver::destroyDevice (VkDevice device) const
+{
+ return m_vk.destroyDevice(device);
+}
+
+VkResult DeviceDriver::getGlobalExtensionInfo (VkExtensionInfoType infoType, deUint32 extensionIndex, deUintptr* pDataSize, void* pData) const
+{
+ return m_vk.getGlobalExtensionInfo(infoType, extensionIndex, pDataSize, pData);
+}
+
+VkResult DeviceDriver::getPhysicalDeviceExtensionInfo (VkPhysicalDevice physicalDevice, VkExtensionInfoType infoType, deUint32 extensionIndex, deUintptr* pDataSize, void* pData) const
+{
+ return m_vk.getPhysicalDeviceExtensionInfo(physicalDevice, infoType, extensionIndex, pDataSize, pData);
+}
+
+VkResult DeviceDriver::enumerateLayers (VkPhysicalDevice physicalDevice, deUintptr maxStringSize, deUintptr* pLayerCount, char* const* pOutLayers, void* pReserved) const
+{
+ return m_vk.enumerateLayers(physicalDevice, maxStringSize, pLayerCount, pOutLayers, pReserved);
+}
+
+VkResult DeviceDriver::getDeviceQueue (VkDevice device, deUint32 queueNodeIndex, deUint32 queueIndex, VkQueue* pQueue) const
+{
+ return m_vk.getDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
+}
+
+VkResult DeviceDriver::queueSubmit (VkQueue queue, deUint32 cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence) const
+{
+ return m_vk.queueSubmit(queue, cmdBufferCount, pCmdBuffers, fence);
+}
+
+VkResult DeviceDriver::queueAddMemReferences (VkQueue queue, deUint32 count, const VkDeviceMemory* pMems) const
+{
+ return m_vk.queueAddMemReferences(queue, count, pMems);
+}
+
+VkResult DeviceDriver::queueRemoveMemReferences (VkQueue queue, deUint32 count, const VkDeviceMemory* pMems) const
+{
+ return m_vk.queueRemoveMemReferences(queue, count, pMems);
+}
+
+VkResult DeviceDriver::queueWaitIdle (VkQueue queue) const
+{
+ return m_vk.queueWaitIdle(queue);
+}
+
+VkResult DeviceDriver::deviceWaitIdle (VkDevice device) const
+{
+ return m_vk.deviceWaitIdle(device);
+}
+
+VkResult DeviceDriver::allocMemory (VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem) const
+{
+ return m_vk.allocMemory(device, pAllocInfo, pMem);
+}
+
+VkResult DeviceDriver::freeMemory (VkDevice device, VkDeviceMemory mem) const
+{
+ return m_vk.freeMemory(device, mem);
+}
+
+VkResult DeviceDriver::setMemoryPriority (VkDevice device, VkDeviceMemory mem, VkMemoryPriority priority) const
+{
+ return m_vk.setMemoryPriority(device, mem, priority);
+}
+
+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
+{
+ return m_vk.unmapMemory(device, mem);
+}
+
+VkResult DeviceDriver::flushMappedMemory (VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size) const
+{
+ return m_vk.flushMappedMemory(device, mem, offset, size);
+}
+
+VkResult DeviceDriver::pinSystemMemory (VkDevice device, const void* pSysMem, deUintptr memSize, VkDeviceMemory* pMem) const
+{
+ return m_vk.pinSystemMemory(device, pSysMem, memSize, pMem);
+}
+
+VkResult DeviceDriver::getMultiDeviceCompatibility (VkPhysicalDevice physicalDevice0, VkPhysicalDevice physicalDevice1, VkPhysicalDeviceCompatibilityInfo* pInfo) const
+{
+ return m_vk.getMultiDeviceCompatibility(physicalDevice0, physicalDevice1, pInfo);
+}
+
+VkResult DeviceDriver::openSharedMemory (VkDevice device, const VkMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem) const
+{
+ return m_vk.openSharedMemory(device, pOpenInfo, pMem);
+}
+
+VkResult DeviceDriver::openSharedSemaphore (VkDevice device, const VkSemaphoreOpenInfo* pOpenInfo, VkSemaphore* pSemaphore) const
+{
+ return m_vk.openSharedSemaphore(device, pOpenInfo, pSemaphore);
+}
+
+VkResult DeviceDriver::openPeerMemory (VkDevice device, const VkPeerMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem) const
+{
+ return m_vk.openPeerMemory(device, pOpenInfo, pMem);
+}
+
+VkResult DeviceDriver::openPeerImage (VkDevice device, const VkPeerImageOpenInfo* pOpenInfo, VkImage* pImage, VkDeviceMemory* pMem) const
+{
+ return m_vk.openPeerImage(device, pOpenInfo, pImage, pMem);
+}
+
+VkResult DeviceDriver::destroyObject (VkDevice device, VkObjectType objType, VkObject object) const
+{
+ return m_vk.destroyObject(device, objType, object);
+}
+
+VkResult DeviceDriver::getObjectInfo (VkDevice device, VkObjectType objType, VkObject object, VkObjectInfoType infoType, deUintptr* pDataSize, void* pData) const
+{
+ return m_vk.getObjectInfo(device, objType, object, infoType, pDataSize, pData);
+}
+
+VkResult DeviceDriver::queueBindObjectMemory (VkQueue queue, VkObjectType objType, VkObject object, deUint32 allocationIdx, VkDeviceMemory mem, VkDeviceSize memOffset) const
+{
+ return m_vk.queueBindObjectMemory(queue, objType, object, allocationIdx, mem, memOffset);
+}
+
+VkResult DeviceDriver::queueBindObjectMemoryRange (VkQueue queue, VkObjectType objType, VkObject object, deUint32 allocationIdx, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset) const
+{
+ return m_vk.queueBindObjectMemoryRange(queue, objType, object, allocationIdx, rangeOffset, rangeSize, mem, memOffset);
+}
+
+VkResult DeviceDriver::queueBindImageMemoryRange (VkQueue queue, VkImage image, deUint32 allocationIdx, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset) const
+{
+ return m_vk.queueBindImageMemoryRange(queue, image, allocationIdx, pBindInfo, mem, memOffset);
+}
+
+VkResult DeviceDriver::createFence (VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence) const
+{
+ return m_vk.createFence(device, pCreateInfo, pFence);
+}
+
+VkResult DeviceDriver::resetFences (VkDevice device, deUint32 fenceCount, VkFence* pFences) const
+{
+ return m_vk.resetFences(device, fenceCount, pFences);
+}
+
+VkResult DeviceDriver::getFenceStatus (VkDevice device, VkFence fence) const
+{
+ return m_vk.getFenceStatus(device, fence);
+}
+
+VkResult DeviceDriver::waitForFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences, deUint32 waitAll, deUint64 timeout) const
+{
+ return m_vk.waitForFences(device, fenceCount, pFences, waitAll, timeout);
+}
+
+VkResult DeviceDriver::createSemaphore (VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore) const
+{
+ return m_vk.createSemaphore(device, pCreateInfo, pSemaphore);
+}
+
+VkResult DeviceDriver::queueSignalSemaphore (VkQueue queue, VkSemaphore semaphore) const
+{
+ return m_vk.queueSignalSemaphore(queue, semaphore);
+}
+
+VkResult DeviceDriver::queueWaitSemaphore (VkQueue queue, VkSemaphore semaphore) const
+{
+ return m_vk.queueWaitSemaphore(queue, semaphore);
+}
+
+VkResult DeviceDriver::createEvent (VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent) const
+{
+ return m_vk.createEvent(device, pCreateInfo, pEvent);
+}
+
+VkResult DeviceDriver::getEventStatus (VkDevice device, VkEvent event) const
+{
+ return m_vk.getEventStatus(device, event);
+}
+
+VkResult DeviceDriver::setEvent (VkDevice device, VkEvent event) const
+{
+ return m_vk.setEvent(device, event);
+}
+
+VkResult DeviceDriver::resetEvent (VkDevice device, VkEvent event) const
+{
+ return m_vk.resetEvent(device, event);
+}
+
+VkResult DeviceDriver::createQueryPool (VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool) const
+{
+ return m_vk.createQueryPool(device, pCreateInfo, pQueryPool);
+}
+
+VkResult DeviceDriver::getQueryPoolResults (VkDevice device, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, deUintptr* pDataSize, void* pData, VkQueryResultFlags flags) const
+{
+ return m_vk.getQueryPoolResults(device, queryPool, startQuery, queryCount, pDataSize, pData, flags);
+}
+
+VkResult DeviceDriver::getFormatInfo (VkDevice device, VkFormat format, VkFormatInfoType infoType, deUintptr* pDataSize, void* pData) const
+{
+ return m_vk.getFormatInfo(device, format, infoType, pDataSize, pData);
+}
+
+VkResult DeviceDriver::createBuffer (VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer) const
+{
+ return m_vk.createBuffer(device, pCreateInfo, pBuffer);
+}
+
+VkResult DeviceDriver::createBufferView (VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView) const
+{
+ return m_vk.createBufferView(device, pCreateInfo, pView);
+}
+
+VkResult DeviceDriver::createImage (VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage) const
+{
+ return m_vk.createImage(device, pCreateInfo, pImage);
+}
+
+VkResult DeviceDriver::getImageSubresourceInfo (VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceInfoType infoType, deUintptr* pDataSize, void* pData) const
+{
+ return m_vk.getImageSubresourceInfo(device, image, pSubresource, infoType, pDataSize, pData);
+}
+
+VkResult DeviceDriver::createImageView (VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView) const
+{
+ return m_vk.createImageView(device, pCreateInfo, pView);
+}
+
+VkResult DeviceDriver::createColorAttachmentView (VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo, VkColorAttachmentView* pView) const
+{
+ return m_vk.createColorAttachmentView(device, pCreateInfo, pView);
+}
+
+VkResult DeviceDriver::createDepthStencilView (VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo, VkDepthStencilView* pView) const
+{
+ return m_vk.createDepthStencilView(device, pCreateInfo, pView);
+}
+
+VkResult DeviceDriver::createShader (VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader) const
+{
+ return m_vk.createShader(device, pCreateInfo, pShader);
+}
+
+VkResult DeviceDriver::createGraphicsPipeline (VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) const
+{
+ return m_vk.createGraphicsPipeline(device, pCreateInfo, pPipeline);
+}
+
+VkResult DeviceDriver::createGraphicsPipelineDerivative (VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline basePipeline, VkPipeline* pPipeline) const
+{
+ return m_vk.createGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline);
+}
+
+VkResult DeviceDriver::createComputePipeline (VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) const
+{
+ return m_vk.createComputePipeline(device, pCreateInfo, pPipeline);
+}
+
+VkResult DeviceDriver::storePipeline (VkDevice device, VkPipeline pipeline, deUintptr* pDataSize, void* pData) const
+{
+ return m_vk.storePipeline(device, pipeline, pDataSize, pData);
+}
+
+VkResult DeviceDriver::loadPipeline (VkDevice device, deUintptr dataSize, const void* pData, VkPipeline* pPipeline) const
+{
+ return m_vk.loadPipeline(device, dataSize, pData, pPipeline);
+}
+
+VkResult DeviceDriver::loadPipelineDerivative (VkDevice device, deUintptr dataSize, const void* pData, VkPipeline basePipeline, VkPipeline* pPipeline) const
+{
+ return m_vk.loadPipelineDerivative(device, dataSize, pData, basePipeline, pPipeline);
+}
+
+VkResult DeviceDriver::createPipelineLayout (VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout) const
+{
+ return m_vk.createPipelineLayout(device, pCreateInfo, pPipelineLayout);
+}
+
+VkResult DeviceDriver::createSampler (VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) const
+{
+ return m_vk.createSampler(device, pCreateInfo, pSampler);
+}
+
+VkResult DeviceDriver::createDescriptorSetLayout (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout) const
+{
+ return m_vk.createDescriptorSetLayout(device, pCreateInfo, pSetLayout);
+}
+
+VkResult DeviceDriver::beginDescriptorPoolUpdate (VkDevice device, VkDescriptorUpdateMode updateMode) const
+{
+ return m_vk.beginDescriptorPoolUpdate(device, updateMode);
+}
+
+VkResult DeviceDriver::endDescriptorPoolUpdate (VkDevice device, VkCmdBuffer cmd) const
+{
+ return m_vk.endDescriptorPoolUpdate(device, cmd);
+}
+
+VkResult DeviceDriver::createDescriptorPool (VkDevice device, VkDescriptorPoolUsage poolUsage, deUint32 maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) const
+{
+ return m_vk.createDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool);
+}
+
+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
+{
+ return m_vk.allocDescriptorSets(device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount);
+}
+
+void DeviceDriver::clearDescriptorSets (VkDevice device, VkDescriptorPool descriptorPool, deUint32 count, const VkDescriptorSet* pDescriptorSets) const
+{
+ m_vk.clearDescriptorSets(device, descriptorPool, count, pDescriptorSets);
+}
+
+void DeviceDriver::updateDescriptors (VkDevice device, VkDescriptorSet descriptorSet, deUint32 updateCount, const void** ppUpdateArray) const
+{
+ m_vk.updateDescriptors(device, descriptorSet, updateCount, ppUpdateArray);
+}
+
+VkResult DeviceDriver::createDynamicViewportState (VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpState* pState) const
+{
+ return m_vk.createDynamicViewportState(device, pCreateInfo, pState);
+}
+
+VkResult DeviceDriver::createDynamicRasterState (VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsState* pState) const
+{
+ return m_vk.createDynamicRasterState(device, pCreateInfo, pState);
+}
+
+VkResult DeviceDriver::createDynamicColorBlendState (VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbState* pState) const
+{
+ return m_vk.createDynamicColorBlendState(device, pCreateInfo, pState);
+}
+
+VkResult DeviceDriver::createDynamicDepthStencilState (VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsState* pState) const
+{
+ return m_vk.createDynamicDepthStencilState(device, pCreateInfo, pState);
+}
+
+VkResult DeviceDriver::createCommandBuffer (VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer) const
+{
+ return m_vk.createCommandBuffer(device, pCreateInfo, pCmdBuffer);
+}
+
+VkResult DeviceDriver::beginCommandBuffer (VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) const
+{
+ return m_vk.beginCommandBuffer(cmdBuffer, pBeginInfo);
+}
+
+VkResult DeviceDriver::endCommandBuffer (VkCmdBuffer cmdBuffer) const
+{
+ return m_vk.endCommandBuffer(cmdBuffer);
+}
+
+VkResult DeviceDriver::resetCommandBuffer (VkCmdBuffer cmdBuffer) const
+{
+ return m_vk.resetCommandBuffer(cmdBuffer);
+}
+
+void DeviceDriver::cmdBindPipeline (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) const
+{
+ m_vk.cmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
+}
+
+void DeviceDriver::cmdBindDynamicStateObject (VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject dynamicState) const
+{
+ m_vk.cmdBindDynamicStateObject(cmdBuffer, stateBindPoint, dynamicState);
+}
+
+void DeviceDriver::cmdBindDescriptorSets (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 firstSet, deUint32 setCount, const VkDescriptorSet* pDescriptorSets, deUint32 dynamicOffsetCount, const deUint32* pDynamicOffsets) const
+{
+ m_vk.cmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+}
+
+void DeviceDriver::cmdBindIndexBuffer (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) const
+{
+ m_vk.cmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
+}
+
+void DeviceDriver::cmdBindVertexBuffers (VkCmdBuffer cmdBuffer, deUint32 startBinding, deUint32 bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) const
+{
+ m_vk.cmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
+}
+
+void DeviceDriver::cmdDraw (VkCmdBuffer cmdBuffer, deUint32 firstVertex, deUint32 vertexCount, deUint32 firstInstance, deUint32 instanceCount) const
+{
+ m_vk.cmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount);
+}
+
+void DeviceDriver::cmdDrawIndexed (VkCmdBuffer cmdBuffer, deUint32 firstIndex, deUint32 indexCount, deInt32 vertexOffset, deUint32 firstInstance, deUint32 instanceCount) const
+{
+ m_vk.cmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
+}
+
+void DeviceDriver::cmdDrawIndirect (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 count, deUint32 stride) const
+{
+ m_vk.cmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
+}
+
+void DeviceDriver::cmdDrawIndexedIndirect (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 count, deUint32 stride) const
+{
+ m_vk.cmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
+}
+
+void DeviceDriver::cmdDispatch (VkCmdBuffer cmdBuffer, deUint32 x, deUint32 y, deUint32 z) const
+{
+ m_vk.cmdDispatch(cmdBuffer, x, y, z);
+}
+
+void DeviceDriver::cmdDispatchIndirect (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset) const
+{
+ m_vk.cmdDispatchIndirect(cmdBuffer, buffer, offset);
+}
+
+void DeviceDriver::cmdCopyBuffer (VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, deUint32 regionCount, const VkBufferCopy* pRegions) const
+{
+ m_vk.cmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
+}
+
+void DeviceDriver::cmdCopyImage (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageCopy* pRegions) const
+{
+ m_vk.cmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+}
+
+void DeviceDriver::cmdBlitImage (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageBlit* pRegions) const
+{
+ m_vk.cmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+}
+
+void DeviceDriver::cmdCopyBufferToImage (VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkBufferImageCopy* pRegions) const
+{
+ m_vk.cmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
+}
+
+void DeviceDriver::cmdCopyImageToBuffer (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, deUint32 regionCount, const VkBufferImageCopy* pRegions) const
+{
+ m_vk.cmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
+}
+
+void DeviceDriver::cmdCloneImageData (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout) const
+{
+ m_vk.cmdCloneImageData(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout);
+}
+
+void DeviceDriver::cmdUpdateBuffer (VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const deUint32* pData) const
+{
+ m_vk.cmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
+}
+
+void DeviceDriver::cmdFillBuffer (VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, deUint32 data) const
+{
+ m_vk.cmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
+}
+
+void DeviceDriver::cmdClearColorImage (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, VkClearColor color, deUint32 rangeCount, const VkImageSubresourceRange* pRanges) const
+{
+ m_vk.cmdClearColorImage(cmdBuffer, image, imageLayout, color, rangeCount, pRanges);
+}
+
+void DeviceDriver::cmdClearDepthStencil (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, deUint32 stencil, deUint32 rangeCount, const VkImageSubresourceRange* pRanges) const
+{
+ m_vk.cmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);
+}
+
+void DeviceDriver::cmdResolveImage (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageResolve* pRegions) const
+{
+ m_vk.cmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+}
+
+void DeviceDriver::cmdSetEvent (VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent) const
+{
+ m_vk.cmdSetEvent(cmdBuffer, event, pipeEvent);
+}
+
+void DeviceDriver::cmdResetEvent (VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent) const
+{
+ m_vk.cmdResetEvent(cmdBuffer, event, pipeEvent);
+}
+
+void DeviceDriver::cmdWaitEvents (VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, deUint32 eventCount, const VkEvent* pEvents, deUint32 memBarrierCount, const void** ppMemBarriers) const
+{
+ m_vk.cmdWaitEvents(cmdBuffer, waitEvent, eventCount, pEvents, memBarrierCount, ppMemBarriers);
+}
+
+void DeviceDriver::cmdPipelineBarrier (VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, deUint32 pipeEventCount, const VkPipeEvent* pPipeEvents, deUint32 memBarrierCount, const void** ppMemBarriers) const
+{
+ m_vk.cmdPipelineBarrier(cmdBuffer, waitEvent, pipeEventCount, pPipeEvents, memBarrierCount, ppMemBarriers);
+}
+
+void DeviceDriver::cmdBeginQuery (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 slot, VkQueryControlFlags flags) const
+{
+ m_vk.cmdBeginQuery(cmdBuffer, queryPool, slot, flags);
+}
+
+void DeviceDriver::cmdEndQuery (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 slot) const
+{
+ m_vk.cmdEndQuery(cmdBuffer, queryPool, slot);
+}
+
+void DeviceDriver::cmdResetQueryPool (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount) const
+{
+ m_vk.cmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
+}
+
+void DeviceDriver::cmdWriteTimestamp (VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset) const
+{
+ m_vk.cmdWriteTimestamp(cmdBuffer, timestampType, destBuffer, destOffset);
+}
+
+void DeviceDriver::cmdCopyQueryPoolResults (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags) const
+{
+ m_vk.cmdCopyQueryPoolResults(cmdBuffer, queryPool, startQuery, queryCount, destBuffer, destOffset, destStride, flags);
+}
+
+void DeviceDriver::cmdInitAtomicCounters (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 startCounter, deUint32 counterCount, const deUint32* pData) const
+{
+ m_vk.cmdInitAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, pData);
+}
+
+void DeviceDriver::cmdLoadAtomicCounters (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 startCounter, deUint32 counterCount, VkBuffer srcBuffer, VkDeviceSize srcOffset) const
+{
+ m_vk.cmdLoadAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, srcBuffer, srcOffset);
+}
+
+void DeviceDriver::cmdSaveAtomicCounters (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 startCounter, deUint32 counterCount, VkBuffer destBuffer, VkDeviceSize destOffset) const
+{
+ m_vk.cmdSaveAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, destBuffer, destOffset);
+}
+
+VkResult DeviceDriver::createFramebuffer (VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer) const
+{
+ return m_vk.createFramebuffer(device, pCreateInfo, pFramebuffer);
+}
+
+VkResult DeviceDriver::createRenderPass (VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass) const
+{
+ return m_vk.createRenderPass(device, pCreateInfo, pRenderPass);
+}
+
+void DeviceDriver::cmdBeginRenderPass (VkCmdBuffer cmdBuffer, const VkRenderPassBegin* pRenderPassBegin) const
+{
+ m_vk.cmdBeginRenderPass(cmdBuffer, pRenderPassBegin);
+}
+
+void DeviceDriver::cmdEndRenderPass (VkCmdBuffer cmdBuffer, VkRenderPass renderPass) const
+{
+ m_vk.cmdEndRenderPass(cmdBuffer, renderPass);
+}
--- /dev/null
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * be lost! Modify the generating script instead.
+ */
+GetPhysicalDeviceInfoFunc getPhysicalDeviceInfo;
+CreateDeviceFunc createDevice;
+DestroyDeviceFunc destroyDevice;
+GetGlobalExtensionInfoFunc getGlobalExtensionInfo;
+GetPhysicalDeviceExtensionInfoFunc getPhysicalDeviceExtensionInfo;
+EnumerateLayersFunc enumerateLayers;
+GetDeviceQueueFunc getDeviceQueue;
+QueueSubmitFunc queueSubmit;
+QueueAddMemReferencesFunc queueAddMemReferences;
+QueueRemoveMemReferencesFunc queueRemoveMemReferences;
+QueueWaitIdleFunc queueWaitIdle;
+DeviceWaitIdleFunc deviceWaitIdle;
+AllocMemoryFunc allocMemory;
+FreeMemoryFunc freeMemory;
+SetMemoryPriorityFunc setMemoryPriority;
+MapMemoryFunc mapMemory;
+UnmapMemoryFunc unmapMemory;
+FlushMappedMemoryFunc flushMappedMemory;
+PinSystemMemoryFunc pinSystemMemory;
+GetMultiDeviceCompatibilityFunc getMultiDeviceCompatibility;
+OpenSharedMemoryFunc openSharedMemory;
+OpenSharedSemaphoreFunc openSharedSemaphore;
+OpenPeerMemoryFunc openPeerMemory;
+OpenPeerImageFunc openPeerImage;
+DestroyObjectFunc destroyObject;
+GetObjectInfoFunc getObjectInfo;
+QueueBindObjectMemoryFunc queueBindObjectMemory;
+QueueBindObjectMemoryRangeFunc queueBindObjectMemoryRange;
+QueueBindImageMemoryRangeFunc queueBindImageMemoryRange;
+CreateFenceFunc createFence;
+ResetFencesFunc resetFences;
+GetFenceStatusFunc getFenceStatus;
+WaitForFencesFunc waitForFences;
+CreateSemaphoreFunc createSemaphore;
+QueueSignalSemaphoreFunc queueSignalSemaphore;
+QueueWaitSemaphoreFunc queueWaitSemaphore;
+CreateEventFunc createEvent;
+GetEventStatusFunc getEventStatus;
+SetEventFunc setEvent;
+ResetEventFunc resetEvent;
+CreateQueryPoolFunc createQueryPool;
+GetQueryPoolResultsFunc getQueryPoolResults;
+GetFormatInfoFunc getFormatInfo;
+CreateBufferFunc createBuffer;
+CreateBufferViewFunc createBufferView;
+CreateImageFunc createImage;
+GetImageSubresourceInfoFunc getImageSubresourceInfo;
+CreateImageViewFunc createImageView;
+CreateColorAttachmentViewFunc createColorAttachmentView;
+CreateDepthStencilViewFunc createDepthStencilView;
+CreateShaderFunc createShader;
+CreateGraphicsPipelineFunc createGraphicsPipeline;
+CreateGraphicsPipelineDerivativeFunc createGraphicsPipelineDerivative;
+CreateComputePipelineFunc createComputePipeline;
+StorePipelineFunc storePipeline;
+LoadPipelineFunc loadPipeline;
+LoadPipelineDerivativeFunc loadPipelineDerivative;
+CreatePipelineLayoutFunc createPipelineLayout;
+CreateSamplerFunc createSampler;
+CreateDescriptorSetLayoutFunc createDescriptorSetLayout;
+BeginDescriptorPoolUpdateFunc beginDescriptorPoolUpdate;
+EndDescriptorPoolUpdateFunc endDescriptorPoolUpdate;
+CreateDescriptorPoolFunc createDescriptorPool;
+ResetDescriptorPoolFunc resetDescriptorPool;
+AllocDescriptorSetsFunc allocDescriptorSets;
+ClearDescriptorSetsFunc clearDescriptorSets;
+UpdateDescriptorsFunc updateDescriptors;
+CreateDynamicViewportStateFunc createDynamicViewportState;
+CreateDynamicRasterStateFunc createDynamicRasterState;
+CreateDynamicColorBlendStateFunc createDynamicColorBlendState;
+CreateDynamicDepthStencilStateFunc createDynamicDepthStencilState;
+CreateCommandBufferFunc createCommandBuffer;
+BeginCommandBufferFunc beginCommandBuffer;
+EndCommandBufferFunc endCommandBuffer;
+ResetCommandBufferFunc resetCommandBuffer;
+CmdBindPipelineFunc cmdBindPipeline;
+CmdBindDynamicStateObjectFunc cmdBindDynamicStateObject;
+CmdBindDescriptorSetsFunc cmdBindDescriptorSets;
+CmdBindIndexBufferFunc cmdBindIndexBuffer;
+CmdBindVertexBuffersFunc cmdBindVertexBuffers;
+CmdDrawFunc cmdDraw;
+CmdDrawIndexedFunc cmdDrawIndexed;
+CmdDrawIndirectFunc cmdDrawIndirect;
+CmdDrawIndexedIndirectFunc cmdDrawIndexedIndirect;
+CmdDispatchFunc cmdDispatch;
+CmdDispatchIndirectFunc cmdDispatchIndirect;
+CmdCopyBufferFunc cmdCopyBuffer;
+CmdCopyImageFunc cmdCopyImage;
+CmdBlitImageFunc cmdBlitImage;
+CmdCopyBufferToImageFunc cmdCopyBufferToImage;
+CmdCopyImageToBufferFunc cmdCopyImageToBuffer;
+CmdCloneImageDataFunc cmdCloneImageData;
+CmdUpdateBufferFunc cmdUpdateBuffer;
+CmdFillBufferFunc cmdFillBuffer;
+CmdClearColorImageFunc cmdClearColorImage;
+CmdClearDepthStencilFunc cmdClearDepthStencil;
+CmdResolveImageFunc cmdResolveImage;
+CmdSetEventFunc cmdSetEvent;
+CmdResetEventFunc cmdResetEvent;
+CmdWaitEventsFunc cmdWaitEvents;
+CmdPipelineBarrierFunc cmdPipelineBarrier;
+CmdBeginQueryFunc cmdBeginQuery;
+CmdEndQueryFunc cmdEndQuery;
+CmdResetQueryPoolFunc cmdResetQueryPool;
+CmdWriteTimestampFunc cmdWriteTimestamp;
+CmdCopyQueryPoolResultsFunc cmdCopyQueryPoolResults;
+CmdInitAtomicCountersFunc cmdInitAtomicCounters;
+CmdLoadAtomicCountersFunc cmdLoadAtomicCounters;
+CmdSaveAtomicCountersFunc cmdSaveAtomicCounters;
+CreateFramebufferFunc createFramebuffer;
+CreateRenderPassFunc createRenderPass;
+CmdBeginRenderPassFunc cmdBeginRenderPass;
+CmdEndRenderPassFunc cmdEndRenderPass;
--- /dev/null
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * 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 VkResult (VK_APIENTRY* EnumeratePhysicalDevicesFunc) (VkInstance instance, deUint32* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetPhysicalDeviceInfoFunc) (VkPhysicalDevice physicalDevice, VkPhysicalDeviceInfoType infoType, deUintptr* pDataSize, void* pData);
+typedef VK_APICALL FunctionPtr (VK_APIENTRY* GetProcAddrFunc) (VkPhysicalDevice physicalDevice, 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* GetGlobalExtensionInfoFunc) (VkExtensionInfoType infoType, deUint32 extensionIndex, deUintptr* pDataSize, void* pData);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetPhysicalDeviceExtensionInfoFunc) (VkPhysicalDevice physicalDevice, VkExtensionInfoType infoType, deUint32 extensionIndex, deUintptr* pDataSize, void* pData);
+typedef VK_APICALL VkResult (VK_APIENTRY* EnumerateLayersFunc) (VkPhysicalDevice physicalDevice, deUintptr maxStringSize, deUintptr* pLayerCount, char* const* pOutLayers, void* pReserved);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetDeviceQueueFunc) (VkDevice device, deUint32 queueNodeIndex, 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* QueueAddMemReferencesFunc) (VkQueue queue, deUint32 count, const VkDeviceMemory* pMems);
+typedef VK_APICALL VkResult (VK_APIENTRY* QueueRemoveMemReferencesFunc) (VkQueue queue, deUint32 count, const VkDeviceMemory* pMems);
+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 VkResult (VK_APIENTRY* SetMemoryPriorityFunc) (VkDevice device, VkDeviceMemory mem, VkMemoryPriority priority);
+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 VkResult (VK_APIENTRY* FlushMappedMemoryFunc) (VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size);
+typedef VK_APICALL VkResult (VK_APIENTRY* PinSystemMemoryFunc) (VkDevice device, const void* pSysMem, deUintptr memSize, VkDeviceMemory* pMem);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetMultiDeviceCompatibilityFunc) (VkPhysicalDevice physicalDevice0, VkPhysicalDevice physicalDevice1, VkPhysicalDeviceCompatibilityInfo* pInfo);
+typedef VK_APICALL VkResult (VK_APIENTRY* OpenSharedMemoryFunc) (VkDevice device, const VkMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem);
+typedef VK_APICALL VkResult (VK_APIENTRY* OpenSharedSemaphoreFunc) (VkDevice device, const VkSemaphoreOpenInfo* pOpenInfo, VkSemaphore* pSemaphore);
+typedef VK_APICALL VkResult (VK_APIENTRY* OpenPeerMemoryFunc) (VkDevice device, const VkPeerMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem);
+typedef VK_APICALL VkResult (VK_APIENTRY* OpenPeerImageFunc) (VkDevice device, const VkPeerImageOpenInfo* pOpenInfo, VkImage* pImage, VkDeviceMemory* pMem);
+typedef VK_APICALL VkResult (VK_APIENTRY* DestroyObjectFunc) (VkDevice device, VkObjectType objType, VkObject object);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetObjectInfoFunc) (VkDevice device, VkObjectType objType, VkObject object, VkObjectInfoType infoType, deUintptr* pDataSize, void* pData);
+typedef VK_APICALL VkResult (VK_APIENTRY* QueueBindObjectMemoryFunc) (VkQueue queue, VkObjectType objType, VkObject object, deUint32 allocationIdx, VkDeviceMemory mem, VkDeviceSize memOffset);
+typedef VK_APICALL VkResult (VK_APIENTRY* QueueBindObjectMemoryRangeFunc) (VkQueue queue, VkObjectType objType, VkObject object, deUint32 allocationIdx, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset);
+typedef VK_APICALL VkResult (VK_APIENTRY* QueueBindImageMemoryRangeFunc) (VkQueue queue, VkImage image, deUint32 allocationIdx, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateFenceFunc) (VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence);
+typedef VK_APICALL VkResult (VK_APIENTRY* ResetFencesFunc) (VkDevice device, deUint32 fenceCount, 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, deUint32 waitAll, deUint64 timeout);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateSemaphoreFunc) (VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore);
+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* 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* GetQueryPoolResultsFunc) (VkDevice device, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, deUintptr* pDataSize, void* pData, VkQueryResultFlags flags);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetFormatInfoFunc) (VkDevice device, VkFormat format, VkFormatInfoType infoType, deUintptr* pDataSize, void* pData);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateBufferFunc) (VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateBufferViewFunc) (VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateImageFunc) (VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetImageSubresourceInfoFunc) (VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceInfoType infoType, deUintptr* pDataSize, void* pData);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateImageViewFunc) (VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateColorAttachmentViewFunc) (VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo, VkColorAttachmentView* pView);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateDepthStencilViewFunc) (VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo, VkDepthStencilView* pView);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateShaderFunc) (VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateGraphicsPipelineFunc) (VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateGraphicsPipelineDerivativeFunc) (VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline basePipeline, VkPipeline* pPipeline);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateComputePipelineFunc) (VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline);
+typedef VK_APICALL VkResult (VK_APIENTRY* StorePipelineFunc) (VkDevice device, VkPipeline pipeline, deUintptr* pDataSize, void* pData);
+typedef VK_APICALL VkResult (VK_APIENTRY* LoadPipelineFunc) (VkDevice device, deUintptr dataSize, const void* pData, VkPipeline* pPipeline);
+typedef VK_APICALL VkResult (VK_APIENTRY* LoadPipelineDerivativeFunc) (VkDevice device, deUintptr dataSize, const void* pData, VkPipeline basePipeline, VkPipeline* pPipeline);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreatePipelineLayoutFunc) (VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateSamplerFunc) (VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateDescriptorSetLayoutFunc) (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout);
+typedef VK_APICALL VkResult (VK_APIENTRY* BeginDescriptorPoolUpdateFunc) (VkDevice device, VkDescriptorUpdateMode updateMode);
+typedef VK_APICALL VkResult (VK_APIENTRY* EndDescriptorPoolUpdateFunc) (VkDevice device, VkCmdBuffer cmd);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateDescriptorPoolFunc) (VkDevice device, VkDescriptorPoolUsage poolUsage, deUint32 maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool);
+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 void (VK_APIENTRY* ClearDescriptorSetsFunc) (VkDevice device, VkDescriptorPool descriptorPool, deUint32 count, const VkDescriptorSet* pDescriptorSets);
+typedef VK_APICALL void (VK_APIENTRY* UpdateDescriptorsFunc) (VkDevice device, VkDescriptorSet descriptorSet, deUint32 updateCount, const void** ppUpdateArray);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateDynamicViewportStateFunc) (VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpState* pState);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateDynamicRasterStateFunc) (VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsState* pState);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateDynamicColorBlendStateFunc) (VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbState* pState);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateDynamicDepthStencilStateFunc) (VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsState* pState);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateCommandBufferFunc) (VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer);
+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);
+typedef VK_APICALL void (VK_APIENTRY* CmdBindPipelineFunc) (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
+typedef VK_APICALL void (VK_APIENTRY* CmdBindDynamicStateObjectFunc) (VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject dynamicState);
+typedef VK_APICALL void (VK_APIENTRY* CmdBindDescriptorSetsFunc) (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, 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* 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* CmdDispatchIndirectFunc) (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset);
+typedef VK_APICALL void (VK_APIENTRY* CmdCopyBufferFunc) (VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, deUint32 regionCount, const VkBufferCopy* pRegions);
+typedef VK_APICALL void (VK_APIENTRY* CmdCopyImageFunc) (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageCopy* pRegions);
+typedef VK_APICALL void (VK_APIENTRY* CmdBlitImageFunc) (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageBlit* pRegions);
+typedef VK_APICALL void (VK_APIENTRY* CmdCopyBufferToImageFunc) (VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkBufferImageCopy* pRegions);
+typedef VK_APICALL void (VK_APIENTRY* CmdCopyImageToBufferFunc) (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, deUint32 regionCount, const VkBufferImageCopy* pRegions);
+typedef VK_APICALL void (VK_APIENTRY* CmdCloneImageDataFunc) (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout);
+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, VkClearColor color, deUint32 rangeCount, const VkImageSubresourceRange* pRanges);
+typedef VK_APICALL void (VK_APIENTRY* CmdClearDepthStencilFunc) (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, deUint32 stencil, deUint32 rangeCount, const VkImageSubresourceRange* pRanges);
+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, VkPipeEvent pipeEvent);
+typedef VK_APICALL void (VK_APIENTRY* CmdResetEventFunc) (VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent);
+typedef VK_APICALL void (VK_APIENTRY* CmdWaitEventsFunc) (VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, deUint32 eventCount, const VkEvent* pEvents, deUint32 memBarrierCount, const void** ppMemBarriers);
+typedef VK_APICALL void (VK_APIENTRY* CmdPipelineBarrierFunc) (VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, deUint32 pipeEventCount, const VkPipeEvent* pPipeEvents, deUint32 memBarrierCount, const void** ppMemBarriers);
+typedef VK_APICALL void (VK_APIENTRY* CmdBeginQueryFunc) (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 slot, VkQueryControlFlags flags);
+typedef VK_APICALL void (VK_APIENTRY* CmdEndQueryFunc) (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 slot);
+typedef VK_APICALL void (VK_APIENTRY* CmdResetQueryPoolFunc) (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount);
+typedef VK_APICALL void (VK_APIENTRY* CmdWriteTimestampFunc) (VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset);
+typedef VK_APICALL void (VK_APIENTRY* CmdCopyQueryPoolResultsFunc) (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags);
+typedef VK_APICALL void (VK_APIENTRY* CmdInitAtomicCountersFunc) (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 startCounter, deUint32 counterCount, const deUint32* pData);
+typedef VK_APICALL void (VK_APIENTRY* CmdLoadAtomicCountersFunc) (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 startCounter, deUint32 counterCount, VkBuffer srcBuffer, VkDeviceSize srcOffset);
+typedef VK_APICALL void (VK_APIENTRY* CmdSaveAtomicCountersFunc) (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 startCounter, deUint32 counterCount, VkBuffer destBuffer, VkDeviceSize destOffset);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateFramebufferFunc) (VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateRenderPassFunc) (VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass);
+typedef VK_APICALL void (VK_APIENTRY* CmdBeginRenderPassFunc) (VkCmdBuffer cmdBuffer, const VkRenderPassBegin* pRenderPassBegin);
+typedef VK_APICALL void (VK_APIENTRY* CmdEndRenderPassFunc) (VkCmdBuffer cmdBuffer, VkRenderPass renderPass);
--- /dev/null
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * be lost! Modify the generating script instead.
+ */
+template<> VkObjectType getObjectType<VkInstanceT> (void) { return VK_OBJECT_TYPE_INSTANCE; }
+template<> VkObjectType getObjectType<VkPhysicalDeviceT> (void) { return VK_OBJECT_TYPE_PHYSICAL_DEVICE; }
+template<> VkObjectType getObjectType<VkDeviceT> (void) { return VK_OBJECT_TYPE_DEVICE; }
+template<> VkObjectType getObjectType<VkQueueT> (void) { return VK_OBJECT_TYPE_QUEUE; }
+template<> VkObjectType getObjectType<VkCmdBufferT> (void) { return VK_OBJECT_TYPE_COMMAND_BUFFER; }
+template<> VkObjectType getObjectType<VkDeviceMemoryT> (void) { return VK_OBJECT_TYPE_DEVICE_MEMORY; }
+template<> VkObjectType getObjectType<VkBufferT> (void) { return VK_OBJECT_TYPE_BUFFER; }
+template<> VkObjectType getObjectType<VkBufferViewT> (void) { return VK_OBJECT_TYPE_BUFFER_VIEW; }
+template<> VkObjectType getObjectType<VkImageT> (void) { return VK_OBJECT_TYPE_IMAGE; }
+template<> VkObjectType getObjectType<VkImageViewT> (void) { return VK_OBJECT_TYPE_IMAGE_VIEW; }
+template<> VkObjectType getObjectType<VkColorAttachmentViewT> (void) { return VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW; }
+template<> VkObjectType getObjectType<VkDepthStencilViewT> (void) { return VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW; }
+template<> VkObjectType getObjectType<VkShaderT> (void) { return VK_OBJECT_TYPE_SHADER; }
+template<> VkObjectType getObjectType<VkPipelineT> (void) { return VK_OBJECT_TYPE_PIPELINE; }
+template<> VkObjectType getObjectType<VkPipelineLayoutT> (void) { return VK_OBJECT_TYPE_PIPELINE_LAYOUT; }
+template<> VkObjectType getObjectType<VkSamplerT> (void) { return VK_OBJECT_TYPE_SAMPLER; }
+template<> VkObjectType getObjectType<VkDescriptorSetT> (void) { return VK_OBJECT_TYPE_DESCRIPTOR_SET; }
+template<> VkObjectType getObjectType<VkDescriptorSetLayoutT> (void) { return VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT; }
+template<> VkObjectType getObjectType<VkDescriptorPoolT> (void) { return VK_OBJECT_TYPE_DESCRIPTOR_POOL; }
+template<> VkObjectType getObjectType<VkDynamicVpStateT> (void) { return VK_OBJECT_TYPE_DYNAMIC_VP_STATE; }
+template<> VkObjectType getObjectType<VkDynamicRsStateT> (void) { return VK_OBJECT_TYPE_DYNAMIC_RS_STATE; }
+template<> VkObjectType getObjectType<VkDynamicCbStateT> (void) { return VK_OBJECT_TYPE_DYNAMIC_CB_STATE; }
+template<> VkObjectType getObjectType<VkDynamicDsStateT> (void) { return VK_OBJECT_TYPE_DYNAMIC_DS_STATE; }
+template<> VkObjectType getObjectType<VkFenceT> (void) { return VK_OBJECT_TYPE_FENCE; }
+template<> VkObjectType getObjectType<VkSemaphoreT> (void) { return VK_OBJECT_TYPE_SEMAPHORE; }
+template<> VkObjectType getObjectType<VkEventT> (void) { return VK_OBJECT_TYPE_EVENT; }
+template<> VkObjectType getObjectType<VkQueryPoolT> (void) { return VK_OBJECT_TYPE_QUERY_POOL; }
+template<> VkObjectType getObjectType<VkFramebufferT> (void) { return VK_OBJECT_TYPE_FRAMEBUFFER; }
+template<> VkObjectType getObjectType<VkRenderPassT> (void) { return VK_OBJECT_TYPE_RENDER_PASS; }
--- /dev/null
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * be lost! Modify the generating script instead.
+ */
+m_vk.getPhysicalDeviceInfo = (GetPhysicalDeviceInfoFunc) GET_PROC_ADDR("vkGetPhysicalDeviceInfo");
+m_vk.createDevice = (CreateDeviceFunc) GET_PROC_ADDR("vkCreateDevice");
+m_vk.destroyDevice = (DestroyDeviceFunc) GET_PROC_ADDR("vkDestroyDevice");
+m_vk.getGlobalExtensionInfo = (GetGlobalExtensionInfoFunc) GET_PROC_ADDR("vkGetGlobalExtensionInfo");
+m_vk.getPhysicalDeviceExtensionInfo = (GetPhysicalDeviceExtensionInfoFunc) GET_PROC_ADDR("vkGetPhysicalDeviceExtensionInfo");
+m_vk.enumerateLayers = (EnumerateLayersFunc) GET_PROC_ADDR("vkEnumerateLayers");
+m_vk.getDeviceQueue = (GetDeviceQueueFunc) GET_PROC_ADDR("vkGetDeviceQueue");
+m_vk.queueSubmit = (QueueSubmitFunc) GET_PROC_ADDR("vkQueueSubmit");
+m_vk.queueAddMemReferences = (QueueAddMemReferencesFunc) GET_PROC_ADDR("vkQueueAddMemReferences");
+m_vk.queueRemoveMemReferences = (QueueRemoveMemReferencesFunc) GET_PROC_ADDR("vkQueueRemoveMemReferences");
+m_vk.queueWaitIdle = (QueueWaitIdleFunc) GET_PROC_ADDR("vkQueueWaitIdle");
+m_vk.deviceWaitIdle = (DeviceWaitIdleFunc) GET_PROC_ADDR("vkDeviceWaitIdle");
+m_vk.allocMemory = (AllocMemoryFunc) GET_PROC_ADDR("vkAllocMemory");
+m_vk.freeMemory = (FreeMemoryFunc) GET_PROC_ADDR("vkFreeMemory");
+m_vk.setMemoryPriority = (SetMemoryPriorityFunc) GET_PROC_ADDR("vkSetMemoryPriority");
+m_vk.mapMemory = (MapMemoryFunc) GET_PROC_ADDR("vkMapMemory");
+m_vk.unmapMemory = (UnmapMemoryFunc) GET_PROC_ADDR("vkUnmapMemory");
+m_vk.flushMappedMemory = (FlushMappedMemoryFunc) GET_PROC_ADDR("vkFlushMappedMemory");
+m_vk.pinSystemMemory = (PinSystemMemoryFunc) GET_PROC_ADDR("vkPinSystemMemory");
+m_vk.getMultiDeviceCompatibility = (GetMultiDeviceCompatibilityFunc) GET_PROC_ADDR("vkGetMultiDeviceCompatibility");
+m_vk.openSharedMemory = (OpenSharedMemoryFunc) GET_PROC_ADDR("vkOpenSharedMemory");
+m_vk.openSharedSemaphore = (OpenSharedSemaphoreFunc) GET_PROC_ADDR("vkOpenSharedSemaphore");
+m_vk.openPeerMemory = (OpenPeerMemoryFunc) GET_PROC_ADDR("vkOpenPeerMemory");
+m_vk.openPeerImage = (OpenPeerImageFunc) GET_PROC_ADDR("vkOpenPeerImage");
+m_vk.destroyObject = (DestroyObjectFunc) GET_PROC_ADDR("vkDestroyObject");
+m_vk.getObjectInfo = (GetObjectInfoFunc) GET_PROC_ADDR("vkGetObjectInfo");
+m_vk.queueBindObjectMemory = (QueueBindObjectMemoryFunc) GET_PROC_ADDR("vkQueueBindObjectMemory");
+m_vk.queueBindObjectMemoryRange = (QueueBindObjectMemoryRangeFunc) GET_PROC_ADDR("vkQueueBindObjectMemoryRange");
+m_vk.queueBindImageMemoryRange = (QueueBindImageMemoryRangeFunc) GET_PROC_ADDR("vkQueueBindImageMemoryRange");
+m_vk.createFence = (CreateFenceFunc) GET_PROC_ADDR("vkCreateFence");
+m_vk.resetFences = (ResetFencesFunc) GET_PROC_ADDR("vkResetFences");
+m_vk.getFenceStatus = (GetFenceStatusFunc) GET_PROC_ADDR("vkGetFenceStatus");
+m_vk.waitForFences = (WaitForFencesFunc) GET_PROC_ADDR("vkWaitForFences");
+m_vk.createSemaphore = (CreateSemaphoreFunc) GET_PROC_ADDR("vkCreateSemaphore");
+m_vk.queueSignalSemaphore = (QueueSignalSemaphoreFunc) GET_PROC_ADDR("vkQueueSignalSemaphore");
+m_vk.queueWaitSemaphore = (QueueWaitSemaphoreFunc) GET_PROC_ADDR("vkQueueWaitSemaphore");
+m_vk.createEvent = (CreateEventFunc) GET_PROC_ADDR("vkCreateEvent");
+m_vk.getEventStatus = (GetEventStatusFunc) GET_PROC_ADDR("vkGetEventStatus");
+m_vk.setEvent = (SetEventFunc) GET_PROC_ADDR("vkSetEvent");
+m_vk.resetEvent = (ResetEventFunc) GET_PROC_ADDR("vkResetEvent");
+m_vk.createQueryPool = (CreateQueryPoolFunc) GET_PROC_ADDR("vkCreateQueryPool");
+m_vk.getQueryPoolResults = (GetQueryPoolResultsFunc) GET_PROC_ADDR("vkGetQueryPoolResults");
+m_vk.getFormatInfo = (GetFormatInfoFunc) GET_PROC_ADDR("vkGetFormatInfo");
+m_vk.createBuffer = (CreateBufferFunc) GET_PROC_ADDR("vkCreateBuffer");
+m_vk.createBufferView = (CreateBufferViewFunc) GET_PROC_ADDR("vkCreateBufferView");
+m_vk.createImage = (CreateImageFunc) GET_PROC_ADDR("vkCreateImage");
+m_vk.getImageSubresourceInfo = (GetImageSubresourceInfoFunc) GET_PROC_ADDR("vkGetImageSubresourceInfo");
+m_vk.createImageView = (CreateImageViewFunc) GET_PROC_ADDR("vkCreateImageView");
+m_vk.createColorAttachmentView = (CreateColorAttachmentViewFunc) GET_PROC_ADDR("vkCreateColorAttachmentView");
+m_vk.createDepthStencilView = (CreateDepthStencilViewFunc) GET_PROC_ADDR("vkCreateDepthStencilView");
+m_vk.createShader = (CreateShaderFunc) GET_PROC_ADDR("vkCreateShader");
+m_vk.createGraphicsPipeline = (CreateGraphicsPipelineFunc) GET_PROC_ADDR("vkCreateGraphicsPipeline");
+m_vk.createGraphicsPipelineDerivative = (CreateGraphicsPipelineDerivativeFunc) GET_PROC_ADDR("vkCreateGraphicsPipelineDerivative");
+m_vk.createComputePipeline = (CreateComputePipelineFunc) GET_PROC_ADDR("vkCreateComputePipeline");
+m_vk.storePipeline = (StorePipelineFunc) GET_PROC_ADDR("vkStorePipeline");
+m_vk.loadPipeline = (LoadPipelineFunc) GET_PROC_ADDR("vkLoadPipeline");
+m_vk.loadPipelineDerivative = (LoadPipelineDerivativeFunc) GET_PROC_ADDR("vkLoadPipelineDerivative");
+m_vk.createPipelineLayout = (CreatePipelineLayoutFunc) GET_PROC_ADDR("vkCreatePipelineLayout");
+m_vk.createSampler = (CreateSamplerFunc) GET_PROC_ADDR("vkCreateSampler");
+m_vk.createDescriptorSetLayout = (CreateDescriptorSetLayoutFunc) GET_PROC_ADDR("vkCreateDescriptorSetLayout");
+m_vk.beginDescriptorPoolUpdate = (BeginDescriptorPoolUpdateFunc) GET_PROC_ADDR("vkBeginDescriptorPoolUpdate");
+m_vk.endDescriptorPoolUpdate = (EndDescriptorPoolUpdateFunc) GET_PROC_ADDR("vkEndDescriptorPoolUpdate");
+m_vk.createDescriptorPool = (CreateDescriptorPoolFunc) GET_PROC_ADDR("vkCreateDescriptorPool");
+m_vk.resetDescriptorPool = (ResetDescriptorPoolFunc) GET_PROC_ADDR("vkResetDescriptorPool");
+m_vk.allocDescriptorSets = (AllocDescriptorSetsFunc) GET_PROC_ADDR("vkAllocDescriptorSets");
+m_vk.clearDescriptorSets = (ClearDescriptorSetsFunc) GET_PROC_ADDR("vkClearDescriptorSets");
+m_vk.updateDescriptors = (UpdateDescriptorsFunc) GET_PROC_ADDR("vkUpdateDescriptors");
+m_vk.createDynamicViewportState = (CreateDynamicViewportStateFunc) GET_PROC_ADDR("vkCreateDynamicViewportState");
+m_vk.createDynamicRasterState = (CreateDynamicRasterStateFunc) GET_PROC_ADDR("vkCreateDynamicRasterState");
+m_vk.createDynamicColorBlendState = (CreateDynamicColorBlendStateFunc) GET_PROC_ADDR("vkCreateDynamicColorBlendState");
+m_vk.createDynamicDepthStencilState = (CreateDynamicDepthStencilStateFunc) GET_PROC_ADDR("vkCreateDynamicDepthStencilState");
+m_vk.createCommandBuffer = (CreateCommandBufferFunc) GET_PROC_ADDR("vkCreateCommandBuffer");
+m_vk.beginCommandBuffer = (BeginCommandBufferFunc) GET_PROC_ADDR("vkBeginCommandBuffer");
+m_vk.endCommandBuffer = (EndCommandBufferFunc) GET_PROC_ADDR("vkEndCommandBuffer");
+m_vk.resetCommandBuffer = (ResetCommandBufferFunc) GET_PROC_ADDR("vkResetCommandBuffer");
+m_vk.cmdBindPipeline = (CmdBindPipelineFunc) GET_PROC_ADDR("vkCmdBindPipeline");
+m_vk.cmdBindDynamicStateObject = (CmdBindDynamicStateObjectFunc) GET_PROC_ADDR("vkCmdBindDynamicStateObject");
+m_vk.cmdBindDescriptorSets = (CmdBindDescriptorSetsFunc) GET_PROC_ADDR("vkCmdBindDescriptorSets");
+m_vk.cmdBindIndexBuffer = (CmdBindIndexBufferFunc) GET_PROC_ADDR("vkCmdBindIndexBuffer");
+m_vk.cmdBindVertexBuffers = (CmdBindVertexBuffersFunc) GET_PROC_ADDR("vkCmdBindVertexBuffers");
+m_vk.cmdDraw = (CmdDrawFunc) GET_PROC_ADDR("vkCmdDraw");
+m_vk.cmdDrawIndexed = (CmdDrawIndexedFunc) GET_PROC_ADDR("vkCmdDrawIndexed");
+m_vk.cmdDrawIndirect = (CmdDrawIndirectFunc) GET_PROC_ADDR("vkCmdDrawIndirect");
+m_vk.cmdDrawIndexedIndirect = (CmdDrawIndexedIndirectFunc) GET_PROC_ADDR("vkCmdDrawIndexedIndirect");
+m_vk.cmdDispatch = (CmdDispatchFunc) GET_PROC_ADDR("vkCmdDispatch");
+m_vk.cmdDispatchIndirect = (CmdDispatchIndirectFunc) GET_PROC_ADDR("vkCmdDispatchIndirect");
+m_vk.cmdCopyBuffer = (CmdCopyBufferFunc) GET_PROC_ADDR("vkCmdCopyBuffer");
+m_vk.cmdCopyImage = (CmdCopyImageFunc) GET_PROC_ADDR("vkCmdCopyImage");
+m_vk.cmdBlitImage = (CmdBlitImageFunc) GET_PROC_ADDR("vkCmdBlitImage");
+m_vk.cmdCopyBufferToImage = (CmdCopyBufferToImageFunc) GET_PROC_ADDR("vkCmdCopyBufferToImage");
+m_vk.cmdCopyImageToBuffer = (CmdCopyImageToBufferFunc) GET_PROC_ADDR("vkCmdCopyImageToBuffer");
+m_vk.cmdCloneImageData = (CmdCloneImageDataFunc) GET_PROC_ADDR("vkCmdCloneImageData");
+m_vk.cmdUpdateBuffer = (CmdUpdateBufferFunc) GET_PROC_ADDR("vkCmdUpdateBuffer");
+m_vk.cmdFillBuffer = (CmdFillBufferFunc) GET_PROC_ADDR("vkCmdFillBuffer");
+m_vk.cmdClearColorImage = (CmdClearColorImageFunc) GET_PROC_ADDR("vkCmdClearColorImage");
+m_vk.cmdClearDepthStencil = (CmdClearDepthStencilFunc) GET_PROC_ADDR("vkCmdClearDepthStencil");
+m_vk.cmdResolveImage = (CmdResolveImageFunc) GET_PROC_ADDR("vkCmdResolveImage");
+m_vk.cmdSetEvent = (CmdSetEventFunc) GET_PROC_ADDR("vkCmdSetEvent");
+m_vk.cmdResetEvent = (CmdResetEventFunc) GET_PROC_ADDR("vkCmdResetEvent");
+m_vk.cmdWaitEvents = (CmdWaitEventsFunc) GET_PROC_ADDR("vkCmdWaitEvents");
+m_vk.cmdPipelineBarrier = (CmdPipelineBarrierFunc) GET_PROC_ADDR("vkCmdPipelineBarrier");
+m_vk.cmdBeginQuery = (CmdBeginQueryFunc) GET_PROC_ADDR("vkCmdBeginQuery");
+m_vk.cmdEndQuery = (CmdEndQueryFunc) GET_PROC_ADDR("vkCmdEndQuery");
+m_vk.cmdResetQueryPool = (CmdResetQueryPoolFunc) GET_PROC_ADDR("vkCmdResetQueryPool");
+m_vk.cmdWriteTimestamp = (CmdWriteTimestampFunc) GET_PROC_ADDR("vkCmdWriteTimestamp");
+m_vk.cmdCopyQueryPoolResults = (CmdCopyQueryPoolResultsFunc) GET_PROC_ADDR("vkCmdCopyQueryPoolResults");
+m_vk.cmdInitAtomicCounters = (CmdInitAtomicCountersFunc) GET_PROC_ADDR("vkCmdInitAtomicCounters");
+m_vk.cmdLoadAtomicCounters = (CmdLoadAtomicCountersFunc) GET_PROC_ADDR("vkCmdLoadAtomicCounters");
+m_vk.cmdSaveAtomicCounters = (CmdSaveAtomicCountersFunc) GET_PROC_ADDR("vkCmdSaveAtomicCounters");
+m_vk.createFramebuffer = (CreateFramebufferFunc) GET_PROC_ADDR("vkCreateFramebuffer");
+m_vk.createRenderPass = (CreateRenderPassFunc) GET_PROC_ADDR("vkCreateRenderPass");
+m_vk.cmdBeginRenderPass = (CmdBeginRenderPassFunc) GET_PROC_ADDR("vkCmdBeginRenderPass");
+m_vk.cmdEndRenderPass = (CmdEndRenderPassFunc) GET_PROC_ADDR("vkCmdEndRenderPass");
--- /dev/null
+/* 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.destroyInstance = (DestroyInstanceFunc) GET_PROC_ADDR("vkDestroyInstance");
+m_vk.enumeratePhysicalDevices = (EnumeratePhysicalDevicesFunc) GET_PROC_ADDR("vkEnumeratePhysicalDevices");
--- /dev/null
+/*-------------------------------------------------------------------------
+ * drawElements Quality Program Vulkan Utilities
+ * -----------------------------------------------
+ *
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Vulkan platform abstraction.
+ *//*--------------------------------------------------------------------*/
+
+#include "vkPlatform.hpp"
+
+namespace vk
+{
+
+PlatformDriver::PlatformDriver (GetProcAddrFunc getProc)
+{
+ m_vk.getProcAddr = getProc;
+
+#define GET_PROC_ADDR(NAME) getProc(DE_NULL, NAME)
+#include "vkInitPlatformFunctionPointers.inl"
+#undef GET_PROC_ADDR
+}
+
+PlatformDriver::~PlatformDriver (void)
+{
+}
+
+DeviceDriver::DeviceDriver (const PlatformInterface& platformInterface, VkPhysicalDevice device)
+{
+#define GET_PROC_ADDR(NAME) platformInterface.getProcAddr(device, NAME)
+#include "vkInitDeviceFunctionPointers.inl"
+#undef GET_PROC_ADDR
+}
+
+DeviceDriver::~DeviceDriver (void)
+{
+}
+
+#include "vkPlatformDriverImpl.inl"
+#include "vkDeviceDriverImpl.inl"
+
+} // vk
--- /dev/null
+#ifndef _VKPLATFORM_HPP
+#define _VKPLATFORM_HPP
+/*-------------------------------------------------------------------------
+ * drawElements Quality Program Vulkan Utilities
+ * -----------------------------------------------
+ *
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Vulkan platform abstraction.
+ *//*--------------------------------------------------------------------*/
+
+#include "vkDefs.hpp"
+#include "tcuFunctionLibrary.hpp"
+
+namespace vk
+{
+
+class Library
+{
+public:
+ Library (void) {}
+ virtual ~Library (void) {}
+
+ virtual const PlatformInterface& getPlatformInterface (void) const = 0;
+};
+
+DE_BEGIN_EXTERN_C
+
+#include "vkFunctionPointerTypes.inl"
+
+DE_END_EXTERN_C
+
+class PlatformDriver : public PlatformInterface
+{
+public:
+ PlatformDriver (GetProcAddrFunc getProc);
+ ~PlatformDriver (void);
+
+#include "vkConcretePlatformInterface.inl"
+
+protected:
+ struct Functions
+ {
+#include "vkPlatformFunctionPointers.inl"
+ };
+
+ Functions m_vk;
+};
+
+class DeviceDriver : public DeviceInterface
+{
+public:
+ DeviceDriver (const PlatformInterface& platformInterface, VkPhysicalDevice device);
+ ~DeviceDriver (void);
+
+#include "vkConcreteDeviceInterface.inl"
+
+protected:
+ struct Functions
+ {
+#include "vkDeviceFunctionPointers.inl"
+ };
+
+ Functions m_vk;
+};
+
+/*--------------------------------------------------------------------*//*!
+ * \brief Vulkan platform interface
+ *//*--------------------------------------------------------------------*/
+class Platform
+{
+public:
+ Platform (void) {}
+ ~Platform (void) {}
+
+ // \todo [2015-01-05 pyry] Parametrize this to select for example debug library / interface?
+ virtual Library* createLibrary (void) const = 0;
+};
+
+} // vk
+
+#endif // _VKPLATFORM_HPP
--- /dev/null
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * be lost! Modify the generating script instead.
+ */
+
+VkResult PlatformDriver::createInstance (const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance) const
+{
+ return m_vk.createInstance(pCreateInfo, pInstance);
+}
+
+VkResult PlatformDriver::destroyInstance (VkInstance instance) const
+{
+ return m_vk.destroyInstance(instance);
+}
+
+VkResult PlatformDriver::enumeratePhysicalDevices (VkInstance instance, deUint32* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) const
+{
+ return m_vk.enumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
+}
+
+FunctionPtr PlatformDriver::getProcAddr (VkPhysicalDevice physicalDevice, const char* pName) const
+{
+ return m_vk.getProcAddr(physicalDevice, pName);
+}
--- /dev/null
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * be lost! Modify the generating script instead.
+ */
+CreateInstanceFunc createInstance;
+DestroyInstanceFunc destroyInstance;
+EnumeratePhysicalDevicesFunc enumeratePhysicalDevices;
+GetProcAddrFunc getProcAddr;
--- /dev/null
+/*-------------------------------------------------------------------------
+ * drawElements Quality Program Vulkan Utilities
+ * -----------------------------------------------
+ *
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Program utilities.
+ *//*--------------------------------------------------------------------*/
+
+#include "vkPrograms.hpp"
+#include "deArrayUtil.hpp"
+#include "deMemory.h"
+
+namespace vk
+{
+
+using std::string;
+using std::vector;
+
+// ProgramBinary
+
+ProgramBinary::ProgramBinary (ProgramFormat format, size_t binarySize, const deUint8* binary)
+ : m_format (format)
+ , m_binary (binary, binary+binarySize)
+{
+}
+
+// Utils
+
+namespace
+{
+
+// \todo [2015-05-12 pyry] All of this is just placeholder until we have proper SPIR-V binary support
+
+enum { GLSL_BINARY_MAGIC = 0x610d510a };
+
+struct BinaryHeader
+{
+ deUint32 magic;
+ deUint32 sourceLength[glu::SHADERTYPE_LAST]; // Length per stage, 0 means that not supplied
+};
+
+DE_STATIC_ASSERT(sizeof(BinaryHeader) == sizeof(deUint32)*7);
+
+#if (DE_ENDIANNESS != DE_LITTLE_ENDIAN)
+# error Big-endian not supported
+#endif
+
+size_t computeSrcArrayTotalLength (const vector<string>& sources)
+{
+ size_t total = 0;
+ for (vector<string>::const_iterator i = sources.begin(); i != sources.end(); ++i)
+ total += i->length();
+ return total;
+}
+
+size_t computeAggregatedSrcLength (const glu::ProgramSources& sources)
+{
+ size_t total = 0;
+ for (int type = 0; type < glu::SHADERTYPE_LAST; type++)
+ total += computeSrcArrayTotalLength(sources.sources[type]);
+ return total;
+}
+
+void encodeGLSLBinary (const glu::ProgramSources& sources, vector<deUint8>& dst)
+{
+ const size_t binarySize = sizeof(BinaryHeader) + computeAggregatedSrcLength(sources);
+
+ dst.resize(binarySize);
+
+ {
+ BinaryHeader* const hdr = (BinaryHeader*)&dst[0];
+ hdr->magic = GLSL_BINARY_MAGIC;
+
+ for (int type = 0; type < glu::SHADERTYPE_LAST; type++)
+ hdr->sourceLength[type] = (deUint32)computeSrcArrayTotalLength(sources.sources[type]);
+ }
+
+ {
+ size_t curOffset = sizeof(BinaryHeader);
+ for (int type = 0; type < glu::SHADERTYPE_LAST; type++)
+ {
+ for (vector<string>::const_iterator srcIter = sources.sources[type].begin();
+ srcIter != sources.sources[type].end();
+ ++srcIter)
+ {
+ if (!srcIter->empty())
+ {
+ deMemcpy(&dst[curOffset], srcIter->c_str(), (int)srcIter->length());
+ curOffset += srcIter->length();
+ }
+ }
+ }
+ }
+}
+
+void decodeGLSLBinary (size_t binarySize, const deUint8* binary, glu::ProgramSources& dst)
+{
+ const BinaryHeader* hdr = (const BinaryHeader*)binary;
+
+ if (binarySize < sizeof(BinaryHeader) || hdr->magic != GLSL_BINARY_MAGIC)
+ TCU_THROW(Exception, "Invalid GLSL program binary");
+
+ {
+ size_t curOffset = sizeof(BinaryHeader);
+
+ for (int type = 0; type < glu::SHADERTYPE_LAST; type++)
+ {
+ if (hdr->sourceLength[type] > 0)
+ {
+ if (curOffset+hdr->sourceLength[type] > binarySize)
+ TCU_THROW(Exception, "Incomplete GLSL program binary");
+
+ dst.sources[type].resize(1);
+ dst.sources[type][0] = std::string((const char*)&binary[curOffset], hdr->sourceLength[type]);
+
+ curOffset += hdr->sourceLength[type];
+ }
+ else
+ dst.sources[type].clear();
+ }
+ }
+}
+
+VkShaderStage getShaderStage (glu::ShaderType type)
+{
+ static const VkShaderStage stageMap[] =
+ {
+ VK_SHADER_STAGE_VERTEX,
+ VK_SHADER_STAGE_FRAGMENT,
+ VK_SHADER_STAGE_GEOMETRY,
+ VK_SHADER_STAGE_TESS_CONTROL,
+ VK_SHADER_STAGE_TESS_EVALUATION,
+ VK_SHADER_STAGE_COMPUTE,
+ };
+ return de::getSizedArrayElement<glu::SHADERTYPE_LAST>(stageMap, type);
+}
+
+} // anonymous
+
+ProgramBinary* buildProgram (const glu::ProgramSources& program, ProgramFormat binaryFormat)
+{
+ if (binaryFormat == PROGRAM_FORMAT_GLSL)
+ {
+ vector<deUint8> binary;
+ encodeGLSLBinary(program, binary);
+ return new ProgramBinary(binaryFormat, binary.size(), &binary[0]);
+ }
+ else
+ TCU_THROW(NotSupportedError, "Unsupported program format");
+}
+
+void setShaderBinary (const DeviceInterface& vk, VkShader shader, const ProgramBinary& binary)
+{
+ DE_UNREF(vk);
+ DE_UNREF(shader);
+ DE_UNREF(binary);
+#if 0
+ if (binary.getFormat() == PROGRAM_FORMAT_GLSL)
+ {
+ glu::ProgramSources sources;
+
+ decodeGLSLBinary(binary.getSize(), binary.getBinary(), sources);
+
+ for (int shaderType = 0; shaderType < glu::SHADERTYPE_LAST; shaderType++)
+ {
+ DE_ASSERT(sources.sources[shaderType].size() <= 1);
+
+ if (!sources.sources[shaderType].empty())
+ vk.programSetSource(program, getShaderStage(static_cast<glu::ShaderType>(shaderType)), sources.sources[shaderType][0].c_str());
+ }
+ }
+ else
+#endif
+ TCU_THROW(NotSupportedError, "Unsupported program format");
+}
+
+} // vk
--- /dev/null
+#ifndef _VKPROGRAMS_HPP
+#define _VKPROGRAMS_HPP
+/*-------------------------------------------------------------------------
+ * drawElements Quality Program Vulkan Utilities
+ * -----------------------------------------------
+ *
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Program utilities.
+ *//*--------------------------------------------------------------------*/
+
+#include "vkDefs.hpp"
+#include "gluShaderProgram.hpp"
+#include "deUniquePtr.hpp"
+#include "deSTLUtil.hpp"
+
+#include <map>
+
+namespace vk
+{
+
+enum ProgramFormat
+{
+ PROGRAM_FORMAT_GLSL = 0
+};
+
+class ProgramBinary
+{
+public:
+ ProgramBinary (ProgramFormat format, size_t binarySize, const deUint8* binary);
+
+ ProgramFormat getFormat (void) const { return m_format; }
+ size_t getSize (void) const { return m_binary.size(); }
+ const deUint8* getBinary (void) const { return m_binary.empty() ? DE_NULL : &m_binary[0]; }
+
+private:
+ const ProgramFormat m_format;
+ const std::vector<deUint8> m_binary;
+};
+
+template<typename Program>
+class ProgramCollection
+{
+public:
+ ProgramCollection (void);
+ ~ProgramCollection (void);
+
+ void clear (void);
+
+ Program& add (const std::string& name);
+ void add (const std::string& name, de::MovePtr<Program>& program);
+
+ bool contains (const std::string& name) const;
+ const Program& get (const std::string& name) const;
+
+ class Iterator
+ {
+ private:
+ typedef typename std::map<std::string, Program*>::const_iterator IteratorImpl;
+
+ public:
+ explicit Iterator (const IteratorImpl& i) : m_impl(i) {}
+
+ Iterator& operator++ (void) { ++m_impl; return *this; }
+ const Program& operator* (void) const { return getProgram(); }
+
+ const std::string& getName (void) const { return m_impl->first; }
+ const Program& getProgram (void) const { return *m_impl->second; }
+
+ bool operator== (const Iterator& other) const { return m_impl == other.m_impl; }
+ bool operator!= (const Iterator& other) const { return m_impl != other.m_impl; }
+
+ private:
+
+ IteratorImpl m_impl;
+ };
+
+ Iterator begin (void) const { return Iterator(m_programs.begin()); }
+ Iterator end (void) const { return Iterator(m_programs.end()); }
+
+private:
+ typedef std::map<std::string, Program*> ProgramMap;
+
+ ProgramMap m_programs;
+};
+
+template<typename Program>
+ProgramCollection<Program>::ProgramCollection (void)
+{
+}
+
+template<typename Program>
+ProgramCollection<Program>::~ProgramCollection (void)
+{
+ clear();
+}
+
+template<typename Program>
+void ProgramCollection<Program>::clear (void)
+{
+ for (typename ProgramMap::const_iterator i = m_programs.begin(); i != m_programs.end(); ++i)
+ delete i->second;
+ m_programs.clear();
+}
+
+template<typename Program>
+Program& ProgramCollection<Program>::add (const std::string& name)
+{
+ DE_ASSERT(!contains(name));
+ de::MovePtr<Program> prog = de::newMovePtr<Program>();
+ m_programs[name] = prog.get();
+ prog.release();
+ return *m_programs[name];
+}
+
+template<typename Program>
+void ProgramCollection<Program>::add (const std::string& name, de::MovePtr<Program>& program)
+{
+ DE_ASSERT(!contains(name));
+ m_programs[name] = program.get();
+ program.release();
+}
+
+template<typename Program>
+bool ProgramCollection<Program>::contains (const std::string& name) const
+{
+ return de::contains(m_programs, name);
+}
+
+template<typename Program>
+const Program& ProgramCollection<Program>::get (const std::string& name) const
+{
+ DE_ASSERT(contains(name));
+ return *m_programs.find(name)->second;
+}
+
+typedef ProgramCollection<glu::ProgramSources> SourceCollection;
+typedef ProgramCollection<ProgramBinary> BinaryCollection;
+
+// \todo [2015-03-13 pyry] Likely need BinaryBuilder abstraction for this
+ProgramBinary* buildProgram (const glu::ProgramSources& program, ProgramFormat binaryFormat);
+void setShaderBinary (const DeviceInterface& deviceInterface, VkShader shader, const ProgramBinary& binary);
+
+} // vk
+
+#endif // _VKPROGRAMS_HPP
--- /dev/null
+/*-------------------------------------------------------------------------
+ * drawElements Quality Program Vulkan Utilities
+ * -----------------------------------------------
+ *
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Vulkan object reference holder.
+ *//*--------------------------------------------------------------------*/
+
+#include "vkRef.hpp"
+
+namespace vk
+{
+
+#include "vkRefUtilImpl.inl"
+
+} // vk
--- /dev/null
+#ifndef _VKREF_HPP
+#define _VKREF_HPP
+/*-------------------------------------------------------------------------
+ * drawElements Quality Program Vulkan Utilities
+ * -----------------------------------------------
+ *
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Vulkan object reference holder.
+ *//*--------------------------------------------------------------------*/
+
+#include "vkDefs.hpp"
+#include "vkStrUtil.hpp"
+#include "deMeta.hpp"
+
+namespace vk
+{
+
+namespace refdetails
+{
+
+using de::meta::EnableIf;
+
+template<typename T>
+struct RefTraits
+{
+ typedef DeviceInterface Interface;
+ enum { REQUIRES_DEVICE = 1 };
+};
+
+template<>
+struct RefTraits<VkInstanceT>
+{
+ typedef PlatformInterface Interface;
+ enum { REQUIRES_DEVICE = 0 };
+};
+
+template<>
+struct RefTraits<VkDeviceT>
+{
+ typedef DeviceInterface Interface;
+ enum { REQUIRES_DEVICE = 0 };
+};
+
+template<typename T>
+struct Checked
+{
+ explicit inline Checked (typename Traits<T>::Type object_) : object(object_) {}
+
+ typename Traits<T>::Type object;
+};
+
+//! Check that object is not null
+template<typename T>
+inline Checked<T> check (typename Traits<T>::Type object)
+{
+ if (!object)
+ throw tcu::TestError("Object check() failed", (std::string(getTypeName<T>()) + " = 0").c_str(), __FILE__, __LINE__);
+ return Checked<T>(object);
+}
+
+//! Declare object as checked earlier
+template<typename T>
+inline Checked<T> notNull (typename Traits<T>::Type object)
+{
+ if (!object)
+ throw tcu::InternalError("Null object was given to notNull()", (std::string(getTypeName<T>()) + " = 0").c_str(), __FILE__, __LINE__);
+ return Checked<T>(object);
+}
+
+//! Allow null object
+template<typename T>
+inline Checked<T> allowNull (typename Traits<T>::Type object)
+{
+ return Checked<T>(object);
+}
+
+// \todo [2015-05-12 pyry] Can we further simplify this using RefTraits<T>::REQUIRES_DEVICE?
+
+template<typename T>
+struct RefData
+{
+ RefData (const typename RefTraits<T>::Interface* vk_,
+ VkDevice device_,
+ typename Traits<T>::Type object_)
+ : vk (vk_)
+ , device(device_)
+ , object(object_)
+ {}
+ RefData (const typename RefTraits<T>::Interface* vk_)
+ : vk (vk_)
+ , device(0)
+ , object(0)
+ {}
+
+ const typename RefTraits<T>::Interface* vk;
+ VkDevice device;
+ typename Traits<T>::Type object;
+};
+
+template<>
+struct RefData<VkInstanceT>
+{
+ RefData (const RefTraits<VkInstanceT>::Interface* vk_,
+ VkInstance object_)
+ : vk (vk_)
+ , object (object_)
+ {}
+ RefData (const RefTraits<VkInstanceT>::Interface* vk_)
+ : vk (vk_)
+ , object(0)
+ {}
+
+ const RefTraits<VkInstanceT>::Interface* vk;
+ Traits<VkInstanceT>::Type object;
+};
+
+template<>
+struct RefData<VkDeviceT>
+{
+ RefData (const RefTraits<VkDeviceT>::Interface* vk_,
+ VkDevice object_)
+ : vk (vk_)
+ , object (object_)
+ {}
+ RefData (const RefTraits<VkDevice>::Interface* vk_)
+ : vk (vk_)
+ , object(0)
+ {}
+
+ const RefTraits<VkDeviceT>::Interface* vk;
+ Traits<VkDeviceT>::Type object;
+};
+
+template<typename T>
+bool hasObject (const RefData<T>& ref)
+{
+ return ref.object != 0;
+}
+
+template<typename T>
+void clearObject (typename EnableIf<RefData<T>, RefTraits<T>::REQUIRES_DEVICE == 1>::Type& ref)
+{
+ ref.object = 0;
+ ref.device = 0;
+}
+
+template<typename T>
+void clearObject (typename EnableIf<RefData<T>, RefTraits<T>::REQUIRES_DEVICE == 0>::Type& ref)
+{
+ ref.object = 0;
+}
+
+template<typename T>
+void assignObject (typename EnableIf<RefData<T>, RefTraits<T>::REQUIRES_DEVICE == 1>::Type& dst, const RefData<T>& src)
+{
+ dst.object = src.object;
+ dst.device = src.device;
+}
+
+template<typename T>
+void assignObject (typename EnableIf<RefData<T>, RefTraits<T>::REQUIRES_DEVICE == 0>::Type& dst, const RefData<T>& src)
+{
+ dst.object = src.object;
+}
+
+template<typename T>
+void destroyObject (const RefData<T>& ref)
+{
+ ref.vk->destroyObject(ref.device, getObjectType<T>(), ref.object);
+}
+
+template<>
+inline void destroyObject<VkInstanceT> (const RefData<VkInstanceT>& ref)
+{
+ ref.vk->destroyInstance(ref.object);
+}
+
+template<>
+inline void destroyObject<VkDeviceT> (const RefData<VkDeviceT>& ref)
+{
+ ref.vk->destroyDevice(ref.object);
+}
+
+template<typename T>
+class RefBase
+{
+public:
+ ~RefBase (void);
+
+ inline typename Traits<T>::Type get (void) const throw() { return m_data.object; }
+ inline typename Traits<T>::Type operator* (void) const throw() { return get(); }
+ inline operator bool (void) const throw() { return !!get(); }
+
+protected:
+ RefBase (RefData<T> data) : m_data(data) {}
+
+ void reset (void); //!< Release previous object, set to null.
+ RefData<T> disown (void) throw(); //!< Disown and return object (ownership transferred to caller).
+ void assign (RefData<T> data); //!< Set new pointer, release previous pointer.
+
+private:
+ RefData<T> m_data;
+};
+
+/*--------------------------------------------------------------------*//*!
+ * \brief Movable Vulkan object reference.
+ *
+ * Similar to de::MovePtr.
+ *//*--------------------------------------------------------------------*/
+template<typename T>
+class Move : public RefBase<T>
+{
+public:
+ template<typename U>
+ Move (typename EnableIf<const typename RefTraits<U>::Interface&, RefTraits<U>::REQUIRES_DEVICE==1>::Type vk,
+ VkDevice device,
+ Checked<U> object)
+ : RefBase<T>(RefData<T>(&vk, device, object.object))
+ {}
+
+ template<typename U>
+ Move (typename EnableIf<const typename RefTraits<U>::Interface&, RefTraits<U>::REQUIRES_DEVICE==0>::Type vk,
+ Checked<U> object)
+ : RefBase<T>(RefData<T>(&vk, object.object))
+ {}
+
+ Move (const typename RefTraits<T>::Interface& vk) : RefBase<T>(RefData<T>(&vk)) {}
+ Move (RefData<T> data) : RefBase<T>(data) {}
+
+ Move<T>& operator= (Move<T>& other);
+ Move<T>& operator= (RefData<T> data);
+
+ operator RefData<T> (void) { return this->disown(); }
+};
+
+/*--------------------------------------------------------------------*//*!
+ * \brief Unique Vulkan object reference.
+ *
+ * Similar to de::UniquePtr.
+ *//*--------------------------------------------------------------------*/
+template<typename T>
+class Unique : public RefBase<T>
+{
+public:
+ template<typename U>
+ Unique (typename EnableIf<const typename RefTraits<U>::Interface&, RefTraits<U>::REQUIRES_DEVICE==1>::Type vk,
+ VkDevice device,
+ Checked<U> object)
+ : RefBase<T>(RefData<T>(&vk, device, object.object))
+ {}
+
+ template<typename U>
+ Unique (typename EnableIf<const typename RefTraits<U>::Interface&, RefTraits<U>::REQUIRES_DEVICE==0>::Type vk,
+ Checked<U> object)
+ : RefBase<T>(RefData<T>(&vk, object.object))
+ {}
+
+ Unique (RefData<T> data) : RefBase<T>(data) {}
+};
+
+// RefBase
+
+template<typename T>
+inline RefBase<T>::~RefBase (void)
+{
+ this->reset();
+}
+
+template<typename T>
+inline void RefBase<T>::reset (void)
+{
+ if (hasObject(m_data))
+ destroyObject<T>(m_data);
+
+ clearObject<T>(m_data);
+}
+
+template<typename T>
+inline RefData<T> RefBase<T>::disown (void) throw()
+{
+ const RefData<T> old = m_data;
+ clearObject<T>(m_data);
+ return old;
+}
+
+template<typename T>
+inline void RefBase<T>::assign (RefData<T> data)
+{
+ this->reset();
+ assignObject<T>(m_data, data);
+}
+
+// Move
+
+template<typename T>
+inline Move<T>& Move<T>::operator= (Move<T>& other)
+{
+ if (this != &other)
+ this->assign(other.disown());
+
+ return *this;
+}
+
+template<typename T>
+inline Move<T>& Move<T>::operator= (RefData<T> data)
+{
+ this->assign(data);
+ return *this;
+}
+
+} // refdetails
+
+using refdetails::Move;
+using refdetails::Unique;
+using refdetails::check;
+using refdetails::notNull;
+using refdetails::allowNull;
+
+#include "vkRefUtil.inl"
+
+} // vk
+
+#endif // _VKREF_HPP
--- /dev/null
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * be lost! Modify the generating script instead.
+ */
+Move<VkInstanceT> createInstance (const PlatformInterface& vk, const VkInstanceCreateInfo* pCreateInfo);
+Move<VkDeviceT> createDevice (const DeviceInterface& vk, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo);
+Move<VkFenceT> createFence (const DeviceInterface& vk, VkDevice device, const VkFenceCreateInfo* pCreateInfo);
+Move<VkSemaphoreT> createSemaphore (const DeviceInterface& vk, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo);
+Move<VkEventT> createEvent (const DeviceInterface& vk, VkDevice device, const VkEventCreateInfo* pCreateInfo);
+Move<VkQueryPoolT> createQueryPool (const DeviceInterface& vk, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo);
+Move<VkBufferT> createBuffer (const DeviceInterface& vk, VkDevice device, const VkBufferCreateInfo* pCreateInfo);
+Move<VkBufferViewT> createBufferView (const DeviceInterface& vk, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo);
+Move<VkImageT> createImage (const DeviceInterface& vk, VkDevice device, const VkImageCreateInfo* pCreateInfo);
+Move<VkImageViewT> createImageView (const DeviceInterface& vk, VkDevice device, const VkImageViewCreateInfo* pCreateInfo);
+Move<VkColorAttachmentViewT> createColorAttachmentView (const DeviceInterface& vk, VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo);
+Move<VkDepthStencilViewT> createDepthStencilView (const DeviceInterface& vk, VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo);
+Move<VkShaderT> createShader (const DeviceInterface& vk, VkDevice device, const VkShaderCreateInfo* pCreateInfo);
+Move<VkPipelineT> createGraphicsPipeline (const DeviceInterface& vk, VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo);
+Move<VkPipelineT> createGraphicsPipelineDerivative (const DeviceInterface& vk, VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline basePipeline);
+Move<VkPipelineT> createComputePipeline (const DeviceInterface& vk, VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo);
+Move<VkPipelineLayoutT> createPipelineLayout (const DeviceInterface& vk, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo);
+Move<VkSamplerT> createSampler (const DeviceInterface& vk, VkDevice device, const VkSamplerCreateInfo* pCreateInfo);
+Move<VkDescriptorSetLayoutT> createDescriptorSetLayout (const DeviceInterface& vk, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo);
+Move<VkDescriptorPoolT> createDescriptorPool (const DeviceInterface& vk, VkDevice device, VkDescriptorPoolUsage poolUsage, deUint32 maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo);
+Move<VkDynamicVpStateT> createDynamicViewportState (const DeviceInterface& vk, VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo);
+Move<VkDynamicRsStateT> createDynamicRasterState (const DeviceInterface& vk, VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo);
+Move<VkDynamicCbStateT> createDynamicColorBlendState (const DeviceInterface& vk, VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo);
+Move<VkDynamicDsStateT> createDynamicDepthStencilState (const DeviceInterface& vk, VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo);
+Move<VkCmdBufferT> createCommandBuffer (const DeviceInterface& vk, VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo);
+Move<VkFramebufferT> createFramebuffer (const DeviceInterface& vk, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo);
+Move<VkRenderPassT> createRenderPass (const DeviceInterface& vk, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo);
--- /dev/null
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * be lost! Modify the generating script instead.
+ */
+Move<VkInstanceT> createInstance (const PlatformInterface& vk, const VkInstanceCreateInfo* pCreateInfo)
+{
+ VkInstance object = 0;
+ vk.createInstance(pCreateInfo, &object);
+ return Move<VkInstanceT>(vk, check<VkInstanceT>(object));
+}
+
+Move<VkDeviceT> createDevice (const DeviceInterface& vk, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo)
+{
+ VkDevice object = 0;
+ vk.createDevice(physicalDevice, pCreateInfo, &object);
+ return Move<VkDeviceT>(vk, check<VkDeviceT>(object));
+}
+
+Move<VkFenceT> createFence (const DeviceInterface& vk, VkDevice device, const VkFenceCreateInfo* pCreateInfo)
+{
+ VkFence object = 0;
+ vk.createFence(device, pCreateInfo, &object);
+ return Move<VkFenceT>(vk, device, check<VkFenceT>(object));
+}
+
+Move<VkSemaphoreT> createSemaphore (const DeviceInterface& vk, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo)
+{
+ VkSemaphore object = 0;
+ vk.createSemaphore(device, pCreateInfo, &object);
+ return Move<VkSemaphoreT>(vk, device, check<VkSemaphoreT>(object));
+}
+
+Move<VkEventT> createEvent (const DeviceInterface& vk, VkDevice device, const VkEventCreateInfo* pCreateInfo)
+{
+ VkEvent object = 0;
+ vk.createEvent(device, pCreateInfo, &object);
+ return Move<VkEventT>(vk, device, check<VkEventT>(object));
+}
+
+Move<VkQueryPoolT> createQueryPool (const DeviceInterface& vk, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo)
+{
+ VkQueryPool object = 0;
+ vk.createQueryPool(device, pCreateInfo, &object);
+ return Move<VkQueryPoolT>(vk, device, check<VkQueryPoolT>(object));
+}
+
+Move<VkBufferT> createBuffer (const DeviceInterface& vk, VkDevice device, const VkBufferCreateInfo* pCreateInfo)
+{
+ VkBuffer object = 0;
+ vk.createBuffer(device, pCreateInfo, &object);
+ return Move<VkBufferT>(vk, device, check<VkBufferT>(object));
+}
+
+Move<VkBufferViewT> createBufferView (const DeviceInterface& vk, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo)
+{
+ VkBufferView object = 0;
+ vk.createBufferView(device, pCreateInfo, &object);
+ return Move<VkBufferViewT>(vk, device, check<VkBufferViewT>(object));
+}
+
+Move<VkImageT> createImage (const DeviceInterface& vk, VkDevice device, const VkImageCreateInfo* pCreateInfo)
+{
+ VkImage object = 0;
+ vk.createImage(device, pCreateInfo, &object);
+ return Move<VkImageT>(vk, device, check<VkImageT>(object));
+}
+
+Move<VkImageViewT> createImageView (const DeviceInterface& vk, VkDevice device, const VkImageViewCreateInfo* pCreateInfo)
+{
+ VkImageView object = 0;
+ vk.createImageView(device, pCreateInfo, &object);
+ return Move<VkImageViewT>(vk, device, check<VkImageViewT>(object));
+}
+
+Move<VkColorAttachmentViewT> createColorAttachmentView (const DeviceInterface& vk, VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo)
+{
+ VkColorAttachmentView object = 0;
+ vk.createColorAttachmentView(device, pCreateInfo, &object);
+ return Move<VkColorAttachmentViewT>(vk, device, check<VkColorAttachmentViewT>(object));
+}
+
+Move<VkDepthStencilViewT> createDepthStencilView (const DeviceInterface& vk, VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo)
+{
+ VkDepthStencilView object = 0;
+ vk.createDepthStencilView(device, pCreateInfo, &object);
+ return Move<VkDepthStencilViewT>(vk, device, check<VkDepthStencilViewT>(object));
+}
+
+Move<VkShaderT> createShader (const DeviceInterface& vk, VkDevice device, const VkShaderCreateInfo* pCreateInfo)
+{
+ VkShader object = 0;
+ vk.createShader(device, pCreateInfo, &object);
+ return Move<VkShaderT>(vk, device, check<VkShaderT>(object));
+}
+
+Move<VkPipelineT> createGraphicsPipeline (const DeviceInterface& vk, VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo)
+{
+ VkPipeline object = 0;
+ vk.createGraphicsPipeline(device, pCreateInfo, &object);
+ return Move<VkPipelineT>(vk, device, check<VkPipelineT>(object));
+}
+
+Move<VkPipelineT> createGraphicsPipelineDerivative (const DeviceInterface& vk, VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline basePipeline)
+{
+ VkPipeline object = 0;
+ vk.createGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, &object);
+ return Move<VkPipelineT>(vk, device, check<VkPipelineT>(object));
+}
+
+Move<VkPipelineT> createComputePipeline (const DeviceInterface& vk, VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo)
+{
+ VkPipeline object = 0;
+ vk.createComputePipeline(device, pCreateInfo, &object);
+ return Move<VkPipelineT>(vk, device, check<VkPipelineT>(object));
+}
+
+Move<VkPipelineLayoutT> createPipelineLayout (const DeviceInterface& vk, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo)
+{
+ VkPipelineLayout object = 0;
+ vk.createPipelineLayout(device, pCreateInfo, &object);
+ return Move<VkPipelineLayoutT>(vk, device, check<VkPipelineLayoutT>(object));
+}
+
+Move<VkSamplerT> createSampler (const DeviceInterface& vk, VkDevice device, const VkSamplerCreateInfo* pCreateInfo)
+{
+ VkSampler object = 0;
+ vk.createSampler(device, pCreateInfo, &object);
+ return Move<VkSamplerT>(vk, device, check<VkSamplerT>(object));
+}
+
+Move<VkDescriptorSetLayoutT> createDescriptorSetLayout (const DeviceInterface& vk, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo)
+{
+ VkDescriptorSetLayout object = 0;
+ vk.createDescriptorSetLayout(device, pCreateInfo, &object);
+ return Move<VkDescriptorSetLayoutT>(vk, device, check<VkDescriptorSetLayoutT>(object));
+}
+
+Move<VkDescriptorPoolT> createDescriptorPool (const DeviceInterface& vk, VkDevice device, VkDescriptorPoolUsage poolUsage, deUint32 maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo)
+{
+ VkDescriptorPool object = 0;
+ vk.createDescriptorPool(device, poolUsage, maxSets, pCreateInfo, &object);
+ return Move<VkDescriptorPoolT>(vk, device, check<VkDescriptorPoolT>(object));
+}
+
+Move<VkDynamicVpStateT> createDynamicViewportState (const DeviceInterface& vk, VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo)
+{
+ VkDynamicVpState object = 0;
+ vk.createDynamicViewportState(device, pCreateInfo, &object);
+ return Move<VkDynamicVpStateT>(vk, device, check<VkDynamicVpStateT>(object));
+}
+
+Move<VkDynamicRsStateT> createDynamicRasterState (const DeviceInterface& vk, VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo)
+{
+ VkDynamicRsState object = 0;
+ vk.createDynamicRasterState(device, pCreateInfo, &object);
+ return Move<VkDynamicRsStateT>(vk, device, check<VkDynamicRsStateT>(object));
+}
+
+Move<VkDynamicCbStateT> createDynamicColorBlendState (const DeviceInterface& vk, VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo)
+{
+ VkDynamicCbState object = 0;
+ vk.createDynamicColorBlendState(device, pCreateInfo, &object);
+ return Move<VkDynamicCbStateT>(vk, device, check<VkDynamicCbStateT>(object));
+}
+
+Move<VkDynamicDsStateT> createDynamicDepthStencilState (const DeviceInterface& vk, VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo)
+{
+ VkDynamicDsState object = 0;
+ vk.createDynamicDepthStencilState(device, pCreateInfo, &object);
+ return Move<VkDynamicDsStateT>(vk, device, check<VkDynamicDsStateT>(object));
+}
+
+Move<VkCmdBufferT> createCommandBuffer (const DeviceInterface& vk, VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo)
+{
+ VkCmdBuffer object = 0;
+ vk.createCommandBuffer(device, pCreateInfo, &object);
+ return Move<VkCmdBufferT>(vk, device, check<VkCmdBufferT>(object));
+}
+
+Move<VkFramebufferT> createFramebuffer (const DeviceInterface& vk, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo)
+{
+ VkFramebuffer object = 0;
+ vk.createFramebuffer(device, pCreateInfo, &object);
+ return Move<VkFramebufferT>(vk, device, check<VkFramebufferT>(object));
+}
+
+Move<VkRenderPassT> createRenderPass (const DeviceInterface& vk, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo)
+{
+ VkRenderPass object = 0;
+ vk.createRenderPass(device, pCreateInfo, &object);
+ return Move<VkRenderPassT>(vk, device, check<VkRenderPassT>(object));
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ * drawElements Quality Program Vulkan Utilities
+ * -----------------------------------------------
+ *
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Pretty-printing and logging utilities.
+ *//*--------------------------------------------------------------------*/
+
+#include "vkStrUtil.hpp"
+
+namespace vk
+{
+
+#include "vkStrUtilImpl.inl"
+
+} // vk
--- /dev/null
+#ifndef _VKSTRUTIL_HPP
+#define _VKSTRUTIL_HPP
+/*-------------------------------------------------------------------------
+ * drawElements Quality Program Vulkan Utilities
+ * -----------------------------------------------
+ *
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Pretty-printing and logging utilities.
+ *//*--------------------------------------------------------------------*/
+
+#include "vkDefs.hpp"
+#include "tcuFormatUtil.hpp"
+
+namespace vk
+{
+
+#include "vkStrUtil.inl"
+
+template<typename T>
+const char* getTypeName (void);
+
+inline std::ostream& operator<< (std::ostream& s, const ApiVersion& version)
+{
+ return s << version.major << "." << version.minor << "." << version.patch;
+}
+
+} // vk
+
+#endif // _VKSTRUTIL_HPP
--- /dev/null
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * be lost! Modify the generating script instead.
+ */
+const char* getMemoryPriorityName (VkMemoryPriority value);
+const char* getImageLayoutName (VkImageLayout value);
+const char* getPipeEventName (VkPipeEvent value);
+const char* getWaitEventName (VkWaitEvent value);
+const char* getAttachmentLoadOpName (VkAttachmentLoadOp value);
+const char* getAttachmentStoreOpName (VkAttachmentStoreOp value);
+const char* getImageTypeName (VkImageType value);
+const char* getImageTilingName (VkImageTiling value);
+const char* getImageViewTypeName (VkImageViewType value);
+const char* getImageAspectName (VkImageAspect value);
+const char* getBufferViewTypeName (VkBufferViewType value);
+const char* getChannelSwizzleName (VkChannelSwizzle value);
+const char* getDescriptorTypeName (VkDescriptorType value);
+const char* getDescriptorPoolUsageName (VkDescriptorPoolUsage value);
+const char* getDescriptorUpdateModeName (VkDescriptorUpdateMode value);
+const char* getDescriptorSetUsageName (VkDescriptorSetUsage value);
+const char* getQueryTypeName (VkQueryType value);
+const char* getTimestampTypeName (VkTimestampType value);
+const char* getBorderColorName (VkBorderColor value);
+const char* getPipelineBindPointName (VkPipelineBindPoint value);
+const char* getStateBindPointName (VkStateBindPoint value);
+const char* getPrimitiveTopologyName (VkPrimitiveTopology value);
+const char* getIndexTypeName (VkIndexType value);
+const char* getTexFilterName (VkTexFilter value);
+const char* getTexMipmapModeName (VkTexMipmapMode value);
+const char* getTexAddressName (VkTexAddress value);
+const char* getCompareOpName (VkCompareOp value);
+const char* getFillModeName (VkFillMode value);
+const char* getCullModeName (VkCullMode value);
+const char* getFrontFaceName (VkFrontFace value);
+const char* getProvokingVertexName (VkProvokingVertex value);
+const char* getCoordinateOriginName (VkCoordinateOrigin value);
+const char* getDepthModeName (VkDepthMode value);
+const char* getBlendName (VkBlend value);
+const char* getBlendOpName (VkBlendOp value);
+const char* getStencilOpName (VkStencilOp value);
+const char* getLogicOpName (VkLogicOp value);
+const char* getSystemAllocTypeName (VkSystemAllocType value);
+const char* getPhysicalDeviceTypeName (VkPhysicalDeviceType value);
+const char* getPhysicalDeviceInfoTypeName (VkPhysicalDeviceInfoType value);
+const char* getExtensionInfoTypeName (VkExtensionInfoType value);
+const char* getFormatInfoTypeName (VkFormatInfoType value);
+const char* getSubresourceInfoTypeName (VkSubresourceInfoType value);
+const char* getObjectInfoTypeName (VkObjectInfoType value);
+const char* getVertexInputStepRateName (VkVertexInputStepRate value);
+const char* getFormatName (VkFormat value);
+const char* getShaderStageName (VkShaderStage value);
+const char* getStructureTypeName (VkStructureType value);
+const char* getObjectTypeName (VkObjectType value);
+const char* getResultName (VkResult value);
+
+inline tcu::Format::Enum<VkMemoryPriority> getMemoryPriorityStr (VkMemoryPriority value) { return tcu::Format::Enum<VkMemoryPriority>(getMemoryPriorityName, value); }
+inline tcu::Format::Enum<VkImageLayout> getImageLayoutStr (VkImageLayout value) { return tcu::Format::Enum<VkImageLayout>(getImageLayoutName, value); }
+inline tcu::Format::Enum<VkPipeEvent> getPipeEventStr (VkPipeEvent value) { return tcu::Format::Enum<VkPipeEvent>(getPipeEventName, value); }
+inline tcu::Format::Enum<VkWaitEvent> getWaitEventStr (VkWaitEvent value) { return tcu::Format::Enum<VkWaitEvent>(getWaitEventName, 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<VkImageType> getImageTypeStr (VkImageType value) { return tcu::Format::Enum<VkImageType>(getImageTypeName, value); }
+inline tcu::Format::Enum<VkImageTiling> getImageTilingStr (VkImageTiling value) { return tcu::Format::Enum<VkImageTiling>(getImageTilingName, value); }
+inline tcu::Format::Enum<VkImageViewType> getImageViewTypeStr (VkImageViewType value) { return tcu::Format::Enum<VkImageViewType>(getImageViewTypeName, value); }
+inline tcu::Format::Enum<VkImageAspect> getImageAspectStr (VkImageAspect value) { return tcu::Format::Enum<VkImageAspect>(getImageAspectName, value); }
+inline tcu::Format::Enum<VkBufferViewType> getBufferViewTypeStr (VkBufferViewType value) { return tcu::Format::Enum<VkBufferViewType>(getBufferViewTypeName, value); }
+inline tcu::Format::Enum<VkChannelSwizzle> getChannelSwizzleStr (VkChannelSwizzle value) { return tcu::Format::Enum<VkChannelSwizzle>(getChannelSwizzleName, 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<VkDescriptorUpdateMode> getDescriptorUpdateModeStr (VkDescriptorUpdateMode value) { return tcu::Format::Enum<VkDescriptorUpdateMode>(getDescriptorUpdateModeName, value); }
+inline tcu::Format::Enum<VkDescriptorSetUsage> getDescriptorSetUsageStr (VkDescriptorSetUsage value) { return tcu::Format::Enum<VkDescriptorSetUsage>(getDescriptorSetUsageName, value); }
+inline tcu::Format::Enum<VkQueryType> getQueryTypeStr (VkQueryType value) { return tcu::Format::Enum<VkQueryType>(getQueryTypeName, value); }
+inline tcu::Format::Enum<VkTimestampType> getTimestampTypeStr (VkTimestampType value) { return tcu::Format::Enum<VkTimestampType>(getTimestampTypeName, value); }
+inline tcu::Format::Enum<VkBorderColor> getBorderColorStr (VkBorderColor value) { return tcu::Format::Enum<VkBorderColor>(getBorderColorName, value); }
+inline tcu::Format::Enum<VkPipelineBindPoint> getPipelineBindPointStr (VkPipelineBindPoint value) { return tcu::Format::Enum<VkPipelineBindPoint>(getPipelineBindPointName, value); }
+inline tcu::Format::Enum<VkStateBindPoint> getStateBindPointStr (VkStateBindPoint value) { return tcu::Format::Enum<VkStateBindPoint>(getStateBindPointName, value); }
+inline tcu::Format::Enum<VkPrimitiveTopology> getPrimitiveTopologyStr (VkPrimitiveTopology value) { return tcu::Format::Enum<VkPrimitiveTopology>(getPrimitiveTopologyName, value); }
+inline tcu::Format::Enum<VkIndexType> getIndexTypeStr (VkIndexType value) { return tcu::Format::Enum<VkIndexType>(getIndexTypeName, 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<VkCompareOp> getCompareOpStr (VkCompareOp value) { return tcu::Format::Enum<VkCompareOp>(getCompareOpName, value); }
+inline tcu::Format::Enum<VkFillMode> getFillModeStr (VkFillMode value) { return tcu::Format::Enum<VkFillMode>(getFillModeName, value); }
+inline tcu::Format::Enum<VkCullMode> getCullModeStr (VkCullMode value) { return tcu::Format::Enum<VkCullMode>(getCullModeName, value); }
+inline tcu::Format::Enum<VkFrontFace> getFrontFaceStr (VkFrontFace value) { return tcu::Format::Enum<VkFrontFace>(getFrontFaceName, value); }
+inline tcu::Format::Enum<VkProvokingVertex> getProvokingVertexStr (VkProvokingVertex value) { return tcu::Format::Enum<VkProvokingVertex>(getProvokingVertexName, value); }
+inline tcu::Format::Enum<VkCoordinateOrigin> getCoordinateOriginStr (VkCoordinateOrigin value) { return tcu::Format::Enum<VkCoordinateOrigin>(getCoordinateOriginName, value); }
+inline tcu::Format::Enum<VkDepthMode> getDepthModeStr (VkDepthMode value) { return tcu::Format::Enum<VkDepthMode>(getDepthModeName, 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<VkStencilOp> getStencilOpStr (VkStencilOp value) { return tcu::Format::Enum<VkStencilOp>(getStencilOpName, value); }
+inline tcu::Format::Enum<VkLogicOp> getLogicOpStr (VkLogicOp value) { return tcu::Format::Enum<VkLogicOp>(getLogicOpName, value); }
+inline tcu::Format::Enum<VkSystemAllocType> getSystemAllocTypeStr (VkSystemAllocType value) { return tcu::Format::Enum<VkSystemAllocType>(getSystemAllocTypeName, value); }
+inline tcu::Format::Enum<VkPhysicalDeviceType> getPhysicalDeviceTypeStr (VkPhysicalDeviceType value) { return tcu::Format::Enum<VkPhysicalDeviceType>(getPhysicalDeviceTypeName, value); }
+inline tcu::Format::Enum<VkPhysicalDeviceInfoType> getPhysicalDeviceInfoTypeStr (VkPhysicalDeviceInfoType value) { return tcu::Format::Enum<VkPhysicalDeviceInfoType>(getPhysicalDeviceInfoTypeName, value); }
+inline tcu::Format::Enum<VkExtensionInfoType> getExtensionInfoTypeStr (VkExtensionInfoType value) { return tcu::Format::Enum<VkExtensionInfoType>(getExtensionInfoTypeName, value); }
+inline tcu::Format::Enum<VkFormatInfoType> getFormatInfoTypeStr (VkFormatInfoType value) { return tcu::Format::Enum<VkFormatInfoType>(getFormatInfoTypeName, value); }
+inline tcu::Format::Enum<VkSubresourceInfoType> getSubresourceInfoTypeStr (VkSubresourceInfoType value) { return tcu::Format::Enum<VkSubresourceInfoType>(getSubresourceInfoTypeName, value); }
+inline tcu::Format::Enum<VkObjectInfoType> getObjectInfoTypeStr (VkObjectInfoType value) { return tcu::Format::Enum<VkObjectInfoType>(getObjectInfoTypeName, value); }
+inline tcu::Format::Enum<VkVertexInputStepRate> getVertexInputStepRateStr (VkVertexInputStepRate value) { return tcu::Format::Enum<VkVertexInputStepRate>(getVertexInputStepRateName, value); }
+inline tcu::Format::Enum<VkFormat> getFormatStr (VkFormat value) { return tcu::Format::Enum<VkFormat>(getFormatName, value); }
+inline tcu::Format::Enum<VkShaderStage> getShaderStageStr (VkShaderStage value) { return tcu::Format::Enum<VkShaderStage>(getShaderStageName, value); }
+inline tcu::Format::Enum<VkStructureType> getStructureTypeStr (VkStructureType value) { return tcu::Format::Enum<VkStructureType>(getStructureTypeName, value); }
+inline tcu::Format::Enum<VkObjectType> getObjectTypeStr (VkObjectType value) { return tcu::Format::Enum<VkObjectType>(getObjectTypeName, value); }
+inline tcu::Format::Enum<VkResult> getResultStr (VkResult value) { return tcu::Format::Enum<VkResult>(getResultName, value); }
+
+inline std::ostream& operator<< (std::ostream& s, VkMemoryPriority value) { return s << getMemoryPriorityStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkImageLayout value) { return s << getImageLayoutStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkPipeEvent value) { return s << getPipeEventStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkWaitEvent value) { return s << getWaitEventStr(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, VkImageType value) { return s << getImageTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkImageTiling value) { return s << getImageTilingStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkImageViewType value) { return s << getImageViewTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkImageAspect value) { return s << getImageAspectStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkBufferViewType value) { return s << getBufferViewTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkChannelSwizzle value) { return s << getChannelSwizzleStr(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, VkDescriptorUpdateMode value) { return s << getDescriptorUpdateModeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkDescriptorSetUsage value) { return s << getDescriptorSetUsageStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkQueryType value) { return s << getQueryTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkTimestampType value) { return s << getTimestampTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkBorderColor value) { return s << getBorderColorStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkPipelineBindPoint value) { return s << getPipelineBindPointStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkStateBindPoint value) { return s << getStateBindPointStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkPrimitiveTopology value) { return s << getPrimitiveTopologyStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkIndexType value) { return s << getIndexTypeStr(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, VkCompareOp value) { return s << getCompareOpStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkFillMode value) { return s << getFillModeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkCullMode value) { return s << getCullModeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkFrontFace value) { return s << getFrontFaceStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkProvokingVertex value) { return s << getProvokingVertexStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkCoordinateOrigin value) { return s << getCoordinateOriginStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkDepthMode value) { return s << getDepthModeStr(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, VkStencilOp value) { return s << getStencilOpStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkLogicOp value) { return s << getLogicOpStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkSystemAllocType value) { return s << getSystemAllocTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkPhysicalDeviceType value) { return s << getPhysicalDeviceTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkPhysicalDeviceInfoType value) { return s << getPhysicalDeviceInfoTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkExtensionInfoType value) { return s << getExtensionInfoTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkFormatInfoType value) { return s << getFormatInfoTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkSubresourceInfoType value) { return s << getSubresourceInfoTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkObjectInfoType value) { return s << getObjectInfoTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkVertexInputStepRate value) { return s << getVertexInputStepRateStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkFormat value) { return s << getFormatStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkShaderStage value) { return s << getShaderStageStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkStructureType value) { return s << getStructureTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkObjectType value) { return s << getObjectTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkResult value) { return s << getResultStr(value); }
+
+tcu::Format::Bitfield<32> getDeviceCreateFlagsStr (VkDeviceCreateFlags value);
+tcu::Format::Bitfield<32> getQueueFlagsStr (VkQueueFlags value);
+tcu::Format::Bitfield<32> getMemoryPropertyFlagsStr (VkMemoryPropertyFlags value);
+tcu::Format::Bitfield<32> getMemoryOutputFlagsStr (VkMemoryOutputFlags value);
+tcu::Format::Bitfield<32> getMemoryInputFlagsStr (VkMemoryInputFlags value);
+tcu::Format::Bitfield<32> getBufferUsageFlagsStr (VkBufferUsageFlags value);
+tcu::Format::Bitfield<32> getBufferCreateFlagsStr (VkBufferCreateFlags value);
+tcu::Format::Bitfield<32> getShaderStageFlagsStr (VkShaderStageFlags value);
+tcu::Format::Bitfield<32> getImageUsageFlagsStr (VkImageUsageFlags value);
+tcu::Format::Bitfield<32> getImageCreateFlagsStr (VkImageCreateFlags value);
+tcu::Format::Bitfield<32> getDepthStencilViewCreateFlagsStr (VkDepthStencilViewCreateFlags value);
+tcu::Format::Bitfield<32> getPipelineCreateFlagsStr (VkPipelineCreateFlags value);
+tcu::Format::Bitfield<32> getChannelFlagsStr (VkChannelFlags value);
+tcu::Format::Bitfield<32> getFenceCreateFlagsStr (VkFenceCreateFlags value);
+tcu::Format::Bitfield<32> getSemaphoreCreateFlagsStr (VkSemaphoreCreateFlags value);
+tcu::Format::Bitfield<32> getFormatFeatureFlagsStr (VkFormatFeatureFlags value);
+tcu::Format::Bitfield<32> getQueryControlFlagsStr (VkQueryControlFlags value);
+tcu::Format::Bitfield<32> getQueryResultFlagsStr (VkQueryResultFlags value);
+tcu::Format::Bitfield<32> getPhysicalDeviceCompatibilityFlagsStr (VkPhysicalDeviceCompatibilityFlags value);
+tcu::Format::Bitfield<32> getCmdBufferOptimizeFlagsStr (VkCmdBufferOptimizeFlags value);
+tcu::Format::Bitfield<32> getQueryPipelineStatisticFlagsStr (VkQueryPipelineStatisticFlags value);
--- /dev/null
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * be lost! Modify the generating script instead.
+ */
+template<> const char* getTypeName<VkObjectT> (void) { return "VkObject"; }
+template<> const char* getTypeName<VkInstanceT> (void) { return "VkInstance"; }
+template<> const char* getTypeName<VkPhysicalDeviceT> (void) { return "VkPhysicalDevice"; }
+template<> const char* getTypeName<VkDeviceT> (void) { return "VkDevice"; }
+template<> const char* getTypeName<VkQueueT> (void) { return "VkQueue"; }
+template<> const char* getTypeName<VkCmdBufferT> (void) { return "VkCmdBuffer"; }
+template<> const char* getTypeName<VkNonDispatchableT> (void) { return "VkNonDispatchable"; }
+template<> const char* getTypeName<VkDeviceMemoryT> (void) { return "VkDeviceMemory"; }
+template<> const char* getTypeName<VkBufferT> (void) { return "VkBuffer"; }
+template<> const char* getTypeName<VkBufferViewT> (void) { return "VkBufferView"; }
+template<> const char* getTypeName<VkImageT> (void) { return "VkImage"; }
+template<> const char* getTypeName<VkImageViewT> (void) { return "VkImageView"; }
+template<> const char* getTypeName<VkColorAttachmentViewT> (void) { return "VkColorAttachmentView"; }
+template<> const char* getTypeName<VkDepthStencilViewT> (void) { return "VkDepthStencilView"; }
+template<> const char* getTypeName<VkShaderT> (void) { return "VkShader"; }
+template<> const char* getTypeName<VkPipelineT> (void) { return "VkPipeline"; }
+template<> const char* getTypeName<VkPipelineLayoutT> (void) { return "VkPipelineLayout"; }
+template<> const char* getTypeName<VkSamplerT> (void) { return "VkSampler"; }
+template<> const char* getTypeName<VkDescriptorSetT> (void) { return "VkDescriptorSet"; }
+template<> const char* getTypeName<VkDescriptorSetLayoutT> (void) { return "VkDescriptorSetLayout"; }
+template<> const char* getTypeName<VkDescriptorPoolT> (void) { return "VkDescriptorPool"; }
+template<> const char* getTypeName<VkDynamicStateObjectT> (void) { return "VkDynamicStateObject"; }
+template<> const char* getTypeName<VkDynamicVpStateT> (void) { return "VkDynamicVpState"; }
+template<> const char* getTypeName<VkDynamicRsStateT> (void) { return "VkDynamicRsState"; }
+template<> const char* getTypeName<VkDynamicCbStateT> (void) { return "VkDynamicCbState"; }
+template<> const char* getTypeName<VkDynamicDsStateT> (void) { return "VkDynamicDsState"; }
+template<> const char* getTypeName<VkFenceT> (void) { return "VkFence"; }
+template<> const char* getTypeName<VkSemaphoreT> (void) { return "VkSemaphore"; }
+template<> const char* getTypeName<VkEventT> (void) { return "VkEvent"; }
+template<> const char* getTypeName<VkQueryPoolT> (void) { return "VkQueryPool"; }
+template<> const char* getTypeName<VkFramebufferT> (void) { return "VkFramebuffer"; }
+template<> const char* getTypeName<VkRenderPassT> (void) { return "VkRenderPass"; }
+
+const char* getMemoryPriorityName (VkMemoryPriority value)
+{
+ switch (value)
+ {
+ case VK_MEMORY_PRIORITY_UNUSED: return "VK_MEMORY_PRIORITY_UNUSED";
+ case VK_MEMORY_PRIORITY_VERY_LOW: return "VK_MEMORY_PRIORITY_VERY_LOW";
+ case VK_MEMORY_PRIORITY_LOW: return "VK_MEMORY_PRIORITY_LOW";
+ case VK_MEMORY_PRIORITY_NORMAL: return "VK_MEMORY_PRIORITY_NORMAL";
+ case VK_MEMORY_PRIORITY_HIGH: return "VK_MEMORY_PRIORITY_HIGH";
+ case VK_MEMORY_PRIORITY_VERY_HIGH: return "VK_MEMORY_PRIORITY_VERY_HIGH";
+ 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_CLEAR_OPTIMAL: return "VK_IMAGE_LAYOUT_CLEAR_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* getPipeEventName (VkPipeEvent value)
+{
+ switch (value)
+ {
+ case VK_PIPE_EVENT_TOP_OF_PIPE: return "VK_PIPE_EVENT_TOP_OF_PIPE";
+ case VK_PIPE_EVENT_VERTEX_PROCESSING_COMPLETE: return "VK_PIPE_EVENT_VERTEX_PROCESSING_COMPLETE";
+ case VK_PIPE_EVENT_LOCAL_FRAGMENT_PROCESSING_COMPLETE: return "VK_PIPE_EVENT_LOCAL_FRAGMENT_PROCESSING_COMPLETE";
+ case VK_PIPE_EVENT_FRAGMENT_PROCESSING_COMPLETE: return "VK_PIPE_EVENT_FRAGMENT_PROCESSING_COMPLETE";
+ case VK_PIPE_EVENT_GRAPHICS_PIPELINE_COMPLETE: return "VK_PIPE_EVENT_GRAPHICS_PIPELINE_COMPLETE";
+ case VK_PIPE_EVENT_COMPUTE_PIPELINE_COMPLETE: return "VK_PIPE_EVENT_COMPUTE_PIPELINE_COMPLETE";
+ case VK_PIPE_EVENT_TRANSFER_COMPLETE: return "VK_PIPE_EVENT_TRANSFER_COMPLETE";
+ case VK_PIPE_EVENT_COMMANDS_COMPLETE: return "VK_PIPE_EVENT_COMMANDS_COMPLETE";
+ default: return DE_NULL;
+ }
+}
+
+const char* getWaitEventName (VkWaitEvent value)
+{
+ switch (value)
+ {
+ case VK_WAIT_EVENT_TOP_OF_PIPE: return "VK_WAIT_EVENT_TOP_OF_PIPE";
+ case VK_WAIT_EVENT_BEFORE_RASTERIZATION: return "VK_WAIT_EVENT_BEFORE_RASTERIZATION";
+ default: return DE_NULL;
+ }
+}
+
+const char* getAttachmentLoadOpName (VkAttachmentLoadOp value)
+{
+ switch (value)
+ {
+ case VK_ATTACHMENT_LOAD_OP_LOAD: return "VK_ATTACHMENT_LOAD_OP_LOAD";
+ case VK_ATTACHMENT_LOAD_OP_CLEAR: return "VK_ATTACHMENT_LOAD_OP_CLEAR";
+ case VK_ATTACHMENT_LOAD_OP_DONT_CARE: return "VK_ATTACHMENT_LOAD_OP_DONT_CARE";
+ default: return DE_NULL;
+ }
+}
+
+const char* getAttachmentStoreOpName (VkAttachmentStoreOp value)
+{
+ switch (value)
+ {
+ case VK_ATTACHMENT_STORE_OP_STORE: return "VK_ATTACHMENT_STORE_OP_STORE";
+ case VK_ATTACHMENT_STORE_OP_RESOLVE_MSAA: return "VK_ATTACHMENT_STORE_OP_RESOLVE_MSAA";
+ case VK_ATTACHMENT_STORE_OP_DONT_CARE: return "VK_ATTACHMENT_STORE_OP_DONT_CARE";
+ default: return DE_NULL;
+ }
+}
+
+const char* getImageTypeName (VkImageType value)
+{
+ switch (value)
+ {
+ case VK_IMAGE_TYPE_1D: return "VK_IMAGE_TYPE_1D";
+ case VK_IMAGE_TYPE_2D: return "VK_IMAGE_TYPE_2D";
+ case VK_IMAGE_TYPE_3D: return "VK_IMAGE_TYPE_3D";
+ default: return DE_NULL;
+ }
+}
+
+const char* getImageTilingName (VkImageTiling value)
+{
+ switch (value)
+ {
+ case VK_IMAGE_TILING_LINEAR: return "VK_IMAGE_TILING_LINEAR";
+ case VK_IMAGE_TILING_OPTIMAL: return "VK_IMAGE_TILING_OPTIMAL";
+ default: return DE_NULL;
+ }
+}
+
+const char* getImageViewTypeName (VkImageViewType value)
+{
+ switch (value)
+ {
+ case VK_IMAGE_VIEW_TYPE_1D: return "VK_IMAGE_VIEW_TYPE_1D";
+ case VK_IMAGE_VIEW_TYPE_2D: return "VK_IMAGE_VIEW_TYPE_2D";
+ case VK_IMAGE_VIEW_TYPE_3D: return "VK_IMAGE_VIEW_TYPE_3D";
+ case VK_IMAGE_VIEW_TYPE_CUBE: return "VK_IMAGE_VIEW_TYPE_CUBE";
+ default: return DE_NULL;
+ }
+}
+
+const char* getImageAspectName (VkImageAspect value)
+{
+ switch (value)
+ {
+ case VK_IMAGE_ASPECT_COLOR: return "VK_IMAGE_ASPECT_COLOR";
+ case VK_IMAGE_ASPECT_DEPTH: return "VK_IMAGE_ASPECT_DEPTH";
+ case VK_IMAGE_ASPECT_STENCIL: return "VK_IMAGE_ASPECT_STENCIL";
+ default: return DE_NULL;
+ }
+}
+
+const char* getBufferViewTypeName (VkBufferViewType 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;
+ }
+}
+
+const char* getChannelSwizzleName (VkChannelSwizzle value)
+{
+ switch (value)
+ {
+ case VK_CHANNEL_SWIZZLE_ZERO: return "VK_CHANNEL_SWIZZLE_ZERO";
+ case VK_CHANNEL_SWIZZLE_ONE: return "VK_CHANNEL_SWIZZLE_ONE";
+ case VK_CHANNEL_SWIZZLE_R: return "VK_CHANNEL_SWIZZLE_R";
+ case VK_CHANNEL_SWIZZLE_G: return "VK_CHANNEL_SWIZZLE_G";
+ case VK_CHANNEL_SWIZZLE_B: return "VK_CHANNEL_SWIZZLE_B";
+ case VK_CHANNEL_SWIZZLE_A: return "VK_CHANNEL_SWIZZLE_A";
+ default: return DE_NULL;
+ }
+}
+
+const char* getDescriptorTypeName (VkDescriptorType value)
+{
+ switch (value)
+ {
+ case VK_DESCRIPTOR_TYPE_SAMPLER: return "VK_DESCRIPTOR_TYPE_SAMPLER";
+ case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: return "VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER";
+ case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: return "VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE";
+ case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: return "VK_DESCRIPTOR_TYPE_STORAGE_IMAGE";
+ case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: return "VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER";
+ case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: return "VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER";
+ case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: return "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER";
+ case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: return "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER";
+ case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: return "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC";
+ case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: return "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC";
+ default: return DE_NULL;
+ }
+}
+
+const char* getDescriptorPoolUsageName (VkDescriptorPoolUsage value)
+{
+ switch (value)
+ {
+ case VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT: return "VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT";
+ case VK_DESCRIPTOR_POOL_USAGE_DYNAMIC: return "VK_DESCRIPTOR_POOL_USAGE_DYNAMIC";
+ default: return DE_NULL;
+ }
+}
+
+const char* getDescriptorUpdateModeName (VkDescriptorUpdateMode value)
+{
+ switch (value)
+ {
+ case VK_DESCRIPTOR_UPDATE_MODE_COPY: return "VK_DESCRIPTOR_UPDATE_MODE_COPY";
+ case VK_DESCRIPTOR_UPDATE_MODE_FASTEST: return "VK_DESCRIPTOR_UPDATE_MODE_FASTEST";
+ default: return DE_NULL;
+ }
+}
+
+const char* getDescriptorSetUsageName (VkDescriptorSetUsage value)
+{
+ switch (value)
+ {
+ case VK_DESCRIPTOR_SET_USAGE_ONE_SHOT: return "VK_DESCRIPTOR_SET_USAGE_ONE_SHOT";
+ case VK_DESCRIPTOR_SET_USAGE_STATIC: return "VK_DESCRIPTOR_SET_USAGE_STATIC";
+ default: return DE_NULL;
+ }
+}
+
+const char* getQueryTypeName (VkQueryType value)
+{
+ switch (value)
+ {
+ case VK_QUERY_TYPE_OCCLUSION: return "VK_QUERY_TYPE_OCCLUSION";
+ case VK_QUERY_TYPE_PIPELINE_STATISTICS: return "VK_QUERY_TYPE_PIPELINE_STATISTICS";
+ default: return DE_NULL;
+ }
+}
+
+const char* getTimestampTypeName (VkTimestampType value)
+{
+ switch (value)
+ {
+ case VK_TIMESTAMP_TYPE_TOP: return "VK_TIMESTAMP_TYPE_TOP";
+ case VK_TIMESTAMP_TYPE_BOTTOM: return "VK_TIMESTAMP_TYPE_BOTTOM";
+ default: return DE_NULL;
+ }
+}
+
+const char* getBorderColorName (VkBorderColor value)
+{
+ switch (value)
+ {
+ case VK_BORDER_COLOR_OPAQUE_WHITE: return "VK_BORDER_COLOR_OPAQUE_WHITE";
+ case VK_BORDER_COLOR_TRANSPARENT_BLACK: return "VK_BORDER_COLOR_TRANSPARENT_BLACK";
+ case VK_BORDER_COLOR_OPAQUE_BLACK: return "VK_BORDER_COLOR_OPAQUE_BLACK";
+ default: return DE_NULL;
+ }
+}
+
+const char* getPipelineBindPointName (VkPipelineBindPoint value)
+{
+ switch (value)
+ {
+ case VK_PIPELINE_BIND_POINT_COMPUTE: return "VK_PIPELINE_BIND_POINT_COMPUTE";
+ case VK_PIPELINE_BIND_POINT_GRAPHICS: return "VK_PIPELINE_BIND_POINT_GRAPHICS";
+ default: return DE_NULL;
+ }
+}
+
+const char* getStateBindPointName (VkStateBindPoint value)
+{
+ switch (value)
+ {
+ case VK_STATE_BIND_POINT_VIEWPORT: return "VK_STATE_BIND_POINT_VIEWPORT";
+ case VK_STATE_BIND_POINT_RASTER: return "VK_STATE_BIND_POINT_RASTER";
+ case VK_STATE_BIND_POINT_COLOR_BLEND: return "VK_STATE_BIND_POINT_COLOR_BLEND";
+ case VK_STATE_BIND_POINT_DEPTH_STENCIL: return "VK_STATE_BIND_POINT_DEPTH_STENCIL";
+ default: return DE_NULL;
+ }
+}
+
+const char* getPrimitiveTopologyName (VkPrimitiveTopology value)
+{
+ switch (value)
+ {
+ case VK_PRIMITIVE_TOPOLOGY_POINT_LIST: return "VK_PRIMITIVE_TOPOLOGY_POINT_LIST";
+ case VK_PRIMITIVE_TOPOLOGY_LINE_LIST: return "VK_PRIMITIVE_TOPOLOGY_LINE_LIST";
+ case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP: return "VK_PRIMITIVE_TOPOLOGY_LINE_STRIP";
+ case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST: return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST";
+ case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP: return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP";
+ case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN: return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN";
+ case VK_PRIMITIVE_TOPOLOGY_LINE_LIST_ADJ: return "VK_PRIMITIVE_TOPOLOGY_LINE_LIST_ADJ";
+ case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_ADJ: return "VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_ADJ";
+ case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_ADJ: return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_ADJ";
+ case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_ADJ: return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_ADJ";
+ case VK_PRIMITIVE_TOPOLOGY_PATCH: return "VK_PRIMITIVE_TOPOLOGY_PATCH";
+ default: return DE_NULL;
+ }
+}
+
+const char* getIndexTypeName (VkIndexType value)
+{
+ switch (value)
+ {
+ case VK_INDEX_TYPE_UINT8: return "VK_INDEX_TYPE_UINT8";
+ case VK_INDEX_TYPE_UINT16: return "VK_INDEX_TYPE_UINT16";
+ case VK_INDEX_TYPE_UINT32: return "VK_INDEX_TYPE_UINT32";
+ default: return DE_NULL;
+ }
+}
+
+const char* getTexFilterName (VkTexFilter value)
+{
+ switch (value)
+ {
+ case VK_TEX_FILTER_NEAREST: return "VK_TEX_FILTER_NEAREST";
+ case VK_TEX_FILTER_LINEAR: return "VK_TEX_FILTER_LINEAR";
+ default: return DE_NULL;
+ }
+}
+
+const char* getTexMipmapModeName (VkTexMipmapMode value)
+{
+ switch (value)
+ {
+ case VK_TEX_MIPMAP_MODE_BASE: return "VK_TEX_MIPMAP_MODE_BASE";
+ case VK_TEX_MIPMAP_MODE_NEAREST: return "VK_TEX_MIPMAP_MODE_NEAREST";
+ case VK_TEX_MIPMAP_MODE_LINEAR: return "VK_TEX_MIPMAP_MODE_LINEAR";
+ default: return DE_NULL;
+ }
+}
+
+const char* getTexAddressName (VkTexAddress 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;
+ }
+}
+
+const char* getCompareOpName (VkCompareOp value)
+{
+ switch (value)
+ {
+ case VK_COMPARE_OP_NEVER: return "VK_COMPARE_OP_NEVER";
+ case VK_COMPARE_OP_LESS: return "VK_COMPARE_OP_LESS";
+ case VK_COMPARE_OP_EQUAL: return "VK_COMPARE_OP_EQUAL";
+ case VK_COMPARE_OP_LESS_EQUAL: return "VK_COMPARE_OP_LESS_EQUAL";
+ case VK_COMPARE_OP_GREATER: return "VK_COMPARE_OP_GREATER";
+ case VK_COMPARE_OP_NOT_EQUAL: return "VK_COMPARE_OP_NOT_EQUAL";
+ case VK_COMPARE_OP_GREATER_EQUAL: return "VK_COMPARE_OP_GREATER_EQUAL";
+ case VK_COMPARE_OP_ALWAYS: return "VK_COMPARE_OP_ALWAYS";
+ default: return DE_NULL;
+ }
+}
+
+const char* getFillModeName (VkFillMode value)
+{
+ switch (value)
+ {
+ case VK_FILL_MODE_POINTS: return "VK_FILL_MODE_POINTS";
+ case VK_FILL_MODE_WIREFRAME: return "VK_FILL_MODE_WIREFRAME";
+ case VK_FILL_MODE_SOLID: return "VK_FILL_MODE_SOLID";
+ default: return DE_NULL;
+ }
+}
+
+const char* getCullModeName (VkCullMode value)
+{
+ switch (value)
+ {
+ case VK_CULL_MODE_NONE: return "VK_CULL_MODE_NONE";
+ case VK_CULL_MODE_FRONT: return "VK_CULL_MODE_FRONT";
+ case VK_CULL_MODE_BACK: return "VK_CULL_MODE_BACK";
+ case VK_CULL_MODE_FRONT_AND_BACK: return "VK_CULL_MODE_FRONT_AND_BACK";
+ default: return DE_NULL;
+ }
+}
+
+const char* getFrontFaceName (VkFrontFace value)
+{
+ switch (value)
+ {
+ case VK_FRONT_FACE_CCW: return "VK_FRONT_FACE_CCW";
+ case VK_FRONT_FACE_CW: return "VK_FRONT_FACE_CW";
+ default: return DE_NULL;
+ }
+}
+
+const char* getProvokingVertexName (VkProvokingVertex value)
+{
+ switch (value)
+ {
+ case VK_PROVOKING_VERTEX_FIRST: return "VK_PROVOKING_VERTEX_FIRST";
+ case VK_PROVOKING_VERTEX_LAST: return "VK_PROVOKING_VERTEX_LAST";
+ default: return DE_NULL;
+ }
+}
+
+const char* getCoordinateOriginName (VkCoordinateOrigin value)
+{
+ switch (value)
+ {
+ case VK_COORDINATE_ORIGIN_UPPER_LEFT: return "VK_COORDINATE_ORIGIN_UPPER_LEFT";
+ case VK_COORDINATE_ORIGIN_LOWER_LEFT: return "VK_COORDINATE_ORIGIN_LOWER_LEFT";
+ default: return DE_NULL;
+ }
+}
+
+const char* getDepthModeName (VkDepthMode value)
+{
+ switch (value)
+ {
+ case VK_DEPTH_MODE_ZERO_TO_ONE: return "VK_DEPTH_MODE_ZERO_TO_ONE";
+ case VK_DEPTH_MODE_NEGATIVE_ONE_TO_ONE: return "VK_DEPTH_MODE_NEGATIVE_ONE_TO_ONE";
+ default: return DE_NULL;
+ }
+}
+
+const char* getBlendName (VkBlend value)
+{
+ switch (value)
+ {
+ case VK_BLEND_ZERO: return "VK_BLEND_ZERO";
+ case VK_BLEND_ONE: return "VK_BLEND_ONE";
+ case VK_BLEND_SRC_COLOR: return "VK_BLEND_SRC_COLOR";
+ case VK_BLEND_ONE_MINUS_SRC_COLOR: return "VK_BLEND_ONE_MINUS_SRC_COLOR";
+ case VK_BLEND_DEST_COLOR: return "VK_BLEND_DEST_COLOR";
+ case VK_BLEND_ONE_MINUS_DEST_COLOR: return "VK_BLEND_ONE_MINUS_DEST_COLOR";
+ case VK_BLEND_SRC_ALPHA: return "VK_BLEND_SRC_ALPHA";
+ case VK_BLEND_ONE_MINUS_SRC_ALPHA: return "VK_BLEND_ONE_MINUS_SRC_ALPHA";
+ case VK_BLEND_DEST_ALPHA: return "VK_BLEND_DEST_ALPHA";
+ case VK_BLEND_ONE_MINUS_DEST_ALPHA: return "VK_BLEND_ONE_MINUS_DEST_ALPHA";
+ case VK_BLEND_CONSTANT_COLOR: return "VK_BLEND_CONSTANT_COLOR";
+ case VK_BLEND_ONE_MINUS_CONSTANT_COLOR: return "VK_BLEND_ONE_MINUS_CONSTANT_COLOR";
+ case VK_BLEND_CONSTANT_ALPHA: return "VK_BLEND_CONSTANT_ALPHA";
+ case VK_BLEND_ONE_MINUS_CONSTANT_ALPHA: return "VK_BLEND_ONE_MINUS_CONSTANT_ALPHA";
+ case VK_BLEND_SRC_ALPHA_SATURATE: return "VK_BLEND_SRC_ALPHA_SATURATE";
+ case VK_BLEND_SRC1_COLOR: return "VK_BLEND_SRC1_COLOR";
+ case VK_BLEND_ONE_MINUS_SRC1_COLOR: return "VK_BLEND_ONE_MINUS_SRC1_COLOR";
+ case VK_BLEND_SRC1_ALPHA: return "VK_BLEND_SRC1_ALPHA";
+ case VK_BLEND_ONE_MINUS_SRC1_ALPHA: return "VK_BLEND_ONE_MINUS_SRC1_ALPHA";
+ default: return DE_NULL;
+ }
+}
+
+const char* getBlendOpName (VkBlendOp value)
+{
+ switch (value)
+ {
+ case VK_BLEND_OP_ADD: return "VK_BLEND_OP_ADD";
+ case VK_BLEND_OP_SUBTRACT: return "VK_BLEND_OP_SUBTRACT";
+ case VK_BLEND_OP_REVERSE_SUBTRACT: return "VK_BLEND_OP_REVERSE_SUBTRACT";
+ case VK_BLEND_OP_MIN: return "VK_BLEND_OP_MIN";
+ case VK_BLEND_OP_MAX: return "VK_BLEND_OP_MAX";
+ default: return DE_NULL;
+ }
+}
+
+const char* getStencilOpName (VkStencilOp value)
+{
+ switch (value)
+ {
+ case VK_STENCIL_OP_KEEP: return "VK_STENCIL_OP_KEEP";
+ case VK_STENCIL_OP_ZERO: return "VK_STENCIL_OP_ZERO";
+ case VK_STENCIL_OP_REPLACE: return "VK_STENCIL_OP_REPLACE";
+ case VK_STENCIL_OP_INC_CLAMP: return "VK_STENCIL_OP_INC_CLAMP";
+ case VK_STENCIL_OP_DEC_CLAMP: return "VK_STENCIL_OP_DEC_CLAMP";
+ case VK_STENCIL_OP_INVERT: return "VK_STENCIL_OP_INVERT";
+ case VK_STENCIL_OP_INC_WRAP: return "VK_STENCIL_OP_INC_WRAP";
+ case VK_STENCIL_OP_DEC_WRAP: return "VK_STENCIL_OP_DEC_WRAP";
+ default: return DE_NULL;
+ }
+}
+
+const char* getLogicOpName (VkLogicOp value)
+{
+ switch (value)
+ {
+ case VK_LOGIC_OP_COPY: return "VK_LOGIC_OP_COPY";
+ case VK_LOGIC_OP_CLEAR: return "VK_LOGIC_OP_CLEAR";
+ case VK_LOGIC_OP_AND: return "VK_LOGIC_OP_AND";
+ case VK_LOGIC_OP_AND_REVERSE: return "VK_LOGIC_OP_AND_REVERSE";
+ case VK_LOGIC_OP_AND_INVERTED: return "VK_LOGIC_OP_AND_INVERTED";
+ case VK_LOGIC_OP_NOOP: return "VK_LOGIC_OP_NOOP";
+ case VK_LOGIC_OP_XOR: return "VK_LOGIC_OP_XOR";
+ case VK_LOGIC_OP_OR: return "VK_LOGIC_OP_OR";
+ case VK_LOGIC_OP_NOR: return "VK_LOGIC_OP_NOR";
+ case VK_LOGIC_OP_EQUIV: return "VK_LOGIC_OP_EQUIV";
+ case VK_LOGIC_OP_INVERT: return "VK_LOGIC_OP_INVERT";
+ case VK_LOGIC_OP_OR_REVERSE: return "VK_LOGIC_OP_OR_REVERSE";
+ case VK_LOGIC_OP_COPY_INVERTED: return "VK_LOGIC_OP_COPY_INVERTED";
+ case VK_LOGIC_OP_OR_INVERTED: return "VK_LOGIC_OP_OR_INVERTED";
+ case VK_LOGIC_OP_NAND: return "VK_LOGIC_OP_NAND";
+ case VK_LOGIC_OP_SET: return "VK_LOGIC_OP_SET";
+ default: return DE_NULL;
+ }
+}
+
+const char* getSystemAllocTypeName (VkSystemAllocType value)
+{
+ switch (value)
+ {
+ case VK_SYSTEM_ALLOC_TYPE_API_OBJECT: return "VK_SYSTEM_ALLOC_TYPE_API_OBJECT";
+ case VK_SYSTEM_ALLOC_TYPE_INTERNAL: return "VK_SYSTEM_ALLOC_TYPE_INTERNAL";
+ case VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP: return "VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP";
+ case VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER: return "VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER";
+ case VK_SYSTEM_ALLOC_TYPE_DEBUG: return "VK_SYSTEM_ALLOC_TYPE_DEBUG";
+ default: return DE_NULL;
+ }
+}
+
+const char* getPhysicalDeviceTypeName (VkPhysicalDeviceType value)
+{
+ switch (value)
+ {
+ case VK_PHYSICAL_DEVICE_TYPE_OTHER: return "VK_PHYSICAL_DEVICE_TYPE_OTHER";
+ case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU: return "VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU";
+ case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU: return "VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU";
+ case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU: return "VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU";
+ case VK_PHYSICAL_DEVICE_TYPE_CPU: return "VK_PHYSICAL_DEVICE_TYPE_CPU";
+ default: return DE_NULL;
+ }
+}
+
+const char* getPhysicalDeviceInfoTypeName (VkPhysicalDeviceInfoType value)
+{
+ switch (value)
+ {
+ case VK_PHYSICAL_DEVICE_INFO_TYPE_PROPERTIES: return "VK_PHYSICAL_DEVICE_INFO_TYPE_PROPERTIES";
+ case VK_PHYSICAL_DEVICE_INFO_TYPE_PERFORMANCE: return "VK_PHYSICAL_DEVICE_INFO_TYPE_PERFORMANCE";
+ case VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PROPERTIES: return "VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PROPERTIES";
+ case VK_PHYSICAL_DEVICE_INFO_TYPE_MEMORY_PROPERTIES: return "VK_PHYSICAL_DEVICE_INFO_TYPE_MEMORY_PROPERTIES";
+ default: return DE_NULL;
+ }
+}
+
+const char* getExtensionInfoTypeName (VkExtensionInfoType value)
+{
+ switch (value)
+ {
+ case VK_EXTENSION_INFO_TYPE_COUNT: return "VK_EXTENSION_INFO_TYPE_COUNT";
+ case VK_EXTENSION_INFO_TYPE_PROPERTIES: return "VK_EXTENSION_INFO_TYPE_PROPERTIES";
+ default: return DE_NULL;
+ }
+}
+
+const char* getFormatInfoTypeName (VkFormatInfoType value)
+{
+ switch (value)
+ {
+ case VK_FORMAT_INFO_TYPE_PROPERTIES: return "VK_FORMAT_INFO_TYPE_PROPERTIES";
+ default: return DE_NULL;
+ }
+}
+
+const char* getSubresourceInfoTypeName (VkSubresourceInfoType value)
+{
+ switch (value)
+ {
+ case VK_SUBRESOURCE_INFO_TYPE_LAYOUT: return "VK_SUBRESOURCE_INFO_TYPE_LAYOUT";
+ default: return DE_NULL;
+ }
+}
+
+const char* getObjectInfoTypeName (VkObjectInfoType value)
+{
+ switch (value)
+ {
+ case VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT: return "VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT";
+ case VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS: return "VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS";
+ default: return DE_NULL;
+ }
+}
+
+const char* getVertexInputStepRateName (VkVertexInputStepRate value)
+{
+ switch (value)
+ {
+ case VK_VERTEX_INPUT_STEP_RATE_VERTEX: return "VK_VERTEX_INPUT_STEP_RATE_VERTEX";
+ case VK_VERTEX_INPUT_STEP_RATE_INSTANCE: return "VK_VERTEX_INPUT_STEP_RATE_INSTANCE";
+ case VK_VERTEX_INPUT_STEP_RATE_DRAW: return "VK_VERTEX_INPUT_STEP_RATE_DRAW";
+ default: return DE_NULL;
+ }
+}
+
+const char* getFormatName (VkFormat value)
+{
+ switch (value)
+ {
+ case VK_FORMAT_UNDEFINED: return "VK_FORMAT_UNDEFINED";
+ case VK_FORMAT_R4G4_UNORM: return "VK_FORMAT_R4G4_UNORM";
+ case VK_FORMAT_R4G4_USCALED: return "VK_FORMAT_R4G4_USCALED";
+ case VK_FORMAT_R4G4B4A4_UNORM: return "VK_FORMAT_R4G4B4A4_UNORM";
+ case VK_FORMAT_R4G4B4A4_USCALED: return "VK_FORMAT_R4G4B4A4_USCALED";
+ case VK_FORMAT_R5G6B5_UNORM: return "VK_FORMAT_R5G6B5_UNORM";
+ case VK_FORMAT_R5G6B5_USCALED: return "VK_FORMAT_R5G6B5_USCALED";
+ case VK_FORMAT_R5G5B5A1_UNORM: return "VK_FORMAT_R5G5B5A1_UNORM";
+ case VK_FORMAT_R5G5B5A1_USCALED: return "VK_FORMAT_R5G5B5A1_USCALED";
+ case VK_FORMAT_R8_UNORM: return "VK_FORMAT_R8_UNORM";
+ case VK_FORMAT_R8_SNORM: return "VK_FORMAT_R8_SNORM";
+ case VK_FORMAT_R8_USCALED: return "VK_FORMAT_R8_USCALED";
+ case VK_FORMAT_R8_SSCALED: return "VK_FORMAT_R8_SSCALED";
+ case VK_FORMAT_R8_UINT: return "VK_FORMAT_R8_UINT";
+ case VK_FORMAT_R8_SINT: return "VK_FORMAT_R8_SINT";
+ case VK_FORMAT_R8_SRGB: return "VK_FORMAT_R8_SRGB";
+ case VK_FORMAT_R8G8_UNORM: return "VK_FORMAT_R8G8_UNORM";
+ case VK_FORMAT_R8G8_SNORM: return "VK_FORMAT_R8G8_SNORM";
+ case VK_FORMAT_R8G8_USCALED: return "VK_FORMAT_R8G8_USCALED";
+ case VK_FORMAT_R8G8_SSCALED: return "VK_FORMAT_R8G8_SSCALED";
+ case VK_FORMAT_R8G8_UINT: return "VK_FORMAT_R8G8_UINT";
+ case VK_FORMAT_R8G8_SINT: return "VK_FORMAT_R8G8_SINT";
+ case VK_FORMAT_R8G8_SRGB: return "VK_FORMAT_R8G8_SRGB";
+ case VK_FORMAT_R8G8B8_UNORM: return "VK_FORMAT_R8G8B8_UNORM";
+ case VK_FORMAT_R8G8B8_SNORM: return "VK_FORMAT_R8G8B8_SNORM";
+ case VK_FORMAT_R8G8B8_USCALED: return "VK_FORMAT_R8G8B8_USCALED";
+ case VK_FORMAT_R8G8B8_SSCALED: return "VK_FORMAT_R8G8B8_SSCALED";
+ case VK_FORMAT_R8G8B8_UINT: return "VK_FORMAT_R8G8B8_UINT";
+ case VK_FORMAT_R8G8B8_SINT: return "VK_FORMAT_R8G8B8_SINT";
+ case VK_FORMAT_R8G8B8_SRGB: return "VK_FORMAT_R8G8B8_SRGB";
+ case VK_FORMAT_R8G8B8A8_UNORM: return "VK_FORMAT_R8G8B8A8_UNORM";
+ case VK_FORMAT_R8G8B8A8_SNORM: return "VK_FORMAT_R8G8B8A8_SNORM";
+ case VK_FORMAT_R8G8B8A8_USCALED: return "VK_FORMAT_R8G8B8A8_USCALED";
+ case VK_FORMAT_R8G8B8A8_SSCALED: return "VK_FORMAT_R8G8B8A8_SSCALED";
+ case VK_FORMAT_R8G8B8A8_UINT: return "VK_FORMAT_R8G8B8A8_UINT";
+ case VK_FORMAT_R8G8B8A8_SINT: return "VK_FORMAT_R8G8B8A8_SINT";
+ case VK_FORMAT_R8G8B8A8_SRGB: return "VK_FORMAT_R8G8B8A8_SRGB";
+ case VK_FORMAT_R10G10B10A2_UNORM: return "VK_FORMAT_R10G10B10A2_UNORM";
+ case VK_FORMAT_R10G10B10A2_SNORM: return "VK_FORMAT_R10G10B10A2_SNORM";
+ case VK_FORMAT_R10G10B10A2_USCALED: return "VK_FORMAT_R10G10B10A2_USCALED";
+ case VK_FORMAT_R10G10B10A2_SSCALED: return "VK_FORMAT_R10G10B10A2_SSCALED";
+ case VK_FORMAT_R10G10B10A2_UINT: return "VK_FORMAT_R10G10B10A2_UINT";
+ case VK_FORMAT_R10G10B10A2_SINT: return "VK_FORMAT_R10G10B10A2_SINT";
+ case VK_FORMAT_R16_UNORM: return "VK_FORMAT_R16_UNORM";
+ case VK_FORMAT_R16_SNORM: return "VK_FORMAT_R16_SNORM";
+ case VK_FORMAT_R16_USCALED: return "VK_FORMAT_R16_USCALED";
+ case VK_FORMAT_R16_SSCALED: return "VK_FORMAT_R16_SSCALED";
+ case VK_FORMAT_R16_UINT: return "VK_FORMAT_R16_UINT";
+ case VK_FORMAT_R16_SINT: return "VK_FORMAT_R16_SINT";
+ case VK_FORMAT_R16_SFLOAT: return "VK_FORMAT_R16_SFLOAT";
+ case VK_FORMAT_R16G16_UNORM: return "VK_FORMAT_R16G16_UNORM";
+ case VK_FORMAT_R16G16_SNORM: return "VK_FORMAT_R16G16_SNORM";
+ case VK_FORMAT_R16G16_USCALED: return "VK_FORMAT_R16G16_USCALED";
+ case VK_FORMAT_R16G16_SSCALED: return "VK_FORMAT_R16G16_SSCALED";
+ case VK_FORMAT_R16G16_UINT: return "VK_FORMAT_R16G16_UINT";
+ case VK_FORMAT_R16G16_SINT: return "VK_FORMAT_R16G16_SINT";
+ case VK_FORMAT_R16G16_SFLOAT: return "VK_FORMAT_R16G16_SFLOAT";
+ case VK_FORMAT_R16G16B16_UNORM: return "VK_FORMAT_R16G16B16_UNORM";
+ case VK_FORMAT_R16G16B16_SNORM: return "VK_FORMAT_R16G16B16_SNORM";
+ case VK_FORMAT_R16G16B16_USCALED: return "VK_FORMAT_R16G16B16_USCALED";
+ case VK_FORMAT_R16G16B16_SSCALED: return "VK_FORMAT_R16G16B16_SSCALED";
+ case VK_FORMAT_R16G16B16_UINT: return "VK_FORMAT_R16G16B16_UINT";
+ case VK_FORMAT_R16G16B16_SINT: return "VK_FORMAT_R16G16B16_SINT";
+ case VK_FORMAT_R16G16B16_SFLOAT: return "VK_FORMAT_R16G16B16_SFLOAT";
+ case VK_FORMAT_R16G16B16A16_UNORM: return "VK_FORMAT_R16G16B16A16_UNORM";
+ case VK_FORMAT_R16G16B16A16_SNORM: return "VK_FORMAT_R16G16B16A16_SNORM";
+ case VK_FORMAT_R16G16B16A16_USCALED: return "VK_FORMAT_R16G16B16A16_USCALED";
+ case VK_FORMAT_R16G16B16A16_SSCALED: return "VK_FORMAT_R16G16B16A16_SSCALED";
+ case VK_FORMAT_R16G16B16A16_UINT: return "VK_FORMAT_R16G16B16A16_UINT";
+ case VK_FORMAT_R16G16B16A16_SINT: return "VK_FORMAT_R16G16B16A16_SINT";
+ case VK_FORMAT_R16G16B16A16_SFLOAT: return "VK_FORMAT_R16G16B16A16_SFLOAT";
+ case VK_FORMAT_R32_UINT: return "VK_FORMAT_R32_UINT";
+ case VK_FORMAT_R32_SINT: return "VK_FORMAT_R32_SINT";
+ case VK_FORMAT_R32_SFLOAT: return "VK_FORMAT_R32_SFLOAT";
+ case VK_FORMAT_R32G32_UINT: return "VK_FORMAT_R32G32_UINT";
+ case VK_FORMAT_R32G32_SINT: return "VK_FORMAT_R32G32_SINT";
+ case VK_FORMAT_R32G32_SFLOAT: return "VK_FORMAT_R32G32_SFLOAT";
+ case VK_FORMAT_R32G32B32_UINT: return "VK_FORMAT_R32G32B32_UINT";
+ case VK_FORMAT_R32G32B32_SINT: return "VK_FORMAT_R32G32B32_SINT";
+ case VK_FORMAT_R32G32B32_SFLOAT: return "VK_FORMAT_R32G32B32_SFLOAT";
+ case VK_FORMAT_R32G32B32A32_UINT: return "VK_FORMAT_R32G32B32A32_UINT";
+ case VK_FORMAT_R32G32B32A32_SINT: return "VK_FORMAT_R32G32B32A32_SINT";
+ case VK_FORMAT_R32G32B32A32_SFLOAT: return "VK_FORMAT_R32G32B32A32_SFLOAT";
+ case VK_FORMAT_R64_SFLOAT: return "VK_FORMAT_R64_SFLOAT";
+ case VK_FORMAT_R64G64_SFLOAT: return "VK_FORMAT_R64G64_SFLOAT";
+ case VK_FORMAT_R64G64B64_SFLOAT: return "VK_FORMAT_R64G64B64_SFLOAT";
+ case VK_FORMAT_R64G64B64A64_SFLOAT: return "VK_FORMAT_R64G64B64A64_SFLOAT";
+ 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_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";
+ case VK_FORMAT_D24_UNORM_S8_UINT: return "VK_FORMAT_D24_UNORM_S8_UINT";
+ case VK_FORMAT_D32_SFLOAT_S8_UINT: return "VK_FORMAT_D32_SFLOAT_S8_UINT";
+ case VK_FORMAT_BC1_RGB_UNORM: return "VK_FORMAT_BC1_RGB_UNORM";
+ case VK_FORMAT_BC1_RGB_SRGB: return "VK_FORMAT_BC1_RGB_SRGB";
+ case VK_FORMAT_BC1_RGBA_UNORM: return "VK_FORMAT_BC1_RGBA_UNORM";
+ case VK_FORMAT_BC1_RGBA_SRGB: return "VK_FORMAT_BC1_RGBA_SRGB";
+ case VK_FORMAT_BC2_UNORM: return "VK_FORMAT_BC2_UNORM";
+ case VK_FORMAT_BC2_SRGB: return "VK_FORMAT_BC2_SRGB";
+ case VK_FORMAT_BC3_UNORM: return "VK_FORMAT_BC3_UNORM";
+ case VK_FORMAT_BC3_SRGB: return "VK_FORMAT_BC3_SRGB";
+ case VK_FORMAT_BC4_UNORM: return "VK_FORMAT_BC4_UNORM";
+ case VK_FORMAT_BC4_SNORM: return "VK_FORMAT_BC4_SNORM";
+ case VK_FORMAT_BC5_UNORM: return "VK_FORMAT_BC5_UNORM";
+ case VK_FORMAT_BC5_SNORM: return "VK_FORMAT_BC5_SNORM";
+ case VK_FORMAT_BC6H_UFLOAT: return "VK_FORMAT_BC6H_UFLOAT";
+ case VK_FORMAT_BC6H_SFLOAT: return "VK_FORMAT_BC6H_SFLOAT";
+ case VK_FORMAT_BC7_UNORM: return "VK_FORMAT_BC7_UNORM";
+ case VK_FORMAT_BC7_SRGB: return "VK_FORMAT_BC7_SRGB";
+ case VK_FORMAT_ETC2_R8G8B8_UNORM: return "VK_FORMAT_ETC2_R8G8B8_UNORM";
+ case VK_FORMAT_ETC2_R8G8B8_SRGB: return "VK_FORMAT_ETC2_R8G8B8_SRGB";
+ case VK_FORMAT_ETC2_R8G8B8A1_UNORM: return "VK_FORMAT_ETC2_R8G8B8A1_UNORM";
+ case VK_FORMAT_ETC2_R8G8B8A1_SRGB: return "VK_FORMAT_ETC2_R8G8B8A1_SRGB";
+ case VK_FORMAT_ETC2_R8G8B8A8_UNORM: return "VK_FORMAT_ETC2_R8G8B8A8_UNORM";
+ case VK_FORMAT_ETC2_R8G8B8A8_SRGB: return "VK_FORMAT_ETC2_R8G8B8A8_SRGB";
+ case VK_FORMAT_EAC_R11_UNORM: return "VK_FORMAT_EAC_R11_UNORM";
+ case VK_FORMAT_EAC_R11_SNORM: return "VK_FORMAT_EAC_R11_SNORM";
+ case VK_FORMAT_EAC_R11G11_UNORM: return "VK_FORMAT_EAC_R11G11_UNORM";
+ case VK_FORMAT_EAC_R11G11_SNORM: return "VK_FORMAT_EAC_R11G11_SNORM";
+ case VK_FORMAT_ASTC_4x4_UNORM: return "VK_FORMAT_ASTC_4x4_UNORM";
+ case VK_FORMAT_ASTC_4x4_SRGB: return "VK_FORMAT_ASTC_4x4_SRGB";
+ case VK_FORMAT_ASTC_5x4_UNORM: return "VK_FORMAT_ASTC_5x4_UNORM";
+ case VK_FORMAT_ASTC_5x4_SRGB: return "VK_FORMAT_ASTC_5x4_SRGB";
+ case VK_FORMAT_ASTC_5x5_UNORM: return "VK_FORMAT_ASTC_5x5_UNORM";
+ case VK_FORMAT_ASTC_5x5_SRGB: return "VK_FORMAT_ASTC_5x5_SRGB";
+ case VK_FORMAT_ASTC_6x5_UNORM: return "VK_FORMAT_ASTC_6x5_UNORM";
+ case VK_FORMAT_ASTC_6x5_SRGB: return "VK_FORMAT_ASTC_6x5_SRGB";
+ case VK_FORMAT_ASTC_6x6_UNORM: return "VK_FORMAT_ASTC_6x6_UNORM";
+ case VK_FORMAT_ASTC_6x6_SRGB: return "VK_FORMAT_ASTC_6x6_SRGB";
+ case VK_FORMAT_ASTC_8x5_UNORM: return "VK_FORMAT_ASTC_8x5_UNORM";
+ case VK_FORMAT_ASTC_8x5_SRGB: return "VK_FORMAT_ASTC_8x5_SRGB";
+ case VK_FORMAT_ASTC_8x6_UNORM: return "VK_FORMAT_ASTC_8x6_UNORM";
+ case VK_FORMAT_ASTC_8x6_SRGB: return "VK_FORMAT_ASTC_8x6_SRGB";
+ case VK_FORMAT_ASTC_8x8_UNORM: return "VK_FORMAT_ASTC_8x8_UNORM";
+ case VK_FORMAT_ASTC_8x8_SRGB: return "VK_FORMAT_ASTC_8x8_SRGB";
+ case VK_FORMAT_ASTC_10x5_UNORM: return "VK_FORMAT_ASTC_10x5_UNORM";
+ case VK_FORMAT_ASTC_10x5_SRGB: return "VK_FORMAT_ASTC_10x5_SRGB";
+ case VK_FORMAT_ASTC_10x6_UNORM: return "VK_FORMAT_ASTC_10x6_UNORM";
+ case VK_FORMAT_ASTC_10x6_SRGB: return "VK_FORMAT_ASTC_10x6_SRGB";
+ case VK_FORMAT_ASTC_10x8_UNORM: return "VK_FORMAT_ASTC_10x8_UNORM";
+ case VK_FORMAT_ASTC_10x8_SRGB: return "VK_FORMAT_ASTC_10x8_SRGB";
+ case VK_FORMAT_ASTC_10x10_UNORM: return "VK_FORMAT_ASTC_10x10_UNORM";
+ case VK_FORMAT_ASTC_10x10_SRGB: return "VK_FORMAT_ASTC_10x10_SRGB";
+ case VK_FORMAT_ASTC_12x10_UNORM: return "VK_FORMAT_ASTC_12x10_UNORM";
+ case VK_FORMAT_ASTC_12x10_SRGB: return "VK_FORMAT_ASTC_12x10_SRGB";
+ case VK_FORMAT_ASTC_12x12_UNORM: return "VK_FORMAT_ASTC_12x12_UNORM";
+ case VK_FORMAT_ASTC_12x12_SRGB: return "VK_FORMAT_ASTC_12x12_SRGB";
+ case VK_FORMAT_B4G4R4A4_UNORM: return "VK_FORMAT_B4G4R4A4_UNORM";
+ case VK_FORMAT_B5G5R5A1_UNORM: return "VK_FORMAT_B5G5R5A1_UNORM";
+ case VK_FORMAT_B5G6R5_UNORM: return "VK_FORMAT_B5G6R5_UNORM";
+ case VK_FORMAT_B5G6R5_USCALED: return "VK_FORMAT_B5G6R5_USCALED";
+ case VK_FORMAT_B8G8R8_UNORM: return "VK_FORMAT_B8G8R8_UNORM";
+ case VK_FORMAT_B8G8R8_SNORM: return "VK_FORMAT_B8G8R8_SNORM";
+ case VK_FORMAT_B8G8R8_USCALED: return "VK_FORMAT_B8G8R8_USCALED";
+ case VK_FORMAT_B8G8R8_SSCALED: return "VK_FORMAT_B8G8R8_SSCALED";
+ case VK_FORMAT_B8G8R8_UINT: return "VK_FORMAT_B8G8R8_UINT";
+ case VK_FORMAT_B8G8R8_SINT: return "VK_FORMAT_B8G8R8_SINT";
+ case VK_FORMAT_B8G8R8_SRGB: return "VK_FORMAT_B8G8R8_SRGB";
+ case VK_FORMAT_B8G8R8A8_UNORM: return "VK_FORMAT_B8G8R8A8_UNORM";
+ case VK_FORMAT_B8G8R8A8_SNORM: return "VK_FORMAT_B8G8R8A8_SNORM";
+ case VK_FORMAT_B8G8R8A8_USCALED: return "VK_FORMAT_B8G8R8A8_USCALED";
+ case VK_FORMAT_B8G8R8A8_SSCALED: return "VK_FORMAT_B8G8R8A8_SSCALED";
+ case VK_FORMAT_B8G8R8A8_UINT: return "VK_FORMAT_B8G8R8A8_UINT";
+ case VK_FORMAT_B8G8R8A8_SINT: return "VK_FORMAT_B8G8R8A8_SINT";
+ case VK_FORMAT_B8G8R8A8_SRGB: return "VK_FORMAT_B8G8R8A8_SRGB";
+ case VK_FORMAT_B10G10R10A2_UNORM: return "VK_FORMAT_B10G10R10A2_UNORM";
+ case VK_FORMAT_B10G10R10A2_SNORM: return "VK_FORMAT_B10G10R10A2_SNORM";
+ case VK_FORMAT_B10G10R10A2_USCALED: return "VK_FORMAT_B10G10R10A2_USCALED";
+ case VK_FORMAT_B10G10R10A2_SSCALED: return "VK_FORMAT_B10G10R10A2_SSCALED";
+ case VK_FORMAT_B10G10R10A2_UINT: return "VK_FORMAT_B10G10R10A2_UINT";
+ case VK_FORMAT_B10G10R10A2_SINT: return "VK_FORMAT_B10G10R10A2_SINT";
+ default: return DE_NULL;
+ }
+}
+
+const char* getShaderStageName (VkShaderStage value)
+{
+ switch (value)
+ {
+ case VK_SHADER_STAGE_VERTEX: return "VK_SHADER_STAGE_VERTEX";
+ case VK_SHADER_STAGE_TESS_CONTROL: return "VK_SHADER_STAGE_TESS_CONTROL";
+ case VK_SHADER_STAGE_TESS_EVALUATION: return "VK_SHADER_STAGE_TESS_EVALUATION";
+ case VK_SHADER_STAGE_GEOMETRY: return "VK_SHADER_STAGE_GEOMETRY";
+ case VK_SHADER_STAGE_FRAGMENT: return "VK_SHADER_STAGE_FRAGMENT";
+ case VK_SHADER_STAGE_COMPUTE: return "VK_SHADER_STAGE_COMPUTE";
+ default: return DE_NULL;
+ }
+}
+
+const char* getStructureTypeName (VkStructureType value)
+{
+ switch (value)
+ {
+ case VK_STRUCTURE_TYPE_APPLICATION_INFO: return "VK_STRUCTURE_TYPE_APPLICATION_INFO";
+ 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_MEMORY_OPEN_INFO: return "VK_STRUCTURE_TYPE_MEMORY_OPEN_INFO";
+ case VK_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO: return "VK_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO";
+ case VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO: return "VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO";
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO: return "VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO";
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: return "VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO: return "VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO: return "VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_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_VP_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_DYNAMIC_DS_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_SEMAPHORE_CREATE_INFO: return "VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO: return "VK_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO";
+ case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO: return "VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: return "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO: return "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO: return "VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO: return "VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO: return "VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO: return "VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO";
+ case VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO: return "VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO";
+ case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: return "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_LAYER_CREATE_INFO: return "VK_STRUCTURE_TYPE_LAYER_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_MEMORY_BARRIER: return "VK_STRUCTURE_TYPE_MEMORY_BARRIER";
+ case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: return "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER";
+ case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: return "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER";
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO: return "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS: return "VK_STRUCTURE_TYPE_UPDATE_SAMPLERS";
+ case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES: return "VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES";
+ case VK_STRUCTURE_TYPE_UPDATE_IMAGES: return "VK_STRUCTURE_TYPE_UPDATE_IMAGES";
+ case VK_STRUCTURE_TYPE_UPDATE_BUFFERS: return "VK_STRUCTURE_TYPE_UPDATE_BUFFERS";
+ case VK_STRUCTURE_TYPE_UPDATE_AS_COPY: return "VK_STRUCTURE_TYPE_UPDATE_AS_COPY";
+ case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO: return "VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO";
+ default: return DE_NULL;
+ }
+}
+
+const char* getObjectTypeName (VkObjectType value)
+{
+ switch (value)
+ {
+ case VK_OBJECT_TYPE_INSTANCE: return "VK_OBJECT_TYPE_INSTANCE";
+ case VK_OBJECT_TYPE_PHYSICAL_DEVICE: return "VK_OBJECT_TYPE_PHYSICAL_DEVICE";
+ case VK_OBJECT_TYPE_DEVICE: return "VK_OBJECT_TYPE_DEVICE";
+ case VK_OBJECT_TYPE_QUEUE: return "VK_OBJECT_TYPE_QUEUE";
+ case VK_OBJECT_TYPE_COMMAND_BUFFER: return "VK_OBJECT_TYPE_COMMAND_BUFFER";
+ case VK_OBJECT_TYPE_DEVICE_MEMORY: return "VK_OBJECT_TYPE_DEVICE_MEMORY";
+ case VK_OBJECT_TYPE_BUFFER: return "VK_OBJECT_TYPE_BUFFER";
+ case VK_OBJECT_TYPE_BUFFER_VIEW: return "VK_OBJECT_TYPE_BUFFER_VIEW";
+ case VK_OBJECT_TYPE_IMAGE: return "VK_OBJECT_TYPE_IMAGE";
+ case VK_OBJECT_TYPE_IMAGE_VIEW: return "VK_OBJECT_TYPE_IMAGE_VIEW";
+ case VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW: return "VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW";
+ case VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW: return "VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW";
+ case VK_OBJECT_TYPE_SHADER: return "VK_OBJECT_TYPE_SHADER";
+ case VK_OBJECT_TYPE_PIPELINE: return "VK_OBJECT_TYPE_PIPELINE";
+ case VK_OBJECT_TYPE_PIPELINE_LAYOUT: return "VK_OBJECT_TYPE_PIPELINE_LAYOUT";
+ case VK_OBJECT_TYPE_SAMPLER: return "VK_OBJECT_TYPE_SAMPLER";
+ case VK_OBJECT_TYPE_DESCRIPTOR_SET: return "VK_OBJECT_TYPE_DESCRIPTOR_SET";
+ case VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT: return "VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT";
+ case VK_OBJECT_TYPE_DESCRIPTOR_POOL: return "VK_OBJECT_TYPE_DESCRIPTOR_POOL";
+ case VK_OBJECT_TYPE_DYNAMIC_VP_STATE: return "VK_OBJECT_TYPE_DYNAMIC_VP_STATE";
+ case VK_OBJECT_TYPE_DYNAMIC_RS_STATE: return "VK_OBJECT_TYPE_DYNAMIC_RS_STATE";
+ case VK_OBJECT_TYPE_DYNAMIC_CB_STATE: return "VK_OBJECT_TYPE_DYNAMIC_CB_STATE";
+ case VK_OBJECT_TYPE_DYNAMIC_DS_STATE: return "VK_OBJECT_TYPE_DYNAMIC_DS_STATE";
+ case VK_OBJECT_TYPE_FENCE: return "VK_OBJECT_TYPE_FENCE";
+ case VK_OBJECT_TYPE_SEMAPHORE: return "VK_OBJECT_TYPE_SEMAPHORE";
+ case VK_OBJECT_TYPE_EVENT: return "VK_OBJECT_TYPE_EVENT";
+ case VK_OBJECT_TYPE_QUERY_POOL: return "VK_OBJECT_TYPE_QUERY_POOL";
+ case VK_OBJECT_TYPE_FRAMEBUFFER: return "VK_OBJECT_TYPE_FRAMEBUFFER";
+ case VK_OBJECT_TYPE_RENDER_PASS: return "VK_OBJECT_TYPE_RENDER_PASS";
+ default: return DE_NULL;
+ }
+}
+
+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_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_INVALID_OBJECT_TYPE: return "VK_ERROR_INVALID_OBJECT_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_TOO_MANY_MEMORY_REFERENCES: return "VK_ERROR_TOO_MANY_MEMORY_REFERENCES";
+ 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_NOT_SHAREABLE: return "VK_ERROR_NOT_SHAREABLE";
+ default: return DE_NULL;
+ }
+}
+
+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_DEVICE_CREATE_MULTI_DEVICE_IQ_MATCH_BIT, "VK_DEVICE_CREATE_MULTI_DEVICE_IQ_MATCH_BIT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getQueueFlagsStr (VkQueueFlags value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_QUEUE_GRAPHICS_BIT, "VK_QUEUE_GRAPHICS_BIT"),
+ tcu::Format::BitDesc(VK_QUEUE_COMPUTE_BIT, "VK_QUEUE_COMPUTE_BIT"),
+ tcu::Format::BitDesc(VK_QUEUE_DMA_BIT, "VK_QUEUE_DMA_BIT"),
+ tcu::Format::BitDesc(VK_QUEUE_MEMMGR_BIT, "VK_QUEUE_MEMMGR_BIT"),
+ tcu::Format::BitDesc(VK_QUEUE_EXTENDED_BIT, "VK_QUEUE_EXTENDED_BIT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getMemoryPropertyFlagsStr (VkMemoryPropertyFlags value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_MEMORY_PROPERTY_DEVICE_ONLY, "VK_MEMORY_PROPERTY_DEVICE_ONLY"),
+ tcu::Format::BitDesc(VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, "VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_PROPERTY_HOST_DEVICE_COHERENT_BIT, "VK_MEMORY_PROPERTY_HOST_DEVICE_COHERENT_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT, "VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT, "VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_PROPERTY_PREFER_HOST_LOCAL, "VK_MEMORY_PROPERTY_PREFER_HOST_LOCAL"),
+ tcu::Format::BitDesc(VK_MEMORY_PROPERTY_SHAREABLE_BIT, "VK_MEMORY_PROPERTY_SHAREABLE_BIT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getMemoryOutputFlagsStr (VkMemoryOutputFlags value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_MEMORY_OUTPUT_CPU_WRITE_BIT, "VK_MEMORY_OUTPUT_CPU_WRITE_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_OUTPUT_SHADER_WRITE_BIT, "VK_MEMORY_OUTPUT_SHADER_WRITE_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT, "VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT, "VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_OUTPUT_TRANSFER_BIT, "VK_MEMORY_OUTPUT_TRANSFER_BIT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getMemoryInputFlagsStr (VkMemoryInputFlags value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_MEMORY_INPUT_CPU_READ_BIT, "VK_MEMORY_INPUT_CPU_READ_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT, "VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_INPUT_INDEX_FETCH_BIT, "VK_MEMORY_INPUT_INDEX_FETCH_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT, "VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_INPUT_UNIFORM_READ_BIT, "VK_MEMORY_INPUT_UNIFORM_READ_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_INPUT_SHADER_READ_BIT, "VK_MEMORY_INPUT_SHADER_READ_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT, "VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT, "VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_INPUT_TRANSFER_BIT, "VK_MEMORY_INPUT_TRANSFER_BIT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getBufferUsageFlagsStr (VkBufferUsageFlags value)
+{
+ 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"),
+ tcu::Format::BitDesc(VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, "VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT"),
+ tcu::Format::BitDesc(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, "VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT"),
+ tcu::Format::BitDesc(VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, "VK_BUFFER_USAGE_STORAGE_BUFFER_BIT"),
+ tcu::Format::BitDesc(VK_BUFFER_USAGE_INDEX_BUFFER_BIT, "VK_BUFFER_USAGE_INDEX_BUFFER_BIT"),
+ tcu::Format::BitDesc(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, "VK_BUFFER_USAGE_VERTEX_BUFFER_BIT"),
+ tcu::Format::BitDesc(VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT, "VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getBufferCreateFlagsStr (VkBufferCreateFlags value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_BUFFER_CREATE_SHAREABLE_BIT, "VK_BUFFER_CREATE_SHAREABLE_BIT"),
+ tcu::Format::BitDesc(VK_BUFFER_CREATE_SPARSE_BIT, "VK_BUFFER_CREATE_SPARSE_BIT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getShaderStageFlagsStr (VkShaderStageFlags value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_SHADER_STAGE_VERTEX_BIT, "VK_SHADER_STAGE_VERTEX_BIT"),
+ tcu::Format::BitDesc(VK_SHADER_STAGE_TESS_CONTROL_BIT, "VK_SHADER_STAGE_TESS_CONTROL_BIT"),
+ tcu::Format::BitDesc(VK_SHADER_STAGE_TESS_EVALUATION_BIT, "VK_SHADER_STAGE_TESS_EVALUATION_BIT"),
+ tcu::Format::BitDesc(VK_SHADER_STAGE_GEOMETRY_BIT, "VK_SHADER_STAGE_GEOMETRY_BIT"),
+ tcu::Format::BitDesc(VK_SHADER_STAGE_FRAGMENT_BIT, "VK_SHADER_STAGE_FRAGMENT_BIT"),
+ tcu::Format::BitDesc(VK_SHADER_STAGE_COMPUTE_BIT, "VK_SHADER_STAGE_COMPUTE_BIT"),
+ tcu::Format::BitDesc(VK_SHADER_STAGE_ALL, "VK_SHADER_STAGE_ALL"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getImageUsageFlagsStr (VkImageUsageFlags value)
+{
+ 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"),
+ };
+ 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_INVARIANT_DATA_BIT, "VK_IMAGE_CREATE_INVARIANT_DATA_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_CREATE_CLONEABLE_BIT, "VK_IMAGE_CREATE_CLONEABLE_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_CREATE_SHAREABLE_BIT, "VK_IMAGE_CREATE_SHAREABLE_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_CREATE_SPARSE_BIT, "VK_IMAGE_CREATE_SPARSE_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> getDepthStencilViewCreateFlagsStr (VkDepthStencilViewCreateFlags value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT, "VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT"),
+ tcu::Format::BitDesc(VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT, "VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getPipelineCreateFlagsStr (VkPipelineCreateFlags value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT, "VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT, "VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getChannelFlagsStr (VkChannelFlags value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_CHANNEL_R_BIT, "VK_CHANNEL_R_BIT"),
+ tcu::Format::BitDesc(VK_CHANNEL_G_BIT, "VK_CHANNEL_G_BIT"),
+ tcu::Format::BitDesc(VK_CHANNEL_B_BIT, "VK_CHANNEL_B_BIT"),
+ tcu::Format::BitDesc(VK_CHANNEL_A_BIT, "VK_CHANNEL_A_BIT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getFenceCreateFlagsStr (VkFenceCreateFlags value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_FENCE_CREATE_SIGNALED_BIT, "VK_FENCE_CREATE_SIGNALED_BIT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getSemaphoreCreateFlagsStr (VkSemaphoreCreateFlags value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_SEMAPHORE_CREATE_SHAREABLE_BIT, "VK_SEMAPHORE_CREATE_SHAREABLE_BIT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getFormatFeatureFlagsStr (VkFormatFeatureFlags value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT, "VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT, "VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT, "VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT, "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT, "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT, "VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT"),
+ 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"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getQueryControlFlagsStr (VkQueryControlFlags value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_QUERY_CONTROL_CONSERVATIVE_BIT, "VK_QUERY_CONTROL_CONSERVATIVE_BIT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getQueryResultFlagsStr (VkQueryResultFlags value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_QUERY_RESULT_32_BIT, "VK_QUERY_RESULT_32_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_RESULT_64_BIT, "VK_QUERY_RESULT_64_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_RESULT_NO_WAIT_BIT, "VK_QUERY_RESULT_NO_WAIT_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_RESULT_WAIT_BIT, "VK_QUERY_RESULT_WAIT_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_RESULT_WITH_AVAILABILITY_BIT, "VK_QUERY_RESULT_WITH_AVAILABILITY_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_RESULT_PARTIAL_BIT, "VK_QUERY_RESULT_PARTIAL_BIT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getPhysicalDeviceCompatibilityFlagsStr (VkPhysicalDeviceCompatibilityFlags value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_PHYSICAL_DEVICE_COMPATIBILITY_FEATURES_BIT, "VK_PHYSICAL_DEVICE_COMPATIBILITY_FEATURES_BIT"),
+ tcu::Format::BitDesc(VK_PHYSICAL_DEVICE_COMPATIBILITY_IQ_MATCH_BIT, "VK_PHYSICAL_DEVICE_COMPATIBILITY_IQ_MATCH_BIT"),
+ tcu::Format::BitDesc(VK_PHYSICAL_DEVICE_COMPATIBILITY_PEER_TRANSFER_BIT, "VK_PHYSICAL_DEVICE_COMPATIBILITY_PEER_TRANSFER_BIT"),
+ tcu::Format::BitDesc(VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_MEMORY_BIT, "VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_MEMORY_BIT"),
+ tcu::Format::BitDesc(VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_SYNC_BIT, "VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_SYNC_BIT"),
+ tcu::Format::BitDesc(VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_DEVICE0_DISPLAY_BIT, "VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_DEVICE0_DISPLAY_BIT"),
+ tcu::Format::BitDesc(VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_DEVICE1_DISPLAY_BIT, "VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_DEVICE1_DISPLAY_BIT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getCmdBufferOptimizeFlagsStr (VkCmdBufferOptimizeFlags value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT, "VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT"),
+ tcu::Format::BitDesc(VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT, "VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT"),
+ tcu::Format::BitDesc(VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT, "VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT"),
+ tcu::Format::BitDesc(VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT, "VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getQueryPipelineStatisticFlagsStr (VkQueryPipelineStatisticFlags value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT, "VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT, "VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT, "VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT, "VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT, "VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT, "VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT, "VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT, "VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT, "VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT, "VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT, "VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
--- /dev/null
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * be lost! Modify the generating script instead.
+ */
+struct VkOffset2D
+{
+ deInt32 x;
+ deInt32 y;
+};
+
+struct VkOffset3D
+{
+ deInt32 x;
+ deInt32 y;
+ deInt32 z;
+};
+
+struct VkExtent2D
+{
+ deInt32 width;
+ deInt32 height;
+};
+
+struct VkExtent3D
+{
+ deInt32 width;
+ deInt32 height;
+ deInt32 depth;
+};
+
+struct VkViewport
+{
+ float originX;
+ float originY;
+ float width;
+ float height;
+ float minDepth;
+ float maxDepth;
+};
+
+struct VkRect
+{
+ VkOffset2D offset;
+ VkExtent2D extent;
+};
+
+struct VkChannelMapping
+{
+ VkChannelSwizzle r;
+ VkChannelSwizzle g;
+ VkChannelSwizzle b;
+ VkChannelSwizzle a;
+};
+
+struct VkPhysicalDeviceProperties
+{
+ deUint32 apiVersion;
+ deUint32 driverVersion;
+ deUint32 vendorId;
+ deUint32 deviceId;
+ VkPhysicalDeviceType deviceType;
+ char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME];
+ VkDeviceSize maxInlineMemoryUpdateSize;
+ deUint32 maxBoundDescriptorSets;
+ deUint32 maxThreadGroupSize;
+ deUint64 timestampFrequency;
+ deUint32 multiColorAttachmentClears;
+ deUint32 maxDescriptorSets;
+ deUint32 maxViewports;
+ deUint32 maxColorAttachments;
+};
+
+struct VkPhysicalDevicePerformance
+{
+ float maxDeviceClock;
+ float aluPerClock;
+ float texPerClock;
+ float primsPerClock;
+ float pixelsPerClock;
+};
+
+struct VkPhysicalDeviceCompatibilityInfo
+{
+ VkPhysicalDeviceCompatibilityFlags compatibilityFlags;
+};
+
+struct VkExtensionProperties
+{
+ char extName[VK_MAX_EXTENSION_NAME];
+ deUint32 version;
+};
+
+struct VkApplicationInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ const char* pAppName;
+ deUint32 appVersion;
+ const char* pEngineName;
+ deUint32 engineVersion;
+ deUint32 apiVersion;
+};
+
+struct VkAllocCallbacks
+{
+ void* pUserData;
+ PFN_vkAllocFunction pfnAlloc;
+ PFN_vkFreeFunction pfnFree;
+};
+
+struct VkDeviceQueueCreateInfo
+{
+ deUint32 queueNodeIndex;
+ deUint32 queueCount;
+};
+
+struct VkDeviceCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 queueRecordCount;
+ const VkDeviceQueueCreateInfo* pRequestedQueues;
+ deUint32 extensionCount;
+ const char*const* ppEnabledExtensionNames;
+ VkDeviceCreateFlags flags;
+};
+
+struct VkInstanceCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ const VkApplicationInfo* pAppInfo;
+ const VkAllocCallbacks* pAllocCb;
+ deUint32 extensionCount;
+ const char*const* ppEnabledExtensionNames;
+};
+
+struct VkLayerCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 layerCount;
+ const char *const* ppActiveLayerNames;
+};
+
+struct VkPhysicalDeviceQueueProperties
+{
+ VkQueueFlags queueFlags;
+ deUint32 queueCount;
+ deUint32 maxAtomicCounters;
+ deUint32 supportsTimestamps;
+ deUint32 maxMemReferences;
+};
+
+struct VkPhysicalDeviceMemoryProperties
+{
+ deUint32 supportsMigration;
+ deUint32 supportsPinning;
+};
+
+struct VkMemoryAllocInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkDeviceSize allocationSize;
+ VkMemoryPropertyFlags memProps;
+ VkMemoryPriority memPriority;
+};
+
+struct VkMemoryOpenInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkDeviceMemory sharedMem;
+};
+
+struct VkPeerMemoryOpenInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkDeviceMemory originalMem;
+};
+
+struct VkMemoryRequirements
+{
+ VkDeviceSize size;
+ VkDeviceSize alignment;
+ VkDeviceSize granularity;
+ VkMemoryPropertyFlags memPropsAllowed;
+ VkMemoryPropertyFlags memPropsRequired;
+};
+
+struct VkFormatProperties
+{
+ VkFormatFeatureFlags linearTilingFeatures;
+ VkFormatFeatureFlags optimalTilingFeatures;
+};
+
+struct VkBufferViewAttachInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkBufferView view;
+};
+
+struct VkImageViewAttachInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkImageView view;
+ VkImageLayout layout;
+};
+
+struct VkUpdateSamplers
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 binding;
+ deUint32 arrayIndex;
+ deUint32 count;
+ const VkSampler* pSamplers;
+};
+
+struct VkSamplerImageViewInfo
+{
+ VkSampler sampler;
+ const VkImageViewAttachInfo* pImageView;
+};
+
+struct VkUpdateSamplerTextures
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 binding;
+ deUint32 arrayIndex;
+ deUint32 count;
+ const VkSamplerImageViewInfo* pSamplerImageViews;
+};
+
+struct VkUpdateImages
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkDescriptorType descriptorType;
+ deUint32 binding;
+ deUint32 arrayIndex;
+ deUint32 count;
+ const VkImageViewAttachInfo* pImageViews;
+};
+
+struct VkUpdateBuffers
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkDescriptorType descriptorType;
+ deUint32 binding;
+ deUint32 arrayIndex;
+ deUint32 count;
+ const VkBufferViewAttachInfo* pBufferViews;
+};
+
+struct VkUpdateAsCopy
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkDescriptorType descriptorType;
+ VkDescriptorSet descriptorSet;
+ deUint32 binding;
+ deUint32 arrayElement;
+ deUint32 count;
+};
+
+struct VkBufferCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkDeviceSize size;
+ VkBufferUsageFlags usage;
+ VkBufferCreateFlags flags;
+};
+
+struct VkBufferViewCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkBuffer buffer;
+ VkBufferViewType viewType;
+ VkFormat format;
+ VkDeviceSize offset;
+ VkDeviceSize range;
+};
+
+struct VkImageSubresource
+{
+ VkImageAspect aspect;
+ deUint32 mipLevel;
+ deUint32 arraySlice;
+};
+
+struct VkImageSubresourceRange
+{
+ VkImageAspect aspect;
+ deUint32 baseMipLevel;
+ deUint32 mipLevels;
+ deUint32 baseArraySlice;
+ deUint32 arraySize;
+};
+
+struct VkMemoryBarrier
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkMemoryOutputFlags outputMask;
+ VkMemoryInputFlags inputMask;
+};
+
+struct VkBufferMemoryBarrier
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkMemoryOutputFlags outputMask;
+ VkMemoryInputFlags inputMask;
+ VkBuffer buffer;
+ VkDeviceSize offset;
+ VkDeviceSize size;
+};
+
+struct VkImageMemoryBarrier
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkMemoryOutputFlags outputMask;
+ VkMemoryInputFlags inputMask;
+ VkImageLayout oldLayout;
+ VkImageLayout newLayout;
+ VkImage image;
+ VkImageSubresourceRange subresourceRange;
+};
+
+struct VkImageCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkImageType imageType;
+ VkFormat format;
+ VkExtent3D extent;
+ deUint32 mipLevels;
+ deUint32 arraySize;
+ deUint32 samples;
+ VkImageTiling tiling;
+ VkImageUsageFlags usage;
+ VkImageCreateFlags flags;
+};
+
+struct VkPeerImageOpenInfo
+{
+ VkImage originalImage;
+};
+
+struct VkSubresourceLayout
+{
+ VkDeviceSize offset;
+ VkDeviceSize size;
+ VkDeviceSize rowPitch;
+ VkDeviceSize depthPitch;
+};
+
+struct VkImageViewCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkImage image;
+ VkImageViewType viewType;
+ VkFormat format;
+ VkChannelMapping channels;
+ VkImageSubresourceRange subresourceRange;
+ float minLod;
+};
+
+struct VkColorAttachmentViewCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkImage image;
+ VkFormat format;
+ deUint32 mipLevel;
+ deUint32 baseArraySlice;
+ deUint32 arraySize;
+ VkImage msaaResolveImage;
+ VkImageSubresourceRange msaaResolveSubResource;
+};
+
+struct VkDepthStencilViewCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkImage image;
+ deUint32 mipLevel;
+ deUint32 baseArraySlice;
+ deUint32 arraySize;
+ VkImage msaaResolveImage;
+ VkImageSubresourceRange msaaResolveSubResource;
+ VkDepthStencilViewCreateFlags flags;
+};
+
+struct VkColorAttachmentBindInfo
+{
+ VkColorAttachmentView view;
+ VkImageLayout layout;
+};
+
+struct VkDepthStencilBindInfo
+{
+ VkDepthStencilView view;
+ VkImageLayout layout;
+};
+
+struct VkBufferCopy
+{
+ VkDeviceSize srcOffset;
+ VkDeviceSize destOffset;
+ VkDeviceSize copySize;
+};
+
+struct VkImageMemoryBindInfo
+{
+ VkImageSubresource subresource;
+ VkOffset3D offset;
+ VkExtent3D extent;
+};
+
+struct VkImageCopy
+{
+ VkImageSubresource srcSubresource;
+ VkOffset3D srcOffset;
+ VkImageSubresource destSubresource;
+ VkOffset3D destOffset;
+ VkExtent3D extent;
+};
+
+struct VkImageBlit
+{
+ VkImageSubresource srcSubresource;
+ VkOffset3D srcOffset;
+ VkExtent3D srcExtent;
+ VkImageSubresource destSubresource;
+ VkOffset3D destOffset;
+ VkExtent3D destExtent;
+};
+
+struct VkBufferImageCopy
+{
+ VkDeviceSize bufferOffset;
+ VkImageSubresource imageSubresource;
+ VkOffset3D imageOffset;
+ VkExtent3D imageExtent;
+};
+
+struct VkImageResolve
+{
+ VkImageSubresource srcSubresource;
+ VkOffset3D srcOffset;
+ VkImageSubresource destSubresource;
+ VkOffset3D destOffset;
+ VkExtent3D extent;
+};
+
+struct VkShaderCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUintptr codeSize;
+ const void* pCode;
+ VkShaderCreateFlags flags;
+};
+
+struct VkDescriptorSetLayoutBinding
+{
+ VkDescriptorType descriptorType;
+ deUint32 count;
+ VkShaderStageFlags stageFlags;
+ const VkSampler* pImmutableSamplers;
+};
+
+struct VkDescriptorSetLayoutCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 count;
+ const VkDescriptorSetLayoutBinding* pBinding;
+};
+
+struct VkDescriptorTypeCount
+{
+ VkDescriptorType type;
+ deUint32 count;
+};
+
+struct VkDescriptorPoolCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 count;
+ const VkDescriptorTypeCount* pTypeCount;
+};
+
+struct VkLinkConstBuffer
+{
+ deUint32 bufferId;
+ deUintptr bufferSize;
+ const void* pBufferData;
+};
+
+struct VkSpecializationMapEntry
+{
+ deUint32 constantId;
+ deUint32 offset;
+};
+
+struct VkSpecializationInfo
+{
+ deUint32 mapEntryCount;
+ const VkSpecializationMapEntry* pMap;
+ const void* pData;
+};
+
+struct VkPipelineShader
+{
+ VkShaderStage stage;
+ VkShader shader;
+ deUint32 linkConstBufferCount;
+ const VkLinkConstBuffer* pLinkConstBufferInfo;
+ const VkSpecializationInfo* pSpecializationInfo;
+};
+
+struct VkComputePipelineCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineShader cs;
+ VkPipelineCreateFlags flags;
+ VkPipelineLayout layout;
+};
+
+struct VkVertexInputBindingDescription
+{
+ deUint32 binding;
+ deUint32 strideInBytes;
+ VkVertexInputStepRate stepRate;
+};
+
+struct VkVertexInputAttributeDescription
+{
+ deUint32 location;
+ deUint32 binding;
+ VkFormat format;
+ deUint32 offsetInBytes;
+};
+
+struct VkPipelineVertexInputCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 bindingCount;
+ const VkVertexInputBindingDescription* pVertexBindingDescriptions;
+ deUint32 attributeCount;
+ const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
+};
+
+struct VkPipelineIaStateCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkPrimitiveTopology topology;
+ deUint32 disableVertexReuse;
+ deUint32 primitiveRestartEnable;
+ deUint32 primitiveRestartIndex;
+};
+
+struct VkPipelineTessStateCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 patchControlPoints;
+};
+
+struct VkPipelineVpStateCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 viewportCount;
+ VkCoordinateOrigin clipOrigin;
+ VkDepthMode depthMode;
+};
+
+struct VkPipelineRsStateCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 depthClipEnable;
+ deUint32 rasterizerDiscardEnable;
+ deUint32 programPointSize;
+ VkCoordinateOrigin pointOrigin;
+ VkProvokingVertex provokingVertex;
+ VkFillMode fillMode;
+ VkCullMode cullMode;
+ VkFrontFace frontFace;
+};
+
+struct VkPipelineMsStateCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 samples;
+ deUint32 multisampleEnable;
+ deUint32 sampleShadingEnable;
+ float minSampleShading;
+ VkSampleMask sampleMask;
+};
+
+struct VkPipelineCbAttachmentState
+{
+ deUint32 blendEnable;
+ VkFormat format;
+ VkBlend srcBlendColor;
+ VkBlend destBlendColor;
+ VkBlendOp blendOpColor;
+ VkBlend srcBlendAlpha;
+ VkBlend destBlendAlpha;
+ VkBlendOp blendOpAlpha;
+ VkChannelFlags channelWriteMask;
+};
+
+struct VkPipelineCbStateCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 alphaToCoverageEnable;
+ deUint32 logicOpEnable;
+ VkLogicOp logicOp;
+ deUint32 attachmentCount;
+ const VkPipelineCbAttachmentState* pAttachments;
+};
+
+struct VkStencilOpState
+{
+ VkStencilOp stencilFailOp;
+ VkStencilOp stencilPassOp;
+ VkStencilOp stencilDepthFailOp;
+ VkCompareOp stencilCompareOp;
+};
+
+struct VkPipelineDsStateCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkFormat format;
+ deUint32 depthTestEnable;
+ deUint32 depthWriteEnable;
+ VkCompareOp depthCompareOp;
+ deUint32 depthBoundsEnable;
+ deUint32 stencilTestEnable;
+ VkStencilOpState front;
+ VkStencilOpState back;
+};
+
+struct VkPipelineShaderStageCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineShader shader;
+};
+
+struct VkGraphicsPipelineCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineCreateFlags flags;
+ VkPipelineLayout layout;
+};
+
+struct VkPipelineLayoutCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 descriptorSetCount;
+ const VkDescriptorSetLayout* pSetLayouts;
+};
+
+struct VkSamplerCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkTexFilter magFilter;
+ VkTexFilter minFilter;
+ VkTexMipmapMode mipMode;
+ VkTexAddress addressU;
+ VkTexAddress addressV;
+ VkTexAddress addressW;
+ float mipLodBias;
+ deUint32 maxAnisotropy;
+ VkCompareOp compareOp;
+ float minLod;
+ float maxLod;
+ VkBorderColor borderColor;
+};
+
+struct VkDynamicVpStateCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 viewportAndScissorCount;
+ const VkViewport* pViewports;
+ const VkRect* pScissors;
+};
+
+struct VkDynamicRsStateCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ float depthBias;
+ float depthBiasClamp;
+ float slopeScaledDepthBias;
+ float pointSize;
+ float pointFadeThreshold;
+ float lineWidth;
+};
+
+struct VkDynamicCbStateCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ float blendConst[4];
+};
+
+struct VkDynamicDsStateCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ float minDepth;
+ float maxDepth;
+ deUint32 stencilReadMask;
+ deUint32 stencilWriteMask;
+ deUint32 stencilFrontRef;
+ deUint32 stencilBackRef;
+};
+
+struct VkCmdBufferCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 queueNodeIndex;
+ VkCmdBufferCreateFlags flags;
+};
+
+struct VkCmdBufferBeginInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkCmdBufferOptimizeFlags flags;
+};
+
+struct VkRenderPassBegin
+{
+ VkRenderPass renderPass;
+ VkFramebuffer framebuffer;
+};
+
+struct VkCmdBufferGraphicsBeginInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkRenderPassBegin renderPassContinue;
+};
+
+struct VkClearColor
+{
+ VkClearColorValue color;
+ deUint32 useRawValue;
+};
+
+struct VkRenderPassCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkRect renderArea;
+ deUint32 colorAttachmentCount;
+ VkExtent2D extent;
+ deUint32 sampleCount;
+ deUint32 layers;
+ const VkFormat* pColorFormats;
+ const VkImageLayout* pColorLayouts;
+ const VkAttachmentLoadOp* pColorLoadOps;
+ const VkAttachmentStoreOp* pColorStoreOps;
+ const VkClearColor* pColorLoadClearValues;
+ VkFormat depthStencilFormat;
+ VkImageLayout depthStencilLayout;
+ VkAttachmentLoadOp depthLoadOp;
+ float depthLoadClearValue;
+ VkAttachmentStoreOp depthStoreOp;
+ VkAttachmentLoadOp stencilLoadOp;
+ deUint32 stencilLoadClearValue;
+ VkAttachmentStoreOp stencilStoreOp;
+};
+
+struct VkEventCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkEventCreateFlags flags;
+};
+
+struct VkFenceCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkFenceCreateFlags flags;
+};
+
+struct VkSemaphoreCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 initialCount;
+ VkSemaphoreCreateFlags flags;
+};
+
+struct VkSemaphoreOpenInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkSemaphore sharedSemaphore;
+};
+
+struct VkQueryPoolCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkQueryType queryType;
+ deUint32 slots;
+ VkQueryPipelineStatisticFlags pipelineStatistics;
+};
+
+struct VkFramebufferCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 colorAttachmentCount;
+ const VkColorAttachmentBindInfo* pColorAttachments;
+ const VkDepthStencilBindInfo* pDepthStencilAttachment;
+ deUint32 sampleCount;
+ deUint32 width;
+ deUint32 height;
+ deUint32 layers;
+};
+
+struct VkDrawIndirectCmd
+{
+ deUint32 vertexCount;
+ deUint32 instanceCount;
+ deUint32 firstVertex;
+ deUint32 firstInstance;
+};
+
+struct VkDrawIndexedIndirectCmd
+{
+ deUint32 indexCount;
+ deUint32 instanceCount;
+ deUint32 firstIndex;
+ deInt32 vertexOffset;
+ deUint32 firstInstance;
+};
+
+struct VkDispatchIndirectCmd
+{
+ deUint32 x;
+ deUint32 y;
+ deUint32 z;
+};
+
--- /dev/null
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * be lost! Modify the generating script instead.
+ */
+virtual VkResult getPhysicalDeviceInfo (VkPhysicalDevice physicalDevice, VkPhysicalDeviceInfoType infoType, deUintptr* pDataSize, void* pData) const = 0;
+virtual VkResult createDevice (VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) const = 0;
+virtual VkResult destroyDevice (VkDevice device) const = 0;
+virtual VkResult getGlobalExtensionInfo (VkExtensionInfoType infoType, deUint32 extensionIndex, deUintptr* pDataSize, void* pData) const = 0;
+virtual VkResult getPhysicalDeviceExtensionInfo (VkPhysicalDevice physicalDevice, VkExtensionInfoType infoType, deUint32 extensionIndex, deUintptr* pDataSize, void* pData) const = 0;
+virtual VkResult enumerateLayers (VkPhysicalDevice physicalDevice, deUintptr maxStringSize, deUintptr* pLayerCount, char* const* pOutLayers, void* pReserved) const = 0;
+virtual VkResult getDeviceQueue (VkDevice device, deUint32 queueNodeIndex, deUint32 queueIndex, VkQueue* pQueue) const = 0;
+virtual VkResult queueSubmit (VkQueue queue, deUint32 cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence) const = 0;
+virtual VkResult queueAddMemReferences (VkQueue queue, deUint32 count, const VkDeviceMemory* pMems) const = 0;
+virtual VkResult queueRemoveMemReferences (VkQueue queue, deUint32 count, const VkDeviceMemory* pMems) 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 VkResult setMemoryPriority (VkDevice device, VkDeviceMemory mem, VkMemoryPriority priority) 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 VkResult flushMappedMemory (VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size) const = 0;
+virtual VkResult pinSystemMemory (VkDevice device, const void* pSysMem, deUintptr memSize, VkDeviceMemory* pMem) const = 0;
+virtual VkResult getMultiDeviceCompatibility (VkPhysicalDevice physicalDevice0, VkPhysicalDevice physicalDevice1, VkPhysicalDeviceCompatibilityInfo* pInfo) const = 0;
+virtual VkResult openSharedMemory (VkDevice device, const VkMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem) const = 0;
+virtual VkResult openSharedSemaphore (VkDevice device, const VkSemaphoreOpenInfo* pOpenInfo, VkSemaphore* pSemaphore) const = 0;
+virtual VkResult openPeerMemory (VkDevice device, const VkPeerMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem) const = 0;
+virtual VkResult openPeerImage (VkDevice device, const VkPeerImageOpenInfo* pOpenInfo, VkImage* pImage, VkDeviceMemory* pMem) const = 0;
+virtual VkResult destroyObject (VkDevice device, VkObjectType objType, VkObject object) const = 0;
+virtual VkResult getObjectInfo (VkDevice device, VkObjectType objType, VkObject object, VkObjectInfoType infoType, deUintptr* pDataSize, void* pData) const = 0;
+virtual VkResult queueBindObjectMemory (VkQueue queue, VkObjectType objType, VkObject object, deUint32 allocationIdx, VkDeviceMemory mem, VkDeviceSize memOffset) const = 0;
+virtual VkResult queueBindObjectMemoryRange (VkQueue queue, VkObjectType objType, VkObject object, deUint32 allocationIdx, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset) const = 0;
+virtual VkResult queueBindImageMemoryRange (VkQueue queue, VkImage image, deUint32 allocationIdx, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset) const = 0;
+virtual VkResult createFence (VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence) const = 0;
+virtual VkResult resetFences (VkDevice device, deUint32 fenceCount, VkFence* pFences) const = 0;
+virtual VkResult getFenceStatus (VkDevice device, VkFence fence) const = 0;
+virtual VkResult waitForFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences, deUint32 waitAll, deUint64 timeout) const = 0;
+virtual VkResult createSemaphore (VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore) 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 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 getQueryPoolResults (VkDevice device, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, deUintptr* pDataSize, void* pData, VkQueryResultFlags flags) const = 0;
+virtual VkResult getFormatInfo (VkDevice device, VkFormat format, VkFormatInfoType infoType, deUintptr* pDataSize, void* pData) const = 0;
+virtual VkResult createBuffer (VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer) const = 0;
+virtual VkResult createBufferView (VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView) const = 0;
+virtual VkResult createImage (VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage) const = 0;
+virtual VkResult getImageSubresourceInfo (VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceInfoType infoType, deUintptr* pDataSize, void* pData) const = 0;
+virtual VkResult createImageView (VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView) const = 0;
+virtual VkResult createColorAttachmentView (VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo, VkColorAttachmentView* pView) const = 0;
+virtual VkResult createDepthStencilView (VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo, VkDepthStencilView* pView) const = 0;
+virtual VkResult createShader (VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader) const = 0;
+virtual VkResult createGraphicsPipeline (VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) const = 0;
+virtual VkResult createGraphicsPipelineDerivative (VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline basePipeline, VkPipeline* pPipeline) const = 0;
+virtual VkResult createComputePipeline (VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) const = 0;
+virtual VkResult storePipeline (VkDevice device, VkPipeline pipeline, deUintptr* pDataSize, void* pData) const = 0;
+virtual VkResult loadPipeline (VkDevice device, deUintptr dataSize, const void* pData, VkPipeline* pPipeline) const = 0;
+virtual VkResult loadPipelineDerivative (VkDevice device, deUintptr dataSize, const void* pData, VkPipeline basePipeline, VkPipeline* pPipeline) const = 0;
+virtual VkResult createPipelineLayout (VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout) const = 0;
+virtual VkResult createSampler (VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) const = 0;
+virtual VkResult createDescriptorSetLayout (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout) const = 0;
+virtual VkResult beginDescriptorPoolUpdate (VkDevice device, VkDescriptorUpdateMode updateMode) const = 0;
+virtual VkResult endDescriptorPoolUpdate (VkDevice device, VkCmdBuffer cmd) const = 0;
+virtual VkResult createDescriptorPool (VkDevice device, VkDescriptorPoolUsage poolUsage, deUint32 maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) 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 void clearDescriptorSets (VkDevice device, VkDescriptorPool descriptorPool, deUint32 count, const VkDescriptorSet* pDescriptorSets) const = 0;
+virtual void updateDescriptors (VkDevice device, VkDescriptorSet descriptorSet, deUint32 updateCount, const void** ppUpdateArray) const = 0;
+virtual VkResult createDynamicViewportState (VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpState* pState) const = 0;
+virtual VkResult createDynamicRasterState (VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsState* pState) const = 0;
+virtual VkResult createDynamicColorBlendState (VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbState* pState) const = 0;
+virtual VkResult createDynamicDepthStencilState (VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsState* pState) const = 0;
+virtual VkResult createCommandBuffer (VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer) const = 0;
+virtual VkResult beginCommandBuffer (VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) const = 0;
+virtual VkResult endCommandBuffer (VkCmdBuffer cmdBuffer) const = 0;
+virtual VkResult resetCommandBuffer (VkCmdBuffer cmdBuffer) const = 0;
+virtual void cmdBindPipeline (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) const = 0;
+virtual void cmdBindDynamicStateObject (VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject dynamicState) const = 0;
+virtual void cmdBindDescriptorSets (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, 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 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 cmdDispatchIndirect (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset) const = 0;
+virtual void cmdCopyBuffer (VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, deUint32 regionCount, const VkBufferCopy* pRegions) const = 0;
+virtual void cmdCopyImage (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageCopy* pRegions) const = 0;
+virtual void cmdBlitImage (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageBlit* pRegions) const = 0;
+virtual void cmdCopyBufferToImage (VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkBufferImageCopy* pRegions) const = 0;
+virtual void cmdCopyImageToBuffer (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, deUint32 regionCount, const VkBufferImageCopy* pRegions) const = 0;
+virtual void cmdCloneImageData (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout) 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, VkClearColor color, deUint32 rangeCount, const VkImageSubresourceRange* pRanges) const = 0;
+virtual void cmdClearDepthStencil (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, deUint32 stencil, deUint32 rangeCount, const VkImageSubresourceRange* pRanges) 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, VkPipeEvent pipeEvent) const = 0;
+virtual void cmdResetEvent (VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent) const = 0;
+virtual void cmdWaitEvents (VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, deUint32 eventCount, const VkEvent* pEvents, deUint32 memBarrierCount, const void** ppMemBarriers) const = 0;
+virtual void cmdPipelineBarrier (VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, deUint32 pipeEventCount, const VkPipeEvent* pPipeEvents, deUint32 memBarrierCount, const void** ppMemBarriers) const = 0;
+virtual void cmdBeginQuery (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 slot, VkQueryControlFlags flags) const = 0;
+virtual void cmdEndQuery (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 slot) const = 0;
+virtual void cmdResetQueryPool (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount) const = 0;
+virtual void cmdWriteTimestamp (VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset) const = 0;
+virtual void cmdCopyQueryPoolResults (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags) const = 0;
+virtual void cmdInitAtomicCounters (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 startCounter, deUint32 counterCount, const deUint32* pData) const = 0;
+virtual void cmdLoadAtomicCounters (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 startCounter, deUint32 counterCount, VkBuffer srcBuffer, VkDeviceSize srcOffset) const = 0;
+virtual void cmdSaveAtomicCounters (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 startCounter, deUint32 counterCount, VkBuffer destBuffer, VkDeviceSize destOffset) const = 0;
+virtual VkResult createFramebuffer (VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer) const = 0;
+virtual VkResult createRenderPass (VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass) const = 0;
+virtual void cmdBeginRenderPass (VkCmdBuffer cmdBuffer, const VkRenderPassBegin* pRenderPassBegin) const = 0;
+virtual void cmdEndRenderPass (VkCmdBuffer cmdBuffer, VkRenderPass renderPass) const = 0;
--- /dev/null
+/* 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 VkResult destroyInstance (VkInstance instance) const = 0;
+virtual VkResult enumeratePhysicalDevices (VkInstance instance, deUint32* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) const = 0;
+virtual FunctionPtr getProcAddr (VkPhysicalDevice physicalDevice, const char* pName) const = 0;
include(gles3/gles3.cmake OPTIONAL)
include(gles31/gles31.cmake OPTIONAL)
include(egl/egl.cmake OPTIONAL)
+include(vulkan/vulkan.cmake OPTIONAL)
# Misc
include(internal/internal.cmake OPTIONAL)
--- /dev/null
+# dEQP-VK
+
+add_subdirectory(api)
+
+include_directories(
+ api
+ )
+
+set(DEQP_VK_COMMON_SRCS
+ vktTestCase.cpp
+ vktTestCase.hpp
+ vktTestCaseUtil.cpp
+ vktTestCaseUtil.hpp
+ vktTestPackage.cpp
+ vktTestPackage.hpp
+ vktInfo.cpp
+ vktInfo.hpp
+ )
+
+set(DEQP_VK_COMMON_LIBS
+ tcutil
+ vkutil
+ deqp-vk-api
+ )
+
+if (DE_OS_IS_WIN32 OR DE_OS_IS_UNIX OR DE_OS_IS_OSX)
+ add_library(deqp-vk-common STATIC ${DEQP_VK_COMMON_SRCS})
+ target_link_libraries(deqp-vk-common ${DEQP_VK_COMMON_LIBS})
+
+ add_executable(vk-build-programs vktBuildPrograms.cpp)
+ target_link_libraries(vk-build-programs deqp-vk-common)
+
+ set(DEQP_VK_SRCS )
+ set(DEQP_VK_LIBS deqp-vk-common)
+
+else ()
+ set(DEQP_VK_SRCS ${DEQP_VK_COMMON_SRCS})
+ set(DEQP_VK_LIBS ${DEQP_VK_COMMON_LIBS})
+
+endif ()
+
+add_deqp_module(deqp-vk "${DEQP_VK_SRCS}" "${DEQP_VK_LIBS}" vktTestPackageEntry.cpp)
--- /dev/null
+# API layer tests
+
+include_directories(..)
+
+set(DEQP_VK_API_SRCS
+ vktApiTests.cpp
+ vktApiTests.hpp
+ )
+
+set(DEQP_VK_API_LIBS
+ tcutil
+ vkutil
+ )
+
+add_library(deqp-vk-api STATIC ${DEQP_VK_API_SRCS})
+target_link_libraries(deqp-vk-api ${DEQP_VK_API_LIBS})
--- /dev/null
+/*-------------------------------------------------------------------------
+ * drawElements Quality Program Vulkan Module
+ * --------------------------------------------
+ *
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief API Tests
+ *//*--------------------------------------------------------------------*/
+
+#include "vktApiTests.hpp"
+
+#include "vktTestCaseUtil.hpp"
+
+#include "vkDefs.hpp"
+#include "vkPlatform.hpp"
+#include "vkStrUtil.hpp"
+#include "vkRef.hpp"
+
+#include "tcuTestLog.hpp"
+#include "tcuFormatUtil.hpp"
+
+#include "deUniquePtr.hpp"
+
+#include "qpInfo.h"
+
+namespace vkt
+{
+namespace api
+{
+
+// \todo [2015-05-11 pyry] Temporary for testing framework
+
+using namespace vk;
+using std::vector;
+using tcu::TestLog;
+
+tcu::TestStatus createSampler (Context& context)
+{
+ const struct VkApplicationInfo appInfo =
+ {
+ VK_STRUCTURE_TYPE_APPLICATION_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ "deqp", // const char* pAppName;
+ qpGetReleaseId(), // deUint32 appVersion;
+ "deqp", // const char* pEngineName;
+ qpGetReleaseId(), // deUint32 engineVersion;
+ VK_API_VERSION // deUint32 apiVersion;
+ };
+ const struct VkInstanceCreateInfo instanceInfo =
+ {
+ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ &appInfo, // const VkApplicationInfo* pAppInfo;
+ DE_NULL, // const VkAllocCallbacks* pAllocCb;
+ 0u, // deUint32 extensionCount;
+ DE_NULL // const char*const* ppEnabledExtensionNames;
+ };
+
+ const PlatformInterface& vkPlatform = context.getPlatformInterface();
+ TestLog& log = context.getTestContext().getLog();
+ const Unique<VkInstanceT> instance (createInstance(vkPlatform, &instanceInfo));
+ vector<VkPhysicalDevice> devices;
+ deUint32 numDevices = 0;
+
+ VK_CHECK(vkPlatform.enumeratePhysicalDevices(*instance, &numDevices, DE_NULL));
+
+ if (numDevices > 0)
+ {
+ devices.resize(numDevices);
+ VK_CHECK(vkPlatform.enumeratePhysicalDevices(*instance, &numDevices, &devices[0]));
+
+ for (deUint32 deviceNdx = 0; deviceNdx < numDevices; deviceNdx++)
+ {
+ const struct VkDeviceQueueCreateInfo queueInfo =
+ {
+ 0u, // deUint32 queueNodeIndex;
+ 1u, // deUint32 queueCount;
+ };
+ const struct VkDeviceCreateInfo deviceInfo =
+ {
+ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 1u, // deUint32 queueRecordCount;
+ &queueInfo, // const VkDeviceQueueCreateInfo* pRequestedQueues;
+ 0u, // deUint32 extensionCount;
+ DE_NULL, // const char*const* ppEnabledExtensionNames;
+ 0u, // VkDeviceCreateFlags flags;
+ };
+
+ 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;
+ 0u, // deUint32 maxAnisotropy;
+ VK_COMPARE_OP_ALWAYS, // VkCompareOp compareOp;
+ 0.0f, // float minLod;
+ 0.0f, // float maxLod;
+ VK_BORDER_COLOR_TRANSPARENT_BLACK, // VkBorderColor borderColor;
+ };
+
+ log << TestLog::Message << deviceNdx << ": " << tcu::toHex(devices[deviceNdx]) << TestLog::EndMessage;
+
+ const DeviceDriver vkDevice (vkPlatform, devices[deviceNdx]);
+ const Unique<VkDeviceT> device (createDevice(vkDevice, devices[deviceNdx], &deviceInfo));
+ Move<VkSamplerT> tmpSampler = createSampler(vkDevice, *device, &samplerInfo);
+ const Unique<VkSamplerT> sampler (tmpSampler);
+ }
+ }
+
+ return tcu::TestStatus::pass("Creating sampler succeeded");
+}
+
+tcu::TestCaseGroup* createTests (tcu::TestContext& testCtx)
+{
+ de::MovePtr<tcu::TestCaseGroup> apiTests (new tcu::TestCaseGroup(testCtx, "api", "API Tests"));
+
+ addFunctionCase(apiTests.get(), "create_sampler", "", createSampler);
+
+ return apiTests.release();
+}
+
+} // api
+} // vkt
--- /dev/null
+#ifndef _VKTAPITESTS_HPP
+#define _VKTAPITESTS_HPP
+/*-------------------------------------------------------------------------
+ * drawElements Quality Program Vulkan Module
+ * --------------------------------------------
+ *
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief API tests
+ *//*--------------------------------------------------------------------*/
+
+#include "tcuDefs.hpp"
+#include "tcuTestCase.hpp"
+
+namespace vkt
+{
+namespace api
+{
+
+tcu::TestCaseGroup* createTests (tcu::TestContext& testCtx);
+
+} // api
+} // vkt
+
+#endif // _VKTAPITESTS_HPP
--- /dev/null
+/*-------------------------------------------------------------------------
+ * drawElements Quality Program Vulkan Module
+ * --------------------------------------------
+ *
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief
+ *//*--------------------------------------------------------------------*/
+
+#include "tcuDefs.hpp"
+#include "tcuCommandLine.hpp"
+#include "tcuPlatform.hpp"
+#include "tcuResource.hpp"
+#include "tcuTestLog.hpp"
+#include "tcuTestHierarchyIterator.hpp"
+#include "deUniquePtr.hpp"
+#include "vkPrograms.hpp"
+#include "vktTestCase.hpp"
+#include "vktTestPackage.hpp"
+
+#include <iostream>
+
+namespace vkt
+{
+
+using std::vector;
+using std::string;
+using de::UniquePtr;
+
+tcu::TestPackageRoot* createRoot (tcu::TestContext& testCtx)
+{
+ vector<tcu::TestNode*> children;
+ children.push_back(new TestPackage(testCtx));
+ return new tcu::TestPackageRoot(testCtx, children);
+}
+
+void buildPrograms (tcu::TestContext& testCtx)
+{
+ const UniquePtr<tcu::TestPackageRoot> root (createRoot(testCtx));
+ tcu::DefaultHierarchyInflater inflater (testCtx);
+ tcu::TestHierarchyIterator iterator (*root, inflater, testCtx.getCommandLine());
+
+ while (iterator.getState() != tcu::TestHierarchyIterator::STATE_FINISHED)
+ {
+ if (iterator.getState() == tcu::TestHierarchyIterator::STATE_ENTER_NODE &&
+ tcu::isTestNodeTypeExecutable(iterator.getNode()->getNodeType()))
+ {
+ const TestCase* const testCase = dynamic_cast<TestCase*>(iterator.getNode());
+ const string path = iterator.getNodePath();
+ vk::SourceCollection progs;
+
+ tcu::print("%s\n", path.c_str());
+
+ testCase->initPrograms(progs);
+
+ for (vk::SourceCollection::Iterator progIter = progs.begin(); progIter != progs.end(); ++progIter)
+ {
+ tcu::print(" %s\n", progIter.getName().c_str());
+
+ // \todo [2015-03-20 pyry] This is POC level, next steps:
+ // - actually build programs
+ // - eliminate duplicates
+ // - store as binaries + name -> prog file map
+ }
+ }
+
+ iterator.next();
+ }
+}
+
+} // vkt
+
+int main (int argc, const char* argv[])
+{
+ try
+ {
+ const tcu::CommandLine cmdLine (argc, argv);
+ tcu::DirArchive archive (".");
+ tcu::TestLog log (cmdLine.getLogFileName(), cmdLine.getLogFlags());
+ tcu::Platform platform;
+ tcu::TestContext testCtx (platform, archive, log, cmdLine, DE_NULL);
+
+ vkt::buildPrograms(testCtx);
+ }
+ catch (const std::exception& e)
+ {
+ tcu::die("%s", e.what());
+ }
+
+ return 0;
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ * drawElements Quality Program Vulkan Module
+ * --------------------------------------------
+ *
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Platform information tests
+ *//*--------------------------------------------------------------------*/
+
+#include "vktInfo.hpp"
+
+#include "vktTestCaseUtil.hpp"
+
+#include "vkPlatform.hpp"
+#include "vkStrUtil.hpp"
+#include "vkRef.hpp"
+
+#include "tcuTestLog.hpp"
+#include "tcuFormatUtil.hpp"
+
+#include "deUniquePtr.hpp"
+#include "deStringUtil.hpp"
+
+#include "qpInfo.h"
+
+namespace vkt
+{
+
+using namespace vk;
+using std::vector;
+using std::string;
+using tcu::TestLog;
+
+tcu::TestStatus enumeratePhysicalDevices (Context& context)
+{
+ const struct VkApplicationInfo appInfo =
+ {
+ VK_STRUCTURE_TYPE_APPLICATION_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ "deqp", // const char* pAppName;
+ qpGetReleaseId(), // deUint32 appVersion;
+ "deqp", // const char* pEngineName;
+ qpGetReleaseId(), // deUint32 engineVersion;
+ VK_API_VERSION // deUint32 apiVersion;
+ };
+ const struct VkInstanceCreateInfo instanceInfo =
+ {
+ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ &appInfo, // const VkApplicationInfo* pAppInfo;
+ DE_NULL, // const VkAllocCallbacks* pAllocCb;
+ 0u, // deUint32 extensionCount;
+ DE_NULL // const char*const* ppEnabledExtensionNames;
+ };
+
+ const PlatformInterface& vkPlatform = context.getPlatformInterface();
+ TestLog& log = context.getTestContext().getLog();
+ const Unique<VkInstanceT> instance (createInstance(vkPlatform, &instanceInfo));
+ vector<VkPhysicalDevice> devices;
+ deUint32 numDevices = 0;
+
+ VK_CHECK(vkPlatform.enumeratePhysicalDevices(*instance, &numDevices, DE_NULL));
+
+ log << TestLog::Integer("NumDevices", "Number of devices", "", QP_KEY_TAG_NONE, deInt64(numDevices));
+
+ if (numDevices > 0)
+ {
+ devices.resize(numDevices);
+ VK_CHECK(vkPlatform.enumeratePhysicalDevices(*instance, &numDevices, &devices[0]));
+
+ for (deUint32 ndx = 0; ndx < numDevices; ndx++)
+ log << TestLog::Message << ndx << ": " << tcu::toHex(devices[ndx]) << TestLog::EndMessage;
+ }
+
+ return tcu::TestStatus::pass("Enumerating devices succeeded");
+}
+
+tcu::TestStatus deviceProperties (Context& context)
+{
+ const struct VkApplicationInfo appInfo =
+ {
+ VK_STRUCTURE_TYPE_APPLICATION_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ "deqp", // const char* pAppName;
+ qpGetReleaseId(), // deUint32 appVersion;
+ "deqp", // const char* pEngineName;
+ qpGetReleaseId(), // deUint32 engineVersion;
+ VK_API_VERSION // deUint32 apiVersion;
+ };
+ const struct VkInstanceCreateInfo instanceInfo =
+ {
+ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ &appInfo, // const VkApplicationInfo* pAppInfo;
+ DE_NULL, // const VkAllocCallbacks* pAllocCb;
+ 0u, // deUint32 extensionCount;
+ DE_NULL // const char*const* ppEnabledExtensionNames;
+ };
+
+ const PlatformInterface& vkPlatform = context.getPlatformInterface();
+ TestLog& log = context.getTestContext().getLog();
+ const Unique<VkInstanceT> instance (createInstance(vkPlatform, &instanceInfo));
+ vector<VkPhysicalDevice> devices;
+ deUint32 numDevices = 0;
+
+ VK_CHECK(vkPlatform.enumeratePhysicalDevices(*instance, &numDevices, DE_NULL));
+
+ if (numDevices > 0)
+ {
+ devices.resize(numDevices);
+ VK_CHECK(vkPlatform.enumeratePhysicalDevices(*instance, &numDevices, &devices[0]));
+
+ for (deUint32 ndx = 0; ndx < numDevices; ndx++)
+ {
+ const VkPhysicalDevice physicalDevice = devices[ndx];
+ const tcu::ScopedLogSection section (log, string("Device") + de::toString(ndx), string("Device ") + de::toString(ndx) + " (" + de::toString(tcu::toHex(physicalDevice)) + ")");
+ const vk::DeviceDriver vkDevice (vkPlatform, physicalDevice);
+ VkPhysicalDeviceProperties properties;
+ deUintptr propertiesSize = sizeof(properties);
+
+ VK_CHECK(vkDevice.getPhysicalDeviceInfo(physicalDevice, VK_PHYSICAL_DEVICE_INFO_TYPE_PROPERTIES, &propertiesSize, &properties));
+
+ log << TestLog::Message << "apiVersion = " << unpackVersion(properties.apiVersion) << "\n"
+ << "driverVersion = " << tcu::toHex(properties.driverVersion) << "\n"
+ << "vendorId = " << tcu::toHex(properties.vendorId) << "\n"
+ << "deviceId = " << tcu::toHex(properties.deviceId) << "\n"
+ << "deviceType = " << properties.deviceType << "\n"
+ << "deviceName = " << properties.deviceName << "\n"
+ << "maxInlineMemoryUpdateSize = " << properties.maxInlineMemoryUpdateSize << "\n"
+ << "maxBoundDescriptorSets = " << properties.maxBoundDescriptorSets << "\n"
+ << "maxThreadGroupSize = " << properties.maxThreadGroupSize << "\n"
+ << "timestampFrequency = " << properties.timestampFrequency << "\n"
+ << "multiColorAttachmentClears = " << properties.multiColorAttachmentClears << "\n"
+ << "maxDescriptorSets = " << properties.maxDescriptorSets << "\n"
+ << "maxViewports = " << properties.maxViewports << "\n"
+ << "maxColorAttachments = " << properties.maxColorAttachments
+ << TestLog::EndMessage;
+ }
+ }
+
+ return tcu::TestStatus::pass("Enumerating devices succeeded");
+}
+
+tcu::TestCaseGroup* createInfoTests (tcu::TestContext& testCtx)
+{
+ de::MovePtr<tcu::TestCaseGroup> infoTests (new tcu::TestCaseGroup(testCtx, "info", "Platform Information Tests"));
+
+ addFunctionCase(infoTests.get(), "physical_devices", "Physical devices", enumeratePhysicalDevices);
+ addFunctionCase(infoTests.get(), "device_properties", "Device properties", deviceProperties);
+
+ return infoTests.release();
+}
+
+} // vkt
--- /dev/null
+#ifndef _VKTINFO_HPP
+#define _VKTINFO_HPP
+/*-------------------------------------------------------------------------
+ * drawElements Quality Program Vulkan Module
+ * --------------------------------------------
+ *
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Platform information tests
+ *//*--------------------------------------------------------------------*/
+
+#include "tcuDefs.hpp"
+#include "tcuTestCase.hpp"
+
+namespace vkt
+{
+
+tcu::TestCaseGroup* createInfoTests (tcu::TestContext& testCtx);
+
+} // vkt
+
+#endif // _VKTINFO_HPP
--- /dev/null
+/*-------------------------------------------------------------------------
+ * drawElements Quality Program Vulkan Module
+ * --------------------------------------------
+ *
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Vulkan test case base classes
+ *//*--------------------------------------------------------------------*/
+
+#include "vktTestCase.hpp"
+
+namespace vkt
+{
+
+void TestCase::initPrograms (vk::ProgramCollection<glu::ProgramSources>&) const
+{
+}
+
+} // vkt
--- /dev/null
+#ifndef _VKTTESTCASE_HPP
+#define _VKTTESTCASE_HPP
+/*-------------------------------------------------------------------------
+ * drawElements Quality Program Vulkan Module
+ * --------------------------------------------
+ *
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Vulkan test case base classes
+ *//*--------------------------------------------------------------------*/
+
+#include "tcuDefs.hpp"
+#include "tcuTestCase.hpp"
+
+namespace glu
+{
+struct ProgramSources;
+}
+
+namespace vk
+{
+class PlatformInterface;
+class ProgramBinary;
+template<typename Program> class ProgramCollection;
+}
+
+namespace vkt
+{
+
+class Context
+{
+public:
+ Context (tcu::TestContext& testCtx,
+ const vk::PlatformInterface& platformInterface,
+ vk::ProgramCollection<vk::ProgramBinary>& progCollection)
+ : m_testCtx (testCtx)
+ , m_platformInterface (platformInterface)
+ , m_progCollection (progCollection) {}
+ ~Context (void) {}
+
+ tcu::TestContext& getTestContext (void) const { return m_testCtx; }
+ const vk::PlatformInterface& getPlatformInterface(void) const { return m_platformInterface; }
+ vk::ProgramCollection<vk::ProgramBinary>& getBinaryCollection (void) const { return m_progCollection; }
+
+protected:
+ tcu::TestContext& m_testCtx;
+ const vk::PlatformInterface& m_platformInterface;
+ vk::ProgramCollection<vk::ProgramBinary>& m_progCollection;
+};
+
+class TestInstance;
+
+class TestCase : public tcu::TestCase
+{
+public:
+ TestCase (tcu::TestContext& testCtx, const std::string& name, const std::string& description);
+ TestCase (tcu::TestContext& testCtx, tcu::TestNodeType type, const std::string& name, const std::string& description);
+ virtual ~TestCase (void) {}
+
+ virtual void initPrograms (vk::ProgramCollection<glu::ProgramSources>& programCollection) const;
+ virtual TestInstance* createInstance (Context& context) const = 0;
+
+ IterateResult iterate (void) { DE_ASSERT(false); return STOP; } // Deprecated in this module
+};
+
+class TestInstance
+{
+public:
+ TestInstance (Context& context) : m_context(context) {}
+ virtual ~TestInstance (void) {}
+
+ virtual tcu::TestStatus iterate (void) = 0;
+
+protected:
+ Context& m_context;
+};
+
+inline TestCase::TestCase (tcu::TestContext& testCtx, const std::string& name, const std::string& description)
+ : tcu::TestCase(testCtx, name.c_str(), description.c_str())
+{
+}
+
+inline TestCase::TestCase (tcu::TestContext& testCtx, tcu::TestNodeType type, const std::string& name, const std::string& description)
+ : tcu::TestCase(testCtx, type, name.c_str(), description.c_str())
+{
+}
+
+} // vkt
+
+#endif // _VKTTESTCASE_HPP
--- /dev/null
+/*-------------------------------------------------------------------------
+ * drawElements Quality Program Vulkan Module
+ * --------------------------------------------
+ *
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief TestCase utilities
+ *//*--------------------------------------------------------------------*/
+
+#include "vktTestCaseUtil.hpp"
+
+DE_EMPTY_CPP_FILE
--- /dev/null
+#ifndef _VKTTESTCASEUTIL_HPP
+#define _VKTTESTCASEUTIL_HPP
+/*-------------------------------------------------------------------------
+ * drawElements Quality Program Vulkan Module
+ * --------------------------------------------
+ *
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief TestCase utilities
+ *//*--------------------------------------------------------------------*/
+
+#include "tcuDefs.hpp"
+#include "vktTestCase.hpp"
+
+namespace vkt
+{
+
+template<typename Arg0>
+struct NoPrograms1
+{
+ void init (vk::ProgramCollection<glu::ProgramSources>&, const Arg0&) const {}
+};
+
+template<typename Instance, typename Arg0, typename Programs = NoPrograms1<Arg0> >
+class InstanceFactory1 : public TestCase
+{
+public:
+ InstanceFactory1 (tcu::TestContext& testCtx, tcu::TestNodeType type, const std::string& name, const std::string& desc, const Arg0& arg0)
+ : TestCase (testCtx, type, name, desc)
+ , m_progs ()
+ , m_arg0 (arg0)
+ {}
+
+ InstanceFactory1 (tcu::TestContext& testCtx, tcu::TestNodeType type, const std::string& name, const std::string& desc, const Programs& progs, const Arg0& arg0)
+ : TestCase (testCtx, type, name, desc)
+ , m_progs (progs)
+ , m_arg0 (arg0)
+ {}
+
+ void initPrograms (vk::ProgramCollection<glu::ProgramSources>& dst) const { m_progs.init(dst, m_arg0); }
+ TestInstance* createInstance (Context& context) const { return new Instance(context, m_arg0); }
+
+private:
+ const Programs m_progs;
+ const Arg0 m_arg0;
+};
+
+class FunctionInstance0 : public TestInstance
+{
+public:
+ typedef tcu::TestStatus (*Function) (Context& context);
+
+ FunctionInstance0 (Context& context, Function function)
+ : TestInstance (context)
+ , m_function (function)
+ {}
+
+ tcu::TestStatus iterate (void) { return m_function(m_context); }
+
+private:
+ const Function m_function;
+};
+
+template<typename Arg0>
+class FunctionInstance1 : public TestInstance
+{
+public:
+ typedef tcu::TestStatus (*Function) (Context& context, const Arg0& arg0);
+
+ struct Args
+ {
+ Args (Function func_, Arg0 arg0_) : func(func_), arg0(arg0_) {}
+
+ Function func;
+ Arg0 arg0;
+ };
+
+ FunctionInstance1 (Context& context, const Args& args)
+ : TestInstance (context)
+ , m_args (args)
+ {}
+
+ tcu::TestStatus iterate (void) { return m_args.func(m_context, m_args.arg0); }
+
+private:
+ const Args m_args;
+};
+
+template<typename Arg0>
+class FunctionPrograms1
+{
+public:
+ typedef void (*Function) (vk::ProgramCollection<glu::ProgramSources>& dst, const Arg0& arg0);
+
+ FunctionPrograms1 (Function func)
+ : m_func(func)
+ {}
+
+ void init (vk::ProgramCollection<glu::ProgramSources>& dst, const typename FunctionInstance1<Arg0>::Args& args) const { m_func(dst, args.arg0); }
+
+private:
+ const Function m_func;
+};
+
+inline TestCase* createFunctionCase (tcu::TestContext& testCtx,
+ tcu::TestNodeType type,
+ const std::string& name,
+ const std::string& desc,
+ FunctionInstance0::Function testFunction)
+{
+ return new InstanceFactory1<FunctionInstance0, typename FunctionInstance0::Function>(testCtx, type, name, desc, testFunction);
+}
+
+template<typename Arg0>
+TestCase* createFunctionCase (tcu::TestContext& testCtx,
+ tcu::TestNodeType type,
+ const std::string& name,
+ const std::string& desc,
+ typename FunctionInstance1<Arg0>::Function testFunction,
+ const Arg0& arg0)
+{
+ return new InstanceFactory1<FunctionInstance1<Arg0>, typename FunctionInstance1<Arg0>::Args>(
+ testCtx, type, name, desc, typename FunctionInstance1<Arg0>::Args(testFunction, arg0));
+}
+
+template<typename Arg0>
+TestCase* createFunctionCase (tcu::TestContext& testCtx,
+ tcu::TestNodeType type,
+ const std::string& name,
+ const std::string& desc,
+ typename FunctionPrograms1<Arg0>::Function initPrograms,
+ typename FunctionInstance1<Arg0>::Function testFunction,
+ const Arg0& arg0)
+{
+ return new InstanceFactory1<FunctionInstance1<Arg0>, typename FunctionInstance1<Arg0>::Args, FunctionPrograms1<Arg0> >(
+ testCtx, type, name, desc, FunctionPrograms1<Arg0>(initPrograms), typename FunctionInstance1<Arg0>::Args(testFunction, arg0));
+}
+
+inline void addFunctionCase (tcu::TestCaseGroup* group,
+ const std::string& name,
+ const std::string& desc,
+ FunctionInstance0::Function testFunc)
+{
+ group->addChild(createFunctionCase(group->getTestContext(), tcu::NODETYPE_SELF_VALIDATE, name, desc, testFunc));
+}
+
+template<typename Arg0>
+void addFunctionCase (tcu::TestCaseGroup* group,
+ const std::string& name,
+ const std::string& desc,
+ typename FunctionInstance1<Arg0>::Function testFunc,
+ const Arg0& arg0)
+{
+ group->addChild(createFunctionCase(group->getTestContext(), tcu::NODETYPE_SELF_VALIDATE, name, desc, testFunc, arg0));
+}
+
+template<typename Arg0>
+void addFunctionCase (tcu::TestCaseGroup* group,
+ tcu::TestNodeType type,
+ const std::string& name,
+ const std::string& desc,
+ typename FunctionInstance1<Arg0>::Function testFunc,
+ const Arg0& arg0)
+{
+ group->addChild(createFunctionCase(group->getTestContext(), type, name, desc, testFunc, arg0));
+}
+
+template<typename Arg0>
+void addFunctionCase (tcu::TestCaseGroup* group,
+ const std::string& name,
+ const std::string& desc,
+ typename FunctionPrograms1<Arg0>::Function initPrograms,
+ typename FunctionInstance1<Arg0>::Function testFunc,
+ const Arg0& arg0)
+{
+ group->addChild(createFunctionCase(group->getTestContext(), tcu::NODETYPE_SELF_VALIDATE, name, desc, initPrograms, testFunc, arg0));
+}
+
+template<typename Arg0>
+void addFunctionCase (tcu::TestCaseGroup* group,
+ tcu::TestNodeType type,
+ const std::string& name,
+ const std::string& desc,
+ typename FunctionPrograms1<Arg0>::Function initPrograms,
+ typename FunctionInstance1<Arg0>::Function testFunc,
+ const Arg0& arg0)
+{
+ group->addChild(createFunctionCase(group->getTestContext(), type, name, desc, initPrograms, testFunc, arg0));
+}
+
+} // vkt
+
+#endif // _VKTTESTCASEUTIL_HPP
--- /dev/null
+/*-------------------------------------------------------------------------
+ * drawElements Quality Program Vulkan Module
+ * --------------------------------------------
+ *
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Vulkan Test Package
+ *//*--------------------------------------------------------------------*/
+
+#include "vktTestPackage.hpp"
+
+#include "tcuPlatform.hpp"
+#include "vkPlatform.hpp"
+#include "vkPrograms.hpp"
+#include "deUniquePtr.hpp"
+
+#include "vktInfo.hpp"
+#include "vktApiTests.hpp"
+
+#include <vector>
+
+namespace vkt
+{
+
+using std::vector;
+using de::UniquePtr;
+using de::MovePtr;
+
+// TestCaseExecutor
+
+class TestCaseExecutor : public tcu::TestCaseExecutor
+{
+public:
+ TestCaseExecutor (tcu::TestContext& testCtx);
+ ~TestCaseExecutor (void);
+
+ virtual void init (tcu::TestCase* testCase, const std::string& path);
+ virtual void deinit (tcu::TestCase* testCase);
+
+ virtual tcu::TestNode::IterateResult iterate (tcu::TestCase* testCase);
+
+private:
+ vk::BinaryCollection m_progCollection;
+ de::UniquePtr<vk::Library> m_library;
+ Context m_context;
+
+ TestInstance* m_instance; //!< Current test case instance
+};
+
+static MovePtr<vk::Library> createLibrary (tcu::TestContext& testCtx)
+{
+ return MovePtr<vk::Library>(testCtx.getPlatform().getVulkanPlatform().createLibrary());
+}
+
+TestCaseExecutor::TestCaseExecutor (tcu::TestContext& testCtx)
+ : m_library (createLibrary(testCtx))
+ , m_context (testCtx, m_library->getPlatformInterface(), m_progCollection)
+ , m_instance (DE_NULL)
+{
+}
+
+TestCaseExecutor::~TestCaseExecutor (void)
+{
+ delete m_instance;
+}
+
+void TestCaseExecutor::init (tcu::TestCase* testCase, const std::string& casePath)
+{
+ const TestCase* vktCase = dynamic_cast<TestCase*>(testCase);
+ vk::SourceCollection sourceProgs;
+
+ DE_UNREF(casePath); // \todo [2015-03-13 pyry] Use this to identify ProgramCollection storage path
+
+ if (!vktCase)
+ TCU_THROW(InternalError, "Test node not an instance of vkt::TestCase");
+
+ m_progCollection.clear();
+ vktCase->initPrograms(sourceProgs);
+
+ // \todo [2015-03-13 pyry] Need abstraction for this - sometimes built on run-time, sometimes loaded from archive
+ for (vk::SourceCollection::Iterator progIter = sourceProgs.begin(); progIter != sourceProgs.end(); ++progIter)
+ {
+ const std::string& name = progIter.getName();
+ const glu::ProgramSources& srcProg = progIter.getProgram();
+ de::MovePtr<vk::ProgramBinary> binProg = de::MovePtr<vk::ProgramBinary>(vk::buildProgram(srcProg, vk::PROGRAM_FORMAT_GLSL));
+
+ m_progCollection.add(name, binProg);
+ }
+
+ DE_ASSERT(!m_instance);
+ m_instance = vktCase->createInstance(m_context);
+}
+
+void TestCaseExecutor::deinit (tcu::TestCase*)
+{
+ delete m_instance;
+ m_instance = DE_NULL;
+}
+
+tcu::TestNode::IterateResult TestCaseExecutor::iterate (tcu::TestCase*)
+{
+ DE_ASSERT(m_instance);
+
+ const tcu::TestStatus result = m_instance->iterate();
+
+ if (result.isComplete())
+ {
+ // Vulkan tests shouldn't set result directly
+ DE_ASSERT(m_context.getTestContext().getTestResult() == QP_TEST_RESULT_LAST);
+ m_context.getTestContext().setTestResult(result.getCode(), result.getDescription().c_str());
+ return tcu::TestNode::STOP;
+ }
+ else
+ return tcu::TestNode::CONTINUE;
+}
+
+// TestPackage
+
+TestPackage::TestPackage (tcu::TestContext& testCtx)
+ : tcu::TestPackage(testCtx, "dEQP-VK", "dEQP Vulkan Tests")
+{
+}
+
+TestPackage::~TestPackage (void)
+{
+}
+
+tcu::TestCaseExecutor* TestPackage::createExecutor (void) const
+{
+ return new TestCaseExecutor(m_testCtx);
+}
+
+void TestPackage::init (void)
+{
+ addChild(createInfoTests (m_testCtx));
+ addChild(api::createTests (m_testCtx));
+}
+
+} // vkt
--- /dev/null
+#ifndef _VKTTESTPACKAGE_HPP
+#define _VKTTESTPACKAGE_HPP
+/*-------------------------------------------------------------------------
+ * drawElements Quality Program Vulkan Module
+ * --------------------------------------------
+ *
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Vulkan Test Package
+ *//*--------------------------------------------------------------------*/
+
+#include "tcuDefs.hpp"
+#include "tcuTestPackage.hpp"
+#include "tcuResource.hpp"
+#include "vktTestCase.hpp"
+
+namespace vkt
+{
+
+class TestPackage : public tcu::TestPackage
+{
+public:
+ TestPackage (tcu::TestContext& testCtx);
+ virtual ~TestPackage (void);
+
+ virtual void init (void);
+ tcu::TestCaseExecutor* createExecutor (void) const;
+};
+
+} // vkt
+
+#endif // _VKTTESTPACKAGE_HPP
--- /dev/null
+/*-------------------------------------------------------------------------
+ * drawElements Quality Program Vulkan Module
+ * --------------------------------------------
+ *
+ * Copyright 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Vulkan Test Package Entry Point.
+ *//*--------------------------------------------------------------------*/
+
+#include "vktTestPackage.hpp"
+
+// Register package to test executor.
+
+static tcu::TestPackage* createTestPackage (tcu::TestContext& testCtx)
+{
+ return new vkt::TestPackage(testCtx);
+}
+
+tcu::TestPackageDescriptor g_vktPackageDescriptor("dEQP-VK", createTestPackage);
--- /dev/null
+add_subdirectory(vulkan)
Module("dEQP-GLES2", "gles2", "deqp-gles2"),
Module("dEQP-GLES3", "gles3", "deqp-gles3"),
Module("dEQP-GLES31", "gles31", "deqp-gles31"),
+ Module("dEQP-VK", "vulkan", "deqp-vk"),
]
DEFAULT_BUILD_DIR = os.path.join(tempfile.gettempdir(), "deqp-caselists", "{targetName}-{buildType}")
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import os
+import re
+import sys
+
+from khr_util.format import indentLines, writeInlFile
+
+DEQP_DIR = os.path.normpath(os.path.join(os.path.dirname(__file__), ".."))
+VULKAN_DIR = os.path.join(DEQP_DIR, "framework", "vulkan")
+
+INL_HEADER = """\
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * be lost! Modify the generating script instead.
+ */\
+"""
+
+PLATFORM_FUNCTIONS = [
+ "vkCreateInstance",
+ "vkDestroyInstance",
+ "vkEnumeratePhysicalDevices",
+]
+GET_PROC_ADDR = "vkGetProcAddr"
+
+OBJECT_TYPE_REPL = {
+ "VkObject": None,
+ "VkNonDispatchable": None,
+ "VkDynamicStateObject": None,
+ "VkCmdBuffer": "VK_OBJECT_TYPE_COMMAND_BUFFER",
+}
+
+DEFINITIONS = [
+ "VK_API_VERSION",
+ "VK_MAX_PHYSICAL_DEVICE_NAME",
+ "VK_MAX_EXTENSION_NAME"
+]
+
+class Handle:
+ TYPE_ROOT = 0
+ TYPE_DISP = 1
+ TYPE_NONDISP = 2
+
+ def __init__ (self, type, name, parent = None):
+ assert (type == Handle.TYPE_ROOT) == (parent == None)
+ self.type = type
+ self.name = name
+ self.parent = parent
+
+ def getObjectType (self):
+ if self.name in OBJECT_TYPE_REPL:
+ return OBJECT_TYPE_REPL[self.name]
+ else:
+ name = re.sub(r'([A-Z])', r'_\1', self.name)
+ return "VK_OBJECT_TYPE_" + name[4:].upper()
+
+class Enum:
+ def __init__ (self, name, values):
+ self.name = name
+ self.values = values
+
+class Bitfield:
+ def __init__ (self, name, values):
+ self.name = name
+ self.values = values
+
+class Variable:
+ def __init__ (self, type, name):
+ self.type = type
+ self.name = name
+
+class Struct:
+ def __init__ (self, name, members):
+ self.name = name
+ self.members = members
+
+class Function:
+ TYPE_GET_PROC_ADDR = 0 # Special
+ TYPE_PLATFORM = 1 # Not bound to VkPhysicalDevice
+ TYPE_DEVICE = 2 # Bound to VkPhysicalDevice
+
+ def __init__ (self, name, returnType, arguments):
+ self.name = name
+ self.returnType = returnType
+ self.arguments = arguments
+
+ def getType (self):
+ if self.name == GET_PROC_ADDR:
+ return Function.TYPE_GET_PROC_ADDR
+ elif self.name in PLATFORM_FUNCTIONS:
+ return Function.TYPE_PLATFORM
+ else:
+ return Function.TYPE_DEVICE
+
+class API:
+ def __init__ (self, definitions, handles, enums, bitfields, structs, functions):
+ self.definitions = definitions
+ self.handles = handles
+ self.enums = enums
+ self.bitfields = bitfields
+ self.structs = structs
+ self.functions = functions
+
+def readFile (filename):
+ with open(filename, 'rb') as f:
+ return f.read()
+
+IDENT_PTRN = r'[a-zA-Z_][a-zA-Z0-9_]*'
+TYPE_PTRN = r'[a-zA-Z_][a-zA-Z0-9_ \t*]*'
+
+def endswith (s, postfix):
+ return len(s) >= len(postfix) and s[len(s)-len(postfix):] == postfix
+
+def fixupEnumValues (values):
+ fixed = []
+ for name, value in values:
+ if endswith(name, "_BEGIN_RANGE") or endswith(name, "_END_RANGE"):
+ continue
+ fixed.append((name, value))
+ return fixed
+
+def fixupType (type):
+ replacements = [
+ ("uint8_t", "deUint8"),
+ ("uint16_t", "deUint16"),
+ ("uint32_t", "deUint32"),
+ ("uint64_t", "deUint64"),
+ ("int8_t", "deInt8"),
+ ("int16_t", "deInt16"),
+ ("int32_t", "deInt32"),
+ ("int64_t", "deInt64"),
+ ("bool32_t", "deUint32"),
+ ("size_t", "deUintptr"),
+ ]
+
+ for src, dst in replacements:
+ type = type.replace(src, dst)
+
+ return type
+
+def fixupFunction (function):
+ fixedArgs = [Variable(fixupType(a.type), a.name) for a in function.arguments]
+ fixedReturnType = fixupType(function.returnType)
+
+ if function.name == "vkGetProcAddr":
+ fixedReturnType = "FunctionPtr"
+
+ return Function(function.name, fixedReturnType, fixedArgs)
+
+def getInterfaceName (function):
+ assert function.name[:2] == "vk"
+ return function.name[2].lower() + function.name[3:]
+
+def getFunctionTypeName (function):
+ assert function.name[:2] == "vk"
+ return function.name[2:] + "Func"
+
+def getBitEnumNameForBitfield (bitfieldName):
+ assert bitfieldName[-1] == "s"
+ return bitfieldName[:-1] + "Bits"
+
+def getBitfieldNameForBitEnum (bitEnumName):
+ assert bitEnumName[-4:] == "Bits"
+ return bitEnumName[:-4] + "s"
+
+def parsePreprocDefinedValue (src, name):
+ return re.search(r'#\s*define\s+' + name + r'\s+([^\n]+)\n', src).group(1).strip()
+
+def parseEnum (name, src):
+ keyValuePtrn = '(' + IDENT_PTRN + r')\s*=\s*([^\s,}]+)\s*[,}]'
+ matches = re.findall(keyValuePtrn, src)
+
+ return Enum(name, fixupEnumValues(matches))
+
+# \note Parses raw enums, some are mapped to bitfields later
+def parseEnums (src):
+ matches = re.findall(r'typedef enum ' + IDENT_PTRN + r'\s*{([^}]*)}\s*(' + IDENT_PTRN + r')\s*;', src)
+ enums = []
+
+ for contents, name in matches:
+ enums.append(parseEnum(name, contents))
+
+ return enums
+
+def parseStruct (name, src):
+ # \todo [pyry] Array support is currently a hack (size coupled with name)
+ typeNamePtrn = r'(' + TYPE_PTRN + ')(\s' + IDENT_PTRN + r'(\[[^\]]+\])*)\s*;'
+ matches = re.findall(typeNamePtrn, src)
+ members = [Variable(fixupType(t.strip()), n.strip()) for t, n, a in matches]
+
+ return Struct(name, members)
+
+def parseStructs (src):
+ matches = re.findall(r'typedef struct ' + IDENT_PTRN + r'\s*{([^}]*)}\s*(' + IDENT_PTRN + r')\s*;', src)
+ structs = []
+
+ for contents, name in matches:
+ structs.append(parseStruct(name, contents))
+
+ return structs
+
+def parseHandles (src):
+ matches = re.findall(r'VK_DEFINE_(NONDISP|DISP)_SUBCLASS_HANDLE\((' + IDENT_PTRN + r'),\s*(' + IDENT_PTRN + r')\)[ \t]*[\n\r]', src)
+ handles = []
+ typeMap = {'DISP': Handle.TYPE_DISP, 'NONDISP': Handle.TYPE_NONDISP}
+ byName = {}
+ root = Handle(Handle.TYPE_ROOT, 'VkObject')
+
+ byName[root.name] = root
+ handles.append(root)
+
+ for type, name, parentName in matches:
+ parent = byName[parentName]
+ handle = Handle(typeMap[type], name, parent)
+
+ byName[handle.name] = handle
+ handles.append(handle)
+
+ return handles
+
+def parseArgList (src):
+ typeNamePtrn = r'(' + TYPE_PTRN + ')(\s' + IDENT_PTRN + r')'
+ args = []
+
+ for rawArg in src.split(','):
+ m = re.search(typeNamePtrn, rawArg)
+ args.append(Variable(m.group(1).strip(), m.group(2).strip()))
+
+ return args
+
+def parseFunctions (src):
+ ptrn = r'(' + TYPE_PTRN + ')VKAPI\s+(' + IDENT_PTRN + r')\s*\(([^)]*)\)\s*;'
+ matches = re.findall(ptrn, src)
+ functions = []
+
+ for returnType, name, argList in matches:
+ functions.append(Function(name.strip(), returnType.strip(), parseArgList(argList)))
+
+ return [fixupFunction(f) for f in functions]
+
+def parseBitfieldNames (src):
+ ptrn = r'typedef\s+VkFlags\s(' + IDENT_PTRN + r')\s*;'
+ matches = re.findall(ptrn, src)
+
+ return matches
+
+def parseAPI (src):
+ definitions = [(name, parsePreprocDefinedValue(src, name)) for name in DEFINITIONS]
+ rawEnums = parseEnums(src)
+ bitfieldNames = parseBitfieldNames(src)
+ enums = []
+ bitfields = []
+ bitfieldEnums = set([getBitEnumNameForBitfield(n) for n in bitfieldNames])
+
+ for enum in rawEnums:
+ if enum.name in bitfieldEnums:
+ bitfields.append(Bitfield(getBitfieldNameForBitEnum(enum.name), enum.values))
+ else:
+ enums.append(enum)
+
+ return API(
+ definitions = definitions,
+ handles = parseHandles(src),
+ enums = enums,
+ bitfields = bitfields,
+ structs = parseStructs(src),
+ functions = parseFunctions(src))
+
+def genEnumSrc (enum):
+ yield "enum %s" % enum.name
+ yield "{"
+ for line in indentLines(["\t%s\t= %s," % v for v in enum.values]):
+ yield line
+ yield "};"
+
+def genBitfieldSrc (bitfield):
+ yield "enum %s" % getBitEnumNameForBitfield(bitfield.name)
+ yield "{"
+ for line in indentLines(["\t%s\t= %s," % v for v in bitfield.values]):
+ yield line
+ yield "};"
+ yield "typedef deUint32 %s;" % bitfield.name
+
+def genStructSrc (struct):
+ yield "struct %s" % struct.name
+ yield "{"
+ for line in indentLines(["\t%s\t%s;" % (m.type, m.name) for m in struct.members]):
+ yield line
+ yield "};"
+
+def genHandlesSrc (handles):
+ def genLines (handles):
+ for handle in handles:
+ if handle.type == Handle.TYPE_ROOT:
+ yield "VK_DEFINE_BASE_HANDLE\t(%s);" % handle.name
+ elif handle.type == Handle.TYPE_DISP:
+ yield "VK_DEFINE_DISP_SUBCLASS_HANDLE\t(%s,\t%s);" % (handle.name, handle.parent.name)
+ elif handle.type == Handle.TYPE_NONDISP:
+ yield "VK_DEFINE_NONDISP_SUBCLASS_HANDLE\t(%s,\t%s);" % (handle.name, handle.parent.name)
+
+ for line in indentLines(genLines(handles)):
+ yield line
+
+def writeBasicTypes (api, filename):
+ def gen ():
+ for line in indentLines(["#define %s\t%s" % define for define in api.definitions]):
+ yield line
+ yield ""
+ for line in genHandlesSrc(api.handles):
+ yield line
+ yield ""
+ for enum in api.enums:
+ for line in genEnumSrc(enum):
+ yield line
+ yield ""
+ for bitfield in api.bitfields:
+ for line in genBitfieldSrc(bitfield):
+ yield line
+ yield ""
+ for line in indentLines(["VK_DEFINE_HANDLE_TYPE_TRAITS(%s);" % handle.name for handle in api.handles]):
+ yield line
+
+ writeInlFile(filename, INL_HEADER, gen())
+
+def writeGetObjectTypeImpl (api, filename):
+ def gen ():
+ for line in indentLines(["template<> VkObjectType\tgetObjectType<%sT>\t(void) { return %s;\t}" % (handle.name, handle.getObjectType()) for handle in api.handles if handle.getObjectType() != None]):
+ yield line
+
+ writeInlFile(filename, INL_HEADER, gen())
+
+def writeStructTypes (api, filename):
+ def gen ():
+ for struct in api.structs:
+ for line in genStructSrc(struct):
+ yield line
+ yield ""
+
+ writeInlFile(filename, INL_HEADER, gen())
+
+def argListToStr (args):
+ return ", ".join("%s %s" % (v.type, v.name) for v in args)
+
+def writeInterfaceDecl (api, filename, functionTypes, concrete):
+ def genProtos ():
+ postfix = "" if concrete else " = 0"
+ for function in api.functions:
+ if function.getType() in functionTypes:
+ yield "virtual %s\t%s\t(%s) const%s;" % (function.returnType, getInterfaceName(function), argListToStr(function.arguments), postfix)
+
+ writeInlFile(filename, INL_HEADER, indentLines(genProtos()))
+
+def writeFunctionPtrTypes (api, filename):
+ def genTypes ():
+ for function in api.functions:
+ yield "typedef VK_APICALL %s\t(VK_APIENTRY* %s)\t(%s);" % (function.returnType, getFunctionTypeName(function), argListToStr(function.arguments))
+
+ writeInlFile(filename, INL_HEADER, indentLines(genTypes()))
+
+def writeFunctionPointers (api, filename, functionTypes):
+ writeInlFile(filename, INL_HEADER, indentLines(["%s\t%s;" % (getFunctionTypeName(function), getInterfaceName(function)) for function in api.functions if function.getType() in functionTypes]))
+
+def writeInitFunctionPointers (api, filename, functionTypes):
+ def makeInitFunctionPointers ():
+ for function in api.functions:
+ if function.getType() in functionTypes:
+ yield "m_vk.%s\t= (%s)\tGET_PROC_ADDR(\"%s\");" % (getInterfaceName(function), getFunctionTypeName(function), function.name)
+
+ writeInlFile(filename, INL_HEADER, indentLines(makeInitFunctionPointers()))
+
+def writeFuncPtrInterfaceImpl (api, filename, functionTypes, className):
+ def makeFuncPtrInterfaceImpl ():
+ for function in api.functions:
+ if function.getType() in functionTypes:
+ yield ""
+ yield "%s %s::%s (%s) const" % (function.returnType, className, getInterfaceName(function), argListToStr(function.arguments))
+ yield "{"
+ yield " %sm_vk.%s(%s);" % ("return " if function.returnType != "void" else "", getInterfaceName(function), ", ".join(a.name for a in function.arguments))
+ yield "}"
+
+ writeInlFile(filename, INL_HEADER, makeFuncPtrInterfaceImpl())
+
+def writeStrUtilProto (api, filename):
+ def makeStrUtilProto ():
+ for line in indentLines(["const char*\tget%sName\t(%s value);" % (enum.name[2:], enum.name) for enum in api.enums]):
+ yield line
+ yield ""
+ for line in indentLines(["inline tcu::Format::Enum<%s>\tget%sStr\t(%s value)\t{ return tcu::Format::Enum<%s>(get%sName, value);\t}" % (e.name, e.name[2:], e.name, e.name, e.name[2:]) for e in api.enums]):
+ yield line
+ yield ""
+ for line in indentLines(["inline std::ostream&\toperator<<\t(std::ostream& s, %s value)\t{ return s << get%sStr(value);\t}" % (e.name, e.name[2:]) for e in api.enums]):
+ yield line
+ yield ""
+ for line in indentLines(["tcu::Format::Bitfield<32>\tget%sStr\t(%s value);" % (bitfield.name[2:], bitfield.name) for bitfield in api.bitfields]):
+ yield line
+
+ writeInlFile(filename, INL_HEADER, makeStrUtilProto())
+
+def writeStrUtilImpl (api, filename):
+ def makeStrUtilImpl ():
+ for line in indentLines(["template<> const char*\tgetTypeName<%sT>\t(void) { return \"%s\";\t}" % (handle.name, handle.name) for handle in api.handles]):
+ yield line
+
+ for enum in api.enums:
+ yield ""
+ yield "const char* get%sName (%s value)" % (enum.name[2:], enum.name)
+ yield "{"
+ yield "\tswitch (value)"
+ yield "\t{"
+ for line in indentLines(["\t\tcase %s:\treturn \"%s\";" % (n, n) for n, v in enum.values] + ["\t\tdefault:\treturn DE_NULL;"]):
+ yield line
+ yield "\t}"
+ yield "}"
+
+ for bitfield in api.bitfields:
+ yield ""
+ yield "tcu::Format::Bitfield<32> get%sStr (%s value)" % (bitfield.name[2:], bitfield.name)
+ yield "{"
+ yield "\tstatic const tcu::Format::BitDesc s_desc[] ="
+ yield "\t{"
+ for line in indentLines(["\t\ttcu::Format::BitDesc(%s,\t\"%s\")," % (n, n) for n, v in bitfield.values]):
+ yield line
+ yield "\t};"
+ yield "\treturn tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));"
+ yield "}"
+
+ writeInlFile(filename, INL_HEADER, makeStrUtilImpl())
+
+class ConstructorFunction:
+ def __init__ (self, name, objectType, iface, arguments):
+ self.name = name
+ self.objectType = objectType
+ self.iface = iface
+ self.arguments = arguments
+
+def getConstructorFunctions (api):
+ funcs = []
+ for function in api.functions:
+ if function.name[:8] == "vkCreate":
+ # \todo [pyry] Rather hacky
+ iface = None
+ if function.getType() == Function.TYPE_PLATFORM:
+ iface = Variable("const PlatformInterface&", "vk")
+ else:
+ iface = Variable("const DeviceInterface&", "vk")
+ objectType = function.arguments[-1].type.replace("*", "").strip()
+ arguments = function.arguments[:-1]
+ funcs.append(ConstructorFunction(getInterfaceName(function), objectType, iface, arguments))
+ return funcs
+
+def writeRefUtilProto (api, filename):
+ functions = getConstructorFunctions(api)
+
+ def makeRefUtilProto ():
+ unindented = []
+ for line in indentLines(["Move<%sT>\t%s\t(%s);" % (function.objectType, function.name, argListToStr([function.iface] + function.arguments)) for function in functions]):
+ yield line
+
+ writeInlFile(filename, INL_HEADER, makeRefUtilProto())
+
+def writeRefUtilImpl (api, filename):
+ functions = getConstructorFunctions(api)
+
+ def makeRefUtilImpl ():
+ for function in functions:
+ maybeDevice = ", device" if "device" in set([a.name for a in function.arguments]) else ""
+
+ yield "Move<%sT> %s (%s)" % (function.objectType, function.name, argListToStr([function.iface] + function.arguments))
+ yield "{"
+ yield "\t%s object = 0;" % function.objectType
+ yield "\tvk.%s(%s);" % (function.name, ", ".join([a.name for a in function.arguments] + ["&object"]))
+ yield "\treturn Move<%sT>(vk%s, check<%sT>(object));" % (function.objectType, maybeDevice, function.objectType)
+ yield "}"
+ yield ""
+
+ writeInlFile(filename, INL_HEADER, makeRefUtilImpl())
+
+if __name__ == "__main__":
+ src = readFile(sys.argv[1])
+ api = parseAPI(src)
+ platformFuncs = set([Function.TYPE_GET_PROC_ADDR, Function.TYPE_PLATFORM])
+ deviceFuncs = set([Function.TYPE_DEVICE])
+
+ writeBasicTypes (api, os.path.join(VULKAN_DIR, "vkBasicTypes.inl"))
+ writeStructTypes (api, os.path.join(VULKAN_DIR, "vkStructTypes.inl"))
+ writeGetObjectTypeImpl (api, os.path.join(VULKAN_DIR, "vkGetObjectTypeImpl.inl"))
+ writeInterfaceDecl (api, os.path.join(VULKAN_DIR, "vkVirtualPlatformInterface.inl"), functionTypes = platformFuncs, concrete = False)
+ writeInterfaceDecl (api, os.path.join(VULKAN_DIR, "vkVirtualDeviceInterface.inl"), functionTypes = deviceFuncs, concrete = False)
+ writeInterfaceDecl (api, os.path.join(VULKAN_DIR, "vkConcretePlatformInterface.inl"), functionTypes = platformFuncs, concrete = True)
+ writeInterfaceDecl (api, os.path.join(VULKAN_DIR, "vkConcreteDeviceInterface.inl"), functionTypes = deviceFuncs, concrete = True)
+ writeFunctionPtrTypes (api, os.path.join(VULKAN_DIR, "vkFunctionPointerTypes.inl"))
+ writeFunctionPointers (api, os.path.join(VULKAN_DIR, "vkPlatformFunctionPointers.inl"), functionTypes = platformFuncs)
+ writeFunctionPointers (api, os.path.join(VULKAN_DIR, "vkDeviceFunctionPointers.inl"), functionTypes = deviceFuncs)
+ writeInitFunctionPointers (api, os.path.join(VULKAN_DIR, "vkInitPlatformFunctionPointers.inl"), functionTypes = set([Function.TYPE_PLATFORM])) # \note No vkGetProcAddr
+ writeInitFunctionPointers (api, os.path.join(VULKAN_DIR, "vkInitDeviceFunctionPointers.inl"), functionTypes = deviceFuncs)
+ writeFuncPtrInterfaceImpl (api, os.path.join(VULKAN_DIR, "vkPlatformDriverImpl.inl"), functionTypes = platformFuncs, className = "PlatformDriver")
+ writeFuncPtrInterfaceImpl (api, os.path.join(VULKAN_DIR, "vkDeviceDriverImpl.inl"), functionTypes = deviceFuncs, className = "DeviceDriver")
+ writeStrUtilProto (api, os.path.join(VULKAN_DIR, "vkStrUtil.inl"))
+ writeStrUtilImpl (api, os.path.join(VULKAN_DIR, "vkStrUtilImpl.inl"))
+ writeRefUtilProto (api, os.path.join(VULKAN_DIR, "vkRefUtil.inl"))
+ writeRefUtilImpl (api, os.path.join(VULKAN_DIR, "vkRefUtilImpl.inl"))
projects / platform / upstream / VK-GL-CTS.git / commitdiff