Vulkan C++ wrapper

Vk.h

#pragma once

#include <cstdint>
#include <cstddef>
#include <cstring>
#include <vulkan/vulkan.h>

namespace vk {

template <typename EnumType, typename T = uint32_t>
class Flags {
	T m_mask;

public:
	Flags(): m_mask(0) {}
	Flags(EnumType bit): m_mask(static_cast<uint32_t>(bit)) {}
	explicit Flags(T mask): m_mask(mask) {}
	Flags(const Flags &rhs): m_mask(rhs.m_mask) {}

	Flags &operator=(const Flags &rhs) { m_mask = rhs.m_mask; return *this; }

	Flags &operator|=(const Flags &rhs) { m_mask |= rhs.m_mask; return *this; }
	Flags &operator&=(const Flags &rhs) { m_mask &= rhs.m_mask; return *this; }
	Flags &operator^=(const Flags &rhs) { m_mask ^= rhs.m_mask; return *this; }

	Flags operator|(const Flags &rhs) const { return Flags(m_mask | rhs.m_mask); }
	Flags operator&(const Flags &rhs) const { return Flags(m_mask & rhs.m_mask); }
	Flags operator^(const Flags &rhs) const { return Flags(m_mask ^ rhs.m_mask); }

	Flags operator~() const { return Flags(~m_mask); }

	bool operator==(const Flags &rhs) const { return m_mask == rhs.m_mask; }
	bool operator!=(const Flags &rhs) const { return m_mask != rhs.m_mask; }

	operator bool() const { return m_mask != 0; }
	explicit operator T() const { return m_mask; }
};

template <typename EnumType, typename T>
inline Flags<EnumType, T> operator|(EnumType bit, const Flags<EnumType, T> &flags)
{
	return flags | bit;
}
template <typename EnumType, typename T>
inline Flags<EnumType, T> operator&(EnumType bit, const Flags<EnumType, T> &flags)
{
	return flags & bit;
}
template <typename EnumType, typename T>
inline Flags<EnumType, T> operator^(EnumType bit, const Flags<EnumType, T> &flags)
{
	return flags ^ bit;
}

typedef uint32_t SampleMask;
typedef uint32_t Bool32;
typedef uint64_t DeviceSize;

#if defined(__LP64__) || defined(_WIN64) || defined(__x86_64__) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
#define VK_EXPLICIT_HANDLE
#else
#define VK_EXPLICIT_HANDLE explicit
#endif

struct NullHandle {};
constexpr NullHandle nullHandle = {};





class Instance {
	VkInstance m_handle;
public:
	Instance(): m_handle(VK_NULL_HANDLE) {}
	Instance(NullHandle): m_handle(VK_NULL_HANDLE) {}
	Instance(VkInstance handle): m_handle(handle) {}
	operator VkInstance() const { return m_handle; }

	VkInstance handle() const { return m_handle; }
	VkInstance *c_ptr() { return &m_handle; }
	const VkInstance *c_ptr() const { return &m_handle; }
};

inline bool operator==(const Instance &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const Instance &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const Instance &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const Instance &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class PhysicalDevice {
	VkPhysicalDevice m_handle;
public:
	PhysicalDevice(): m_handle(VK_NULL_HANDLE) {}
	PhysicalDevice(NullHandle): m_handle(VK_NULL_HANDLE) {}
	PhysicalDevice(VkPhysicalDevice handle): m_handle(handle) {}
	operator VkPhysicalDevice() const { return m_handle; }

	VkPhysicalDevice handle() const { return m_handle; }
	VkPhysicalDevice *c_ptr() { return &m_handle; }
	const VkPhysicalDevice *c_ptr() const { return &m_handle; }
};

inline bool operator==(const PhysicalDevice &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const PhysicalDevice &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const PhysicalDevice &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const PhysicalDevice &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class Device {
	VkDevice m_handle;
public:
	Device(): m_handle(VK_NULL_HANDLE) {}
	Device(NullHandle): m_handle(VK_NULL_HANDLE) {}
	Device(VkDevice handle): m_handle(handle) {}
	operator VkDevice() const { return m_handle; }

	VkDevice handle() const { return m_handle; }
	VkDevice *c_ptr() { return &m_handle; }
	const VkDevice *c_ptr() const { return &m_handle; }
};

inline bool operator==(const Device &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const Device &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const Device &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const Device &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class Queue {
	VkQueue m_handle;
public:
	Queue(): m_handle(VK_NULL_HANDLE) {}
	Queue(NullHandle): m_handle(VK_NULL_HANDLE) {}
	Queue(VkQueue handle): m_handle(handle) {}
	operator VkQueue() const { return m_handle; }

	VkQueue handle() const { return m_handle; }
	VkQueue *c_ptr() { return &m_handle; }
	const VkQueue *c_ptr() const { return &m_handle; }
};

inline bool operator==(const Queue &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const Queue &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const Queue &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const Queue &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class CommandBuffer {
	VkCommandBuffer m_handle;
public:
	CommandBuffer(): m_handle(VK_NULL_HANDLE) {}
	CommandBuffer(NullHandle): m_handle(VK_NULL_HANDLE) {}
	CommandBuffer(VkCommandBuffer handle): m_handle(handle) {}
	operator VkCommandBuffer() const { return m_handle; }

	VkCommandBuffer handle() const { return m_handle; }
	VkCommandBuffer *c_ptr() { return &m_handle; }
	const VkCommandBuffer *c_ptr() const { return &m_handle; }
};

inline bool operator==(const CommandBuffer &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const CommandBuffer &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const CommandBuffer &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const CommandBuffer &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class DeviceMemory {
	VkDeviceMemory m_handle;
public:
	DeviceMemory(): m_handle(VK_NULL_HANDLE) {}
	DeviceMemory(NullHandle): m_handle(VK_NULL_HANDLE) {}
	VK_EXPLICIT_HANDLE DeviceMemory(VkDeviceMemory handle): m_handle(handle) {}
	VK_EXPLICIT_HANDLE operator VkDeviceMemory() const { return m_handle; }

	VkDeviceMemory handle() const { return m_handle; }
	VkDeviceMemory *c_ptr() { return &m_handle; }
	const VkDeviceMemory *c_ptr() const { return &m_handle; }
};

inline bool operator==(const DeviceMemory &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const DeviceMemory &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const DeviceMemory &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const DeviceMemory &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class CommandPool {
	VkCommandPool m_handle;
public:
	CommandPool(): m_handle(VK_NULL_HANDLE) {}
	CommandPool(NullHandle): m_handle(VK_NULL_HANDLE) {}
	VK_EXPLICIT_HANDLE CommandPool(VkCommandPool handle): m_handle(handle) {}
	VK_EXPLICIT_HANDLE operator VkCommandPool() const { return m_handle; }

	VkCommandPool handle() const { return m_handle; }
	VkCommandPool *c_ptr() { return &m_handle; }
	const VkCommandPool *c_ptr() const { return &m_handle; }
};

inline bool operator==(const CommandPool &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const CommandPool &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const CommandPool &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const CommandPool &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class Buffer {
	VkBuffer m_handle;
public:
	Buffer(): m_handle(VK_NULL_HANDLE) {}
	Buffer(NullHandle): m_handle(VK_NULL_HANDLE) {}
	VK_EXPLICIT_HANDLE Buffer(VkBuffer handle): m_handle(handle) {}
	VK_EXPLICIT_HANDLE operator VkBuffer() const { return m_handle; }

	VkBuffer handle() const { return m_handle; }
	VkBuffer *c_ptr() { return &m_handle; }
	const VkBuffer *c_ptr() const { return &m_handle; }
};

inline bool operator==(const Buffer &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const Buffer &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const Buffer &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const Buffer &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class BufferView {
	VkBufferView m_handle;
public:
	BufferView(): m_handle(VK_NULL_HANDLE) {}
	BufferView(NullHandle): m_handle(VK_NULL_HANDLE) {}
	VK_EXPLICIT_HANDLE BufferView(VkBufferView handle): m_handle(handle) {}
	VK_EXPLICIT_HANDLE operator VkBufferView() const { return m_handle; }

	VkBufferView handle() const { return m_handle; }
	VkBufferView *c_ptr() { return &m_handle; }
	const VkBufferView *c_ptr() const { return &m_handle; }
};

inline bool operator==(const BufferView &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const BufferView &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const BufferView &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const BufferView &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class Image {
	VkImage m_handle;
public:
	Image(): m_handle(VK_NULL_HANDLE) {}
	Image(NullHandle): m_handle(VK_NULL_HANDLE) {}
	VK_EXPLICIT_HANDLE Image(VkImage handle): m_handle(handle) {}
	VK_EXPLICIT_HANDLE operator VkImage() const { return m_handle; }

	VkImage handle() const { return m_handle; }
	VkImage *c_ptr() { return &m_handle; }
	const VkImage *c_ptr() const { return &m_handle; }
};

inline bool operator==(const Image &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const Image &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const Image &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const Image &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class ImageView {
	VkImageView m_handle;
public:
	ImageView(): m_handle(VK_NULL_HANDLE) {}
	ImageView(NullHandle): m_handle(VK_NULL_HANDLE) {}
	VK_EXPLICIT_HANDLE ImageView(VkImageView handle): m_handle(handle) {}
	VK_EXPLICIT_HANDLE operator VkImageView() const { return m_handle; }

	VkImageView handle() const { return m_handle; }
	VkImageView *c_ptr() { return &m_handle; }
	const VkImageView *c_ptr() const { return &m_handle; }
};

inline bool operator==(const ImageView &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const ImageView &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const ImageView &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const ImageView &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class ShaderModule {
	VkShaderModule m_handle;
public:
	ShaderModule(): m_handle(VK_NULL_HANDLE) {}
	ShaderModule(NullHandle): m_handle(VK_NULL_HANDLE) {}
	VK_EXPLICIT_HANDLE ShaderModule(VkShaderModule handle): m_handle(handle) {}
	VK_EXPLICIT_HANDLE operator VkShaderModule() const { return m_handle; }

	VkShaderModule handle() const { return m_handle; }
	VkShaderModule *c_ptr() { return &m_handle; }
	const VkShaderModule *c_ptr() const { return &m_handle; }
};

inline bool operator==(const ShaderModule &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const ShaderModule &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const ShaderModule &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const ShaderModule &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class Pipeline {
	VkPipeline m_handle;
public:
	Pipeline(): m_handle(VK_NULL_HANDLE) {}
	Pipeline(NullHandle): m_handle(VK_NULL_HANDLE) {}
	VK_EXPLICIT_HANDLE Pipeline(VkPipeline handle): m_handle(handle) {}
	VK_EXPLICIT_HANDLE operator VkPipeline() const { return m_handle; }

	VkPipeline handle() const { return m_handle; }
	VkPipeline *c_ptr() { return &m_handle; }
	const VkPipeline *c_ptr() const { return &m_handle; }
};

inline bool operator==(const Pipeline &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const Pipeline &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const Pipeline &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const Pipeline &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class PipelineLayout {
	VkPipelineLayout m_handle;
public:
	PipelineLayout(): m_handle(VK_NULL_HANDLE) {}
	PipelineLayout(NullHandle): m_handle(VK_NULL_HANDLE) {}
	VK_EXPLICIT_HANDLE PipelineLayout(VkPipelineLayout handle): m_handle(handle) {}
	VK_EXPLICIT_HANDLE operator VkPipelineLayout() const { return m_handle; }

	VkPipelineLayout handle() const { return m_handle; }
	VkPipelineLayout *c_ptr() { return &m_handle; }
	const VkPipelineLayout *c_ptr() const { return &m_handle; }
};

inline bool operator==(const PipelineLayout &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const PipelineLayout &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const PipelineLayout &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const PipelineLayout &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class Sampler {
	VkSampler m_handle;
public:
	Sampler(): m_handle(VK_NULL_HANDLE) {}
	Sampler(NullHandle): m_handle(VK_NULL_HANDLE) {}
	VK_EXPLICIT_HANDLE Sampler(VkSampler handle): m_handle(handle) {}
	VK_EXPLICIT_HANDLE operator VkSampler() const { return m_handle; }

	VkSampler handle() const { return m_handle; }
	VkSampler *c_ptr() { return &m_handle; }
	const VkSampler *c_ptr() const { return &m_handle; }
};

inline bool operator==(const Sampler &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const Sampler &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const Sampler &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const Sampler &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class DescriptorSet {
	VkDescriptorSet m_handle;
public:
	DescriptorSet(): m_handle(VK_NULL_HANDLE) {}
	DescriptorSet(NullHandle): m_handle(VK_NULL_HANDLE) {}
	VK_EXPLICIT_HANDLE DescriptorSet(VkDescriptorSet handle): m_handle(handle) {}
	VK_EXPLICIT_HANDLE operator VkDescriptorSet() const { return m_handle; }

	VkDescriptorSet handle() const { return m_handle; }
	VkDescriptorSet *c_ptr() { return &m_handle; }
	const VkDescriptorSet *c_ptr() const { return &m_handle; }
};

inline bool operator==(const DescriptorSet &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const DescriptorSet &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const DescriptorSet &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const DescriptorSet &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class DescriptorSetLayout {
	VkDescriptorSetLayout m_handle;
public:
	DescriptorSetLayout(): m_handle(VK_NULL_HANDLE) {}
	DescriptorSetLayout(NullHandle): m_handle(VK_NULL_HANDLE) {}
	VK_EXPLICIT_HANDLE DescriptorSetLayout(VkDescriptorSetLayout handle): m_handle(handle) {}
	VK_EXPLICIT_HANDLE operator VkDescriptorSetLayout() const { return m_handle; }

	VkDescriptorSetLayout handle() const { return m_handle; }
	VkDescriptorSetLayout *c_ptr() { return &m_handle; }
	const VkDescriptorSetLayout *c_ptr() const { return &m_handle; }
};

inline bool operator==(const DescriptorSetLayout &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const DescriptorSetLayout &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const DescriptorSetLayout &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const DescriptorSetLayout &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class DescriptorPool {
	VkDescriptorPool m_handle;
public:
	DescriptorPool(): m_handle(VK_NULL_HANDLE) {}
	DescriptorPool(NullHandle): m_handle(VK_NULL_HANDLE) {}
	VK_EXPLICIT_HANDLE DescriptorPool(VkDescriptorPool handle): m_handle(handle) {}
	VK_EXPLICIT_HANDLE operator VkDescriptorPool() const { return m_handle; }

	VkDescriptorPool handle() const { return m_handle; }
	VkDescriptorPool *c_ptr() { return &m_handle; }
	const VkDescriptorPool *c_ptr() const { return &m_handle; }
};

inline bool operator==(const DescriptorPool &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const DescriptorPool &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const DescriptorPool &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const DescriptorPool &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class Fence {
	VkFence m_handle;
public:
	Fence(): m_handle(VK_NULL_HANDLE) {}
	Fence(NullHandle): m_handle(VK_NULL_HANDLE) {}
	VK_EXPLICIT_HANDLE Fence(VkFence handle): m_handle(handle) {}
	VK_EXPLICIT_HANDLE operator VkFence() const { return m_handle; }

	VkFence handle() const { return m_handle; }
	VkFence *c_ptr() { return &m_handle; }
	const VkFence *c_ptr() const { return &m_handle; }
};

inline bool operator==(const Fence &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const Fence &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const Fence &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const Fence &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class Semaphore {
	VkSemaphore m_handle;
public:
	Semaphore(): m_handle(VK_NULL_HANDLE) {}
	Semaphore(NullHandle): m_handle(VK_NULL_HANDLE) {}
	VK_EXPLICIT_HANDLE Semaphore(VkSemaphore handle): m_handle(handle) {}
	VK_EXPLICIT_HANDLE operator VkSemaphore() const { return m_handle; }

	VkSemaphore handle() const { return m_handle; }
	VkSemaphore *c_ptr() { return &m_handle; }
	const VkSemaphore *c_ptr() const { return &m_handle; }
};

inline bool operator==(const Semaphore &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const Semaphore &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const Semaphore &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const Semaphore &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class Event {
	VkEvent m_handle;
public:
	Event(): m_handle(VK_NULL_HANDLE) {}
	Event(NullHandle): m_handle(VK_NULL_HANDLE) {}
	VK_EXPLICIT_HANDLE Event(VkEvent handle): m_handle(handle) {}
	VK_EXPLICIT_HANDLE operator VkEvent() const { return m_handle; }

	VkEvent handle() const { return m_handle; }
	VkEvent *c_ptr() { return &m_handle; }
	const VkEvent *c_ptr() const { return &m_handle; }
};

inline bool operator==(const Event &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const Event &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const Event &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const Event &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class QueryPool {
	VkQueryPool m_handle;
public:
	QueryPool(): m_handle(VK_NULL_HANDLE) {}
	QueryPool(NullHandle): m_handle(VK_NULL_HANDLE) {}
	VK_EXPLICIT_HANDLE QueryPool(VkQueryPool handle): m_handle(handle) {}
	VK_EXPLICIT_HANDLE operator VkQueryPool() const { return m_handle; }

	VkQueryPool handle() const { return m_handle; }
	VkQueryPool *c_ptr() { return &m_handle; }
	const VkQueryPool *c_ptr() const { return &m_handle; }
};

inline bool operator==(const QueryPool &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const QueryPool &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const QueryPool &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const QueryPool &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class Framebuffer {
	VkFramebuffer m_handle;
public:
	Framebuffer(): m_handle(VK_NULL_HANDLE) {}
	Framebuffer(NullHandle): m_handle(VK_NULL_HANDLE) {}
	VK_EXPLICIT_HANDLE Framebuffer(VkFramebuffer handle): m_handle(handle) {}
	VK_EXPLICIT_HANDLE operator VkFramebuffer() const { return m_handle; }

	VkFramebuffer handle() const { return m_handle; }
	VkFramebuffer *c_ptr() { return &m_handle; }
	const VkFramebuffer *c_ptr() const { return &m_handle; }
};

inline bool operator==(const Framebuffer &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const Framebuffer &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const Framebuffer &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const Framebuffer &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class RenderPass {
	VkRenderPass m_handle;
public:
	RenderPass(): m_handle(VK_NULL_HANDLE) {}
	RenderPass(NullHandle): m_handle(VK_NULL_HANDLE) {}
	VK_EXPLICIT_HANDLE RenderPass(VkRenderPass handle): m_handle(handle) {}
	VK_EXPLICIT_HANDLE operator VkRenderPass() const { return m_handle; }

	VkRenderPass handle() const { return m_handle; }
	VkRenderPass *c_ptr() { return &m_handle; }
	const VkRenderPass *c_ptr() const { return &m_handle; }
};

inline bool operator==(const RenderPass &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const RenderPass &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const RenderPass &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const RenderPass &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class PipelineCache {
	VkPipelineCache m_handle;
public:
	PipelineCache(): m_handle(VK_NULL_HANDLE) {}
	PipelineCache(NullHandle): m_handle(VK_NULL_HANDLE) {}
	VK_EXPLICIT_HANDLE PipelineCache(VkPipelineCache handle): m_handle(handle) {}
	VK_EXPLICIT_HANDLE operator VkPipelineCache() const { return m_handle; }

	VkPipelineCache handle() const { return m_handle; }
	VkPipelineCache *c_ptr() { return &m_handle; }
	const VkPipelineCache *c_ptr() const { return &m_handle; }
};

inline bool operator==(const PipelineCache &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const PipelineCache &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const PipelineCache &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const PipelineCache &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class DisplayKHR {
	VkDisplayKHR m_handle;
public:
	DisplayKHR(): m_handle(VK_NULL_HANDLE) {}
	DisplayKHR(NullHandle): m_handle(VK_NULL_HANDLE) {}
	VK_EXPLICIT_HANDLE DisplayKHR(VkDisplayKHR handle): m_handle(handle) {}
	VK_EXPLICIT_HANDLE operator VkDisplayKHR() const { return m_handle; }

	VkDisplayKHR handle() const { return m_handle; }
	VkDisplayKHR *c_ptr() { return &m_handle; }
	const VkDisplayKHR *c_ptr() const { return &m_handle; }
};

inline bool operator==(const DisplayKHR &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const DisplayKHR &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const DisplayKHR &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const DisplayKHR &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class DisplayModeKHR {
	VkDisplayModeKHR m_handle;
public:
	DisplayModeKHR(): m_handle(VK_NULL_HANDLE) {}
	DisplayModeKHR(NullHandle): m_handle(VK_NULL_HANDLE) {}
	VK_EXPLICIT_HANDLE DisplayModeKHR(VkDisplayModeKHR handle): m_handle(handle) {}
	VK_EXPLICIT_HANDLE operator VkDisplayModeKHR() const { return m_handle; }

	VkDisplayModeKHR handle() const { return m_handle; }
	VkDisplayModeKHR *c_ptr() { return &m_handle; }
	const VkDisplayModeKHR *c_ptr() const { return &m_handle; }
};

inline bool operator==(const DisplayModeKHR &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const DisplayModeKHR &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const DisplayModeKHR &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const DisplayModeKHR &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class SurfaceKHR {
	VkSurfaceKHR m_handle;
public:
	SurfaceKHR(): m_handle(VK_NULL_HANDLE) {}
	SurfaceKHR(NullHandle): m_handle(VK_NULL_HANDLE) {}
	VK_EXPLICIT_HANDLE SurfaceKHR(VkSurfaceKHR handle): m_handle(handle) {}
	VK_EXPLICIT_HANDLE operator VkSurfaceKHR() const { return m_handle; }

	VkSurfaceKHR handle() const { return m_handle; }
	VkSurfaceKHR *c_ptr() { return &m_handle; }
	const VkSurfaceKHR *c_ptr() const { return &m_handle; }
};

inline bool operator==(const SurfaceKHR &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const SurfaceKHR &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const SurfaceKHR &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const SurfaceKHR &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class SwapchainKHR {
	VkSwapchainKHR m_handle;
public:
	SwapchainKHR(): m_handle(VK_NULL_HANDLE) {}
	SwapchainKHR(NullHandle): m_handle(VK_NULL_HANDLE) {}
	VK_EXPLICIT_HANDLE SwapchainKHR(VkSwapchainKHR handle): m_handle(handle) {}
	VK_EXPLICIT_HANDLE operator VkSwapchainKHR() const { return m_handle; }

	VkSwapchainKHR handle() const { return m_handle; }
	VkSwapchainKHR *c_ptr() { return &m_handle; }
	const VkSwapchainKHR *c_ptr() const { return &m_handle; }
};

inline bool operator==(const SwapchainKHR &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const SwapchainKHR &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const SwapchainKHR &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const SwapchainKHR &rhs) { return rhs.handle() != VK_NULL_HANDLE; }

class DebugReportCallbackEXT {
	VkDebugReportCallbackEXT m_handle;
public:
	DebugReportCallbackEXT(): m_handle(VK_NULL_HANDLE) {}
	DebugReportCallbackEXT(NullHandle): m_handle(VK_NULL_HANDLE) {}
	VK_EXPLICIT_HANDLE DebugReportCallbackEXT(VkDebugReportCallbackEXT handle): m_handle(handle) {}
	VK_EXPLICIT_HANDLE operator VkDebugReportCallbackEXT() const { return m_handle; }

	VkDebugReportCallbackEXT handle() const { return m_handle; }
	VkDebugReportCallbackEXT *c_ptr() { return &m_handle; }
	const VkDebugReportCallbackEXT *c_ptr() const { return &m_handle; }
};

inline bool operator==(const DebugReportCallbackEXT &lhs, NullHandle) { return lhs.handle() == VK_NULL_HANDLE; }
inline bool operator==(NullHandle, const DebugReportCallbackEXT &rhs) { return rhs.handle() == VK_NULL_HANDLE; }
inline bool operator!=(const DebugReportCallbackEXT &lhs, NullHandle) { return lhs.handle() != VK_NULL_HANDLE; }
inline bool operator!=(NullHandle, const DebugReportCallbackEXT &rhs) { return rhs.handle() != VK_NULL_HANDLE; }


enum class AttachmentLoadOp {
	eLoad = VK_ATTACHMENT_LOAD_OP_LOAD,
	eClear = VK_ATTACHMENT_LOAD_OP_CLEAR,
	eDontCare = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
};

inline const char *getEnumString(AttachmentLoadOp e)
{
	switch (e) {
	case AttachmentLoadOp::eLoad: return "AttachmentLoadOp::eLoad";
	case AttachmentLoadOp::eClear: return "AttachmentLoadOp::eClear";
	case AttachmentLoadOp::eDontCare: return "AttachmentLoadOp::eDontCare";
	default: return "<invalid enum>";
	}
}


enum class AttachmentStoreOp {
	eStore = VK_ATTACHMENT_STORE_OP_STORE,
	eDontCare = VK_ATTACHMENT_STORE_OP_DONT_CARE,
};

inline const char *getEnumString(AttachmentStoreOp e)
{
	switch (e) {
	case AttachmentStoreOp::eStore: return "AttachmentStoreOp::eStore";
	case AttachmentStoreOp::eDontCare: return "AttachmentStoreOp::eDontCare";
	default: return "<invalid enum>";
	}
}


enum class BlendFactor {
	eZero = VK_BLEND_FACTOR_ZERO,
	eOne = VK_BLEND_FACTOR_ONE,
	eSrcColor = VK_BLEND_FACTOR_SRC_COLOR,
	eOneMinusSrcColor = VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR,
	eDstColor = VK_BLEND_FACTOR_DST_COLOR,
	eOneMinusDstColor = VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR,
	eSrcAlpha = VK_BLEND_FACTOR_SRC_ALPHA,
	eOneMinusSrcAlpha = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
	eDstAlpha = VK_BLEND_FACTOR_DST_ALPHA,
	eOneMinusDstAlpha = VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA,
	eConstantColor = VK_BLEND_FACTOR_CONSTANT_COLOR,
	eOneMinusConstantColor = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR,
	eConstantAlpha = VK_BLEND_FACTOR_CONSTANT_ALPHA,
	eOneMinusConstantAlpha = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA,
	eSrcAlphaSaturate = VK_BLEND_FACTOR_SRC_ALPHA_SATURATE,
	eSrc1Color = VK_BLEND_FACTOR_SRC1_COLOR,
	eOneMinusSrc1Color = VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR,
	eSrc1Alpha = VK_BLEND_FACTOR_SRC1_ALPHA,
	eOneMinusSrc1Alpha = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA,
};

inline const char *getEnumString(BlendFactor e)
{
	switch (e) {
	case BlendFactor::eZero: return "BlendFactor::eZero";
	case BlendFactor::eOne: return "BlendFactor::eOne";
	case BlendFactor::eSrcColor: return "BlendFactor::eSrcColor";
	case BlendFactor::eOneMinusSrcColor: return "BlendFactor::eOneMinusSrcColor";
	case BlendFactor::eDstColor: return "BlendFactor::eDstColor";
	case BlendFactor::eOneMinusDstColor: return "BlendFactor::eOneMinusDstColor";
	case BlendFactor::eSrcAlpha: return "BlendFactor::eSrcAlpha";
	case BlendFactor::eOneMinusSrcAlpha: return "BlendFactor::eOneMinusSrcAlpha";
	case BlendFactor::eDstAlpha: return "BlendFactor::eDstAlpha";
	case BlendFactor::eOneMinusDstAlpha: return "BlendFactor::eOneMinusDstAlpha";
	case BlendFactor::eConstantColor: return "BlendFactor::eConstantColor";
	case BlendFactor::eOneMinusConstantColor: return "BlendFactor::eOneMinusConstantColor";
	case BlendFactor::eConstantAlpha: return "BlendFactor::eConstantAlpha";
	case BlendFactor::eOneMinusConstantAlpha: return "BlendFactor::eOneMinusConstantAlpha";
	case BlendFactor::eSrcAlphaSaturate: return "BlendFactor::eSrcAlphaSaturate";
	case BlendFactor::eSrc1Color: return "BlendFactor::eSrc1Color";
	case BlendFactor::eOneMinusSrc1Color: return "BlendFactor::eOneMinusSrc1Color";
	case BlendFactor::eSrc1Alpha: return "BlendFactor::eSrc1Alpha";
	case BlendFactor::eOneMinusSrc1Alpha: return "BlendFactor::eOneMinusSrc1Alpha";
	default: return "<invalid enum>";
	}
}


enum class BlendOp {
	eAdd = VK_BLEND_OP_ADD,
	eSubtract = VK_BLEND_OP_SUBTRACT,
	eReverseSubtract = VK_BLEND_OP_REVERSE_SUBTRACT,
	eMin = VK_BLEND_OP_MIN,
	eMax = VK_BLEND_OP_MAX,
};

inline const char *getEnumString(BlendOp e)
{
	switch (e) {
	case BlendOp::eAdd: return "BlendOp::eAdd";
	case BlendOp::eSubtract: return "BlendOp::eSubtract";
	case BlendOp::eReverseSubtract: return "BlendOp::eReverseSubtract";
	case BlendOp::eMin: return "BlendOp::eMin";
	case BlendOp::eMax: return "BlendOp::eMax";
	default: return "<invalid enum>";
	}
}


enum class BorderColor {
	eFloatTransparentBlack = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
	eIntTransparentBlack = VK_BORDER_COLOR_INT_TRANSPARENT_BLACK,
	eFloatOpaqueBlack = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK,
	eIntOpaqueBlack = VK_BORDER_COLOR_INT_OPAQUE_BLACK,
	eFloatOpaqueWhite = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE,
	eIntOpaqueWhite = VK_BORDER_COLOR_INT_OPAQUE_WHITE,
};

inline const char *getEnumString(BorderColor e)
{
	switch (e) {
	case BorderColor::eFloatTransparentBlack: return "BorderColor::eFloatTransparentBlack";
	case BorderColor::eIntTransparentBlack: return "BorderColor::eIntTransparentBlack";
	case BorderColor::eFloatOpaqueBlack: return "BorderColor::eFloatOpaqueBlack";
	case BorderColor::eIntOpaqueBlack: return "BorderColor::eIntOpaqueBlack";
	case BorderColor::eFloatOpaqueWhite: return "BorderColor::eFloatOpaqueWhite";
	case BorderColor::eIntOpaqueWhite: return "BorderColor::eIntOpaqueWhite";
	default: return "<invalid enum>";
	}
}


enum class PipelineCacheHeaderVersion {
	eOne = VK_PIPELINE_CACHE_HEADER_VERSION_ONE,
};

inline const char *getEnumString(PipelineCacheHeaderVersion e)
{
	switch (e) {
	case PipelineCacheHeaderVersion::eOne: return "PipelineCacheHeaderVersion::eOne";
	default: return "<invalid enum>";
	}
}


enum class ComponentSwizzle {
	eIdentity = VK_COMPONENT_SWIZZLE_IDENTITY,
	eZero = VK_COMPONENT_SWIZZLE_ZERO,
	eOne = VK_COMPONENT_SWIZZLE_ONE,
	eR = VK_COMPONENT_SWIZZLE_R,
	eG = VK_COMPONENT_SWIZZLE_G,
	eB = VK_COMPONENT_SWIZZLE_B,
	eA = VK_COMPONENT_SWIZZLE_A,
};

inline const char *getEnumString(ComponentSwizzle e)
{
	switch (e) {
	case ComponentSwizzle::eIdentity: return "ComponentSwizzle::eIdentity";
	case ComponentSwizzle::eZero: return "ComponentSwizzle::eZero";
	case ComponentSwizzle::eOne: return "ComponentSwizzle::eOne";
	case ComponentSwizzle::eR: return "ComponentSwizzle::eR";
	case ComponentSwizzle::eG: return "ComponentSwizzle::eG";
	case ComponentSwizzle::eB: return "ComponentSwizzle::eB";
	case ComponentSwizzle::eA: return "ComponentSwizzle::eA";
	default: return "<invalid enum>";
	}
}


enum class CommandBufferLevel {
	ePrimary = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
	eSecondary = VK_COMMAND_BUFFER_LEVEL_SECONDARY,
};

inline const char *getEnumString(CommandBufferLevel e)
{
	switch (e) {
	case CommandBufferLevel::ePrimary: return "CommandBufferLevel::ePrimary";
	case CommandBufferLevel::eSecondary: return "CommandBufferLevel::eSecondary";
	default: return "<invalid enum>";
	}
}


enum class CompareOp {
	eNever = VK_COMPARE_OP_NEVER,
	eLess = VK_COMPARE_OP_LESS,
	eEqual = VK_COMPARE_OP_EQUAL,
	eLessOrEqual = VK_COMPARE_OP_LESS_OR_EQUAL,
	eGreater = VK_COMPARE_OP_GREATER,
	eNotEqual = VK_COMPARE_OP_NOT_EQUAL,
	eGreaterOrEqual = VK_COMPARE_OP_GREATER_OR_EQUAL,
	eAlways = VK_COMPARE_OP_ALWAYS,
};

inline const char *getEnumString(CompareOp e)
{
	switch (e) {
	case CompareOp::eNever: return "CompareOp::eNever";
	case CompareOp::eLess: return "CompareOp::eLess";
	case CompareOp::eEqual: return "CompareOp::eEqual";
	case CompareOp::eLessOrEqual: return "CompareOp::eLessOrEqual";
	case CompareOp::eGreater: return "CompareOp::eGreater";
	case CompareOp::eNotEqual: return "CompareOp::eNotEqual";
	case CompareOp::eGreaterOrEqual: return "CompareOp::eGreaterOrEqual";
	case CompareOp::eAlways: return "CompareOp::eAlways";
	default: return "<invalid enum>";
	}
}


enum class DescriptorType {
	eSampler = VK_DESCRIPTOR_TYPE_SAMPLER,
	eCombinedImageSampler = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
	eSampledImage = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
	eStorageImage = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
	eUniformTexelBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,
	eStorageTexelBuffer = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,
	eUniformBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
	eStorageBuffer = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
	eUniformBufferDynamic = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
	eStorageBufferDynamic = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC,
	eInputAttachment = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
};

inline const char *getEnumString(DescriptorType e)
{
	switch (e) {
	case DescriptorType::eSampler: return "DescriptorType::eSampler";
	case DescriptorType::eCombinedImageSampler: return "DescriptorType::eCombinedImageSampler";
	case DescriptorType::eSampledImage: return "DescriptorType::eSampledImage";
	case DescriptorType::eStorageImage: return "DescriptorType::eStorageImage";
	case DescriptorType::eUniformTexelBuffer: return "DescriptorType::eUniformTexelBuffer";
	case DescriptorType::eStorageTexelBuffer: return "DescriptorType::eStorageTexelBuffer";
	case DescriptorType::eUniformBuffer: return "DescriptorType::eUniformBuffer";
	case DescriptorType::eStorageBuffer: return "DescriptorType::eStorageBuffer";
	case DescriptorType::eUniformBufferDynamic: return "DescriptorType::eUniformBufferDynamic";
	case DescriptorType::eStorageBufferDynamic: return "DescriptorType::eStorageBufferDynamic";
	case DescriptorType::eInputAttachment: return "DescriptorType::eInputAttachment";
	default: return "<invalid enum>";
	}
}


enum class DynamicState {
	eViewport = VK_DYNAMIC_STATE_VIEWPORT,
	eScissor = VK_DYNAMIC_STATE_SCISSOR,
	eLineWidth = VK_DYNAMIC_STATE_LINE_WIDTH,
	eDepthBias = VK_DYNAMIC_STATE_DEPTH_BIAS,
	eBlendConstants = VK_DYNAMIC_STATE_BLEND_CONSTANTS,
	eDepthBounds = VK_DYNAMIC_STATE_DEPTH_BOUNDS,
	eStencilCompareMask = VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK,
	eStencilWriteMask = VK_DYNAMIC_STATE_STENCIL_WRITE_MASK,
	eStencilReference = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
};

inline const char *getEnumString(DynamicState e)
{
	switch (e) {
	case DynamicState::eViewport: return "DynamicState::eViewport";
	case DynamicState::eScissor: return "DynamicState::eScissor";
	case DynamicState::eLineWidth: return "DynamicState::eLineWidth";
	case DynamicState::eDepthBias: return "DynamicState::eDepthBias";
	case DynamicState::eBlendConstants: return "DynamicState::eBlendConstants";
	case DynamicState::eDepthBounds: return "DynamicState::eDepthBounds";
	case DynamicState::eStencilCompareMask: return "DynamicState::eStencilCompareMask";
	case DynamicState::eStencilWriteMask: return "DynamicState::eStencilWriteMask";
	case DynamicState::eStencilReference: return "DynamicState::eStencilReference";
	default: return "<invalid enum>";
	}
}


enum class PolygonMode {
	eFill = VK_POLYGON_MODE_FILL,
	eLine = VK_POLYGON_MODE_LINE,
	ePoint = VK_POLYGON_MODE_POINT,
};

inline const char *getEnumString(PolygonMode e)
{
	switch (e) {
	case PolygonMode::eFill: return "PolygonMode::eFill";
	case PolygonMode::eLine: return "PolygonMode::eLine";
	case PolygonMode::ePoint: return "PolygonMode::ePoint";
	default: return "<invalid enum>";
	}
}


enum class Format {
	eUndefined = VK_FORMAT_UNDEFINED,
	eR4G4UnormPack8 = VK_FORMAT_R4G4_UNORM_PACK8,
	eR4G4B4A4UnormPack16 = VK_FORMAT_R4G4B4A4_UNORM_PACK16,
	eB4G4R4A4UnormPack16 = VK_FORMAT_B4G4R4A4_UNORM_PACK16,
	eR5G6B5UnormPack16 = VK_FORMAT_R5G6B5_UNORM_PACK16,
	eB5G6R5UnormPack16 = VK_FORMAT_B5G6R5_UNORM_PACK16,
	eR5G5B5A1UnormPack16 = VK_FORMAT_R5G5B5A1_UNORM_PACK16,
	eB5G5R5A1UnormPack16 = VK_FORMAT_B5G5R5A1_UNORM_PACK16,
	eA1R5G5B5UnormPack16 = VK_FORMAT_A1R5G5B5_UNORM_PACK16,
	eR8Unorm = VK_FORMAT_R8_UNORM,
	eR8Snorm = VK_FORMAT_R8_SNORM,
	eR8Uscaled = VK_FORMAT_R8_USCALED,
	eR8Sscaled = VK_FORMAT_R8_SSCALED,
	eR8Uint = VK_FORMAT_R8_UINT,
	eR8Sint = VK_FORMAT_R8_SINT,
	eR8Srgb = VK_FORMAT_R8_SRGB,
	eR8G8Unorm = VK_FORMAT_R8G8_UNORM,
	eR8G8Snorm = VK_FORMAT_R8G8_SNORM,
	eR8G8Uscaled = VK_FORMAT_R8G8_USCALED,
	eR8G8Sscaled = VK_FORMAT_R8G8_SSCALED,
	eR8G8Uint = VK_FORMAT_R8G8_UINT,
	eR8G8Sint = VK_FORMAT_R8G8_SINT,
	eR8G8Srgb = VK_FORMAT_R8G8_SRGB,
	eR8G8B8Unorm = VK_FORMAT_R8G8B8_UNORM,
	eR8G8B8Snorm = VK_FORMAT_R8G8B8_SNORM,
	eR8G8B8Uscaled = VK_FORMAT_R8G8B8_USCALED,
	eR8G8B8Sscaled = VK_FORMAT_R8G8B8_SSCALED,
	eR8G8B8Uint = VK_FORMAT_R8G8B8_UINT,
	eR8G8B8Sint = VK_FORMAT_R8G8B8_SINT,
	eR8G8B8Srgb = VK_FORMAT_R8G8B8_SRGB,
	eB8G8R8Unorm = VK_FORMAT_B8G8R8_UNORM,
	eB8G8R8Snorm = VK_FORMAT_B8G8R8_SNORM,
	eB8G8R8Uscaled = VK_FORMAT_B8G8R8_USCALED,
	eB8G8R8Sscaled = VK_FORMAT_B8G8R8_SSCALED,
	eB8G8R8Uint = VK_FORMAT_B8G8R8_UINT,
	eB8G8R8Sint = VK_FORMAT_B8G8R8_SINT,
	eB8G8R8Srgb = VK_FORMAT_B8G8R8_SRGB,
	eR8G8B8A8Unorm = VK_FORMAT_R8G8B8A8_UNORM,
	eR8G8B8A8Snorm = VK_FORMAT_R8G8B8A8_SNORM,
	eR8G8B8A8Uscaled = VK_FORMAT_R8G8B8A8_USCALED,
	eR8G8B8A8Sscaled = VK_FORMAT_R8G8B8A8_SSCALED,
	eR8G8B8A8Uint = VK_FORMAT_R8G8B8A8_UINT,
	eR8G8B8A8Sint = VK_FORMAT_R8G8B8A8_SINT,
	eR8G8B8A8Srgb = VK_FORMAT_R8G8B8A8_SRGB,
	eB8G8R8A8Unorm = VK_FORMAT_B8G8R8A8_UNORM,
	eB8G8R8A8Snorm = VK_FORMAT_B8G8R8A8_SNORM,
	eB8G8R8A8Uscaled = VK_FORMAT_B8G8R8A8_USCALED,
	eB8G8R8A8Sscaled = VK_FORMAT_B8G8R8A8_SSCALED,
	eB8G8R8A8Uint = VK_FORMAT_B8G8R8A8_UINT,
	eB8G8R8A8Sint = VK_FORMAT_B8G8R8A8_SINT,
	eB8G8R8A8Srgb = VK_FORMAT_B8G8R8A8_SRGB,
	eA8B8G8R8UnormPack32 = VK_FORMAT_A8B8G8R8_UNORM_PACK32,
	eA8B8G8R8SnormPack32 = VK_FORMAT_A8B8G8R8_SNORM_PACK32,
	eA8B8G8R8UscaledPack32 = VK_FORMAT_A8B8G8R8_USCALED_PACK32,
	eA8B8G8R8SscaledPack32 = VK_FORMAT_A8B8G8R8_SSCALED_PACK32,
	eA8B8G8R8UintPack32 = VK_FORMAT_A8B8G8R8_UINT_PACK32,
	eA8B8G8R8SintPack32 = VK_FORMAT_A8B8G8R8_SINT_PACK32,
	eA8B8G8R8SrgbPack32 = VK_FORMAT_A8B8G8R8_SRGB_PACK32,
	eA2R10G10B10UnormPack32 = VK_FORMAT_A2R10G10B10_UNORM_PACK32,
	eA2R10G10B10SnormPack32 = VK_FORMAT_A2R10G10B10_SNORM_PACK32,
	eA2R10G10B10UscaledPack32 = VK_FORMAT_A2R10G10B10_USCALED_PACK32,
	eA2R10G10B10SscaledPack32 = VK_FORMAT_A2R10G10B10_SSCALED_PACK32,
	eA2R10G10B10UintPack32 = VK_FORMAT_A2R10G10B10_UINT_PACK32,
	eA2R10G10B10SintPack32 = VK_FORMAT_A2R10G10B10_SINT_PACK32,
	eA2B10G10R10UnormPack32 = VK_FORMAT_A2B10G10R10_UNORM_PACK32,
	eA2B10G10R10SnormPack32 = VK_FORMAT_A2B10G10R10_SNORM_PACK32,
	eA2B10G10R10UscaledPack32 = VK_FORMAT_A2B10G10R10_USCALED_PACK32,
	eA2B10G10R10SscaledPack32 = VK_FORMAT_A2B10G10R10_SSCALED_PACK32,
	eA2B10G10R10UintPack32 = VK_FORMAT_A2B10G10R10_UINT_PACK32,
	eA2B10G10R10SintPack32 = VK_FORMAT_A2B10G10R10_SINT_PACK32,
	eR16Unorm = VK_FORMAT_R16_UNORM,
	eR16Snorm = VK_FORMAT_R16_SNORM,
	eR16Uscaled = VK_FORMAT_R16_USCALED,
	eR16Sscaled = VK_FORMAT_R16_SSCALED,
	eR16Uint = VK_FORMAT_R16_UINT,
	eR16Sint = VK_FORMAT_R16_SINT,
	eR16Sfloat = VK_FORMAT_R16_SFLOAT,
	eR16G16Unorm = VK_FORMAT_R16G16_UNORM,
	eR16G16Snorm = VK_FORMAT_R16G16_SNORM,
	eR16G16Uscaled = VK_FORMAT_R16G16_USCALED,
	eR16G16Sscaled = VK_FORMAT_R16G16_SSCALED,
	eR16G16Uint = VK_FORMAT_R16G16_UINT,
	eR16G16Sint = VK_FORMAT_R16G16_SINT,
	eR16G16Sfloat = VK_FORMAT_R16G16_SFLOAT,
	eR16G16B16Unorm = VK_FORMAT_R16G16B16_UNORM,
	eR16G16B16Snorm = VK_FORMAT_R16G16B16_SNORM,
	eR16G16B16Uscaled = VK_FORMAT_R16G16B16_USCALED,
	eR16G16B16Sscaled = VK_FORMAT_R16G16B16_SSCALED,
	eR16G16B16Uint = VK_FORMAT_R16G16B16_UINT,
	eR16G16B16Sint = VK_FORMAT_R16G16B16_SINT,
	eR16G16B16Sfloat = VK_FORMAT_R16G16B16_SFLOAT,
	eR16G16B16A16Unorm = VK_FORMAT_R16G16B16A16_UNORM,
	eR16G16B16A16Snorm = VK_FORMAT_R16G16B16A16_SNORM,
	eR16G16B16A16Uscaled = VK_FORMAT_R16G16B16A16_USCALED,
	eR16G16B16A16Sscaled = VK_FORMAT_R16G16B16A16_SSCALED,
	eR16G16B16A16Uint = VK_FORMAT_R16G16B16A16_UINT,
	eR16G16B16A16Sint = VK_FORMAT_R16G16B16A16_SINT,
	eR16G16B16A16Sfloat = VK_FORMAT_R16G16B16A16_SFLOAT,
	eR32Uint = VK_FORMAT_R32_UINT,
	eR32Sint = VK_FORMAT_R32_SINT,
	eR32Sfloat = VK_FORMAT_R32_SFLOAT,
	eR32G32Uint = VK_FORMAT_R32G32_UINT,
	eR32G32Sint = VK_FORMAT_R32G32_SINT,
	eR32G32Sfloat = VK_FORMAT_R32G32_SFLOAT,
	eR32G32B32Uint = VK_FORMAT_R32G32B32_UINT,
	eR32G32B32Sint = VK_FORMAT_R32G32B32_SINT,
	eR32G32B32Sfloat = VK_FORMAT_R32G32B32_SFLOAT,
	eR32G32B32A32Uint = VK_FORMAT_R32G32B32A32_UINT,
	eR32G32B32A32Sint = VK_FORMAT_R32G32B32A32_SINT,
	eR32G32B32A32Sfloat = VK_FORMAT_R32G32B32A32_SFLOAT,
	eR64Uint = VK_FORMAT_R64_UINT,
	eR64Sint = VK_FORMAT_R64_SINT,
	eR64Sfloat = VK_FORMAT_R64_SFLOAT,
	eR64G64Uint = VK_FORMAT_R64G64_UINT,
	eR64G64Sint = VK_FORMAT_R64G64_SINT,
	eR64G64Sfloat = VK_FORMAT_R64G64_SFLOAT,
	eR64G64B64Uint = VK_FORMAT_R64G64B64_UINT,
	eR64G64B64Sint = VK_FORMAT_R64G64B64_SINT,
	eR64G64B64Sfloat = VK_FORMAT_R64G64B64_SFLOAT,
	eR64G64B64A64Uint = VK_FORMAT_R64G64B64A64_UINT,
	eR64G64B64A64Sint = VK_FORMAT_R64G64B64A64_SINT,
	eR64G64B64A64Sfloat = VK_FORMAT_R64G64B64A64_SFLOAT,
	eB10G11R11UfloatPack32 = VK_FORMAT_B10G11R11_UFLOAT_PACK32,
	eE5B9G9R9UfloatPack32 = VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
	eD16Unorm = VK_FORMAT_D16_UNORM,
	eX8D24UnormPack32 = VK_FORMAT_X8_D24_UNORM_PACK32,
	eD32Sfloat = VK_FORMAT_D32_SFLOAT,
	eS8Uint = VK_FORMAT_S8_UINT,
	eD16UnormS8Uint = VK_FORMAT_D16_UNORM_S8_UINT,
	eD24UnormS8Uint = VK_FORMAT_D24_UNORM_S8_UINT,
	eD32SfloatS8Uint = VK_FORMAT_D32_SFLOAT_S8_UINT,
	eBc1RgbUnormBlock = VK_FORMAT_BC1_RGB_UNORM_BLOCK,
	eBc1RgbSrgbBlock = VK_FORMAT_BC1_RGB_SRGB_BLOCK,
	eBc1RgbaUnormBlock = VK_FORMAT_BC1_RGBA_UNORM_BLOCK,
	eBc1RgbaSrgbBlock = VK_FORMAT_BC1_RGBA_SRGB_BLOCK,
	eBc2UnormBlock = VK_FORMAT_BC2_UNORM_BLOCK,
	eBc2SrgbBlock = VK_FORMAT_BC2_SRGB_BLOCK,
	eBc3UnormBlock = VK_FORMAT_BC3_UNORM_BLOCK,
	eBc3SrgbBlock = VK_FORMAT_BC3_SRGB_BLOCK,
	eBc4UnormBlock = VK_FORMAT_BC4_UNORM_BLOCK,
	eBc4SnormBlock = VK_FORMAT_BC4_SNORM_BLOCK,
	eBc5UnormBlock = VK_FORMAT_BC5_UNORM_BLOCK,
	eBc5SnormBlock = VK_FORMAT_BC5_SNORM_BLOCK,
	eBc6HUfloatBlock = VK_FORMAT_BC6H_UFLOAT_BLOCK,
	eBc6HSfloatBlock = VK_FORMAT_BC6H_SFLOAT_BLOCK,
	eBc7UnormBlock = VK_FORMAT_BC7_UNORM_BLOCK,
	eBc7SrgbBlock = VK_FORMAT_BC7_SRGB_BLOCK,
	eEtc2R8G8B8UnormBlock = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
	eEtc2R8G8B8SrgbBlock = VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
	eEtc2R8G8B8A1UnormBlock = VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
	eEtc2R8G8B8A1SrgbBlock = VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
	eEtc2R8G8B8A8UnormBlock = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
	eEtc2R8G8B8A8SrgbBlock = VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,
	eEacR11UnormBlock = VK_FORMAT_EAC_R11_UNORM_BLOCK,
	eEacR11SnormBlock = VK_FORMAT_EAC_R11_SNORM_BLOCK,
	eEacR11G11UnormBlock = VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
	eEacR11G11SnormBlock = VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
	eAstc4x4UnormBlock = VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
	eAstc4x4SrgbBlock = VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
	eAstc5x4UnormBlock = VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
	eAstc5x4SrgbBlock = VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
	eAstc5x5UnormBlock = VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
	eAstc5x5SrgbBlock = VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
	eAstc6x5UnormBlock = VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
	eAstc6x5SrgbBlock = VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
	eAstc6x6UnormBlock = VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
	eAstc6x6SrgbBlock = VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
	eAstc8x5UnormBlock = VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
	eAstc8x5SrgbBlock = VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
	eAstc8x6UnormBlock = VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
	eAstc8x6SrgbBlock = VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
	eAstc8x8UnormBlock = VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
	eAstc8x8SrgbBlock = VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
	eAstc10x5UnormBlock = VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
	eAstc10x5SrgbBlock = VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
	eAstc10x6UnormBlock = VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
	eAstc10x6SrgbBlock = VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
	eAstc10x8UnormBlock = VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
	eAstc10x8SrgbBlock = VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
	eAstc10x10UnormBlock = VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
	eAstc10x10SrgbBlock = VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
	eAstc12x10UnormBlock = VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
	eAstc12x10SrgbBlock = VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
	eAstc12x12UnormBlock = VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
	eAstc12x12SrgbBlock = VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
};

inline const char *getEnumString(Format e)
{
	switch (e) {
	case Format::eUndefined: return "Format::eUndefined";
	case Format::eR4G4UnormPack8: return "Format::eR4G4UnormPack8";
	case Format::eR4G4B4A4UnormPack16: return "Format::eR4G4B4A4UnormPack16";
	case Format::eB4G4R4A4UnormPack16: return "Format::eB4G4R4A4UnormPack16";
	case Format::eR5G6B5UnormPack16: return "Format::eR5G6B5UnormPack16";
	case Format::eB5G6R5UnormPack16: return "Format::eB5G6R5UnormPack16";
	case Format::eR5G5B5A1UnormPack16: return "Format::eR5G5B5A1UnormPack16";
	case Format::eB5G5R5A1UnormPack16: return "Format::eB5G5R5A1UnormPack16";
	case Format::eA1R5G5B5UnormPack16: return "Format::eA1R5G5B5UnormPack16";
	case Format::eR8Unorm: return "Format::eR8Unorm";
	case Format::eR8Snorm: return "Format::eR8Snorm";
	case Format::eR8Uscaled: return "Format::eR8Uscaled";
	case Format::eR8Sscaled: return "Format::eR8Sscaled";
	case Format::eR8Uint: return "Format::eR8Uint";
	case Format::eR8Sint: return "Format::eR8Sint";
	case Format::eR8Srgb: return "Format::eR8Srgb";
	case Format::eR8G8Unorm: return "Format::eR8G8Unorm";
	case Format::eR8G8Snorm: return "Format::eR8G8Snorm";
	case Format::eR8G8Uscaled: return "Format::eR8G8Uscaled";
	case Format::eR8G8Sscaled: return "Format::eR8G8Sscaled";
	case Format::eR8G8Uint: return "Format::eR8G8Uint";
	case Format::eR8G8Sint: return "Format::eR8G8Sint";
	case Format::eR8G8Srgb: return "Format::eR8G8Srgb";
	case Format::eR8G8B8Unorm: return "Format::eR8G8B8Unorm";
	case Format::eR8G8B8Snorm: return "Format::eR8G8B8Snorm";
	case Format::eR8G8B8Uscaled: return "Format::eR8G8B8Uscaled";
	case Format::eR8G8B8Sscaled: return "Format::eR8G8B8Sscaled";
	case Format::eR8G8B8Uint: return "Format::eR8G8B8Uint";
	case Format::eR8G8B8Sint: return "Format::eR8G8B8Sint";
	case Format::eR8G8B8Srgb: return "Format::eR8G8B8Srgb";
	case Format::eB8G8R8Unorm: return "Format::eB8G8R8Unorm";
	case Format::eB8G8R8Snorm: return "Format::eB8G8R8Snorm";
	case Format::eB8G8R8Uscaled: return "Format::eB8G8R8Uscaled";
	case Format::eB8G8R8Sscaled: return "Format::eB8G8R8Sscaled";
	case Format::eB8G8R8Uint: return "Format::eB8G8R8Uint";
	case Format::eB8G8R8Sint: return "Format::eB8G8R8Sint";
	case Format::eB8G8R8Srgb: return "Format::eB8G8R8Srgb";
	case Format::eR8G8B8A8Unorm: return "Format::eR8G8B8A8Unorm";
	case Format::eR8G8B8A8Snorm: return "Format::eR8G8B8A8Snorm";
	case Format::eR8G8B8A8Uscaled: return "Format::eR8G8B8A8Uscaled";
	case Format::eR8G8B8A8Sscaled: return "Format::eR8G8B8A8Sscaled";
	case Format::eR8G8B8A8Uint: return "Format::eR8G8B8A8Uint";
	case Format::eR8G8B8A8Sint: return "Format::eR8G8B8A8Sint";
	case Format::eR8G8B8A8Srgb: return "Format::eR8G8B8A8Srgb";
	case Format::eB8G8R8A8Unorm: return "Format::eB8G8R8A8Unorm";
	case Format::eB8G8R8A8Snorm: return "Format::eB8G8R8A8Snorm";
	case Format::eB8G8R8A8Uscaled: return "Format::eB8G8R8A8Uscaled";
	case Format::eB8G8R8A8Sscaled: return "Format::eB8G8R8A8Sscaled";
	case Format::eB8G8R8A8Uint: return "Format::eB8G8R8A8Uint";
	case Format::eB8G8R8A8Sint: return "Format::eB8G8R8A8Sint";
	case Format::eB8G8R8A8Srgb: return "Format::eB8G8R8A8Srgb";
	case Format::eA8B8G8R8UnormPack32: return "Format::eA8B8G8R8UnormPack32";
	case Format::eA8B8G8R8SnormPack32: return "Format::eA8B8G8R8SnormPack32";
	case Format::eA8B8G8R8UscaledPack32: return "Format::eA8B8G8R8UscaledPack32";
	case Format::eA8B8G8R8SscaledPack32: return "Format::eA8B8G8R8SscaledPack32";
	case Format::eA8B8G8R8UintPack32: return "Format::eA8B8G8R8UintPack32";
	case Format::eA8B8G8R8SintPack32: return "Format::eA8B8G8R8SintPack32";
	case Format::eA8B8G8R8SrgbPack32: return "Format::eA8B8G8R8SrgbPack32";
	case Format::eA2R10G10B10UnormPack32: return "Format::eA2R10G10B10UnormPack32";
	case Format::eA2R10G10B10SnormPack32: return "Format::eA2R10G10B10SnormPack32";
	case Format::eA2R10G10B10UscaledPack32: return "Format::eA2R10G10B10UscaledPack32";
	case Format::eA2R10G10B10SscaledPack32: return "Format::eA2R10G10B10SscaledPack32";
	case Format::eA2R10G10B10UintPack32: return "Format::eA2R10G10B10UintPack32";
	case Format::eA2R10G10B10SintPack32: return "Format::eA2R10G10B10SintPack32";
	case Format::eA2B10G10R10UnormPack32: return "Format::eA2B10G10R10UnormPack32";
	case Format::eA2B10G10R10SnormPack32: return "Format::eA2B10G10R10SnormPack32";
	case Format::eA2B10G10R10UscaledPack32: return "Format::eA2B10G10R10UscaledPack32";
	case Format::eA2B10G10R10SscaledPack32: return "Format::eA2B10G10R10SscaledPack32";
	case Format::eA2B10G10R10UintPack32: return "Format::eA2B10G10R10UintPack32";
	case Format::eA2B10G10R10SintPack32: return "Format::eA2B10G10R10SintPack32";
	case Format::eR16Unorm: return "Format::eR16Unorm";
	case Format::eR16Snorm: return "Format::eR16Snorm";
	case Format::eR16Uscaled: return "Format::eR16Uscaled";
	case Format::eR16Sscaled: return "Format::eR16Sscaled";
	case Format::eR16Uint: return "Format::eR16Uint";
	case Format::eR16Sint: return "Format::eR16Sint";
	case Format::eR16Sfloat: return "Format::eR16Sfloat";
	case Format::eR16G16Unorm: return "Format::eR16G16Unorm";
	case Format::eR16G16Snorm: return "Format::eR16G16Snorm";
	case Format::eR16G16Uscaled: return "Format::eR16G16Uscaled";
	case Format::eR16G16Sscaled: return "Format::eR16G16Sscaled";
	case Format::eR16G16Uint: return "Format::eR16G16Uint";
	case Format::eR16G16Sint: return "Format::eR16G16Sint";
	case Format::eR16G16Sfloat: return "Format::eR16G16Sfloat";
	case Format::eR16G16B16Unorm: return "Format::eR16G16B16Unorm";
	case Format::eR16G16B16Snorm: return "Format::eR16G16B16Snorm";
	case Format::eR16G16B16Uscaled: return "Format::eR16G16B16Uscaled";
	case Format::eR16G16B16Sscaled: return "Format::eR16G16B16Sscaled";
	case Format::eR16G16B16Uint: return "Format::eR16G16B16Uint";
	case Format::eR16G16B16Sint: return "Format::eR16G16B16Sint";
	case Format::eR16G16B16Sfloat: return "Format::eR16G16B16Sfloat";
	case Format::eR16G16B16A16Unorm: return "Format::eR16G16B16A16Unorm";
	case Format::eR16G16B16A16Snorm: return "Format::eR16G16B16A16Snorm";
	case Format::eR16G16B16A16Uscaled: return "Format::eR16G16B16A16Uscaled";
	case Format::eR16G16B16A16Sscaled: return "Format::eR16G16B16A16Sscaled";
	case Format::eR16G16B16A16Uint: return "Format::eR16G16B16A16Uint";
	case Format::eR16G16B16A16Sint: return "Format::eR16G16B16A16Sint";
	case Format::eR16G16B16A16Sfloat: return "Format::eR16G16B16A16Sfloat";
	case Format::eR32Uint: return "Format::eR32Uint";
	case Format::eR32Sint: return "Format::eR32Sint";
	case Format::eR32Sfloat: return "Format::eR32Sfloat";
	case Format::eR32G32Uint: return "Format::eR32G32Uint";
	case Format::eR32G32Sint: return "Format::eR32G32Sint";
	case Format::eR32G32Sfloat: return "Format::eR32G32Sfloat";
	case Format::eR32G32B32Uint: return "Format::eR32G32B32Uint";
	case Format::eR32G32B32Sint: return "Format::eR32G32B32Sint";
	case Format::eR32G32B32Sfloat: return "Format::eR32G32B32Sfloat";
	case Format::eR32G32B32A32Uint: return "Format::eR32G32B32A32Uint";
	case Format::eR32G32B32A32Sint: return "Format::eR32G32B32A32Sint";
	case Format::eR32G32B32A32Sfloat: return "Format::eR32G32B32A32Sfloat";
	case Format::eR64Uint: return "Format::eR64Uint";
	case Format::eR64Sint: return "Format::eR64Sint";
	case Format::eR64Sfloat: return "Format::eR64Sfloat";
	case Format::eR64G64Uint: return "Format::eR64G64Uint";
	case Format::eR64G64Sint: return "Format::eR64G64Sint";
	case Format::eR64G64Sfloat: return "Format::eR64G64Sfloat";
	case Format::eR64G64B64Uint: return "Format::eR64G64B64Uint";
	case Format::eR64G64B64Sint: return "Format::eR64G64B64Sint";
	case Format::eR64G64B64Sfloat: return "Format::eR64G64B64Sfloat";
	case Format::eR64G64B64A64Uint: return "Format::eR64G64B64A64Uint";
	case Format::eR64G64B64A64Sint: return "Format::eR64G64B64A64Sint";
	case Format::eR64G64B64A64Sfloat: return "Format::eR64G64B64A64Sfloat";
	case Format::eB10G11R11UfloatPack32: return "Format::eB10G11R11UfloatPack32";
	case Format::eE5B9G9R9UfloatPack32: return "Format::eE5B9G9R9UfloatPack32";
	case Format::eD16Unorm: return "Format::eD16Unorm";
	case Format::eX8D24UnormPack32: return "Format::eX8D24UnormPack32";
	case Format::eD32Sfloat: return "Format::eD32Sfloat";
	case Format::eS8Uint: return "Format::eS8Uint";
	case Format::eD16UnormS8Uint: return "Format::eD16UnormS8Uint";
	case Format::eD24UnormS8Uint: return "Format::eD24UnormS8Uint";
	case Format::eD32SfloatS8Uint: return "Format::eD32SfloatS8Uint";
	case Format::eBc1RgbUnormBlock: return "Format::eBc1RgbUnormBlock";
	case Format::eBc1RgbSrgbBlock: return "Format::eBc1RgbSrgbBlock";
	case Format::eBc1RgbaUnormBlock: return "Format::eBc1RgbaUnormBlock";
	case Format::eBc1RgbaSrgbBlock: return "Format::eBc1RgbaSrgbBlock";
	case Format::eBc2UnormBlock: return "Format::eBc2UnormBlock";
	case Format::eBc2SrgbBlock: return "Format::eBc2SrgbBlock";
	case Format::eBc3UnormBlock: return "Format::eBc3UnormBlock";
	case Format::eBc3SrgbBlock: return "Format::eBc3SrgbBlock";
	case Format::eBc4UnormBlock: return "Format::eBc4UnormBlock";
	case Format::eBc4SnormBlock: return "Format::eBc4SnormBlock";
	case Format::eBc5UnormBlock: return "Format::eBc5UnormBlock";
	case Format::eBc5SnormBlock: return "Format::eBc5SnormBlock";
	case Format::eBc6HUfloatBlock: return "Format::eBc6HUfloatBlock";
	case Format::eBc6HSfloatBlock: return "Format::eBc6HSfloatBlock";
	case Format::eBc7UnormBlock: return "Format::eBc7UnormBlock";
	case Format::eBc7SrgbBlock: return "Format::eBc7SrgbBlock";
	case Format::eEtc2R8G8B8UnormBlock: return "Format::eEtc2R8G8B8UnormBlock";
	case Format::eEtc2R8G8B8SrgbBlock: return "Format::eEtc2R8G8B8SrgbBlock";
	case Format::eEtc2R8G8B8A1UnormBlock: return "Format::eEtc2R8G8B8A1UnormBlock";
	case Format::eEtc2R8G8B8A1SrgbBlock: return "Format::eEtc2R8G8B8A1SrgbBlock";
	case Format::eEtc2R8G8B8A8UnormBlock: return "Format::eEtc2R8G8B8A8UnormBlock";
	case Format::eEtc2R8G8B8A8SrgbBlock: return "Format::eEtc2R8G8B8A8SrgbBlock";
	case Format::eEacR11UnormBlock: return "Format::eEacR11UnormBlock";
	case Format::eEacR11SnormBlock: return "Format::eEacR11SnormBlock";
	case Format::eEacR11G11UnormBlock: return "Format::eEacR11G11UnormBlock";
	case Format::eEacR11G11SnormBlock: return "Format::eEacR11G11SnormBlock";
	case Format::eAstc4x4UnormBlock: return "Format::eAstc4x4UnormBlock";
	case Format::eAstc4x4SrgbBlock: return "Format::eAstc4x4SrgbBlock";
	case Format::eAstc5x4UnormBlock: return "Format::eAstc5x4UnormBlock";
	case Format::eAstc5x4SrgbBlock: return "Format::eAstc5x4SrgbBlock";
	case Format::eAstc5x5UnormBlock: return "Format::eAstc5x5UnormBlock";
	case Format::eAstc5x5SrgbBlock: return "Format::eAstc5x5SrgbBlock";
	case Format::eAstc6x5UnormBlock: return "Format::eAstc6x5UnormBlock";
	case Format::eAstc6x5SrgbBlock: return "Format::eAstc6x5SrgbBlock";
	case Format::eAstc6x6UnormBlock: return "Format::eAstc6x6UnormBlock";
	case Format::eAstc6x6SrgbBlock: return "Format::eAstc6x6SrgbBlock";
	case Format::eAstc8x5UnormBlock: return "Format::eAstc8x5UnormBlock";
	case Format::eAstc8x5SrgbBlock: return "Format::eAstc8x5SrgbBlock";
	case Format::eAstc8x6UnormBlock: return "Format::eAstc8x6UnormBlock";
	case Format::eAstc8x6SrgbBlock: return "Format::eAstc8x6SrgbBlock";
	case Format::eAstc8x8UnormBlock: return "Format::eAstc8x8UnormBlock";
	case Format::eAstc8x8SrgbBlock: return "Format::eAstc8x8SrgbBlock";
	case Format::eAstc10x5UnormBlock: return "Format::eAstc10x5UnormBlock";
	case Format::eAstc10x5SrgbBlock: return "Format::eAstc10x5SrgbBlock";
	case Format::eAstc10x6UnormBlock: return "Format::eAstc10x6UnormBlock";
	case Format::eAstc10x6SrgbBlock: return "Format::eAstc10x6SrgbBlock";
	case Format::eAstc10x8UnormBlock: return "Format::eAstc10x8UnormBlock";
	case Format::eAstc10x8SrgbBlock: return "Format::eAstc10x8SrgbBlock";
	case Format::eAstc10x10UnormBlock: return "Format::eAstc10x10UnormBlock";
	case Format::eAstc10x10SrgbBlock: return "Format::eAstc10x10SrgbBlock";
	case Format::eAstc12x10UnormBlock: return "Format::eAstc12x10UnormBlock";
	case Format::eAstc12x10SrgbBlock: return "Format::eAstc12x10SrgbBlock";
	case Format::eAstc12x12UnormBlock: return "Format::eAstc12x12UnormBlock";
	case Format::eAstc12x12SrgbBlock: return "Format::eAstc12x12SrgbBlock";
	default: return "<invalid enum>";
	}
}


enum class FrontFace {
	eCounterClockwise = VK_FRONT_FACE_COUNTER_CLOCKWISE,
	eClockwise = VK_FRONT_FACE_CLOCKWISE,
};

inline const char *getEnumString(FrontFace e)
{
	switch (e) {
	case FrontFace::eCounterClockwise: return "FrontFace::eCounterClockwise";
	case FrontFace::eClockwise: return "FrontFace::eClockwise";
	default: return "<invalid enum>";
	}
}


enum class ImageLayout {
	eUndefined = VK_IMAGE_LAYOUT_UNDEFINED,
	eGeneral = VK_IMAGE_LAYOUT_GENERAL,
	eColorAttachmentOptimal = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
	eDepthStencilAttachmentOptimal = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
	eDepthStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,
	eShaderReadOnlyOptimal = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
	eTransferSrcOptimal = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
	eTransferDstOptimal = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
	ePreinitialized = VK_IMAGE_LAYOUT_PREINITIALIZED,
};

inline const char *getEnumString(ImageLayout e)
{
	switch (e) {
	case ImageLayout::eUndefined: return "ImageLayout::eUndefined";
	case ImageLayout::eGeneral: return "ImageLayout::eGeneral";
	case ImageLayout::eColorAttachmentOptimal: return "ImageLayout::eColorAttachmentOptimal";
	case ImageLayout::eDepthStencilAttachmentOptimal: return "ImageLayout::eDepthStencilAttachmentOptimal";
	case ImageLayout::eDepthStencilReadOnlyOptimal: return "ImageLayout::eDepthStencilReadOnlyOptimal";
	case ImageLayout::eShaderReadOnlyOptimal: return "ImageLayout::eShaderReadOnlyOptimal";
	case ImageLayout::eTransferSrcOptimal: return "ImageLayout::eTransferSrcOptimal";
	case ImageLayout::eTransferDstOptimal: return "ImageLayout::eTransferDstOptimal";
	case ImageLayout::ePreinitialized: return "ImageLayout::ePreinitialized";
	default: return "<invalid enum>";
	}
}


enum class ImageTiling {
	eOptimal = VK_IMAGE_TILING_OPTIMAL,
	eLinear = VK_IMAGE_TILING_LINEAR,
};

inline const char *getEnumString(ImageTiling e)
{
	switch (e) {
	case ImageTiling::eOptimal: return "ImageTiling::eOptimal";
	case ImageTiling::eLinear: return "ImageTiling::eLinear";
	default: return "<invalid enum>";
	}
}


enum class ImageType {
	e1D = VK_IMAGE_TYPE_1D,
	e2D = VK_IMAGE_TYPE_2D,
	e3D = VK_IMAGE_TYPE_3D,
};

inline const char *getEnumString(ImageType e)
{
	switch (e) {
	case ImageType::e1D: return "ImageType::e1D";
	case ImageType::e2D: return "ImageType::e2D";
	case ImageType::e3D: return "ImageType::e3D";
	default: return "<invalid enum>";
	}
}


enum class ImageViewType {
	e1D = VK_IMAGE_VIEW_TYPE_1D,
	e2D = VK_IMAGE_VIEW_TYPE_2D,
	e3D = VK_IMAGE_VIEW_TYPE_3D,
	eCube = VK_IMAGE_VIEW_TYPE_CUBE,
	e1DArray = VK_IMAGE_VIEW_TYPE_1D_ARRAY,
	e2DArray = VK_IMAGE_VIEW_TYPE_2D_ARRAY,
	eCubeArray = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY,
};

inline const char *getEnumString(ImageViewType e)
{
	switch (e) {
	case ImageViewType::e1D: return "ImageViewType::e1D";
	case ImageViewType::e2D: return "ImageViewType::e2D";
	case ImageViewType::e3D: return "ImageViewType::e3D";
	case ImageViewType::eCube: return "ImageViewType::eCube";
	case ImageViewType::e1DArray: return "ImageViewType::e1DArray";
	case ImageViewType::e2DArray: return "ImageViewType::e2DArray";
	case ImageViewType::eCubeArray: return "ImageViewType::eCubeArray";
	default: return "<invalid enum>";
	}
}


enum class SharingMode {
	eExclusive = VK_SHARING_MODE_EXCLUSIVE,
	eConcurrent = VK_SHARING_MODE_CONCURRENT,
};

inline const char *getEnumString(SharingMode e)
{
	switch (e) {
	case SharingMode::eExclusive: return "SharingMode::eExclusive";
	case SharingMode::eConcurrent: return "SharingMode::eConcurrent";
	default: return "<invalid enum>";
	}
}


enum class IndexType {
	eUint16 = VK_INDEX_TYPE_UINT16,
	eUint32 = VK_INDEX_TYPE_UINT32,
};

inline const char *getEnumString(IndexType e)
{
	switch (e) {
	case IndexType::eUint16: return "IndexType::eUint16";
	case IndexType::eUint32: return "IndexType::eUint32";
	default: return "<invalid enum>";
	}
}


enum class LogicOp {
	eClear = VK_LOGIC_OP_CLEAR,
	eAnd = VK_LOGIC_OP_AND,
	eAndReverse = VK_LOGIC_OP_AND_REVERSE,
	eCopy = VK_LOGIC_OP_COPY,
	eAndInverted = VK_LOGIC_OP_AND_INVERTED,
	eNoOp = VK_LOGIC_OP_NO_OP,
	eXor = VK_LOGIC_OP_XOR,
	eOr = VK_LOGIC_OP_OR,
	eNor = VK_LOGIC_OP_NOR,
	eEquivalent = VK_LOGIC_OP_EQUIVALENT,
	eInvert = VK_LOGIC_OP_INVERT,
	eOrReverse = VK_LOGIC_OP_OR_REVERSE,
	eCopyInverted = VK_LOGIC_OP_COPY_INVERTED,
	eOrInverted = VK_LOGIC_OP_OR_INVERTED,
	eNand = VK_LOGIC_OP_NAND,
	eSet = VK_LOGIC_OP_SET,
};

inline const char *getEnumString(LogicOp e)
{
	switch (e) {
	case LogicOp::eClear: return "LogicOp::eClear";
	case LogicOp::eAnd: return "LogicOp::eAnd";
	case LogicOp::eAndReverse: return "LogicOp::eAndReverse";
	case LogicOp::eCopy: return "LogicOp::eCopy";
	case LogicOp::eAndInverted: return "LogicOp::eAndInverted";
	case LogicOp::eNoOp: return "LogicOp::eNoOp";
	case LogicOp::eXor: return "LogicOp::eXor";
	case LogicOp::eOr: return "LogicOp::eOr";
	case LogicOp::eNor: return "LogicOp::eNor";
	case LogicOp::eEquivalent: return "LogicOp::eEquivalent";
	case LogicOp::eInvert: return "LogicOp::eInvert";
	case LogicOp::eOrReverse: return "LogicOp::eOrReverse";
	case LogicOp::eCopyInverted: return "LogicOp::eCopyInverted";
	case LogicOp::eOrInverted: return "LogicOp::eOrInverted";
	case LogicOp::eNand: return "LogicOp::eNand";
	case LogicOp::eSet: return "LogicOp::eSet";
	default: return "<invalid enum>";
	}
}


enum class PhysicalDeviceType {
	eOther = VK_PHYSICAL_DEVICE_TYPE_OTHER,
	eIntegratedGpu = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU,
	eDiscreteGpu = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU,
	eVirtualGpu = VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU,
	eCpu = VK_PHYSICAL_DEVICE_TYPE_CPU,
};

inline const char *getEnumString(PhysicalDeviceType e)
{
	switch (e) {
	case PhysicalDeviceType::eOther: return "PhysicalDeviceType::eOther";
	case PhysicalDeviceType::eIntegratedGpu: return "PhysicalDeviceType::eIntegratedGpu";
	case PhysicalDeviceType::eDiscreteGpu: return "PhysicalDeviceType::eDiscreteGpu";
	case PhysicalDeviceType::eVirtualGpu: return "PhysicalDeviceType::eVirtualGpu";
	case PhysicalDeviceType::eCpu: return "PhysicalDeviceType::eCpu";
	default: return "<invalid enum>";
	}
}


enum class PipelineBindPoint {
	eGraphics = VK_PIPELINE_BIND_POINT_GRAPHICS,
	eCompute = VK_PIPELINE_BIND_POINT_COMPUTE,
};

inline const char *getEnumString(PipelineBindPoint e)
{
	switch (e) {
	case PipelineBindPoint::eGraphics: return "PipelineBindPoint::eGraphics";
	case PipelineBindPoint::eCompute: return "PipelineBindPoint::eCompute";
	default: return "<invalid enum>";
	}
}


enum class PrimitiveTopology {
	ePointList = VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
	eLineList = VK_PRIMITIVE_TOPOLOGY_LINE_LIST,
	eLineStrip = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP,
	eTriangleList = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
	eTriangleStrip = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
	eTriangleFan = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN,
	eLineListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY,
	eLineStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY,
	eTriangleListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY,
	eTriangleStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY,
	ePatchList = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST,
};

inline const char *getEnumString(PrimitiveTopology e)
{
	switch (e) {
	case PrimitiveTopology::ePointList: return "PrimitiveTopology::ePointList";
	case PrimitiveTopology::eLineList: return "PrimitiveTopology::eLineList";
	case PrimitiveTopology::eLineStrip: return "PrimitiveTopology::eLineStrip";
	case PrimitiveTopology::eTriangleList: return "PrimitiveTopology::eTriangleList";
	case PrimitiveTopology::eTriangleStrip: return "PrimitiveTopology::eTriangleStrip";
	case PrimitiveTopology::eTriangleFan: return "PrimitiveTopology::eTriangleFan";
	case PrimitiveTopology::eLineListWithAdjacency: return "PrimitiveTopology::eLineListWithAdjacency";
	case PrimitiveTopology::eLineStripWithAdjacency: return "PrimitiveTopology::eLineStripWithAdjacency";
	case PrimitiveTopology::eTriangleListWithAdjacency: return "PrimitiveTopology::eTriangleListWithAdjacency";
	case PrimitiveTopology::eTriangleStripWithAdjacency: return "PrimitiveTopology::eTriangleStripWithAdjacency";
	case PrimitiveTopology::ePatchList: return "PrimitiveTopology::ePatchList";
	default: return "<invalid enum>";
	}
}


enum class QueryType {
	eOcclusion = VK_QUERY_TYPE_OCCLUSION,
	ePipelineStatistics = VK_QUERY_TYPE_PIPELINE_STATISTICS,
	eTimestamp = VK_QUERY_TYPE_TIMESTAMP,
};

inline const char *getEnumString(QueryType e)
{
	switch (e) {
	case QueryType::eOcclusion: return "QueryType::eOcclusion";
	case QueryType::ePipelineStatistics: return "QueryType::ePipelineStatistics";
	case QueryType::eTimestamp: return "QueryType::eTimestamp";
	default: return "<invalid enum>";
	}
}


enum class SubpassContents {
	eInline = VK_SUBPASS_CONTENTS_INLINE,
	eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS,
};

inline const char *getEnumString(SubpassContents e)
{
	switch (e) {
	case SubpassContents::eInline: return "SubpassContents::eInline";
	case SubpassContents::eSecondaryCommandBuffers: return "SubpassContents::eSecondaryCommandBuffers";
	default: return "<invalid enum>";
	}
}


enum class Result {
	eSuccess = VK_SUCCESS,
	eNotReady = VK_NOT_READY,
	eTimeout = VK_TIMEOUT,
	eEventSet = VK_EVENT_SET,
	eEventReset = VK_EVENT_RESET,
	eIncomplete = VK_INCOMPLETE,
	eErrorOutOfHostMemory = VK_ERROR_OUT_OF_HOST_MEMORY,
	eErrorOutOfDeviceMemory = VK_ERROR_OUT_OF_DEVICE_MEMORY,
	eErrorInitializationFailed = VK_ERROR_INITIALIZATION_FAILED,
	eErrorDeviceLost = VK_ERROR_DEVICE_LOST,
	eErrorMemoryMapFailed = VK_ERROR_MEMORY_MAP_FAILED,
	eErrorLayerNotPresent = VK_ERROR_LAYER_NOT_PRESENT,
	eErrorExtensionNotPresent = VK_ERROR_EXTENSION_NOT_PRESENT,
	eErrorFeatureNotPresent = VK_ERROR_FEATURE_NOT_PRESENT,
	eErrorIncompatibleDriver = VK_ERROR_INCOMPATIBLE_DRIVER,
	eErrorTooManyObjects = VK_ERROR_TOO_MANY_OBJECTS,
	eErrorFormatNotSupported = VK_ERROR_FORMAT_NOT_SUPPORTED,
};

inline const char *getEnumString(Result e)
{
	switch (e) {
	case Result::eSuccess: return "Result::eSuccess";
	case Result::eNotReady: return "Result::eNotReady";
	case Result::eTimeout: return "Result::eTimeout";
	case Result::eEventSet: return "Result::eEventSet";
	case Result::eEventReset: return "Result::eEventReset";
	case Result::eIncomplete: return "Result::eIncomplete";
	case Result::eErrorOutOfHostMemory: return "Result::eErrorOutOfHostMemory";
	case Result::eErrorOutOfDeviceMemory: return "Result::eErrorOutOfDeviceMemory";
	case Result::eErrorInitializationFailed: return "Result::eErrorInitializationFailed";
	case Result::eErrorDeviceLost: return "Result::eErrorDeviceLost";
	case Result::eErrorMemoryMapFailed: return "Result::eErrorMemoryMapFailed";
	case Result::eErrorLayerNotPresent: return "Result::eErrorLayerNotPresent";
	case Result::eErrorExtensionNotPresent: return "Result::eErrorExtensionNotPresent";
	case Result::eErrorFeatureNotPresent: return "Result::eErrorFeatureNotPresent";
	case Result::eErrorIncompatibleDriver: return "Result::eErrorIncompatibleDriver";
	case Result::eErrorTooManyObjects: return "Result::eErrorTooManyObjects";
	case Result::eErrorFormatNotSupported: return "Result::eErrorFormatNotSupported";
	default: return "<invalid enum>";
	}
}


enum class StencilOp {
	eKeep = VK_STENCIL_OP_KEEP,
	eZero = VK_STENCIL_OP_ZERO,
	eReplace = VK_STENCIL_OP_REPLACE,
	eIncrementAndClamp = VK_STENCIL_OP_INCREMENT_AND_CLAMP,
	eDecrementAndClamp = VK_STENCIL_OP_DECREMENT_AND_CLAMP,
	eInvert = VK_STENCIL_OP_INVERT,
	eIncrementAndWrap = VK_STENCIL_OP_INCREMENT_AND_WRAP,
	eDecrementAndWrap = VK_STENCIL_OP_DECREMENT_AND_WRAP,
};

inline const char *getEnumString(StencilOp e)
{
	switch (e) {
	case StencilOp::eKeep: return "StencilOp::eKeep";
	case StencilOp::eZero: return "StencilOp::eZero";
	case StencilOp::eReplace: return "StencilOp::eReplace";
	case StencilOp::eIncrementAndClamp: return "StencilOp::eIncrementAndClamp";
	case StencilOp::eDecrementAndClamp: return "StencilOp::eDecrementAndClamp";
	case StencilOp::eInvert: return "StencilOp::eInvert";
	case StencilOp::eIncrementAndWrap: return "StencilOp::eIncrementAndWrap";
	case StencilOp::eDecrementAndWrap: return "StencilOp::eDecrementAndWrap";
	default: return "<invalid enum>";
	}
}


enum class StructureType {
	eApplicationInfo = VK_STRUCTURE_TYPE_APPLICATION_INFO,
	eInstanceCreateInfo = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
	eDeviceQueueCreateInfo = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
	eDeviceCreateInfo = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
	eSubmitInfo = VK_STRUCTURE_TYPE_SUBMIT_INFO,
	eMemoryAllocateInfo = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
	eMappedMemoryRange = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
	eBindSparseInfo = VK_STRUCTURE_TYPE_BIND_SPARSE_INFO,
	eFenceCreateInfo = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
	eSemaphoreCreateInfo = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
	eEventCreateInfo = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
	eQueryPoolCreateInfo = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,
	eBufferCreateInfo = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
	eBufferViewCreateInfo = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,
	eImageCreateInfo = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
	eImageViewCreateInfo = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
	eShaderModuleCreateInfo = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
	ePipelineCacheCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO,
	ePipelineShaderStageCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
	ePipelineVertexInputStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
	ePipelineInputAssemblyStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
	ePipelineTessellationStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO,
	ePipelineViewportStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
	ePipelineRasterizationStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
	ePipelineMultisampleStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
	ePipelineDepthStencilStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
	ePipelineColorBlendStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
	ePipelineDynamicStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
	eGraphicsPipelineCreateInfo = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
	eComputePipelineCreateInfo = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
	ePipelineLayoutCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
	eSamplerCreateInfo = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
	eDescriptorSetLayoutCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
	eDescriptorPoolCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
	eDescriptorSetAllocateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
	eWriteDescriptorSet = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
	eCopyDescriptorSet = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET,
	eFramebufferCreateInfo = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
	eRenderPassCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
	eCommandPoolCreateInfo = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
	eCommandBufferAllocateInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
	eCommandBufferInheritanceInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
	eCommandBufferBeginInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
	eRenderPassBeginInfo = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
	eBufferMemoryBarrier = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
	eImageMemoryBarrier = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
	eMemoryBarrier = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
	eLoaderInstanceCreateInfo = VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO,
	eLoaderDeviceCreateInfo = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO,
};

inline const char *getEnumString(StructureType e)
{
	switch (e) {
	case StructureType::eApplicationInfo: return "StructureType::eApplicationInfo";
	case StructureType::eInstanceCreateInfo: return "StructureType::eInstanceCreateInfo";
	case StructureType::eDeviceQueueCreateInfo: return "StructureType::eDeviceQueueCreateInfo";
	case StructureType::eDeviceCreateInfo: return "StructureType::eDeviceCreateInfo";
	case StructureType::eSubmitInfo: return "StructureType::eSubmitInfo";
	case StructureType::eMemoryAllocateInfo: return "StructureType::eMemoryAllocateInfo";
	case StructureType::eMappedMemoryRange: return "StructureType::eMappedMemoryRange";
	case StructureType::eBindSparseInfo: return "StructureType::eBindSparseInfo";
	case StructureType::eFenceCreateInfo: return "StructureType::eFenceCreateInfo";
	case StructureType::eSemaphoreCreateInfo: return "StructureType::eSemaphoreCreateInfo";
	case StructureType::eEventCreateInfo: return "StructureType::eEventCreateInfo";
	case StructureType::eQueryPoolCreateInfo: return "StructureType::eQueryPoolCreateInfo";
	case StructureType::eBufferCreateInfo: return "StructureType::eBufferCreateInfo";
	case StructureType::eBufferViewCreateInfo: return "StructureType::eBufferViewCreateInfo";
	case StructureType::eImageCreateInfo: return "StructureType::eImageCreateInfo";
	case StructureType::eImageViewCreateInfo: return "StructureType::eImageViewCreateInfo";
	case StructureType::eShaderModuleCreateInfo: return "StructureType::eShaderModuleCreateInfo";
	case StructureType::ePipelineCacheCreateInfo: return "StructureType::ePipelineCacheCreateInfo";
	case StructureType::ePipelineShaderStageCreateInfo: return "StructureType::ePipelineShaderStageCreateInfo";
	case StructureType::ePipelineVertexInputStateCreateInfo: return "StructureType::ePipelineVertexInputStateCreateInfo";
	case StructureType::ePipelineInputAssemblyStateCreateInfo: return "StructureType::ePipelineInputAssemblyStateCreateInfo";
	case StructureType::ePipelineTessellationStateCreateInfo: return "StructureType::ePipelineTessellationStateCreateInfo";
	case StructureType::ePipelineViewportStateCreateInfo: return "StructureType::ePipelineViewportStateCreateInfo";
	case StructureType::ePipelineRasterizationStateCreateInfo: return "StructureType::ePipelineRasterizationStateCreateInfo";
	case StructureType::ePipelineMultisampleStateCreateInfo: return "StructureType::ePipelineMultisampleStateCreateInfo";
	case StructureType::ePipelineDepthStencilStateCreateInfo: return "StructureType::ePipelineDepthStencilStateCreateInfo";
	case StructureType::ePipelineColorBlendStateCreateInfo: return "StructureType::ePipelineColorBlendStateCreateInfo";
	case StructureType::ePipelineDynamicStateCreateInfo: return "StructureType::ePipelineDynamicStateCreateInfo";
	case StructureType::eGraphicsPipelineCreateInfo: return "StructureType::eGraphicsPipelineCreateInfo";
	case StructureType::eComputePipelineCreateInfo: return "StructureType::eComputePipelineCreateInfo";
	case StructureType::ePipelineLayoutCreateInfo: return "StructureType::ePipelineLayoutCreateInfo";
	case StructureType::eSamplerCreateInfo: return "StructureType::eSamplerCreateInfo";
	case StructureType::eDescriptorSetLayoutCreateInfo: return "StructureType::eDescriptorSetLayoutCreateInfo";
	case StructureType::eDescriptorPoolCreateInfo: return "StructureType::eDescriptorPoolCreateInfo";
	case StructureType::eDescriptorSetAllocateInfo: return "StructureType::eDescriptorSetAllocateInfo";
	case StructureType::eWriteDescriptorSet: return "StructureType::eWriteDescriptorSet";
	case StructureType::eCopyDescriptorSet: return "StructureType::eCopyDescriptorSet";
	case StructureType::eFramebufferCreateInfo: return "StructureType::eFramebufferCreateInfo";
	case StructureType::eRenderPassCreateInfo: return "StructureType::eRenderPassCreateInfo";
	case StructureType::eCommandPoolCreateInfo: return "StructureType::eCommandPoolCreateInfo";
	case StructureType::eCommandBufferAllocateInfo: return "StructureType::eCommandBufferAllocateInfo";
	case StructureType::eCommandBufferInheritanceInfo: return "StructureType::eCommandBufferInheritanceInfo";
	case StructureType::eCommandBufferBeginInfo: return "StructureType::eCommandBufferBeginInfo";
	case StructureType::eRenderPassBeginInfo: return "StructureType::eRenderPassBeginInfo";
	case StructureType::eBufferMemoryBarrier: return "StructureType::eBufferMemoryBarrier";
	case StructureType::eImageMemoryBarrier: return "StructureType::eImageMemoryBarrier";
	case StructureType::eMemoryBarrier: return "StructureType::eMemoryBarrier";
	case StructureType::eLoaderInstanceCreateInfo: return "StructureType::eLoaderInstanceCreateInfo";
	case StructureType::eLoaderDeviceCreateInfo: return "StructureType::eLoaderDeviceCreateInfo";
	default: return "<invalid enum>";
	}
}


enum class SystemAllocationScope {
	eCommand = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND,
	eObject = VK_SYSTEM_ALLOCATION_SCOPE_OBJECT,
	eCache = VK_SYSTEM_ALLOCATION_SCOPE_CACHE,
	eDevice = VK_SYSTEM_ALLOCATION_SCOPE_DEVICE,
	eInstance = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE,
};

inline const char *getEnumString(SystemAllocationScope e)
{
	switch (e) {
	case SystemAllocationScope::eCommand: return "SystemAllocationScope::eCommand";
	case SystemAllocationScope::eObject: return "SystemAllocationScope::eObject";
	case SystemAllocationScope::eCache: return "SystemAllocationScope::eCache";
	case SystemAllocationScope::eDevice: return "SystemAllocationScope::eDevice";
	case SystemAllocationScope::eInstance: return "SystemAllocationScope::eInstance";
	default: return "<invalid enum>";
	}
}


enum class InternalAllocationType {
	eExecutable = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
};

inline const char *getEnumString(InternalAllocationType e)
{
	switch (e) {
	case InternalAllocationType::eExecutable: return "InternalAllocationType::eExecutable";
	default: return "<invalid enum>";
	}
}


enum class SamplerAddressMode {
	eRepeat = VK_SAMPLER_ADDRESS_MODE_REPEAT,
	eMirroredRepeat = VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
	eClampToEdge = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
	eClampToBorder = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
	eMirrorClampToEdge = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,
};

inline const char *getEnumString(SamplerAddressMode e)
{
	switch (e) {
	case SamplerAddressMode::eRepeat: return "SamplerAddressMode::eRepeat";
	case SamplerAddressMode::eMirroredRepeat: return "SamplerAddressMode::eMirroredRepeat";
	case SamplerAddressMode::eClampToEdge: return "SamplerAddressMode::eClampToEdge";
	case SamplerAddressMode::eClampToBorder: return "SamplerAddressMode::eClampToBorder";
	case SamplerAddressMode::eMirrorClampToEdge: return "SamplerAddressMode::eMirrorClampToEdge";
	default: return "<invalid enum>";
	}
}


enum class Filter {
	eNearest = VK_FILTER_NEAREST,
	eLinear = VK_FILTER_LINEAR,
};

inline const char *getEnumString(Filter e)
{
	switch (e) {
	case Filter::eNearest: return "Filter::eNearest";
	case Filter::eLinear: return "Filter::eLinear";
	default: return "<invalid enum>";
	}
}


enum class SamplerMipmapMode {
	eNearest = VK_SAMPLER_MIPMAP_MODE_NEAREST,
	eLinear = VK_SAMPLER_MIPMAP_MODE_LINEAR,
};

inline const char *getEnumString(SamplerMipmapMode e)
{
	switch (e) {
	case SamplerMipmapMode::eNearest: return "SamplerMipmapMode::eNearest";
	case SamplerMipmapMode::eLinear: return "SamplerMipmapMode::eLinear";
	default: return "<invalid enum>";
	}
}


enum class VertexInputRate {
	eVertex = VK_VERTEX_INPUT_RATE_VERTEX,
	eInstance = VK_VERTEX_INPUT_RATE_INSTANCE,
};

inline const char *getEnumString(VertexInputRate e)
{
	switch (e) {
	case VertexInputRate::eVertex: return "VertexInputRate::eVertex";
	case VertexInputRate::eInstance: return "VertexInputRate::eInstance";
	default: return "<invalid enum>";
	}
}


enum class ColorSpaceKHR {
	eSrgbNonlinear = VK_COLORSPACE_SRGB_NONLINEAR_KHR,
};

inline const char *getEnumString(ColorSpaceKHR e)
{
	switch (e) {
	case ColorSpaceKHR::eSrgbNonlinear: return "ColorSpaceKHR::eSrgbNonlinear";
	default: return "<invalid enum>";
	}
}


enum class PresentModeKHR {
	eImmediate = VK_PRESENT_MODE_IMMEDIATE_KHR,
	eMailbox = VK_PRESENT_MODE_MAILBOX_KHR,
	eFifo = VK_PRESENT_MODE_FIFO_KHR,
	eFifoRelaxed = VK_PRESENT_MODE_FIFO_RELAXED_KHR,
};

inline const char *getEnumString(PresentModeKHR e)
{
	switch (e) {
	case PresentModeKHR::eImmediate: return "PresentModeKHR::eImmediate";
	case PresentModeKHR::eMailbox: return "PresentModeKHR::eMailbox";
	case PresentModeKHR::eFifo: return "PresentModeKHR::eFifo";
	case PresentModeKHR::eFifoRelaxed: return "PresentModeKHR::eFifoRelaxed";
	default: return "<invalid enum>";
	}
}


enum class DebugReportObjectTypeEXT {
	eUnknown = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
	eInstance = VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT,
	ePhysicalDevice = VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
	eDevice = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
	eQueue = VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT,
	eSemaphore = VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT,
	eCommandBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
	eFence = VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT,
	eDeviceMemory = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
	eBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
	eImage = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
	eEvent = VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT,
	eQueryPool = VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT,
	eBufferView = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT,
	eImageView = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT,
	eShaderModule = VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT,
	ePipelineCache = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT,
	ePipelineLayout = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT,
	eRenderPass = VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
	ePipeline = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
	eDescriptorSetLayout = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT,
	eSampler = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT,
	eDescriptorPool = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT,
	eDescriptorSet = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
	eFramebuffer = VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT,
	eCommandPool = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT,
	eSurfaceKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT,
	eSwapchainKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
	eDebugReport = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT,
};

inline const char *getEnumString(DebugReportObjectTypeEXT e)
{
	switch (e) {
	case DebugReportObjectTypeEXT::eUnknown: return "DebugReportObjectTypeEXT::eUnknown";
	case DebugReportObjectTypeEXT::eInstance: return "DebugReportObjectTypeEXT::eInstance";
	case DebugReportObjectTypeEXT::ePhysicalDevice: return "DebugReportObjectTypeEXT::ePhysicalDevice";
	case DebugReportObjectTypeEXT::eDevice: return "DebugReportObjectTypeEXT::eDevice";
	case DebugReportObjectTypeEXT::eQueue: return "DebugReportObjectTypeEXT::eQueue";
	case DebugReportObjectTypeEXT::eSemaphore: return "DebugReportObjectTypeEXT::eSemaphore";
	case DebugReportObjectTypeEXT::eCommandBuffer: return "DebugReportObjectTypeEXT::eCommandBuffer";
	case DebugReportObjectTypeEXT::eFence: return "DebugReportObjectTypeEXT::eFence";
	case DebugReportObjectTypeEXT::eDeviceMemory: return "DebugReportObjectTypeEXT::eDeviceMemory";
	case DebugReportObjectTypeEXT::eBuffer: return "DebugReportObjectTypeEXT::eBuffer";
	case DebugReportObjectTypeEXT::eImage: return "DebugReportObjectTypeEXT::eImage";
	case DebugReportObjectTypeEXT::eEvent: return "DebugReportObjectTypeEXT::eEvent";
	case DebugReportObjectTypeEXT::eQueryPool: return "DebugReportObjectTypeEXT::eQueryPool";
	case DebugReportObjectTypeEXT::eBufferView: return "DebugReportObjectTypeEXT::eBufferView";
	case DebugReportObjectTypeEXT::eImageView: return "DebugReportObjectTypeEXT::eImageView";
	case DebugReportObjectTypeEXT::eShaderModule: return "DebugReportObjectTypeEXT::eShaderModule";
	case DebugReportObjectTypeEXT::ePipelineCache: return "DebugReportObjectTypeEXT::ePipelineCache";
	case DebugReportObjectTypeEXT::ePipelineLayout: return "DebugReportObjectTypeEXT::ePipelineLayout";
	case DebugReportObjectTypeEXT::eRenderPass: return "DebugReportObjectTypeEXT::eRenderPass";
	case DebugReportObjectTypeEXT::ePipeline: return "DebugReportObjectTypeEXT::ePipeline";
	case DebugReportObjectTypeEXT::eDescriptorSetLayout: return "DebugReportObjectTypeEXT::eDescriptorSetLayout";
	case DebugReportObjectTypeEXT::eSampler: return "DebugReportObjectTypeEXT::eSampler";
	case DebugReportObjectTypeEXT::eDescriptorPool: return "DebugReportObjectTypeEXT::eDescriptorPool";
	case DebugReportObjectTypeEXT::eDescriptorSet: return "DebugReportObjectTypeEXT::eDescriptorSet";
	case DebugReportObjectTypeEXT::eFramebuffer: return "DebugReportObjectTypeEXT::eFramebuffer";
	case DebugReportObjectTypeEXT::eCommandPool: return "DebugReportObjectTypeEXT::eCommandPool";
	case DebugReportObjectTypeEXT::eSurfaceKhr: return "DebugReportObjectTypeEXT::eSurfaceKhr";
	case DebugReportObjectTypeEXT::eSwapchainKhr: return "DebugReportObjectTypeEXT::eSwapchainKhr";
	case DebugReportObjectTypeEXT::eDebugReport: return "DebugReportObjectTypeEXT::eDebugReport";
	default: return "<invalid enum>";
	}
}


enum class DebugReportErrorEXT {
	eNone = VK_DEBUG_REPORT_ERROR_NONE_EXT,
	eCallbackRef = VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT,
};

inline const char *getEnumString(DebugReportErrorEXT e)
{
	switch (e) {
	case DebugReportErrorEXT::eNone: return "DebugReportErrorEXT::eNone";
	case DebugReportErrorEXT::eCallbackRef: return "DebugReportErrorEXT::eCallbackRef";
	default: return "<invalid enum>";
	}
}





enum class FramebufferCreateFlagBits {
};

inline const char *getEnumString(FramebufferCreateFlagBits e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using FramebufferCreateFlags = Flags<FramebufferCreateFlagBits, VkFramebufferCreateFlags>;

inline FramebufferCreateFlags operator|(FramebufferCreateFlagBits bit0, FramebufferCreateFlagBits bit1)
{
	return FramebufferCreateFlags(bit0) | bit1;
}


enum class QueryPoolCreateFlagBits {
};

inline const char *getEnumString(QueryPoolCreateFlagBits e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using QueryPoolCreateFlags = Flags<QueryPoolCreateFlagBits, VkQueryPoolCreateFlags>;

inline QueryPoolCreateFlags operator|(QueryPoolCreateFlagBits bit0, QueryPoolCreateFlagBits bit1)
{
	return QueryPoolCreateFlags(bit0) | bit1;
}


enum class RenderPassCreateFlagBits {
};

inline const char *getEnumString(RenderPassCreateFlagBits e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using RenderPassCreateFlags = Flags<RenderPassCreateFlagBits, VkRenderPassCreateFlags>;

inline RenderPassCreateFlags operator|(RenderPassCreateFlagBits bit0, RenderPassCreateFlagBits bit1)
{
	return RenderPassCreateFlags(bit0) | bit1;
}


enum class SamplerCreateFlagBits {
};

inline const char *getEnumString(SamplerCreateFlagBits e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using SamplerCreateFlags = Flags<SamplerCreateFlagBits, VkSamplerCreateFlags>;

inline SamplerCreateFlags operator|(SamplerCreateFlagBits bit0, SamplerCreateFlagBits bit1)
{
	return SamplerCreateFlags(bit0) | bit1;
}


enum class PipelineLayoutCreateFlagBits {
};

inline const char *getEnumString(PipelineLayoutCreateFlagBits e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using PipelineLayoutCreateFlags = Flags<PipelineLayoutCreateFlagBits, VkPipelineLayoutCreateFlags>;

inline PipelineLayoutCreateFlags operator|(PipelineLayoutCreateFlagBits bit0, PipelineLayoutCreateFlagBits bit1)
{
	return PipelineLayoutCreateFlags(bit0) | bit1;
}


enum class PipelineCacheCreateFlagBits {
};

inline const char *getEnumString(PipelineCacheCreateFlagBits e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using PipelineCacheCreateFlags = Flags<PipelineCacheCreateFlagBits, VkPipelineCacheCreateFlags>;

inline PipelineCacheCreateFlags operator|(PipelineCacheCreateFlagBits bit0, PipelineCacheCreateFlagBits bit1)
{
	return PipelineCacheCreateFlags(bit0) | bit1;
}


enum class PipelineDepthStencilStateCreateFlagBits {
};

inline const char *getEnumString(PipelineDepthStencilStateCreateFlagBits e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using PipelineDepthStencilStateCreateFlags = Flags<PipelineDepthStencilStateCreateFlagBits, VkPipelineDepthStencilStateCreateFlags>;

inline PipelineDepthStencilStateCreateFlags operator|(PipelineDepthStencilStateCreateFlagBits bit0, PipelineDepthStencilStateCreateFlagBits bit1)
{
	return PipelineDepthStencilStateCreateFlags(bit0) | bit1;
}


enum class PipelineDynamicStateCreateFlagBits {
};

inline const char *getEnumString(PipelineDynamicStateCreateFlagBits e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using PipelineDynamicStateCreateFlags = Flags<PipelineDynamicStateCreateFlagBits, VkPipelineDynamicStateCreateFlags>;

inline PipelineDynamicStateCreateFlags operator|(PipelineDynamicStateCreateFlagBits bit0, PipelineDynamicStateCreateFlagBits bit1)
{
	return PipelineDynamicStateCreateFlags(bit0) | bit1;
}


enum class PipelineColorBlendStateCreateFlagBits {
};

inline const char *getEnumString(PipelineColorBlendStateCreateFlagBits e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using PipelineColorBlendStateCreateFlags = Flags<PipelineColorBlendStateCreateFlagBits, VkPipelineColorBlendStateCreateFlags>;

inline PipelineColorBlendStateCreateFlags operator|(PipelineColorBlendStateCreateFlagBits bit0, PipelineColorBlendStateCreateFlagBits bit1)
{
	return PipelineColorBlendStateCreateFlags(bit0) | bit1;
}


enum class PipelineMultisampleStateCreateFlagBits {
};

inline const char *getEnumString(PipelineMultisampleStateCreateFlagBits e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using PipelineMultisampleStateCreateFlags = Flags<PipelineMultisampleStateCreateFlagBits, VkPipelineMultisampleStateCreateFlags>;

inline PipelineMultisampleStateCreateFlags operator|(PipelineMultisampleStateCreateFlagBits bit0, PipelineMultisampleStateCreateFlagBits bit1)
{
	return PipelineMultisampleStateCreateFlags(bit0) | bit1;
}


enum class PipelineRasterizationStateCreateFlagBits {
};

inline const char *getEnumString(PipelineRasterizationStateCreateFlagBits e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using PipelineRasterizationStateCreateFlags = Flags<PipelineRasterizationStateCreateFlagBits, VkPipelineRasterizationStateCreateFlags>;

inline PipelineRasterizationStateCreateFlags operator|(PipelineRasterizationStateCreateFlagBits bit0, PipelineRasterizationStateCreateFlagBits bit1)
{
	return PipelineRasterizationStateCreateFlags(bit0) | bit1;
}


enum class PipelineViewportStateCreateFlagBits {
};

inline const char *getEnumString(PipelineViewportStateCreateFlagBits e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using PipelineViewportStateCreateFlags = Flags<PipelineViewportStateCreateFlagBits, VkPipelineViewportStateCreateFlags>;

inline PipelineViewportStateCreateFlags operator|(PipelineViewportStateCreateFlagBits bit0, PipelineViewportStateCreateFlagBits bit1)
{
	return PipelineViewportStateCreateFlags(bit0) | bit1;
}


enum class PipelineTessellationStateCreateFlagBits {
};

inline const char *getEnumString(PipelineTessellationStateCreateFlagBits e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using PipelineTessellationStateCreateFlags = Flags<PipelineTessellationStateCreateFlagBits, VkPipelineTessellationStateCreateFlags>;

inline PipelineTessellationStateCreateFlags operator|(PipelineTessellationStateCreateFlagBits bit0, PipelineTessellationStateCreateFlagBits bit1)
{
	return PipelineTessellationStateCreateFlags(bit0) | bit1;
}


enum class PipelineInputAssemblyStateCreateFlagBits {
};

inline const char *getEnumString(PipelineInputAssemblyStateCreateFlagBits e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using PipelineInputAssemblyStateCreateFlags = Flags<PipelineInputAssemblyStateCreateFlagBits, VkPipelineInputAssemblyStateCreateFlags>;

inline PipelineInputAssemblyStateCreateFlags operator|(PipelineInputAssemblyStateCreateFlagBits bit0, PipelineInputAssemblyStateCreateFlagBits bit1)
{
	return PipelineInputAssemblyStateCreateFlags(bit0) | bit1;
}


enum class PipelineVertexInputStateCreateFlagBits {
};

inline const char *getEnumString(PipelineVertexInputStateCreateFlagBits e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using PipelineVertexInputStateCreateFlags = Flags<PipelineVertexInputStateCreateFlagBits, VkPipelineVertexInputStateCreateFlags>;

inline PipelineVertexInputStateCreateFlags operator|(PipelineVertexInputStateCreateFlagBits bit0, PipelineVertexInputStateCreateFlagBits bit1)
{
	return PipelineVertexInputStateCreateFlags(bit0) | bit1;
}


enum class PipelineShaderStageCreateFlagBits {
};

inline const char *getEnumString(PipelineShaderStageCreateFlagBits e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using PipelineShaderStageCreateFlags = Flags<PipelineShaderStageCreateFlagBits, VkPipelineShaderStageCreateFlags>;

inline PipelineShaderStageCreateFlags operator|(PipelineShaderStageCreateFlagBits bit0, PipelineShaderStageCreateFlagBits bit1)
{
	return PipelineShaderStageCreateFlags(bit0) | bit1;
}


enum class DescriptorSetLayoutCreateFlagBits {
};

inline const char *getEnumString(DescriptorSetLayoutCreateFlagBits e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using DescriptorSetLayoutCreateFlags = Flags<DescriptorSetLayoutCreateFlagBits, VkDescriptorSetLayoutCreateFlags>;

inline DescriptorSetLayoutCreateFlags operator|(DescriptorSetLayoutCreateFlagBits bit0, DescriptorSetLayoutCreateFlagBits bit1)
{
	return DescriptorSetLayoutCreateFlags(bit0) | bit1;
}


enum class BufferViewCreateFlagBits {
};

inline const char *getEnumString(BufferViewCreateFlagBits e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using BufferViewCreateFlags = Flags<BufferViewCreateFlagBits, VkBufferViewCreateFlags>;

inline BufferViewCreateFlags operator|(BufferViewCreateFlagBits bit0, BufferViewCreateFlagBits bit1)
{
	return BufferViewCreateFlags(bit0) | bit1;
}


enum class InstanceCreateFlagBits {
};

inline const char *getEnumString(InstanceCreateFlagBits e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using InstanceCreateFlags = Flags<InstanceCreateFlagBits, VkInstanceCreateFlags>;

inline InstanceCreateFlags operator|(InstanceCreateFlagBits bit0, InstanceCreateFlagBits bit1)
{
	return InstanceCreateFlags(bit0) | bit1;
}


enum class DeviceCreateFlagBits {
};

inline const char *getEnumString(DeviceCreateFlagBits e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using DeviceCreateFlags = Flags<DeviceCreateFlagBits, VkDeviceCreateFlags>;

inline DeviceCreateFlags operator|(DeviceCreateFlagBits bit0, DeviceCreateFlagBits bit1)
{
	return DeviceCreateFlags(bit0) | bit1;
}


enum class DeviceQueueCreateFlagBits {
};

inline const char *getEnumString(DeviceQueueCreateFlagBits e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using DeviceQueueCreateFlags = Flags<DeviceQueueCreateFlagBits, VkDeviceQueueCreateFlags>;

inline DeviceQueueCreateFlags operator|(DeviceQueueCreateFlagBits bit0, DeviceQueueCreateFlagBits bit1)
{
	return DeviceQueueCreateFlags(bit0) | bit1;
}


enum class QueueFlagBits {
	eGraphics = VK_QUEUE_GRAPHICS_BIT,
	eCompute = VK_QUEUE_COMPUTE_BIT,
	eTransfer = VK_QUEUE_TRANSFER_BIT,
	eSparseBinding = VK_QUEUE_SPARSE_BINDING_BIT,
};

inline const char *getEnumString(QueueFlagBits e)
{
	switch (e) {
	case QueueFlagBits::eGraphics: return "QueueFlagBits::eGraphics";
	case QueueFlagBits::eCompute: return "QueueFlagBits::eCompute";
	case QueueFlagBits::eTransfer: return "QueueFlagBits::eTransfer";
	case QueueFlagBits::eSparseBinding: return "QueueFlagBits::eSparseBinding";
	default: return "<invalid enum>";
	}
}


using QueueFlags = Flags<QueueFlagBits, VkQueueFlags>;

inline QueueFlags operator|(QueueFlagBits bit0, QueueFlagBits bit1)
{
	return QueueFlags(bit0) | bit1;
}


enum class MemoryPropertyFlagBits {
	eDeviceLocal = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
	eHostVisible = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
	eHostCoherent = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
	eHostCached = VK_MEMORY_PROPERTY_HOST_CACHED_BIT,
	eLazilyAllocated = VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT,
};

inline const char *getEnumString(MemoryPropertyFlagBits e)
{
	switch (e) {
	case MemoryPropertyFlagBits::eDeviceLocal: return "MemoryPropertyFlagBits::eDeviceLocal";
	case MemoryPropertyFlagBits::eHostVisible: return "MemoryPropertyFlagBits::eHostVisible";
	case MemoryPropertyFlagBits::eHostCoherent: return "MemoryPropertyFlagBits::eHostCoherent";
	case MemoryPropertyFlagBits::eHostCached: return "MemoryPropertyFlagBits::eHostCached";
	case MemoryPropertyFlagBits::eLazilyAllocated: return "MemoryPropertyFlagBits::eLazilyAllocated";
	default: return "<invalid enum>";
	}
}


using MemoryPropertyFlags = Flags<MemoryPropertyFlagBits, VkMemoryPropertyFlags>;

inline MemoryPropertyFlags operator|(MemoryPropertyFlagBits bit0, MemoryPropertyFlagBits bit1)
{
	return MemoryPropertyFlags(bit0) | bit1;
}


enum class MemoryHeapFlagBits {
	eDeviceLocal = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT,
};

inline const char *getEnumString(MemoryHeapFlagBits e)
{
	switch (e) {
	case MemoryHeapFlagBits::eDeviceLocal: return "MemoryHeapFlagBits::eDeviceLocal";
	default: return "<invalid enum>";
	}
}


using MemoryHeapFlags = Flags<MemoryHeapFlagBits, VkMemoryHeapFlags>;

inline MemoryHeapFlags operator|(MemoryHeapFlagBits bit0, MemoryHeapFlagBits bit1)
{
	return MemoryHeapFlags(bit0) | bit1;
}


enum class AccessFlagBits {
	eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
	eIndexRead = VK_ACCESS_INDEX_READ_BIT,
	eVertexAttributeRead = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT,
	eUniformRead = VK_ACCESS_UNIFORM_READ_BIT,
	eInputAttachmentRead = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
	eShaderRead = VK_ACCESS_SHADER_READ_BIT,
	eShaderWrite = VK_ACCESS_SHADER_WRITE_BIT,
	eColorAttachmentRead = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT,
	eColorAttachmentWrite = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
	eDepthStencilAttachmentRead = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT,
	eDepthStencilAttachmentWrite = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
	eTransferRead = VK_ACCESS_TRANSFER_READ_BIT,
	eTransferWrite = VK_ACCESS_TRANSFER_WRITE_BIT,
	eHostRead = VK_ACCESS_HOST_READ_BIT,
	eHostWrite = VK_ACCESS_HOST_WRITE_BIT,
	eMemoryRead = VK_ACCESS_MEMORY_READ_BIT,
	eMemoryWrite = VK_ACCESS_MEMORY_WRITE_BIT,
};

inline const char *getEnumString(AccessFlagBits e)
{
	switch (e) {
	case AccessFlagBits::eIndirectCommandRead: return "AccessFlagBits::eIndirectCommandRead";
	case AccessFlagBits::eIndexRead: return "AccessFlagBits::eIndexRead";
	case AccessFlagBits::eVertexAttributeRead: return "AccessFlagBits::eVertexAttributeRead";
	case AccessFlagBits::eUniformRead: return "AccessFlagBits::eUniformRead";
	case AccessFlagBits::eInputAttachmentRead: return "AccessFlagBits::eInputAttachmentRead";
	case AccessFlagBits::eShaderRead: return "AccessFlagBits::eShaderRead";
	case AccessFlagBits::eShaderWrite: return "AccessFlagBits::eShaderWrite";
	case AccessFlagBits::eColorAttachmentRead: return "AccessFlagBits::eColorAttachmentRead";
	case AccessFlagBits::eColorAttachmentWrite: return "AccessFlagBits::eColorAttachmentWrite";
	case AccessFlagBits::eDepthStencilAttachmentRead: return "AccessFlagBits::eDepthStencilAttachmentRead";
	case AccessFlagBits::eDepthStencilAttachmentWrite: return "AccessFlagBits::eDepthStencilAttachmentWrite";
	case AccessFlagBits::eTransferRead: return "AccessFlagBits::eTransferRead";
	case AccessFlagBits::eTransferWrite: return "AccessFlagBits::eTransferWrite";
	case AccessFlagBits::eHostRead: return "AccessFlagBits::eHostRead";
	case AccessFlagBits::eHostWrite: return "AccessFlagBits::eHostWrite";
	case AccessFlagBits::eMemoryRead: return "AccessFlagBits::eMemoryRead";
	case AccessFlagBits::eMemoryWrite: return "AccessFlagBits::eMemoryWrite";
	default: return "<invalid enum>";
	}
}


using AccessFlags = Flags<AccessFlagBits, VkAccessFlags>;

inline AccessFlags operator|(AccessFlagBits bit0, AccessFlagBits bit1)
{
	return AccessFlags(bit0) | bit1;
}


enum class BufferUsageFlagBits {
	eTransferSrc = VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
	eTransferDst = VK_BUFFER_USAGE_TRANSFER_DST_BIT,
	eUniformTexelBuffer = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT,
	eStorageTexelBuffer = VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT,
	eUniformBuffer = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
	eStorageBuffer = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
	eIndexBuffer = VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
	eVertexBuffer = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
	eIndirectBuffer = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT,
};

inline const char *getEnumString(BufferUsageFlagBits e)
{
	switch (e) {
	case BufferUsageFlagBits::eTransferSrc: return "BufferUsageFlagBits::eTransferSrc";
	case BufferUsageFlagBits::eTransferDst: return "BufferUsageFlagBits::eTransferDst";
	case BufferUsageFlagBits::eUniformTexelBuffer: return "BufferUsageFlagBits::eUniformTexelBuffer";
	case BufferUsageFlagBits::eStorageTexelBuffer: return "BufferUsageFlagBits::eStorageTexelBuffer";
	case BufferUsageFlagBits::eUniformBuffer: return "BufferUsageFlagBits::eUniformBuffer";
	case BufferUsageFlagBits::eStorageBuffer: return "BufferUsageFlagBits::eStorageBuffer";
	case BufferUsageFlagBits::eIndexBuffer: return "BufferUsageFlagBits::eIndexBuffer";
	case BufferUsageFlagBits::eVertexBuffer: return "BufferUsageFlagBits::eVertexBuffer";
	case BufferUsageFlagBits::eIndirectBuffer: return "BufferUsageFlagBits::eIndirectBuffer";
	default: return "<invalid enum>";
	}
}


using BufferUsageFlags = Flags<BufferUsageFlagBits, VkBufferUsageFlags>;

inline BufferUsageFlags operator|(BufferUsageFlagBits bit0, BufferUsageFlagBits bit1)
{
	return BufferUsageFlags(bit0) | bit1;
}


enum class BufferCreateFlagBits {
	eSparseBinding = VK_BUFFER_CREATE_SPARSE_BINDING_BIT,
	eSparseResidency = VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT,
	eSparseAliased = VK_BUFFER_CREATE_SPARSE_ALIASED_BIT,
};

inline const char *getEnumString(BufferCreateFlagBits e)
{
	switch (e) {
	case BufferCreateFlagBits::eSparseBinding: return "BufferCreateFlagBits::eSparseBinding";
	case BufferCreateFlagBits::eSparseResidency: return "BufferCreateFlagBits::eSparseResidency";
	case BufferCreateFlagBits::eSparseAliased: return "BufferCreateFlagBits::eSparseAliased";
	default: return "<invalid enum>";
	}
}


using BufferCreateFlags = Flags<BufferCreateFlagBits, VkBufferCreateFlags>;

inline BufferCreateFlags operator|(BufferCreateFlagBits bit0, BufferCreateFlagBits bit1)
{
	return BufferCreateFlags(bit0) | bit1;
}


enum class ShaderStageFlagBits {
	eVertex = VK_SHADER_STAGE_VERTEX_BIT,
	eTessellationControl = VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT,
	eTessellationEvaluation = VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT,
	eGeometry = VK_SHADER_STAGE_GEOMETRY_BIT,
	eFragment = VK_SHADER_STAGE_FRAGMENT_BIT,
	eCompute = VK_SHADER_STAGE_COMPUTE_BIT,
	eAllGraphics = VK_SHADER_STAGE_ALL_GRAPHICS,
	eAll = VK_SHADER_STAGE_ALL,
};

inline const char *getEnumString(ShaderStageFlagBits e)
{
	switch (e) {
	case ShaderStageFlagBits::eVertex: return "ShaderStageFlagBits::eVertex";
	case ShaderStageFlagBits::eTessellationControl: return "ShaderStageFlagBits::eTessellationControl";
	case ShaderStageFlagBits::eTessellationEvaluation: return "ShaderStageFlagBits::eTessellationEvaluation";
	case ShaderStageFlagBits::eGeometry: return "ShaderStageFlagBits::eGeometry";
	case ShaderStageFlagBits::eFragment: return "ShaderStageFlagBits::eFragment";
	case ShaderStageFlagBits::eCompute: return "ShaderStageFlagBits::eCompute";
	case ShaderStageFlagBits::eAllGraphics: return "ShaderStageFlagBits::eAllGraphics";
	case ShaderStageFlagBits::eAll: return "ShaderStageFlagBits::eAll";
	default: return "<invalid enum>";
	}
}


using ShaderStageFlags = Flags<ShaderStageFlagBits, VkShaderStageFlags>;

inline ShaderStageFlags operator|(ShaderStageFlagBits bit0, ShaderStageFlagBits bit1)
{
	return ShaderStageFlags(bit0) | bit1;
}


enum class ImageUsageFlagBits {
	eTransferSrc = VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
	eTransferDst = VK_IMAGE_USAGE_TRANSFER_DST_BIT,
	eSampled = VK_IMAGE_USAGE_SAMPLED_BIT,
	eStorage = VK_IMAGE_USAGE_STORAGE_BIT,
	eColorAttachment = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
	eDepthStencilAttachment = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
	eTransientAttachment = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
	eInputAttachment = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT,
};

inline const char *getEnumString(ImageUsageFlagBits e)
{
	switch (e) {
	case ImageUsageFlagBits::eTransferSrc: return "ImageUsageFlagBits::eTransferSrc";
	case ImageUsageFlagBits::eTransferDst: return "ImageUsageFlagBits::eTransferDst";
	case ImageUsageFlagBits::eSampled: return "ImageUsageFlagBits::eSampled";
	case ImageUsageFlagBits::eStorage: return "ImageUsageFlagBits::eStorage";
	case ImageUsageFlagBits::eColorAttachment: return "ImageUsageFlagBits::eColorAttachment";
	case ImageUsageFlagBits::eDepthStencilAttachment: return "ImageUsageFlagBits::eDepthStencilAttachment";
	case ImageUsageFlagBits::eTransientAttachment: return "ImageUsageFlagBits::eTransientAttachment";
	case ImageUsageFlagBits::eInputAttachment: return "ImageUsageFlagBits::eInputAttachment";
	default: return "<invalid enum>";
	}
}


using ImageUsageFlags = Flags<ImageUsageFlagBits, VkImageUsageFlags>;

inline ImageUsageFlags operator|(ImageUsageFlagBits bit0, ImageUsageFlagBits bit1)
{
	return ImageUsageFlags(bit0) | bit1;
}


enum class ImageCreateFlagBits {
	eSparseBinding = VK_IMAGE_CREATE_SPARSE_BINDING_BIT,
	eSparseResidency = VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT,
	eSparseAliased = VK_IMAGE_CREATE_SPARSE_ALIASED_BIT,
	eMutableFormat = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT,
	eCubeCompatible = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT,
};

inline const char *getEnumString(ImageCreateFlagBits e)
{
	switch (e) {
	case ImageCreateFlagBits::eSparseBinding: return "ImageCreateFlagBits::eSparseBinding";
	case ImageCreateFlagBits::eSparseResidency: return "ImageCreateFlagBits::eSparseResidency";
	case ImageCreateFlagBits::eSparseAliased: return "ImageCreateFlagBits::eSparseAliased";
	case ImageCreateFlagBits::eMutableFormat: return "ImageCreateFlagBits::eMutableFormat";
	case ImageCreateFlagBits::eCubeCompatible: return "ImageCreateFlagBits::eCubeCompatible";
	default: return "<invalid enum>";
	}
}


using ImageCreateFlags = Flags<ImageCreateFlagBits, VkImageCreateFlags>;

inline ImageCreateFlags operator|(ImageCreateFlagBits bit0, ImageCreateFlagBits bit1)
{
	return ImageCreateFlags(bit0) | bit1;
}


enum class ImageViewCreateFlagBits {
};

inline const char *getEnumString(ImageViewCreateFlagBits e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using ImageViewCreateFlags = Flags<ImageViewCreateFlagBits, VkImageViewCreateFlags>;

inline ImageViewCreateFlags operator|(ImageViewCreateFlagBits bit0, ImageViewCreateFlagBits bit1)
{
	return ImageViewCreateFlags(bit0) | bit1;
}


enum class PipelineCreateFlagBits {
	eDisableOptimization = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT,
	eAllowDerivatives = VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT,
	eDerivative = VK_PIPELINE_CREATE_DERIVATIVE_BIT,
};

inline const char *getEnumString(PipelineCreateFlagBits e)
{
	switch (e) {
	case PipelineCreateFlagBits::eDisableOptimization: return "PipelineCreateFlagBits::eDisableOptimization";
	case PipelineCreateFlagBits::eAllowDerivatives: return "PipelineCreateFlagBits::eAllowDerivatives";
	case PipelineCreateFlagBits::eDerivative: return "PipelineCreateFlagBits::eDerivative";
	default: return "<invalid enum>";
	}
}


using PipelineCreateFlags = Flags<PipelineCreateFlagBits, VkPipelineCreateFlags>;

inline PipelineCreateFlags operator|(PipelineCreateFlagBits bit0, PipelineCreateFlagBits bit1)
{
	return PipelineCreateFlags(bit0) | bit1;
}


enum class ColorComponentFlagBits {
	eR = VK_COLOR_COMPONENT_R_BIT,
	eG = VK_COLOR_COMPONENT_G_BIT,
	eB = VK_COLOR_COMPONENT_B_BIT,
	eA = VK_COLOR_COMPONENT_A_BIT,
};

inline const char *getEnumString(ColorComponentFlagBits e)
{
	switch (e) {
	case ColorComponentFlagBits::eR: return "ColorComponentFlagBits::eR";
	case ColorComponentFlagBits::eG: return "ColorComponentFlagBits::eG";
	case ColorComponentFlagBits::eB: return "ColorComponentFlagBits::eB";
	case ColorComponentFlagBits::eA: return "ColorComponentFlagBits::eA";
	default: return "<invalid enum>";
	}
}


using ColorComponentFlags = Flags<ColorComponentFlagBits, VkColorComponentFlags>;

inline ColorComponentFlags operator|(ColorComponentFlagBits bit0, ColorComponentFlagBits bit1)
{
	return ColorComponentFlags(bit0) | bit1;
}


enum class FenceCreateFlagBits {
	eSignaled = VK_FENCE_CREATE_SIGNALED_BIT,
};

inline const char *getEnumString(FenceCreateFlagBits e)
{
	switch (e) {
	case FenceCreateFlagBits::eSignaled: return "FenceCreateFlagBits::eSignaled";
	default: return "<invalid enum>";
	}
}


using FenceCreateFlags = Flags<FenceCreateFlagBits, VkFenceCreateFlags>;

inline FenceCreateFlags operator|(FenceCreateFlagBits bit0, FenceCreateFlagBits bit1)
{
	return FenceCreateFlags(bit0) | bit1;
}


enum class SemaphoreCreateFlagBits {
};

inline const char *getEnumString(SemaphoreCreateFlagBits e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using SemaphoreCreateFlags = Flags<SemaphoreCreateFlagBits, VkSemaphoreCreateFlags>;

inline SemaphoreCreateFlags operator|(SemaphoreCreateFlagBits bit0, SemaphoreCreateFlagBits bit1)
{
	return SemaphoreCreateFlags(bit0) | bit1;
}


enum class FormatFeatureFlagBits {
	eSampledImage = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT,
	eStorageImage = VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT,
	eStorageImageAtomic = VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT,
	eUniformTexelBuffer = VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT,
	eStorageTexelBuffer = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT,
	eStorageTexelBufferAtomic = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT,
	eVertexBuffer = VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT,
	eColorAttachment = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT,
	eColorAttachmentBlend = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT,
	eDepthStencilAttachment = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT,
	eBlitSrc = VK_FORMAT_FEATURE_BLIT_SRC_BIT,
	eBlitDst = VK_FORMAT_FEATURE_BLIT_DST_BIT,
	eSampledImageFilterLinear = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT,
};

inline const char *getEnumString(FormatFeatureFlagBits e)
{
	switch (e) {
	case FormatFeatureFlagBits::eSampledImage: return "FormatFeatureFlagBits::eSampledImage";
	case FormatFeatureFlagBits::eStorageImage: return "FormatFeatureFlagBits::eStorageImage";
	case FormatFeatureFlagBits::eStorageImageAtomic: return "FormatFeatureFlagBits::eStorageImageAtomic";
	case FormatFeatureFlagBits::eUniformTexelBuffer: return "FormatFeatureFlagBits::eUniformTexelBuffer";
	case FormatFeatureFlagBits::eStorageTexelBuffer: return "FormatFeatureFlagBits::eStorageTexelBuffer";
	case FormatFeatureFlagBits::eStorageTexelBufferAtomic: return "FormatFeatureFlagBits::eStorageTexelBufferAtomic";
	case FormatFeatureFlagBits::eVertexBuffer: return "FormatFeatureFlagBits::eVertexBuffer";
	case FormatFeatureFlagBits::eColorAttachment: return "FormatFeatureFlagBits::eColorAttachment";
	case FormatFeatureFlagBits::eColorAttachmentBlend: return "FormatFeatureFlagBits::eColorAttachmentBlend";
	case FormatFeatureFlagBits::eDepthStencilAttachment: return "FormatFeatureFlagBits::eDepthStencilAttachment";
	case FormatFeatureFlagBits::eBlitSrc: return "FormatFeatureFlagBits::eBlitSrc";
	case FormatFeatureFlagBits::eBlitDst: return "FormatFeatureFlagBits::eBlitDst";
	case FormatFeatureFlagBits::eSampledImageFilterLinear: return "FormatFeatureFlagBits::eSampledImageFilterLinear";
	default: return "<invalid enum>";
	}
}


using FormatFeatureFlags = Flags<FormatFeatureFlagBits, VkFormatFeatureFlags>;

inline FormatFeatureFlags operator|(FormatFeatureFlagBits bit0, FormatFeatureFlagBits bit1)
{
	return FormatFeatureFlags(bit0) | bit1;
}


enum class QueryControlFlagBits {
	ePrecise = VK_QUERY_CONTROL_PRECISE_BIT,
};

inline const char *getEnumString(QueryControlFlagBits e)
{
	switch (e) {
	case QueryControlFlagBits::ePrecise: return "QueryControlFlagBits::ePrecise";
	default: return "<invalid enum>";
	}
}


using QueryControlFlags = Flags<QueryControlFlagBits, VkQueryControlFlags>;

inline QueryControlFlags operator|(QueryControlFlagBits bit0, QueryControlFlagBits bit1)
{
	return QueryControlFlags(bit0) | bit1;
}


enum class QueryResultFlagBits {
	e64 = VK_QUERY_RESULT_64_BIT,
	eWait = VK_QUERY_RESULT_WAIT_BIT,
	eWithAvailability = VK_QUERY_RESULT_WITH_AVAILABILITY_BIT,
	ePartial = VK_QUERY_RESULT_PARTIAL_BIT,
};

inline const char *getEnumString(QueryResultFlagBits e)
{
	switch (e) {
	case QueryResultFlagBits::e64: return "QueryResultFlagBits::e64";
	case QueryResultFlagBits::eWait: return "QueryResultFlagBits::eWait";
	case QueryResultFlagBits::eWithAvailability: return "QueryResultFlagBits::eWithAvailability";
	case QueryResultFlagBits::ePartial: return "QueryResultFlagBits::ePartial";
	default: return "<invalid enum>";
	}
}


using QueryResultFlags = Flags<QueryResultFlagBits, VkQueryResultFlags>;

inline QueryResultFlags operator|(QueryResultFlagBits bit0, QueryResultFlagBits bit1)
{
	return QueryResultFlags(bit0) | bit1;
}


enum class ShaderModuleCreateFlagBits {
};

inline const char *getEnumString(ShaderModuleCreateFlagBits e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using ShaderModuleCreateFlags = Flags<ShaderModuleCreateFlagBits, VkShaderModuleCreateFlags>;

inline ShaderModuleCreateFlags operator|(ShaderModuleCreateFlagBits bit0, ShaderModuleCreateFlagBits bit1)
{
	return ShaderModuleCreateFlags(bit0) | bit1;
}


enum class EventCreateFlagBits {
};

inline const char *getEnumString(EventCreateFlagBits e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using EventCreateFlags = Flags<EventCreateFlagBits, VkEventCreateFlags>;

inline EventCreateFlags operator|(EventCreateFlagBits bit0, EventCreateFlagBits bit1)
{
	return EventCreateFlags(bit0) | bit1;
}


enum class CommandPoolCreateFlagBits {
	eTransient = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,
	eResetCommandBuffer = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
};

inline const char *getEnumString(CommandPoolCreateFlagBits e)
{
	switch (e) {
	case CommandPoolCreateFlagBits::eTransient: return "CommandPoolCreateFlagBits::eTransient";
	case CommandPoolCreateFlagBits::eResetCommandBuffer: return "CommandPoolCreateFlagBits::eResetCommandBuffer";
	default: return "<invalid enum>";
	}
}


using CommandPoolCreateFlags = Flags<CommandPoolCreateFlagBits, VkCommandPoolCreateFlags>;

inline CommandPoolCreateFlags operator|(CommandPoolCreateFlagBits bit0, CommandPoolCreateFlagBits bit1)
{
	return CommandPoolCreateFlags(bit0) | bit1;
}


enum class CommandPoolResetFlagBits {
	eReleaseResources = VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT,
};

inline const char *getEnumString(CommandPoolResetFlagBits e)
{
	switch (e) {
	case CommandPoolResetFlagBits::eReleaseResources: return "CommandPoolResetFlagBits::eReleaseResources";
	default: return "<invalid enum>";
	}
}


using CommandPoolResetFlags = Flags<CommandPoolResetFlagBits, VkCommandPoolResetFlags>;

inline CommandPoolResetFlags operator|(CommandPoolResetFlagBits bit0, CommandPoolResetFlagBits bit1)
{
	return CommandPoolResetFlags(bit0) | bit1;
}


enum class CommandBufferResetFlagBits {
	eReleaseResources = VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT,
};

inline const char *getEnumString(CommandBufferResetFlagBits e)
{
	switch (e) {
	case CommandBufferResetFlagBits::eReleaseResources: return "CommandBufferResetFlagBits::eReleaseResources";
	default: return "<invalid enum>";
	}
}


using CommandBufferResetFlags = Flags<CommandBufferResetFlagBits, VkCommandBufferResetFlags>;

inline CommandBufferResetFlags operator|(CommandBufferResetFlagBits bit0, CommandBufferResetFlagBits bit1)
{
	return CommandBufferResetFlags(bit0) | bit1;
}


enum class CommandBufferUsageFlagBits {
	eOneTimeSubmit = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
	eRenderPassContinue = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT,
	eSimultaneousUse = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
};

inline const char *getEnumString(CommandBufferUsageFlagBits e)
{
	switch (e) {
	case CommandBufferUsageFlagBits::eOneTimeSubmit: return "CommandBufferUsageFlagBits::eOneTimeSubmit";
	case CommandBufferUsageFlagBits::eRenderPassContinue: return "CommandBufferUsageFlagBits::eRenderPassContinue";
	case CommandBufferUsageFlagBits::eSimultaneousUse: return "CommandBufferUsageFlagBits::eSimultaneousUse";
	default: return "<invalid enum>";
	}
}


using CommandBufferUsageFlags = Flags<CommandBufferUsageFlagBits, VkCommandBufferUsageFlags>;

inline CommandBufferUsageFlags operator|(CommandBufferUsageFlagBits bit0, CommandBufferUsageFlagBits bit1)
{
	return CommandBufferUsageFlags(bit0) | bit1;
}


enum class QueryPipelineStatisticFlagBits {
	eInputAssemblyVertices = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT,
	eInputAssemblyPrimitives = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT,
	eVertexShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT,
	eGeometryShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT,
	eGeometryShaderPrimitives = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT,
	eClippingInvocations = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT,
	eClippingPrimitives = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT,
	eFragmentShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT,
	eTessellationControlShaderPatches = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT,
	eTessellationEvaluationShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT,
	eComputeShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT,
};

inline const char *getEnumString(QueryPipelineStatisticFlagBits e)
{
	switch (e) {
	case QueryPipelineStatisticFlagBits::eInputAssemblyVertices: return "QueryPipelineStatisticFlagBits::eInputAssemblyVertices";
	case QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives: return "QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives";
	case QueryPipelineStatisticFlagBits::eVertexShaderInvocations: return "QueryPipelineStatisticFlagBits::eVertexShaderInvocations";
	case QueryPipelineStatisticFlagBits::eGeometryShaderInvocations: return "QueryPipelineStatisticFlagBits::eGeometryShaderInvocations";
	case QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives: return "QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives";
	case QueryPipelineStatisticFlagBits::eClippingInvocations: return "QueryPipelineStatisticFlagBits::eClippingInvocations";
	case QueryPipelineStatisticFlagBits::eClippingPrimitives: return "QueryPipelineStatisticFlagBits::eClippingPrimitives";
	case QueryPipelineStatisticFlagBits::eFragmentShaderInvocations: return "QueryPipelineStatisticFlagBits::eFragmentShaderInvocations";
	case QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches: return "QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches";
	case QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations: return "QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations";
	case QueryPipelineStatisticFlagBits::eComputeShaderInvocations: return "QueryPipelineStatisticFlagBits::eComputeShaderInvocations";
	default: return "<invalid enum>";
	}
}


using QueryPipelineStatisticFlags = Flags<QueryPipelineStatisticFlagBits, VkQueryPipelineStatisticFlags>;

inline QueryPipelineStatisticFlags operator|(QueryPipelineStatisticFlagBits bit0, QueryPipelineStatisticFlagBits bit1)
{
	return QueryPipelineStatisticFlags(bit0) | bit1;
}


enum class MemoryMapFlagBits {
};

inline const char *getEnumString(MemoryMapFlagBits e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using MemoryMapFlags = Flags<MemoryMapFlagBits, VkMemoryMapFlags>;

inline MemoryMapFlags operator|(MemoryMapFlagBits bit0, MemoryMapFlagBits bit1)
{
	return MemoryMapFlags(bit0) | bit1;
}


enum class ImageAspectFlagBits {
	eColor = VK_IMAGE_ASPECT_COLOR_BIT,
	eDepth = VK_IMAGE_ASPECT_DEPTH_BIT,
	eStencil = VK_IMAGE_ASPECT_STENCIL_BIT,
	eMetadata = VK_IMAGE_ASPECT_METADATA_BIT,
};

inline const char *getEnumString(ImageAspectFlagBits e)
{
	switch (e) {
	case ImageAspectFlagBits::eColor: return "ImageAspectFlagBits::eColor";
	case ImageAspectFlagBits::eDepth: return "ImageAspectFlagBits::eDepth";
	case ImageAspectFlagBits::eStencil: return "ImageAspectFlagBits::eStencil";
	case ImageAspectFlagBits::eMetadata: return "ImageAspectFlagBits::eMetadata";
	default: return "<invalid enum>";
	}
}


using ImageAspectFlags = Flags<ImageAspectFlagBits, VkImageAspectFlags>;

inline ImageAspectFlags operator|(ImageAspectFlagBits bit0, ImageAspectFlagBits bit1)
{
	return ImageAspectFlags(bit0) | bit1;
}


enum class SparseMemoryBindFlagBits {
	eMetadata = VK_SPARSE_MEMORY_BIND_METADATA_BIT,
};

inline const char *getEnumString(SparseMemoryBindFlagBits e)
{
	switch (e) {
	case SparseMemoryBindFlagBits::eMetadata: return "SparseMemoryBindFlagBits::eMetadata";
	default: return "<invalid enum>";
	}
}


using SparseMemoryBindFlags = Flags<SparseMemoryBindFlagBits, VkSparseMemoryBindFlags>;

inline SparseMemoryBindFlags operator|(SparseMemoryBindFlagBits bit0, SparseMemoryBindFlagBits bit1)
{
	return SparseMemoryBindFlags(bit0) | bit1;
}


enum class SparseImageFormatFlagBits {
	eSingleMiptail = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT,
	eAlignedMipSize = VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT,
	eNonstandardBlockSize = VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT,
};

inline const char *getEnumString(SparseImageFormatFlagBits e)
{
	switch (e) {
	case SparseImageFormatFlagBits::eSingleMiptail: return "SparseImageFormatFlagBits::eSingleMiptail";
	case SparseImageFormatFlagBits::eAlignedMipSize: return "SparseImageFormatFlagBits::eAlignedMipSize";
	case SparseImageFormatFlagBits::eNonstandardBlockSize: return "SparseImageFormatFlagBits::eNonstandardBlockSize";
	default: return "<invalid enum>";
	}
}


using SparseImageFormatFlags = Flags<SparseImageFormatFlagBits, VkSparseImageFormatFlags>;

inline SparseImageFormatFlags operator|(SparseImageFormatFlagBits bit0, SparseImageFormatFlagBits bit1)
{
	return SparseImageFormatFlags(bit0) | bit1;
}


enum class SubpassDescriptionFlagBits {
};

inline const char *getEnumString(SubpassDescriptionFlagBits e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using SubpassDescriptionFlags = Flags<SubpassDescriptionFlagBits, VkSubpassDescriptionFlags>;

inline SubpassDescriptionFlags operator|(SubpassDescriptionFlagBits bit0, SubpassDescriptionFlagBits bit1)
{
	return SubpassDescriptionFlags(bit0) | bit1;
}


enum class PipelineStageFlagBits {
	eTopOfPipe = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
	eDrawIndirect = VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT,
	eVertexInput = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT,
	eVertexShader = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,
	eTessellationControlShader = VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT,
	eTessellationEvaluationShader = VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT,
	eGeometryShader = VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT,
	eFragmentShader = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
	eEarlyFragmentTests = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
	eLateFragmentTests = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
	eColorAttachmentOutput = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
	eComputeShader = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
	eTransfer = VK_PIPELINE_STAGE_TRANSFER_BIT,
	eBottomOfPipe = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
	eHost = VK_PIPELINE_STAGE_HOST_BIT,
	eAllGraphics = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
	eAllCommands = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
};

inline const char *getEnumString(PipelineStageFlagBits e)
{
	switch (e) {
	case PipelineStageFlagBits::eTopOfPipe: return "PipelineStageFlagBits::eTopOfPipe";
	case PipelineStageFlagBits::eDrawIndirect: return "PipelineStageFlagBits::eDrawIndirect";
	case PipelineStageFlagBits::eVertexInput: return "PipelineStageFlagBits::eVertexInput";
	case PipelineStageFlagBits::eVertexShader: return "PipelineStageFlagBits::eVertexShader";
	case PipelineStageFlagBits::eTessellationControlShader: return "PipelineStageFlagBits::eTessellationControlShader";
	case PipelineStageFlagBits::eTessellationEvaluationShader: return "PipelineStageFlagBits::eTessellationEvaluationShader";
	case PipelineStageFlagBits::eGeometryShader: return "PipelineStageFlagBits::eGeometryShader";
	case PipelineStageFlagBits::eFragmentShader: return "PipelineStageFlagBits::eFragmentShader";
	case PipelineStageFlagBits::eEarlyFragmentTests: return "PipelineStageFlagBits::eEarlyFragmentTests";
	case PipelineStageFlagBits::eLateFragmentTests: return "PipelineStageFlagBits::eLateFragmentTests";
	case PipelineStageFlagBits::eColorAttachmentOutput: return "PipelineStageFlagBits::eColorAttachmentOutput";
	case PipelineStageFlagBits::eComputeShader: return "PipelineStageFlagBits::eComputeShader";
	case PipelineStageFlagBits::eTransfer: return "PipelineStageFlagBits::eTransfer";
	case PipelineStageFlagBits::eBottomOfPipe: return "PipelineStageFlagBits::eBottomOfPipe";
	case PipelineStageFlagBits::eHost: return "PipelineStageFlagBits::eHost";
	case PipelineStageFlagBits::eAllGraphics: return "PipelineStageFlagBits::eAllGraphics";
	case PipelineStageFlagBits::eAllCommands: return "PipelineStageFlagBits::eAllCommands";
	default: return "<invalid enum>";
	}
}


using PipelineStageFlags = Flags<PipelineStageFlagBits, VkPipelineStageFlags>;

inline PipelineStageFlags operator|(PipelineStageFlagBits bit0, PipelineStageFlagBits bit1)
{
	return PipelineStageFlags(bit0) | bit1;
}


enum class SampleCountFlagBits {
	e1 = VK_SAMPLE_COUNT_1_BIT,
	e2 = VK_SAMPLE_COUNT_2_BIT,
	e4 = VK_SAMPLE_COUNT_4_BIT,
	e8 = VK_SAMPLE_COUNT_8_BIT,
	e16 = VK_SAMPLE_COUNT_16_BIT,
	e32 = VK_SAMPLE_COUNT_32_BIT,
	e64 = VK_SAMPLE_COUNT_64_BIT,
};

inline const char *getEnumString(SampleCountFlagBits e)
{
	switch (e) {
	case SampleCountFlagBits::e1: return "SampleCountFlagBits::e1";
	case SampleCountFlagBits::e2: return "SampleCountFlagBits::e2";
	case SampleCountFlagBits::e4: return "SampleCountFlagBits::e4";
	case SampleCountFlagBits::e8: return "SampleCountFlagBits::e8";
	case SampleCountFlagBits::e16: return "SampleCountFlagBits::e16";
	case SampleCountFlagBits::e32: return "SampleCountFlagBits::e32";
	case SampleCountFlagBits::e64: return "SampleCountFlagBits::e64";
	default: return "<invalid enum>";
	}
}


using SampleCountFlags = Flags<SampleCountFlagBits, VkSampleCountFlags>;

inline SampleCountFlags operator|(SampleCountFlagBits bit0, SampleCountFlagBits bit1)
{
	return SampleCountFlags(bit0) | bit1;
}


enum class AttachmentDescriptionFlagBits {
	eMayAlias = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT,
};

inline const char *getEnumString(AttachmentDescriptionFlagBits e)
{
	switch (e) {
	case AttachmentDescriptionFlagBits::eMayAlias: return "AttachmentDescriptionFlagBits::eMayAlias";
	default: return "<invalid enum>";
	}
}


using AttachmentDescriptionFlags = Flags<AttachmentDescriptionFlagBits, VkAttachmentDescriptionFlags>;

inline AttachmentDescriptionFlags operator|(AttachmentDescriptionFlagBits bit0, AttachmentDescriptionFlagBits bit1)
{
	return AttachmentDescriptionFlags(bit0) | bit1;
}


enum class StencilFaceFlagBits {
	eFront = VK_STENCIL_FACE_FRONT_BIT,
	eBack = VK_STENCIL_FACE_BACK_BIT,
	eVkStencilFrontAndBack = VK_STENCIL_FRONT_AND_BACK,
};

inline const char *getEnumString(StencilFaceFlagBits e)
{
	switch (e) {
	case StencilFaceFlagBits::eFront: return "StencilFaceFlagBits::eFront";
	case StencilFaceFlagBits::eBack: return "StencilFaceFlagBits::eBack";
	case StencilFaceFlagBits::eVkStencilFrontAndBack: return "StencilFaceFlagBits::eVkStencilFrontAndBack";
	default: return "<invalid enum>";
	}
}


using StencilFaceFlags = Flags<StencilFaceFlagBits, VkStencilFaceFlags>;

inline StencilFaceFlags operator|(StencilFaceFlagBits bit0, StencilFaceFlagBits bit1)
{
	return StencilFaceFlags(bit0) | bit1;
}


enum class CullModeFlagBits {
	eNone = VK_CULL_MODE_NONE,
	eFront = VK_CULL_MODE_FRONT_BIT,
	eBack = VK_CULL_MODE_BACK_BIT,
	eFrontAndBack = VK_CULL_MODE_FRONT_AND_BACK,
};

inline const char *getEnumString(CullModeFlagBits e)
{
	switch (e) {
	case CullModeFlagBits::eNone: return "CullModeFlagBits::eNone";
	case CullModeFlagBits::eFront: return "CullModeFlagBits::eFront";
	case CullModeFlagBits::eBack: return "CullModeFlagBits::eBack";
	case CullModeFlagBits::eFrontAndBack: return "CullModeFlagBits::eFrontAndBack";
	default: return "<invalid enum>";
	}
}


using CullModeFlags = Flags<CullModeFlagBits, VkCullModeFlags>;

inline CullModeFlags operator|(CullModeFlagBits bit0, CullModeFlagBits bit1)
{
	return CullModeFlags(bit0) | bit1;
}


enum class DescriptorPoolCreateFlagBits {
	eFreeDescriptorSet = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
};

inline const char *getEnumString(DescriptorPoolCreateFlagBits e)
{
	switch (e) {
	case DescriptorPoolCreateFlagBits::eFreeDescriptorSet: return "DescriptorPoolCreateFlagBits::eFreeDescriptorSet";
	default: return "<invalid enum>";
	}
}


using DescriptorPoolCreateFlags = Flags<DescriptorPoolCreateFlagBits, VkDescriptorPoolCreateFlags>;

inline DescriptorPoolCreateFlags operator|(DescriptorPoolCreateFlagBits bit0, DescriptorPoolCreateFlagBits bit1)
{
	return DescriptorPoolCreateFlags(bit0) | bit1;
}


enum class DescriptorPoolResetFlagBits {
};

inline const char *getEnumString(DescriptorPoolResetFlagBits e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using DescriptorPoolResetFlags = Flags<DescriptorPoolResetFlagBits, VkDescriptorPoolResetFlags>;

inline DescriptorPoolResetFlags operator|(DescriptorPoolResetFlagBits bit0, DescriptorPoolResetFlagBits bit1)
{
	return DescriptorPoolResetFlags(bit0) | bit1;
}


enum class DependencyFlagBits {
	eByRegion = VK_DEPENDENCY_BY_REGION_BIT,
};

inline const char *getEnumString(DependencyFlagBits e)
{
	switch (e) {
	case DependencyFlagBits::eByRegion: return "DependencyFlagBits::eByRegion";
	default: return "<invalid enum>";
	}
}


using DependencyFlags = Flags<DependencyFlagBits, VkDependencyFlags>;

inline DependencyFlags operator|(DependencyFlagBits bit0, DependencyFlagBits bit1)
{
	return DependencyFlags(bit0) | bit1;
}


enum class CompositeAlphaFlagBitsKHR {
	eOpaque = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
	ePreMultiplied = VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR,
	ePostMultiplied = VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR,
	eInherit = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR,
};

inline const char *getEnumString(CompositeAlphaFlagBitsKHR e)
{
	switch (e) {
	case CompositeAlphaFlagBitsKHR::eOpaque: return "CompositeAlphaFlagBitsKHR::eOpaque";
	case CompositeAlphaFlagBitsKHR::ePreMultiplied: return "CompositeAlphaFlagBitsKHR::ePreMultiplied";
	case CompositeAlphaFlagBitsKHR::ePostMultiplied: return "CompositeAlphaFlagBitsKHR::ePostMultiplied";
	case CompositeAlphaFlagBitsKHR::eInherit: return "CompositeAlphaFlagBitsKHR::eInherit";
	default: return "<invalid enum>";
	}
}


using CompositeAlphaFlagsKHR = Flags<CompositeAlphaFlagBitsKHR, VkCompositeAlphaFlagsKHR>;

inline CompositeAlphaFlagsKHR operator|(CompositeAlphaFlagBitsKHR bit0, CompositeAlphaFlagBitsKHR bit1)
{
	return CompositeAlphaFlagsKHR(bit0) | bit1;
}


enum class DisplayPlaneAlphaFlagBitsKHR {
	eOpaque = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR,
	eGlobal = VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR,
	ePerPixel = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR,
	ePerPixelPremultiplied = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR,
};

inline const char *getEnumString(DisplayPlaneAlphaFlagBitsKHR e)
{
	switch (e) {
	case DisplayPlaneAlphaFlagBitsKHR::eOpaque: return "DisplayPlaneAlphaFlagBitsKHR::eOpaque";
	case DisplayPlaneAlphaFlagBitsKHR::eGlobal: return "DisplayPlaneAlphaFlagBitsKHR::eGlobal";
	case DisplayPlaneAlphaFlagBitsKHR::ePerPixel: return "DisplayPlaneAlphaFlagBitsKHR::ePerPixel";
	case DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied: return "DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied";
	default: return "<invalid enum>";
	}
}


using DisplayPlaneAlphaFlagsKHR = Flags<DisplayPlaneAlphaFlagBitsKHR, VkDisplayPlaneAlphaFlagsKHR>;

inline DisplayPlaneAlphaFlagsKHR operator|(DisplayPlaneAlphaFlagBitsKHR bit0, DisplayPlaneAlphaFlagBitsKHR bit1)
{
	return DisplayPlaneAlphaFlagsKHR(bit0) | bit1;
}


enum class SurfaceTransformFlagBitsKHR {
	eIdentity = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR,
	eRotate90 = VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR,
	eRotate180 = VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR,
	eRotate270 = VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR,
	eHorizontalMirror = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR,
	eHorizontalMirrorRotate90 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR,
	eHorizontalMirrorRotate180 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR,
	eHorizontalMirrorRotate270 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR,
	eInherit = VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR,
};

inline const char *getEnumString(SurfaceTransformFlagBitsKHR e)
{
	switch (e) {
	case SurfaceTransformFlagBitsKHR::eIdentity: return "SurfaceTransformFlagBitsKHR::eIdentity";
	case SurfaceTransformFlagBitsKHR::eRotate90: return "SurfaceTransformFlagBitsKHR::eRotate90";
	case SurfaceTransformFlagBitsKHR::eRotate180: return "SurfaceTransformFlagBitsKHR::eRotate180";
	case SurfaceTransformFlagBitsKHR::eRotate270: return "SurfaceTransformFlagBitsKHR::eRotate270";
	case SurfaceTransformFlagBitsKHR::eHorizontalMirror: return "SurfaceTransformFlagBitsKHR::eHorizontalMirror";
	case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90: return "SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90";
	case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180: return "SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180";
	case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270: return "SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270";
	case SurfaceTransformFlagBitsKHR::eInherit: return "SurfaceTransformFlagBitsKHR::eInherit";
	default: return "<invalid enum>";
	}
}


using SurfaceTransformFlagsKHR = Flags<SurfaceTransformFlagBitsKHR, VkSurfaceTransformFlagsKHR>;

inline SurfaceTransformFlagsKHR operator|(SurfaceTransformFlagBitsKHR bit0, SurfaceTransformFlagBitsKHR bit1)
{
	return SurfaceTransformFlagsKHR(bit0) | bit1;
}


enum class SwapchainCreateFlagBitsKHR {
};

inline const char *getEnumString(SwapchainCreateFlagBitsKHR e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using SwapchainCreateFlagsKHR = Flags<SwapchainCreateFlagBitsKHR, VkSwapchainCreateFlagsKHR>;

inline SwapchainCreateFlagsKHR operator|(SwapchainCreateFlagBitsKHR bit0, SwapchainCreateFlagBitsKHR bit1)
{
	return SwapchainCreateFlagsKHR(bit0) | bit1;
}


enum class DisplayModeCreateFlagBitsKHR {
};

inline const char *getEnumString(DisplayModeCreateFlagBitsKHR e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using DisplayModeCreateFlagsKHR = Flags<DisplayModeCreateFlagBitsKHR, VkDisplayModeCreateFlagsKHR>;

inline DisplayModeCreateFlagsKHR operator|(DisplayModeCreateFlagBitsKHR bit0, DisplayModeCreateFlagBitsKHR bit1)
{
	return DisplayModeCreateFlagsKHR(bit0) | bit1;
}


enum class DisplaySurfaceCreateFlagBitsKHR {
};

inline const char *getEnumString(DisplaySurfaceCreateFlagBitsKHR e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using DisplaySurfaceCreateFlagsKHR = Flags<DisplaySurfaceCreateFlagBitsKHR, VkDisplaySurfaceCreateFlagsKHR>;

inline DisplaySurfaceCreateFlagsKHR operator|(DisplaySurfaceCreateFlagBitsKHR bit0, DisplaySurfaceCreateFlagBitsKHR bit1)
{
	return DisplaySurfaceCreateFlagsKHR(bit0) | bit1;
}

#ifdef VK_USE_PLATFORM_ANDROID_KHR

enum class AndroidSurfaceCreateFlagBitsKHR {
};

inline const char *getEnumString(AndroidSurfaceCreateFlagBitsKHR e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using AndroidSurfaceCreateFlagsKHR = Flags<AndroidSurfaceCreateFlagBitsKHR, VkAndroidSurfaceCreateFlagsKHR>;

inline AndroidSurfaceCreateFlagsKHR operator|(AndroidSurfaceCreateFlagBitsKHR bit0, AndroidSurfaceCreateFlagBitsKHR bit1)
{
	return AndroidSurfaceCreateFlagsKHR(bit0) | bit1;
}
#endif

#ifdef VK_USE_PLATFORM_MIR_KHR

enum class MirSurfaceCreateFlagBitsKHR {
};

inline const char *getEnumString(MirSurfaceCreateFlagBitsKHR e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using MirSurfaceCreateFlagsKHR = Flags<MirSurfaceCreateFlagBitsKHR, VkMirSurfaceCreateFlagsKHR>;

inline MirSurfaceCreateFlagsKHR operator|(MirSurfaceCreateFlagBitsKHR bit0, MirSurfaceCreateFlagBitsKHR bit1)
{
	return MirSurfaceCreateFlagsKHR(bit0) | bit1;
}
#endif

#ifdef VK_USE_PLATFORM_WAYLAND_KHR

enum class WaylandSurfaceCreateFlagBitsKHR {
};

inline const char *getEnumString(WaylandSurfaceCreateFlagBitsKHR e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using WaylandSurfaceCreateFlagsKHR = Flags<WaylandSurfaceCreateFlagBitsKHR, VkWaylandSurfaceCreateFlagsKHR>;

inline WaylandSurfaceCreateFlagsKHR operator|(WaylandSurfaceCreateFlagBitsKHR bit0, WaylandSurfaceCreateFlagBitsKHR bit1)
{
	return WaylandSurfaceCreateFlagsKHR(bit0) | bit1;
}
#endif

#ifdef VK_USE_PLATFORM_WIN32_KHR

enum class Win32SurfaceCreateFlagBitsKHR {
};

inline const char *getEnumString(Win32SurfaceCreateFlagBitsKHR e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using Win32SurfaceCreateFlagsKHR = Flags<Win32SurfaceCreateFlagBitsKHR, VkWin32SurfaceCreateFlagsKHR>;

inline Win32SurfaceCreateFlagsKHR operator|(Win32SurfaceCreateFlagBitsKHR bit0, Win32SurfaceCreateFlagBitsKHR bit1)
{
	return Win32SurfaceCreateFlagsKHR(bit0) | bit1;
}
#endif

#ifdef VK_USE_PLATFORM_XLIB_KHR

enum class XlibSurfaceCreateFlagBitsKHR {
};

inline const char *getEnumString(XlibSurfaceCreateFlagBitsKHR e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using XlibSurfaceCreateFlagsKHR = Flags<XlibSurfaceCreateFlagBitsKHR, VkXlibSurfaceCreateFlagsKHR>;

inline XlibSurfaceCreateFlagsKHR operator|(XlibSurfaceCreateFlagBitsKHR bit0, XlibSurfaceCreateFlagBitsKHR bit1)
{
	return XlibSurfaceCreateFlagsKHR(bit0) | bit1;
}
#endif

#ifdef VK_USE_PLATFORM_XCB_KHR

enum class XcbSurfaceCreateFlagBitsKHR {
};

inline const char *getEnumString(XcbSurfaceCreateFlagBitsKHR e)
{
	switch (e) {
	default: return "<invalid enum>";
	}
}


using XcbSurfaceCreateFlagsKHR = Flags<XcbSurfaceCreateFlagBitsKHR, VkXcbSurfaceCreateFlagsKHR>;

inline XcbSurfaceCreateFlagsKHR operator|(XcbSurfaceCreateFlagBitsKHR bit0, XcbSurfaceCreateFlagBitsKHR bit1)
{
	return XcbSurfaceCreateFlagsKHR(bit0) | bit1;
}
#endif


enum class DebugReportFlagBitsEXT {
	eInformation = VK_DEBUG_REPORT_INFORMATION_BIT_EXT,
	eWarning = VK_DEBUG_REPORT_WARNING_BIT_EXT,
	ePerformanceWarning = VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
	eError = VK_DEBUG_REPORT_ERROR_BIT_EXT,
	eDebug = VK_DEBUG_REPORT_DEBUG_BIT_EXT,
};

inline const char *getEnumString(DebugReportFlagBitsEXT e)
{
	switch (e) {
	case DebugReportFlagBitsEXT::eInformation: return "DebugReportFlagBitsEXT::eInformation";
	case DebugReportFlagBitsEXT::eWarning: return "DebugReportFlagBitsEXT::eWarning";
	case DebugReportFlagBitsEXT::ePerformanceWarning: return "DebugReportFlagBitsEXT::ePerformanceWarning";
	case DebugReportFlagBitsEXT::eError: return "DebugReportFlagBitsEXT::eError";
	case DebugReportFlagBitsEXT::eDebug: return "DebugReportFlagBitsEXT::eDebug";
	default: return "<invalid enum>";
	}
}


using DebugReportFlagsEXT = Flags<DebugReportFlagBitsEXT, VkDebugReportFlagsEXT>;

inline DebugReportFlagsEXT operator|(DebugReportFlagBitsEXT bit0, DebugReportFlagBitsEXT bit1)
{
	return DebugReportFlagsEXT(bit0) | bit1;
}



class AllocationCallbacks {
	VkAllocationCallbacks m_struct;
public:
	AllocationCallbacks()
	{
		std::memset(&m_struct, 0, sizeof(VkAllocationCallbacks));
		
	}
	AllocationCallbacks(const VkAllocationCallbacks &r): m_struct(r) {}

	
	const void* pUserData() const
	{
		return m_struct.pUserData;
	}
	AllocationCallbacks &pUserData(void* pUserData)
	{
		m_struct.pUserData = pUserData;
		return *this;
	}
	PFN_vkAllocationFunction pfnAllocation() const
	{
		return m_struct.pfnAllocation;
	}
	AllocationCallbacks &pfnAllocation(PFN_vkAllocationFunction pfnAllocation)
	{
		m_struct.pfnAllocation = pfnAllocation;
		return *this;
	}
	PFN_vkReallocationFunction pfnReallocation() const
	{
		return m_struct.pfnReallocation;
	}
	AllocationCallbacks &pfnReallocation(PFN_vkReallocationFunction pfnReallocation)
	{
		m_struct.pfnReallocation = pfnReallocation;
		return *this;
	}
	PFN_vkFreeFunction pfnFree() const
	{
		return m_struct.pfnFree;
	}
	AllocationCallbacks &pfnFree(PFN_vkFreeFunction pfnFree)
	{
		m_struct.pfnFree = pfnFree;
		return *this;
	}
	PFN_vkInternalAllocationNotification pfnInternalAllocation() const
	{
		return m_struct.pfnInternalAllocation;
	}
	AllocationCallbacks &pfnInternalAllocation(PFN_vkInternalAllocationNotification pfnInternalAllocation)
	{
		m_struct.pfnInternalAllocation = pfnInternalAllocation;
		return *this;
	}
	PFN_vkInternalFreeNotification pfnInternalFree() const
	{
		return m_struct.pfnInternalFree;
	}
	AllocationCallbacks &pfnInternalFree(PFN_vkInternalFreeNotification pfnInternalFree)
	{
		m_struct.pfnInternalFree = pfnInternalFree;
		return *this;
	}

	VkAllocationCallbacks *c_ptr() { return &m_struct; }
	const VkAllocationCallbacks *c_ptr() const { return &m_struct; }

	operator const VkAllocationCallbacks&() const { return m_struct; }
};

#ifdef VK_USE_PLATFORM_ANDROID_KHR
class AndroidSurfaceCreateInfoKHR {
	VkAndroidSurfaceCreateInfoKHR m_struct;
public:
	AndroidSurfaceCreateInfoKHR()
	{
		std::memset(&m_struct, 0, sizeof(VkAndroidSurfaceCreateInfoKHR));
		m_struct.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
	}
	AndroidSurfaceCreateInfoKHR(const VkAndroidSurfaceCreateInfoKHR &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	AndroidSurfaceCreateInfoKHR &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	AndroidSurfaceCreateInfoKHR &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	AndroidSurfaceCreateFlagsKHR flags() const
	{
		return AndroidSurfaceCreateFlagsKHR(m_struct.flags);
	}
	AndroidSurfaceCreateInfoKHR &flags(AndroidSurfaceCreateFlagsKHR flags)
	{
		m_struct.flags = static_cast<VkAndroidSurfaceCreateFlagsKHR>(flags);
		return *this;
	}
	const ANativeWindow* window() const
	{
		return m_struct.window;
	}
	AndroidSurfaceCreateInfoKHR &window(ANativeWindow* window)
	{
		m_struct.window = window;
		return *this;
	}

	VkAndroidSurfaceCreateInfoKHR *c_ptr() { return &m_struct; }
	const VkAndroidSurfaceCreateInfoKHR *c_ptr() const { return &m_struct; }

	operator const VkAndroidSurfaceCreateInfoKHR&() const { return m_struct; }
};
#endif
class ApplicationInfo {
	VkApplicationInfo m_struct;
public:
	ApplicationInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkApplicationInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
	}
	ApplicationInfo(const VkApplicationInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	ApplicationInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	ApplicationInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	const char* pApplicationName() const
	{
		return m_struct.pApplicationName;
	}
	ApplicationInfo &pApplicationName(const char* pApplicationName)
	{
		m_struct.pApplicationName = pApplicationName;
		return *this;
	}
	uint32_t applicationVersion() const
	{
		return m_struct.applicationVersion;
	}
	ApplicationInfo &applicationVersion(uint32_t applicationVersion)
	{
		m_struct.applicationVersion = applicationVersion;
		return *this;
	}
	const char* pEngineName() const
	{
		return m_struct.pEngineName;
	}
	ApplicationInfo &pEngineName(const char* pEngineName)
	{
		m_struct.pEngineName = pEngineName;
		return *this;
	}
	uint32_t engineVersion() const
	{
		return m_struct.engineVersion;
	}
	ApplicationInfo &engineVersion(uint32_t engineVersion)
	{
		m_struct.engineVersion = engineVersion;
		return *this;
	}
	uint32_t apiVersion() const
	{
		return m_struct.apiVersion;
	}
	ApplicationInfo &apiVersion(uint32_t apiVersion)
	{
		m_struct.apiVersion = apiVersion;
		return *this;
	}

	VkApplicationInfo *c_ptr() { return &m_struct; }
	const VkApplicationInfo *c_ptr() const { return &m_struct; }

	operator const VkApplicationInfo&() const { return m_struct; }
};

class AttachmentDescription {
	VkAttachmentDescription m_struct;
public:
	AttachmentDescription()
	{
		std::memset(&m_struct, 0, sizeof(VkAttachmentDescription));
		
	}
	AttachmentDescription(const VkAttachmentDescription &r): m_struct(r) {}

	
	AttachmentDescriptionFlags flags() const
	{
		return AttachmentDescriptionFlags(m_struct.flags);
	}
	AttachmentDescription &flags(AttachmentDescriptionFlags flags)
	{
		m_struct.flags = static_cast<VkAttachmentDescriptionFlags>(flags);
		return *this;
	}
	Format format() const
	{
		return static_cast<Format>(m_struct.format);
	}
	AttachmentDescription &format(Format format)
	{
		m_struct.format = static_cast<VkFormat>(format);
		return *this;
	}
	SampleCountFlagBits samples() const
	{
		return static_cast<SampleCountFlagBits>(m_struct.samples);
	}
	AttachmentDescription &samples(SampleCountFlagBits samples)
	{
		m_struct.samples = static_cast<VkSampleCountFlagBits>(samples);
		return *this;
	}
	AttachmentLoadOp loadOp() const
	{
		return static_cast<AttachmentLoadOp>(m_struct.loadOp);
	}
	AttachmentDescription &loadOp(AttachmentLoadOp loadOp)
	{
		m_struct.loadOp = static_cast<VkAttachmentLoadOp>(loadOp);
		return *this;
	}
	AttachmentStoreOp storeOp() const
	{
		return static_cast<AttachmentStoreOp>(m_struct.storeOp);
	}
	AttachmentDescription &storeOp(AttachmentStoreOp storeOp)
	{
		m_struct.storeOp = static_cast<VkAttachmentStoreOp>(storeOp);
		return *this;
	}
	AttachmentLoadOp stencilLoadOp() const
	{
		return static_cast<AttachmentLoadOp>(m_struct.stencilLoadOp);
	}
	AttachmentDescription &stencilLoadOp(AttachmentLoadOp stencilLoadOp)
	{
		m_struct.stencilLoadOp = static_cast<VkAttachmentLoadOp>(stencilLoadOp);
		return *this;
	}
	AttachmentStoreOp stencilStoreOp() const
	{
		return static_cast<AttachmentStoreOp>(m_struct.stencilStoreOp);
	}
	AttachmentDescription &stencilStoreOp(AttachmentStoreOp stencilStoreOp)
	{
		m_struct.stencilStoreOp = static_cast<VkAttachmentStoreOp>(stencilStoreOp);
		return *this;
	}
	ImageLayout initialLayout() const
	{
		return static_cast<ImageLayout>(m_struct.initialLayout);
	}
	AttachmentDescription &initialLayout(ImageLayout initialLayout)
	{
		m_struct.initialLayout = static_cast<VkImageLayout>(initialLayout);
		return *this;
	}
	ImageLayout finalLayout() const
	{
		return static_cast<ImageLayout>(m_struct.finalLayout);
	}
	AttachmentDescription &finalLayout(ImageLayout finalLayout)
	{
		m_struct.finalLayout = static_cast<VkImageLayout>(finalLayout);
		return *this;
	}

	VkAttachmentDescription *c_ptr() { return &m_struct; }
	const VkAttachmentDescription *c_ptr() const { return &m_struct; }

	operator const VkAttachmentDescription&() const { return m_struct; }
};

class AttachmentReference {
	VkAttachmentReference m_struct;
public:
	AttachmentReference()
	{
		std::memset(&m_struct, 0, sizeof(VkAttachmentReference));
		
	}
	AttachmentReference(const VkAttachmentReference &r): m_struct(r) {}

	
	uint32_t attachment() const
	{
		return m_struct.attachment;
	}
	AttachmentReference &attachment(uint32_t attachment)
	{
		m_struct.attachment = attachment;
		return *this;
	}
	ImageLayout layout() const
	{
		return static_cast<ImageLayout>(m_struct.layout);
	}
	AttachmentReference &layout(ImageLayout layout)
	{
		m_struct.layout = static_cast<VkImageLayout>(layout);
		return *this;
	}

	VkAttachmentReference *c_ptr() { return &m_struct; }
	const VkAttachmentReference *c_ptr() const { return &m_struct; }

	operator const VkAttachmentReference&() const { return m_struct; }
};

class BufferCopy {
	VkBufferCopy m_struct;
public:
	BufferCopy()
	{
		std::memset(&m_struct, 0, sizeof(VkBufferCopy));
		
	}
	BufferCopy(const VkBufferCopy &r): m_struct(r) {}

	
	DeviceSize srcOffset() const
	{
		return m_struct.srcOffset;
	}
	BufferCopy &srcOffset(DeviceSize srcOffset)
	{
		m_struct.srcOffset = srcOffset;
		return *this;
	}
	DeviceSize dstOffset() const
	{
		return m_struct.dstOffset;
	}
	BufferCopy &dstOffset(DeviceSize dstOffset)
	{
		m_struct.dstOffset = dstOffset;
		return *this;
	}
	DeviceSize size() const
	{
		return m_struct.size;
	}
	BufferCopy &size(DeviceSize size)
	{
		m_struct.size = size;
		return *this;
	}

	VkBufferCopy *c_ptr() { return &m_struct; }
	const VkBufferCopy *c_ptr() const { return &m_struct; }

	operator const VkBufferCopy&() const { return m_struct; }
};

class BufferCreateInfo {
	VkBufferCreateInfo m_struct;
public:
	BufferCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkBufferCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
	}
	BufferCreateInfo(const VkBufferCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	BufferCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	BufferCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	BufferCreateFlags flags() const
	{
		return BufferCreateFlags(m_struct.flags);
	}
	BufferCreateInfo &flags(BufferCreateFlags flags)
	{
		m_struct.flags = static_cast<VkBufferCreateFlags>(flags);
		return *this;
	}
	DeviceSize size() const
	{
		return m_struct.size;
	}
	BufferCreateInfo &size(DeviceSize size)
	{
		m_struct.size = size;
		return *this;
	}
	BufferUsageFlags usage() const
	{
		return BufferUsageFlags(m_struct.usage);
	}
	BufferCreateInfo &usage(BufferUsageFlags usage)
	{
		m_struct.usage = static_cast<VkBufferUsageFlags>(usage);
		return *this;
	}
	SharingMode sharingMode() const
	{
		return static_cast<SharingMode>(m_struct.sharingMode);
	}
	BufferCreateInfo &sharingMode(SharingMode sharingMode)
	{
		m_struct.sharingMode = static_cast<VkSharingMode>(sharingMode);
		return *this;
	}
	uint32_t queueFamilyIndexCount() const
	{
		return m_struct.queueFamilyIndexCount;
	}
	BufferCreateInfo &queueFamilyIndexCount(uint32_t queueFamilyIndexCount)
	{
		m_struct.queueFamilyIndexCount = queueFamilyIndexCount;
		return *this;
	}
	const uint32_t* pQueueFamilyIndices() const
	{
		return m_struct.pQueueFamilyIndices;
	}
	BufferCreateInfo &pQueueFamilyIndices(const uint32_t* pQueueFamilyIndices)
	{
		m_struct.pQueueFamilyIndices = pQueueFamilyIndices;
		return *this;
	}

	VkBufferCreateInfo *c_ptr() { return &m_struct; }
	const VkBufferCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkBufferCreateInfo&() const { return m_struct; }
};

class BufferMemoryBarrier {
	VkBufferMemoryBarrier m_struct;
public:
	BufferMemoryBarrier()
	{
		std::memset(&m_struct, 0, sizeof(VkBufferMemoryBarrier));
		m_struct.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
	}
	BufferMemoryBarrier(const VkBufferMemoryBarrier &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	BufferMemoryBarrier &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	BufferMemoryBarrier &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	AccessFlags srcAccessMask() const
	{
		return AccessFlags(m_struct.srcAccessMask);
	}
	BufferMemoryBarrier &srcAccessMask(AccessFlags srcAccessMask)
	{
		m_struct.srcAccessMask = static_cast<VkAccessFlags>(srcAccessMask);
		return *this;
	}
	AccessFlags dstAccessMask() const
	{
		return AccessFlags(m_struct.dstAccessMask);
	}
	BufferMemoryBarrier &dstAccessMask(AccessFlags dstAccessMask)
	{
		m_struct.dstAccessMask = static_cast<VkAccessFlags>(dstAccessMask);
		return *this;
	}
	uint32_t srcQueueFamilyIndex() const
	{
		return m_struct.srcQueueFamilyIndex;
	}
	BufferMemoryBarrier &srcQueueFamilyIndex(uint32_t srcQueueFamilyIndex)
	{
		m_struct.srcQueueFamilyIndex = srcQueueFamilyIndex;
		return *this;
	}
	uint32_t dstQueueFamilyIndex() const
	{
		return m_struct.dstQueueFamilyIndex;
	}
	BufferMemoryBarrier &dstQueueFamilyIndex(uint32_t dstQueueFamilyIndex)
	{
		m_struct.dstQueueFamilyIndex = dstQueueFamilyIndex;
		return *this;
	}
	Buffer buffer() const
	{
		return Buffer(m_struct.buffer);
	}
	BufferMemoryBarrier &buffer(Buffer buffer)
	{
		m_struct.buffer = static_cast<VkBuffer>(buffer);
		return *this;
	}
	DeviceSize offset() const
	{
		return m_struct.offset;
	}
	BufferMemoryBarrier &offset(DeviceSize offset)
	{
		m_struct.offset = offset;
		return *this;
	}
	DeviceSize size() const
	{
		return m_struct.size;
	}
	BufferMemoryBarrier &size(DeviceSize size)
	{
		m_struct.size = size;
		return *this;
	}

	VkBufferMemoryBarrier *c_ptr() { return &m_struct; }
	const VkBufferMemoryBarrier *c_ptr() const { return &m_struct; }

	operator const VkBufferMemoryBarrier&() const { return m_struct; }
};

class BufferViewCreateInfo {
	VkBufferViewCreateInfo m_struct;
public:
	BufferViewCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkBufferViewCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
	}
	BufferViewCreateInfo(const VkBufferViewCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	BufferViewCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	BufferViewCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	BufferViewCreateFlags flags() const
	{
		return BufferViewCreateFlags(m_struct.flags);
	}
	BufferViewCreateInfo &flags(BufferViewCreateFlags flags)
	{
		m_struct.flags = static_cast<VkBufferViewCreateFlags>(flags);
		return *this;
	}
	Buffer buffer() const
	{
		return Buffer(m_struct.buffer);
	}
	BufferViewCreateInfo &buffer(Buffer buffer)
	{
		m_struct.buffer = static_cast<VkBuffer>(buffer);
		return *this;
	}
	Format format() const
	{
		return static_cast<Format>(m_struct.format);
	}
	BufferViewCreateInfo &format(Format format)
	{
		m_struct.format = static_cast<VkFormat>(format);
		return *this;
	}
	DeviceSize offset() const
	{
		return m_struct.offset;
	}
	BufferViewCreateInfo &offset(DeviceSize offset)
	{
		m_struct.offset = offset;
		return *this;
	}
	DeviceSize range() const
	{
		return m_struct.range;
	}
	BufferViewCreateInfo &range(DeviceSize range)
	{
		m_struct.range = range;
		return *this;
	}

	VkBufferViewCreateInfo *c_ptr() { return &m_struct; }
	const VkBufferViewCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkBufferViewCreateInfo&() const { return m_struct; }
};

class ClearColorValue {
	VkClearColorValue m_struct;
public:
	ClearColorValue()
	{
		std::memset(&m_struct, 0, sizeof(VkClearColorValue));
		
	}
	ClearColorValue(const VkClearColorValue &r): m_struct(r) {}

	
	const float* float32() const
	{
		return reinterpret_cast<const float*>(m_struct.float32);
	}
	ClearColorValue &float32(float* float32)
	{
		std::memcpy(m_struct.float32, float32, 4 * sizeof(float));
		return *this;
	}
	const int32_t* int32() const
	{
		return reinterpret_cast<const int32_t*>(m_struct.int32);
	}
	ClearColorValue &int32(int32_t* int32)
	{
		std::memcpy(m_struct.int32, int32, 4 * sizeof(int32_t));
		return *this;
	}
	const uint32_t* uint32() const
	{
		return reinterpret_cast<const uint32_t*>(m_struct.uint32);
	}
	ClearColorValue &uint32(uint32_t* uint32)
	{
		std::memcpy(m_struct.uint32, uint32, 4 * sizeof(uint32_t));
		return *this;
	}

	VkClearColorValue *c_ptr() { return &m_struct; }
	const VkClearColorValue *c_ptr() const { return &m_struct; }

	operator const VkClearColorValue&() const { return m_struct; }
};

class ClearDepthStencilValue {
	VkClearDepthStencilValue m_struct;
public:
	ClearDepthStencilValue()
	{
		std::memset(&m_struct, 0, sizeof(VkClearDepthStencilValue));
		
	}
	ClearDepthStencilValue(const VkClearDepthStencilValue &r): m_struct(r) {}

	
	float depth() const
	{
		return m_struct.depth;
	}
	ClearDepthStencilValue &depth(float depth)
	{
		m_struct.depth = depth;
		return *this;
	}
	uint32_t stencil() const
	{
		return m_struct.stencil;
	}
	ClearDepthStencilValue &stencil(uint32_t stencil)
	{
		m_struct.stencil = stencil;
		return *this;
	}

	VkClearDepthStencilValue *c_ptr() { return &m_struct; }
	const VkClearDepthStencilValue *c_ptr() const { return &m_struct; }

	operator const VkClearDepthStencilValue&() const { return m_struct; }
};

class CommandBufferAllocateInfo {
	VkCommandBufferAllocateInfo m_struct;
public:
	CommandBufferAllocateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkCommandBufferAllocateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
	}
	CommandBufferAllocateInfo(const VkCommandBufferAllocateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	CommandBufferAllocateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	CommandBufferAllocateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	CommandPool commandPool() const
	{
		return CommandPool(m_struct.commandPool);
	}
	CommandBufferAllocateInfo &commandPool(CommandPool commandPool)
	{
		m_struct.commandPool = static_cast<VkCommandPool>(commandPool);
		return *this;
	}
	CommandBufferLevel level() const
	{
		return static_cast<CommandBufferLevel>(m_struct.level);
	}
	CommandBufferAllocateInfo &level(CommandBufferLevel level)
	{
		m_struct.level = static_cast<VkCommandBufferLevel>(level);
		return *this;
	}
	uint32_t commandBufferCount() const
	{
		return m_struct.commandBufferCount;
	}
	CommandBufferAllocateInfo &commandBufferCount(uint32_t commandBufferCount)
	{
		m_struct.commandBufferCount = commandBufferCount;
		return *this;
	}

	VkCommandBufferAllocateInfo *c_ptr() { return &m_struct; }
	const VkCommandBufferAllocateInfo *c_ptr() const { return &m_struct; }

	operator const VkCommandBufferAllocateInfo&() const { return m_struct; }
};

class CommandBufferInheritanceInfo {
	VkCommandBufferInheritanceInfo m_struct;
public:
	CommandBufferInheritanceInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkCommandBufferInheritanceInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO;
	}
	CommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	CommandBufferInheritanceInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	CommandBufferInheritanceInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	RenderPass renderPass() const
	{
		return RenderPass(m_struct.renderPass);
	}
	CommandBufferInheritanceInfo &renderPass(RenderPass renderPass)
	{
		m_struct.renderPass = static_cast<VkRenderPass>(renderPass);
		return *this;
	}
	uint32_t subpass() const
	{
		return m_struct.subpass;
	}
	CommandBufferInheritanceInfo &subpass(uint32_t subpass)
	{
		m_struct.subpass = subpass;
		return *this;
	}
	Framebuffer framebuffer() const
	{
		return Framebuffer(m_struct.framebuffer);
	}
	CommandBufferInheritanceInfo &framebuffer(Framebuffer framebuffer)
	{
		m_struct.framebuffer = static_cast<VkFramebuffer>(framebuffer);
		return *this;
	}
	Bool32 occlusionQueryEnable() const
	{
		return m_struct.occlusionQueryEnable;
	}
	CommandBufferInheritanceInfo &occlusionQueryEnable(Bool32 occlusionQueryEnable)
	{
		m_struct.occlusionQueryEnable = occlusionQueryEnable;
		return *this;
	}
	QueryControlFlags queryFlags() const
	{
		return QueryControlFlags(m_struct.queryFlags);
	}
	CommandBufferInheritanceInfo &queryFlags(QueryControlFlags queryFlags)
	{
		m_struct.queryFlags = static_cast<VkQueryControlFlags>(queryFlags);
		return *this;
	}
	QueryPipelineStatisticFlags pipelineStatistics() const
	{
		return QueryPipelineStatisticFlags(m_struct.pipelineStatistics);
	}
	CommandBufferInheritanceInfo &pipelineStatistics(QueryPipelineStatisticFlags pipelineStatistics)
	{
		m_struct.pipelineStatistics = static_cast<VkQueryPipelineStatisticFlags>(pipelineStatistics);
		return *this;
	}

	VkCommandBufferInheritanceInfo *c_ptr() { return &m_struct; }
	const VkCommandBufferInheritanceInfo *c_ptr() const { return &m_struct; }

	operator const VkCommandBufferInheritanceInfo&() const { return m_struct; }
};

class CommandPoolCreateInfo {
	VkCommandPoolCreateInfo m_struct;
public:
	CommandPoolCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkCommandPoolCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
	}
	CommandPoolCreateInfo(const VkCommandPoolCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	CommandPoolCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	CommandPoolCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	CommandPoolCreateFlags flags() const
	{
		return CommandPoolCreateFlags(m_struct.flags);
	}
	CommandPoolCreateInfo &flags(CommandPoolCreateFlags flags)
	{
		m_struct.flags = static_cast<VkCommandPoolCreateFlags>(flags);
		return *this;
	}
	uint32_t queueFamilyIndex() const
	{
		return m_struct.queueFamilyIndex;
	}
	CommandPoolCreateInfo &queueFamilyIndex(uint32_t queueFamilyIndex)
	{
		m_struct.queueFamilyIndex = queueFamilyIndex;
		return *this;
	}

	VkCommandPoolCreateInfo *c_ptr() { return &m_struct; }
	const VkCommandPoolCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkCommandPoolCreateInfo&() const { return m_struct; }
};

class ComponentMapping {
	VkComponentMapping m_struct;
public:
	ComponentMapping()
	{
		std::memset(&m_struct, 0, sizeof(VkComponentMapping));
		
	}
	ComponentMapping(const VkComponentMapping &r): m_struct(r) {}

	
	ComponentSwizzle r() const
	{
		return static_cast<ComponentSwizzle>(m_struct.r);
	}
	ComponentMapping &r(ComponentSwizzle r)
	{
		m_struct.r = static_cast<VkComponentSwizzle>(r);
		return *this;
	}
	ComponentSwizzle g() const
	{
		return static_cast<ComponentSwizzle>(m_struct.g);
	}
	ComponentMapping &g(ComponentSwizzle g)
	{
		m_struct.g = static_cast<VkComponentSwizzle>(g);
		return *this;
	}
	ComponentSwizzle b() const
	{
		return static_cast<ComponentSwizzle>(m_struct.b);
	}
	ComponentMapping &b(ComponentSwizzle b)
	{
		m_struct.b = static_cast<VkComponentSwizzle>(b);
		return *this;
	}
	ComponentSwizzle a() const
	{
		return static_cast<ComponentSwizzle>(m_struct.a);
	}
	ComponentMapping &a(ComponentSwizzle a)
	{
		m_struct.a = static_cast<VkComponentSwizzle>(a);
		return *this;
	}

	VkComponentMapping *c_ptr() { return &m_struct; }
	const VkComponentMapping *c_ptr() const { return &m_struct; }

	operator const VkComponentMapping&() const { return m_struct; }
};

class CopyDescriptorSet {
	VkCopyDescriptorSet m_struct;
public:
	CopyDescriptorSet()
	{
		std::memset(&m_struct, 0, sizeof(VkCopyDescriptorSet));
		m_struct.sType = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET;
	}
	CopyDescriptorSet(const VkCopyDescriptorSet &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	CopyDescriptorSet &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	CopyDescriptorSet &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	DescriptorSet srcSet() const
	{
		return DescriptorSet(m_struct.srcSet);
	}
	CopyDescriptorSet &srcSet(DescriptorSet srcSet)
	{
		m_struct.srcSet = static_cast<VkDescriptorSet>(srcSet);
		return *this;
	}
	uint32_t srcBinding() const
	{
		return m_struct.srcBinding;
	}
	CopyDescriptorSet &srcBinding(uint32_t srcBinding)
	{
		m_struct.srcBinding = srcBinding;
		return *this;
	}
	uint32_t srcArrayElement() const
	{
		return m_struct.srcArrayElement;
	}
	CopyDescriptorSet &srcArrayElement(uint32_t srcArrayElement)
	{
		m_struct.srcArrayElement = srcArrayElement;
		return *this;
	}
	DescriptorSet dstSet() const
	{
		return DescriptorSet(m_struct.dstSet);
	}
	CopyDescriptorSet &dstSet(DescriptorSet dstSet)
	{
		m_struct.dstSet = static_cast<VkDescriptorSet>(dstSet);
		return *this;
	}
	uint32_t dstBinding() const
	{
		return m_struct.dstBinding;
	}
	CopyDescriptorSet &dstBinding(uint32_t dstBinding)
	{
		m_struct.dstBinding = dstBinding;
		return *this;
	}
	uint32_t dstArrayElement() const
	{
		return m_struct.dstArrayElement;
	}
	CopyDescriptorSet &dstArrayElement(uint32_t dstArrayElement)
	{
		m_struct.dstArrayElement = dstArrayElement;
		return *this;
	}
	uint32_t descriptorCount() const
	{
		return m_struct.descriptorCount;
	}
	CopyDescriptorSet &descriptorCount(uint32_t descriptorCount)
	{
		m_struct.descriptorCount = descriptorCount;
		return *this;
	}

	VkCopyDescriptorSet *c_ptr() { return &m_struct; }
	const VkCopyDescriptorSet *c_ptr() const { return &m_struct; }

	operator const VkCopyDescriptorSet&() const { return m_struct; }
};

class DebugReportCallbackCreateInfoEXT {
	VkDebugReportCallbackCreateInfoEXT m_struct;
public:
	DebugReportCallbackCreateInfoEXT()
	{
		std::memset(&m_struct, 0, sizeof(VkDebugReportCallbackCreateInfoEXT));
		m_struct.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
	}
	DebugReportCallbackCreateInfoEXT(const VkDebugReportCallbackCreateInfoEXT &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	DebugReportCallbackCreateInfoEXT &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	DebugReportCallbackCreateInfoEXT &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	DebugReportFlagsEXT flags() const
	{
		return DebugReportFlagsEXT(m_struct.flags);
	}
	DebugReportCallbackCreateInfoEXT &flags(DebugReportFlagsEXT flags)
	{
		m_struct.flags = static_cast<VkDebugReportFlagsEXT>(flags);
		return *this;
	}
	PFN_vkDebugReportCallbackEXT pfnCallback() const
	{
		return m_struct.pfnCallback;
	}
	DebugReportCallbackCreateInfoEXT &pfnCallback(PFN_vkDebugReportCallbackEXT pfnCallback)
	{
		m_struct.pfnCallback = pfnCallback;
		return *this;
	}
	const void* pUserData() const
	{
		return m_struct.pUserData;
	}
	DebugReportCallbackCreateInfoEXT &pUserData(void* pUserData)
	{
		m_struct.pUserData = pUserData;
		return *this;
	}

	VkDebugReportCallbackCreateInfoEXT *c_ptr() { return &m_struct; }
	const VkDebugReportCallbackCreateInfoEXT *c_ptr() const { return &m_struct; }

	operator const VkDebugReportCallbackCreateInfoEXT&() const { return m_struct; }
};

class DescriptorBufferInfo {
	VkDescriptorBufferInfo m_struct;
public:
	DescriptorBufferInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkDescriptorBufferInfo));
		
	}
	DescriptorBufferInfo(const VkDescriptorBufferInfo &r): m_struct(r) {}

	
	Buffer buffer() const
	{
		return Buffer(m_struct.buffer);
	}
	DescriptorBufferInfo &buffer(Buffer buffer)
	{
		m_struct.buffer = static_cast<VkBuffer>(buffer);
		return *this;
	}
	DeviceSize offset() const
	{
		return m_struct.offset;
	}
	DescriptorBufferInfo &offset(DeviceSize offset)
	{
		m_struct.offset = offset;
		return *this;
	}
	DeviceSize range() const
	{
		return m_struct.range;
	}
	DescriptorBufferInfo &range(DeviceSize range)
	{
		m_struct.range = range;
		return *this;
	}

	VkDescriptorBufferInfo *c_ptr() { return &m_struct; }
	const VkDescriptorBufferInfo *c_ptr() const { return &m_struct; }

	operator const VkDescriptorBufferInfo&() const { return m_struct; }
};

class DescriptorImageInfo {
	VkDescriptorImageInfo m_struct;
public:
	DescriptorImageInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkDescriptorImageInfo));
		
	}
	DescriptorImageInfo(const VkDescriptorImageInfo &r): m_struct(r) {}

	
	Sampler sampler() const
	{
		return Sampler(m_struct.sampler);
	}
	DescriptorImageInfo &sampler(Sampler sampler)
	{
		m_struct.sampler = static_cast<VkSampler>(sampler);
		return *this;
	}
	ImageView imageView() const
	{
		return ImageView(m_struct.imageView);
	}
	DescriptorImageInfo &imageView(ImageView imageView)
	{
		m_struct.imageView = static_cast<VkImageView>(imageView);
		return *this;
	}
	ImageLayout imageLayout() const
	{
		return static_cast<ImageLayout>(m_struct.imageLayout);
	}
	DescriptorImageInfo &imageLayout(ImageLayout imageLayout)
	{
		m_struct.imageLayout = static_cast<VkImageLayout>(imageLayout);
		return *this;
	}

	VkDescriptorImageInfo *c_ptr() { return &m_struct; }
	const VkDescriptorImageInfo *c_ptr() const { return &m_struct; }

	operator const VkDescriptorImageInfo&() const { return m_struct; }
};

class DescriptorPoolSize {
	VkDescriptorPoolSize m_struct;
public:
	DescriptorPoolSize()
	{
		std::memset(&m_struct, 0, sizeof(VkDescriptorPoolSize));
		
	}
	DescriptorPoolSize(const VkDescriptorPoolSize &r): m_struct(r) {}

	
	DescriptorType type() const
	{
		return static_cast<DescriptorType>(m_struct.type);
	}
	DescriptorPoolSize &type(DescriptorType type)
	{
		m_struct.type = static_cast<VkDescriptorType>(type);
		return *this;
	}
	uint32_t descriptorCount() const
	{
		return m_struct.descriptorCount;
	}
	DescriptorPoolSize &descriptorCount(uint32_t descriptorCount)
	{
		m_struct.descriptorCount = descriptorCount;
		return *this;
	}

	VkDescriptorPoolSize *c_ptr() { return &m_struct; }
	const VkDescriptorPoolSize *c_ptr() const { return &m_struct; }

	operator const VkDescriptorPoolSize&() const { return m_struct; }
};

class DescriptorSetAllocateInfo {
	VkDescriptorSetAllocateInfo m_struct;
public:
	DescriptorSetAllocateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkDescriptorSetAllocateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
	}
	DescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	DescriptorSetAllocateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	DescriptorSetAllocateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	DescriptorPool descriptorPool() const
	{
		return DescriptorPool(m_struct.descriptorPool);
	}
	DescriptorSetAllocateInfo &descriptorPool(DescriptorPool descriptorPool)
	{
		m_struct.descriptorPool = static_cast<VkDescriptorPool>(descriptorPool);
		return *this;
	}
	uint32_t descriptorSetCount() const
	{
		return m_struct.descriptorSetCount;
	}
	DescriptorSetAllocateInfo &descriptorSetCount(uint32_t descriptorSetCount)
	{
		m_struct.descriptorSetCount = descriptorSetCount;
		return *this;
	}
	const DescriptorSetLayout* pSetLayouts() const
	{
		return reinterpret_cast<const DescriptorSetLayout*>(m_struct.pSetLayouts);
	}
	DescriptorSetAllocateInfo &pSetLayouts(const DescriptorSetLayout* pSetLayouts)
	{
		m_struct.pSetLayouts = reinterpret_cast<const VkDescriptorSetLayout*>(pSetLayouts);
		return *this;
	}

	VkDescriptorSetAllocateInfo *c_ptr() { return &m_struct; }
	const VkDescriptorSetAllocateInfo *c_ptr() const { return &m_struct; }

	operator const VkDescriptorSetAllocateInfo&() const { return m_struct; }
};

class DescriptorSetLayoutBinding {
	VkDescriptorSetLayoutBinding m_struct;
public:
	DescriptorSetLayoutBinding()
	{
		std::memset(&m_struct, 0, sizeof(VkDescriptorSetLayoutBinding));
		
	}
	DescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding &r): m_struct(r) {}

	
	uint32_t binding() const
	{
		return m_struct.binding;
	}
	DescriptorSetLayoutBinding &binding(uint32_t binding)
	{
		m_struct.binding = binding;
		return *this;
	}
	DescriptorType descriptorType() const
	{
		return static_cast<DescriptorType>(m_struct.descriptorType);
	}
	DescriptorSetLayoutBinding &descriptorType(DescriptorType descriptorType)
	{
		m_struct.descriptorType = static_cast<VkDescriptorType>(descriptorType);
		return *this;
	}
	uint32_t descriptorCount() const
	{
		return m_struct.descriptorCount;
	}
	DescriptorSetLayoutBinding &descriptorCount(uint32_t descriptorCount)
	{
		m_struct.descriptorCount = descriptorCount;
		return *this;
	}
	ShaderStageFlags stageFlags() const
	{
		return ShaderStageFlags(m_struct.stageFlags);
	}
	DescriptorSetLayoutBinding &stageFlags(ShaderStageFlags stageFlags)
	{
		m_struct.stageFlags = static_cast<VkShaderStageFlags>(stageFlags);
		return *this;
	}
	const Sampler* pImmutableSamplers() const
	{
		return reinterpret_cast<const Sampler*>(m_struct.pImmutableSamplers);
	}
	DescriptorSetLayoutBinding &pImmutableSamplers(const Sampler* pImmutableSamplers)
	{
		m_struct.pImmutableSamplers = reinterpret_cast<const VkSampler*>(pImmutableSamplers);
		return *this;
	}

	VkDescriptorSetLayoutBinding *c_ptr() { return &m_struct; }
	const VkDescriptorSetLayoutBinding *c_ptr() const { return &m_struct; }

	operator const VkDescriptorSetLayoutBinding&() const { return m_struct; }
};

class DeviceQueueCreateInfo {
	VkDeviceQueueCreateInfo m_struct;
public:
	DeviceQueueCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkDeviceQueueCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
	}
	DeviceQueueCreateInfo(const VkDeviceQueueCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	DeviceQueueCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	DeviceQueueCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	DeviceQueueCreateFlags flags() const
	{
		return DeviceQueueCreateFlags(m_struct.flags);
	}
	DeviceQueueCreateInfo &flags(DeviceQueueCreateFlags flags)
	{
		m_struct.flags = static_cast<VkDeviceQueueCreateFlags>(flags);
		return *this;
	}
	uint32_t queueFamilyIndex() const
	{
		return m_struct.queueFamilyIndex;
	}
	DeviceQueueCreateInfo &queueFamilyIndex(uint32_t queueFamilyIndex)
	{
		m_struct.queueFamilyIndex = queueFamilyIndex;
		return *this;
	}
	uint32_t queueCount() const
	{
		return m_struct.queueCount;
	}
	DeviceQueueCreateInfo &queueCount(uint32_t queueCount)
	{
		m_struct.queueCount = queueCount;
		return *this;
	}
	const float* pQueuePriorities() const
	{
		return m_struct.pQueuePriorities;
	}
	DeviceQueueCreateInfo &pQueuePriorities(const float* pQueuePriorities)
	{
		m_struct.pQueuePriorities = pQueuePriorities;
		return *this;
	}

	VkDeviceQueueCreateInfo *c_ptr() { return &m_struct; }
	const VkDeviceQueueCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkDeviceQueueCreateInfo&() const { return m_struct; }
};

class DispatchIndirectCommand {
	VkDispatchIndirectCommand m_struct;
public:
	DispatchIndirectCommand()
	{
		std::memset(&m_struct, 0, sizeof(VkDispatchIndirectCommand));
		
	}
	DispatchIndirectCommand(const VkDispatchIndirectCommand &r): m_struct(r) {}

	
	uint32_t x() const
	{
		return m_struct.x;
	}
	DispatchIndirectCommand &x(uint32_t x)
	{
		m_struct.x = x;
		return *this;
	}
	uint32_t y() const
	{
		return m_struct.y;
	}
	DispatchIndirectCommand &y(uint32_t y)
	{
		m_struct.y = y;
		return *this;
	}
	uint32_t z() const
	{
		return m_struct.z;
	}
	DispatchIndirectCommand &z(uint32_t z)
	{
		m_struct.z = z;
		return *this;
	}

	VkDispatchIndirectCommand *c_ptr() { return &m_struct; }
	const VkDispatchIndirectCommand *c_ptr() const { return &m_struct; }

	operator const VkDispatchIndirectCommand&() const { return m_struct; }
};

class DisplayPlanePropertiesKHR {
	VkDisplayPlanePropertiesKHR m_struct;
public:
	DisplayPlanePropertiesKHR()
	{
		std::memset(&m_struct, 0, sizeof(VkDisplayPlanePropertiesKHR));
		
	}
	DisplayPlanePropertiesKHR(const VkDisplayPlanePropertiesKHR &r): m_struct(r) {}

	
	DisplayKHR currentDisplay() const
	{
		return DisplayKHR(m_struct.currentDisplay);
	}
	DisplayPlanePropertiesKHR &currentDisplay(DisplayKHR currentDisplay)
	{
		m_struct.currentDisplay = static_cast<VkDisplayKHR>(currentDisplay);
		return *this;
	}
	uint32_t currentStackIndex() const
	{
		return m_struct.currentStackIndex;
	}
	DisplayPlanePropertiesKHR &currentStackIndex(uint32_t currentStackIndex)
	{
		m_struct.currentStackIndex = currentStackIndex;
		return *this;
	}

	VkDisplayPlanePropertiesKHR *c_ptr() { return &m_struct; }
	const VkDisplayPlanePropertiesKHR *c_ptr() const { return &m_struct; }

	operator const VkDisplayPlanePropertiesKHR&() const { return m_struct; }
};

class DrawIndexedIndirectCommand {
	VkDrawIndexedIndirectCommand m_struct;
public:
	DrawIndexedIndirectCommand()
	{
		std::memset(&m_struct, 0, sizeof(VkDrawIndexedIndirectCommand));
		
	}
	DrawIndexedIndirectCommand(const VkDrawIndexedIndirectCommand &r): m_struct(r) {}

	
	uint32_t indexCount() const
	{
		return m_struct.indexCount;
	}
	DrawIndexedIndirectCommand &indexCount(uint32_t indexCount)
	{
		m_struct.indexCount = indexCount;
		return *this;
	}
	uint32_t instanceCount() const
	{
		return m_struct.instanceCount;
	}
	DrawIndexedIndirectCommand &instanceCount(uint32_t instanceCount)
	{
		m_struct.instanceCount = instanceCount;
		return *this;
	}
	uint32_t firstIndex() const
	{
		return m_struct.firstIndex;
	}
	DrawIndexedIndirectCommand &firstIndex(uint32_t firstIndex)
	{
		m_struct.firstIndex = firstIndex;
		return *this;
	}
	int32_t vertexOffset() const
	{
		return m_struct.vertexOffset;
	}
	DrawIndexedIndirectCommand &vertexOffset(int32_t vertexOffset)
	{
		m_struct.vertexOffset = vertexOffset;
		return *this;
	}
	uint32_t firstInstance() const
	{
		return m_struct.firstInstance;
	}
	DrawIndexedIndirectCommand &firstInstance(uint32_t firstInstance)
	{
		m_struct.firstInstance = firstInstance;
		return *this;
	}

	VkDrawIndexedIndirectCommand *c_ptr() { return &m_struct; }
	const VkDrawIndexedIndirectCommand *c_ptr() const { return &m_struct; }

	operator const VkDrawIndexedIndirectCommand&() const { return m_struct; }
};

class DrawIndirectCommand {
	VkDrawIndirectCommand m_struct;
public:
	DrawIndirectCommand()
	{
		std::memset(&m_struct, 0, sizeof(VkDrawIndirectCommand));
		
	}
	DrawIndirectCommand(const VkDrawIndirectCommand &r): m_struct(r) {}

	
	uint32_t vertexCount() const
	{
		return m_struct.vertexCount;
	}
	DrawIndirectCommand &vertexCount(uint32_t vertexCount)
	{
		m_struct.vertexCount = vertexCount;
		return *this;
	}
	uint32_t instanceCount() const
	{
		return m_struct.instanceCount;
	}
	DrawIndirectCommand &instanceCount(uint32_t instanceCount)
	{
		m_struct.instanceCount = instanceCount;
		return *this;
	}
	uint32_t firstVertex() const
	{
		return m_struct.firstVertex;
	}
	DrawIndirectCommand &firstVertex(uint32_t firstVertex)
	{
		m_struct.firstVertex = firstVertex;
		return *this;
	}
	uint32_t firstInstance() const
	{
		return m_struct.firstInstance;
	}
	DrawIndirectCommand &firstInstance(uint32_t firstInstance)
	{
		m_struct.firstInstance = firstInstance;
		return *this;
	}

	VkDrawIndirectCommand *c_ptr() { return &m_struct; }
	const VkDrawIndirectCommand *c_ptr() const { return &m_struct; }

	operator const VkDrawIndirectCommand&() const { return m_struct; }
};

class EventCreateInfo {
	VkEventCreateInfo m_struct;
public:
	EventCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkEventCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO;
	}
	EventCreateInfo(const VkEventCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	EventCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	EventCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	EventCreateFlags flags() const
	{
		return EventCreateFlags(m_struct.flags);
	}
	EventCreateInfo &flags(EventCreateFlags flags)
	{
		m_struct.flags = static_cast<VkEventCreateFlags>(flags);
		return *this;
	}

	VkEventCreateInfo *c_ptr() { return &m_struct; }
	const VkEventCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkEventCreateInfo&() const { return m_struct; }
};

class ExtensionProperties {
	VkExtensionProperties m_struct;
public:
	ExtensionProperties()
	{
		std::memset(&m_struct, 0, sizeof(VkExtensionProperties));
		
	}
	ExtensionProperties(const VkExtensionProperties &r): m_struct(r) {}

	
	const char* extensionName() const
	{
		return reinterpret_cast<const char*>(m_struct.extensionName);
	}
	
	uint32_t specVersion() const
	{
		return m_struct.specVersion;
	}
	

	VkExtensionProperties *c_ptr() { return &m_struct; }
	const VkExtensionProperties *c_ptr() const { return &m_struct; }

	operator const VkExtensionProperties&() const { return m_struct; }
};

class Extent2D {
	VkExtent2D m_struct;
public:
	Extent2D()
	{
		std::memset(&m_struct, 0, sizeof(VkExtent2D));
		
	}
	Extent2D(const VkExtent2D &r): m_struct(r) {}

	
	uint32_t width() const
	{
		return m_struct.width;
	}
	Extent2D &width(uint32_t width)
	{
		m_struct.width = width;
		return *this;
	}
	uint32_t height() const
	{
		return m_struct.height;
	}
	Extent2D &height(uint32_t height)
	{
		m_struct.height = height;
		return *this;
	}

	VkExtent2D *c_ptr() { return &m_struct; }
	const VkExtent2D *c_ptr() const { return &m_struct; }

	operator const VkExtent2D&() const { return m_struct; }
};

class Extent3D {
	VkExtent3D m_struct;
public:
	Extent3D()
	{
		std::memset(&m_struct, 0, sizeof(VkExtent3D));
		
	}
	Extent3D(const VkExtent3D &r): m_struct(r) {}

	
	uint32_t width() const
	{
		return m_struct.width;
	}
	Extent3D &width(uint32_t width)
	{
		m_struct.width = width;
		return *this;
	}
	uint32_t height() const
	{
		return m_struct.height;
	}
	Extent3D &height(uint32_t height)
	{
		m_struct.height = height;
		return *this;
	}
	uint32_t depth() const
	{
		return m_struct.depth;
	}
	Extent3D &depth(uint32_t depth)
	{
		m_struct.depth = depth;
		return *this;
	}

	VkExtent3D *c_ptr() { return &m_struct; }
	const VkExtent3D *c_ptr() const { return &m_struct; }

	operator const VkExtent3D&() const { return m_struct; }
};

class FenceCreateInfo {
	VkFenceCreateInfo m_struct;
public:
	FenceCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkFenceCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
	}
	FenceCreateInfo(const VkFenceCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	FenceCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	FenceCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	FenceCreateFlags flags() const
	{
		return FenceCreateFlags(m_struct.flags);
	}
	FenceCreateInfo &flags(FenceCreateFlags flags)
	{
		m_struct.flags = static_cast<VkFenceCreateFlags>(flags);
		return *this;
	}

	VkFenceCreateInfo *c_ptr() { return &m_struct; }
	const VkFenceCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkFenceCreateInfo&() const { return m_struct; }
};

class FormatProperties {
	VkFormatProperties m_struct;
public:
	FormatProperties()
	{
		std::memset(&m_struct, 0, sizeof(VkFormatProperties));
		
	}
	FormatProperties(const VkFormatProperties &r): m_struct(r) {}

	
	FormatFeatureFlags linearTilingFeatures() const
	{
		return FormatFeatureFlags(m_struct.linearTilingFeatures);
	}
	
	FormatFeatureFlags optimalTilingFeatures() const
	{
		return FormatFeatureFlags(m_struct.optimalTilingFeatures);
	}
	
	FormatFeatureFlags bufferFeatures() const
	{
		return FormatFeatureFlags(m_struct.bufferFeatures);
	}
	

	VkFormatProperties *c_ptr() { return &m_struct; }
	const VkFormatProperties *c_ptr() const { return &m_struct; }

	operator const VkFormatProperties&() const { return m_struct; }
};

class FramebufferCreateInfo {
	VkFramebufferCreateInfo m_struct;
public:
	FramebufferCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkFramebufferCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
	}
	FramebufferCreateInfo(const VkFramebufferCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	FramebufferCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	FramebufferCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	FramebufferCreateFlags flags() const
	{
		return FramebufferCreateFlags(m_struct.flags);
	}
	FramebufferCreateInfo &flags(FramebufferCreateFlags flags)
	{
		m_struct.flags = static_cast<VkFramebufferCreateFlags>(flags);
		return *this;
	}
	RenderPass renderPass() const
	{
		return RenderPass(m_struct.renderPass);
	}
	FramebufferCreateInfo &renderPass(RenderPass renderPass)
	{
		m_struct.renderPass = static_cast<VkRenderPass>(renderPass);
		return *this;
	}
	uint32_t attachmentCount() const
	{
		return m_struct.attachmentCount;
	}
	FramebufferCreateInfo &attachmentCount(uint32_t attachmentCount)
	{
		m_struct.attachmentCount = attachmentCount;
		return *this;
	}
	const ImageView* pAttachments() const
	{
		return reinterpret_cast<const ImageView*>(m_struct.pAttachments);
	}
	FramebufferCreateInfo &pAttachments(const ImageView* pAttachments)
	{
		m_struct.pAttachments = reinterpret_cast<const VkImageView*>(pAttachments);
		return *this;
	}
	uint32_t width() const
	{
		return m_struct.width;
	}
	FramebufferCreateInfo &width(uint32_t width)
	{
		m_struct.width = width;
		return *this;
	}
	uint32_t height() const
	{
		return m_struct.height;
	}
	FramebufferCreateInfo &height(uint32_t height)
	{
		m_struct.height = height;
		return *this;
	}
	uint32_t layers() const
	{
		return m_struct.layers;
	}
	FramebufferCreateInfo &layers(uint32_t layers)
	{
		m_struct.layers = layers;
		return *this;
	}

	VkFramebufferCreateInfo *c_ptr() { return &m_struct; }
	const VkFramebufferCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkFramebufferCreateInfo&() const { return m_struct; }
};

class ImageSubresource {
	VkImageSubresource m_struct;
public:
	ImageSubresource()
	{
		std::memset(&m_struct, 0, sizeof(VkImageSubresource));
		
	}
	ImageSubresource(const VkImageSubresource &r): m_struct(r) {}

	
	ImageAspectFlags aspectMask() const
	{
		return ImageAspectFlags(m_struct.aspectMask);
	}
	ImageSubresource &aspectMask(ImageAspectFlags aspectMask)
	{
		m_struct.aspectMask = static_cast<VkImageAspectFlags>(aspectMask);
		return *this;
	}
	uint32_t mipLevel() const
	{
		return m_struct.mipLevel;
	}
	ImageSubresource &mipLevel(uint32_t mipLevel)
	{
		m_struct.mipLevel = mipLevel;
		return *this;
	}
	uint32_t arrayLayer() const
	{
		return m_struct.arrayLayer;
	}
	ImageSubresource &arrayLayer(uint32_t arrayLayer)
	{
		m_struct.arrayLayer = arrayLayer;
		return *this;
	}

	VkImageSubresource *c_ptr() { return &m_struct; }
	const VkImageSubresource *c_ptr() const { return &m_struct; }

	operator const VkImageSubresource&() const { return m_struct; }
};

class ImageSubresourceLayers {
	VkImageSubresourceLayers m_struct;
public:
	ImageSubresourceLayers()
	{
		std::memset(&m_struct, 0, sizeof(VkImageSubresourceLayers));
		
	}
	ImageSubresourceLayers(const VkImageSubresourceLayers &r): m_struct(r) {}

	
	ImageAspectFlags aspectMask() const
	{
		return ImageAspectFlags(m_struct.aspectMask);
	}
	ImageSubresourceLayers &aspectMask(ImageAspectFlags aspectMask)
	{
		m_struct.aspectMask = static_cast<VkImageAspectFlags>(aspectMask);
		return *this;
	}
	uint32_t mipLevel() const
	{
		return m_struct.mipLevel;
	}
	ImageSubresourceLayers &mipLevel(uint32_t mipLevel)
	{
		m_struct.mipLevel = mipLevel;
		return *this;
	}
	uint32_t baseArrayLayer() const
	{
		return m_struct.baseArrayLayer;
	}
	ImageSubresourceLayers &baseArrayLayer(uint32_t baseArrayLayer)
	{
		m_struct.baseArrayLayer = baseArrayLayer;
		return *this;
	}
	uint32_t layerCount() const
	{
		return m_struct.layerCount;
	}
	ImageSubresourceLayers &layerCount(uint32_t layerCount)
	{
		m_struct.layerCount = layerCount;
		return *this;
	}

	VkImageSubresourceLayers *c_ptr() { return &m_struct; }
	const VkImageSubresourceLayers *c_ptr() const { return &m_struct; }

	operator const VkImageSubresourceLayers&() const { return m_struct; }
};

class ImageSubresourceRange {
	VkImageSubresourceRange m_struct;
public:
	ImageSubresourceRange()
	{
		std::memset(&m_struct, 0, sizeof(VkImageSubresourceRange));
		
	}
	ImageSubresourceRange(const VkImageSubresourceRange &r): m_struct(r) {}

	
	ImageAspectFlags aspectMask() const
	{
		return ImageAspectFlags(m_struct.aspectMask);
	}
	ImageSubresourceRange &aspectMask(ImageAspectFlags aspectMask)
	{
		m_struct.aspectMask = static_cast<VkImageAspectFlags>(aspectMask);
		return *this;
	}
	uint32_t baseMipLevel() const
	{
		return m_struct.baseMipLevel;
	}
	ImageSubresourceRange &baseMipLevel(uint32_t baseMipLevel)
	{
		m_struct.baseMipLevel = baseMipLevel;
		return *this;
	}
	uint32_t levelCount() const
	{
		return m_struct.levelCount;
	}
	ImageSubresourceRange &levelCount(uint32_t levelCount)
	{
		m_struct.levelCount = levelCount;
		return *this;
	}
	uint32_t baseArrayLayer() const
	{
		return m_struct.baseArrayLayer;
	}
	ImageSubresourceRange &baseArrayLayer(uint32_t baseArrayLayer)
	{
		m_struct.baseArrayLayer = baseArrayLayer;
		return *this;
	}
	uint32_t layerCount() const
	{
		return m_struct.layerCount;
	}
	ImageSubresourceRange &layerCount(uint32_t layerCount)
	{
		m_struct.layerCount = layerCount;
		return *this;
	}

	VkImageSubresourceRange *c_ptr() { return &m_struct; }
	const VkImageSubresourceRange *c_ptr() const { return &m_struct; }

	operator const VkImageSubresourceRange&() const { return m_struct; }
};

class LayerProperties {
	VkLayerProperties m_struct;
public:
	LayerProperties()
	{
		std::memset(&m_struct, 0, sizeof(VkLayerProperties));
		
	}
	LayerProperties(const VkLayerProperties &r): m_struct(r) {}

	
	const char* layerName() const
	{
		return reinterpret_cast<const char*>(m_struct.layerName);
	}
	
	uint32_t specVersion() const
	{
		return m_struct.specVersion;
	}
	
	uint32_t implementationVersion() const
	{
		return m_struct.implementationVersion;
	}
	
	const char* description() const
	{
		return reinterpret_cast<const char*>(m_struct.description);
	}
	

	VkLayerProperties *c_ptr() { return &m_struct; }
	const VkLayerProperties *c_ptr() const { return &m_struct; }

	operator const VkLayerProperties&() const { return m_struct; }
};

class MappedMemoryRange {
	VkMappedMemoryRange m_struct;
public:
	MappedMemoryRange()
	{
		std::memset(&m_struct, 0, sizeof(VkMappedMemoryRange));
		m_struct.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
	}
	MappedMemoryRange(const VkMappedMemoryRange &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	MappedMemoryRange &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	MappedMemoryRange &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	DeviceMemory memory() const
	{
		return DeviceMemory(m_struct.memory);
	}
	MappedMemoryRange &memory(DeviceMemory memory)
	{
		m_struct.memory = static_cast<VkDeviceMemory>(memory);
		return *this;
	}
	DeviceSize offset() const
	{
		return m_struct.offset;
	}
	MappedMemoryRange &offset(DeviceSize offset)
	{
		m_struct.offset = offset;
		return *this;
	}
	DeviceSize size() const
	{
		return m_struct.size;
	}
	MappedMemoryRange &size(DeviceSize size)
	{
		m_struct.size = size;
		return *this;
	}

	VkMappedMemoryRange *c_ptr() { return &m_struct; }
	const VkMappedMemoryRange *c_ptr() const { return &m_struct; }

	operator const VkMappedMemoryRange&() const { return m_struct; }
};

class MemoryAllocateInfo {
	VkMemoryAllocateInfo m_struct;
public:
	MemoryAllocateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkMemoryAllocateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
	}
	MemoryAllocateInfo(const VkMemoryAllocateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	MemoryAllocateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	MemoryAllocateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	DeviceSize allocationSize() const
	{
		return m_struct.allocationSize;
	}
	MemoryAllocateInfo &allocationSize(DeviceSize allocationSize)
	{
		m_struct.allocationSize = allocationSize;
		return *this;
	}
	uint32_t memoryTypeIndex() const
	{
		return m_struct.memoryTypeIndex;
	}
	MemoryAllocateInfo &memoryTypeIndex(uint32_t memoryTypeIndex)
	{
		m_struct.memoryTypeIndex = memoryTypeIndex;
		return *this;
	}

	VkMemoryAllocateInfo *c_ptr() { return &m_struct; }
	const VkMemoryAllocateInfo *c_ptr() const { return &m_struct; }

	operator const VkMemoryAllocateInfo&() const { return m_struct; }
};

class MemoryBarrier {
	VkMemoryBarrier m_struct;
public:
	MemoryBarrier()
	{
		std::memset(&m_struct, 0, sizeof(VkMemoryBarrier));
		m_struct.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER;
	}
	MemoryBarrier(const VkMemoryBarrier &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	MemoryBarrier &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	MemoryBarrier &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	AccessFlags srcAccessMask() const
	{
		return AccessFlags(m_struct.srcAccessMask);
	}
	MemoryBarrier &srcAccessMask(AccessFlags srcAccessMask)
	{
		m_struct.srcAccessMask = static_cast<VkAccessFlags>(srcAccessMask);
		return *this;
	}
	AccessFlags dstAccessMask() const
	{
		return AccessFlags(m_struct.dstAccessMask);
	}
	MemoryBarrier &dstAccessMask(AccessFlags dstAccessMask)
	{
		m_struct.dstAccessMask = static_cast<VkAccessFlags>(dstAccessMask);
		return *this;
	}

	VkMemoryBarrier *c_ptr() { return &m_struct; }
	const VkMemoryBarrier *c_ptr() const { return &m_struct; }

	operator const VkMemoryBarrier&() const { return m_struct; }
};

class MemoryHeap {
	VkMemoryHeap m_struct;
public:
	MemoryHeap()
	{
		std::memset(&m_struct, 0, sizeof(VkMemoryHeap));
		
	}
	MemoryHeap(const VkMemoryHeap &r): m_struct(r) {}

	
	DeviceSize size() const
	{
		return m_struct.size;
	}
	
	MemoryHeapFlags flags() const
	{
		return MemoryHeapFlags(m_struct.flags);
	}
	

	VkMemoryHeap *c_ptr() { return &m_struct; }
	const VkMemoryHeap *c_ptr() const { return &m_struct; }

	operator const VkMemoryHeap&() const { return m_struct; }
};

class MemoryRequirements {
	VkMemoryRequirements m_struct;
public:
	MemoryRequirements()
	{
		std::memset(&m_struct, 0, sizeof(VkMemoryRequirements));
		
	}
	MemoryRequirements(const VkMemoryRequirements &r): m_struct(r) {}

	
	DeviceSize size() const
	{
		return m_struct.size;
	}
	
	DeviceSize alignment() const
	{
		return m_struct.alignment;
	}
	
	uint32_t memoryTypeBits() const
	{
		return m_struct.memoryTypeBits;
	}
	

	VkMemoryRequirements *c_ptr() { return &m_struct; }
	const VkMemoryRequirements *c_ptr() const { return &m_struct; }

	operator const VkMemoryRequirements&() const { return m_struct; }
};

class MemoryType {
	VkMemoryType m_struct;
public:
	MemoryType()
	{
		std::memset(&m_struct, 0, sizeof(VkMemoryType));
		
	}
	MemoryType(const VkMemoryType &r): m_struct(r) {}

	
	MemoryPropertyFlags propertyFlags() const
	{
		return MemoryPropertyFlags(m_struct.propertyFlags);
	}
	
	uint32_t heapIndex() const
	{
		return m_struct.heapIndex;
	}
	

	VkMemoryType *c_ptr() { return &m_struct; }
	const VkMemoryType *c_ptr() const { return &m_struct; }

	operator const VkMemoryType&() const { return m_struct; }
};

#ifdef VK_USE_PLATFORM_MIR_KHR
class MirSurfaceCreateInfoKHR {
	VkMirSurfaceCreateInfoKHR m_struct;
public:
	MirSurfaceCreateInfoKHR()
	{
		std::memset(&m_struct, 0, sizeof(VkMirSurfaceCreateInfoKHR));
		m_struct.sType = VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR;
	}
	MirSurfaceCreateInfoKHR(const VkMirSurfaceCreateInfoKHR &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	MirSurfaceCreateInfoKHR &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	MirSurfaceCreateInfoKHR &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	MirSurfaceCreateFlagsKHR flags() const
	{
		return MirSurfaceCreateFlagsKHR(m_struct.flags);
	}
	MirSurfaceCreateInfoKHR &flags(MirSurfaceCreateFlagsKHR flags)
	{
		m_struct.flags = static_cast<VkMirSurfaceCreateFlagsKHR>(flags);
		return *this;
	}
	const MirConnection* connection() const
	{
		return m_struct.connection;
	}
	MirSurfaceCreateInfoKHR &connection(MirConnection* connection)
	{
		m_struct.connection = connection;
		return *this;
	}
	const MirSurface* mirSurface() const
	{
		return m_struct.mirSurface;
	}
	MirSurfaceCreateInfoKHR &mirSurface(MirSurface* mirSurface)
	{
		m_struct.mirSurface = mirSurface;
		return *this;
	}

	VkMirSurfaceCreateInfoKHR *c_ptr() { return &m_struct; }
	const VkMirSurfaceCreateInfoKHR *c_ptr() const { return &m_struct; }

	operator const VkMirSurfaceCreateInfoKHR&() const { return m_struct; }
};
#endif
class Offset2D {
	VkOffset2D m_struct;
public:
	Offset2D()
	{
		std::memset(&m_struct, 0, sizeof(VkOffset2D));
		
	}
	Offset2D(const VkOffset2D &r): m_struct(r) {}

	
	int32_t x() const
	{
		return m_struct.x;
	}
	Offset2D &x(int32_t x)
	{
		m_struct.x = x;
		return *this;
	}
	int32_t y() const
	{
		return m_struct.y;
	}
	Offset2D &y(int32_t y)
	{
		m_struct.y = y;
		return *this;
	}

	VkOffset2D *c_ptr() { return &m_struct; }
	const VkOffset2D *c_ptr() const { return &m_struct; }

	operator const VkOffset2D&() const { return m_struct; }
};

class Offset3D {
	VkOffset3D m_struct;
public:
	Offset3D()
	{
		std::memset(&m_struct, 0, sizeof(VkOffset3D));
		
	}
	Offset3D(const VkOffset3D &r): m_struct(r) {}

	
	int32_t x() const
	{
		return m_struct.x;
	}
	Offset3D &x(int32_t x)
	{
		m_struct.x = x;
		return *this;
	}
	int32_t y() const
	{
		return m_struct.y;
	}
	Offset3D &y(int32_t y)
	{
		m_struct.y = y;
		return *this;
	}
	int32_t z() const
	{
		return m_struct.z;
	}
	Offset3D &z(int32_t z)
	{
		m_struct.z = z;
		return *this;
	}

	VkOffset3D *c_ptr() { return &m_struct; }
	const VkOffset3D *c_ptr() const { return &m_struct; }

	operator const VkOffset3D&() const { return m_struct; }
};

class PhysicalDeviceFeatures {
	VkPhysicalDeviceFeatures m_struct;
public:
	PhysicalDeviceFeatures()
	{
		std::memset(&m_struct, 0, sizeof(VkPhysicalDeviceFeatures));
		
	}
	PhysicalDeviceFeatures(const VkPhysicalDeviceFeatures &r): m_struct(r) {}

	
	Bool32 robustBufferAccess() const
	{
		return m_struct.robustBufferAccess;
	}
	PhysicalDeviceFeatures &robustBufferAccess(Bool32 robustBufferAccess)
	{
		m_struct.robustBufferAccess = robustBufferAccess;
		return *this;
	}
	Bool32 fullDrawIndexUint32() const
	{
		return m_struct.fullDrawIndexUint32;
	}
	PhysicalDeviceFeatures &fullDrawIndexUint32(Bool32 fullDrawIndexUint32)
	{
		m_struct.fullDrawIndexUint32 = fullDrawIndexUint32;
		return *this;
	}
	Bool32 imageCubeArray() const
	{
		return m_struct.imageCubeArray;
	}
	PhysicalDeviceFeatures &imageCubeArray(Bool32 imageCubeArray)
	{
		m_struct.imageCubeArray = imageCubeArray;
		return *this;
	}
	Bool32 independentBlend() const
	{
		return m_struct.independentBlend;
	}
	PhysicalDeviceFeatures &independentBlend(Bool32 independentBlend)
	{
		m_struct.independentBlend = independentBlend;
		return *this;
	}
	Bool32 geometryShader() const
	{
		return m_struct.geometryShader;
	}
	PhysicalDeviceFeatures &geometryShader(Bool32 geometryShader)
	{
		m_struct.geometryShader = geometryShader;
		return *this;
	}
	Bool32 tessellationShader() const
	{
		return m_struct.tessellationShader;
	}
	PhysicalDeviceFeatures &tessellationShader(Bool32 tessellationShader)
	{
		m_struct.tessellationShader = tessellationShader;
		return *this;
	}
	Bool32 sampleRateShading() const
	{
		return m_struct.sampleRateShading;
	}
	PhysicalDeviceFeatures &sampleRateShading(Bool32 sampleRateShading)
	{
		m_struct.sampleRateShading = sampleRateShading;
		return *this;
	}
	Bool32 dualSrcBlend() const
	{
		return m_struct.dualSrcBlend;
	}
	PhysicalDeviceFeatures &dualSrcBlend(Bool32 dualSrcBlend)
	{
		m_struct.dualSrcBlend = dualSrcBlend;
		return *this;
	}
	Bool32 logicOp() const
	{
		return m_struct.logicOp;
	}
	PhysicalDeviceFeatures &logicOp(Bool32 logicOp)
	{
		m_struct.logicOp = logicOp;
		return *this;
	}
	Bool32 multiDrawIndirect() const
	{
		return m_struct.multiDrawIndirect;
	}
	PhysicalDeviceFeatures &multiDrawIndirect(Bool32 multiDrawIndirect)
	{
		m_struct.multiDrawIndirect = multiDrawIndirect;
		return *this;
	}
	Bool32 drawIndirectFirstInstance() const
	{
		return m_struct.drawIndirectFirstInstance;
	}
	PhysicalDeviceFeatures &drawIndirectFirstInstance(Bool32 drawIndirectFirstInstance)
	{
		m_struct.drawIndirectFirstInstance = drawIndirectFirstInstance;
		return *this;
	}
	Bool32 depthClamp() const
	{
		return m_struct.depthClamp;
	}
	PhysicalDeviceFeatures &depthClamp(Bool32 depthClamp)
	{
		m_struct.depthClamp = depthClamp;
		return *this;
	}
	Bool32 depthBiasClamp() const
	{
		return m_struct.depthBiasClamp;
	}
	PhysicalDeviceFeatures &depthBiasClamp(Bool32 depthBiasClamp)
	{
		m_struct.depthBiasClamp = depthBiasClamp;
		return *this;
	}
	Bool32 fillModeNonSolid() const
	{
		return m_struct.fillModeNonSolid;
	}
	PhysicalDeviceFeatures &fillModeNonSolid(Bool32 fillModeNonSolid)
	{
		m_struct.fillModeNonSolid = fillModeNonSolid;
		return *this;
	}
	Bool32 depthBounds() const
	{
		return m_struct.depthBounds;
	}
	PhysicalDeviceFeatures &depthBounds(Bool32 depthBounds)
	{
		m_struct.depthBounds = depthBounds;
		return *this;
	}
	Bool32 wideLines() const
	{
		return m_struct.wideLines;
	}
	PhysicalDeviceFeatures &wideLines(Bool32 wideLines)
	{
		m_struct.wideLines = wideLines;
		return *this;
	}
	Bool32 largePoints() const
	{
		return m_struct.largePoints;
	}
	PhysicalDeviceFeatures &largePoints(Bool32 largePoints)
	{
		m_struct.largePoints = largePoints;
		return *this;
	}
	Bool32 alphaToOne() const
	{
		return m_struct.alphaToOne;
	}
	PhysicalDeviceFeatures &alphaToOne(Bool32 alphaToOne)
	{
		m_struct.alphaToOne = alphaToOne;
		return *this;
	}
	Bool32 multiViewport() const
	{
		return m_struct.multiViewport;
	}
	PhysicalDeviceFeatures &multiViewport(Bool32 multiViewport)
	{
		m_struct.multiViewport = multiViewport;
		return *this;
	}
	Bool32 samplerAnisotropy() const
	{
		return m_struct.samplerAnisotropy;
	}
	PhysicalDeviceFeatures &samplerAnisotropy(Bool32 samplerAnisotropy)
	{
		m_struct.samplerAnisotropy = samplerAnisotropy;
		return *this;
	}
	Bool32 textureCompressionETC2() const
	{
		return m_struct.textureCompressionETC2;
	}
	PhysicalDeviceFeatures &textureCompressionETC2(Bool32 textureCompressionETC2)
	{
		m_struct.textureCompressionETC2 = textureCompressionETC2;
		return *this;
	}
	Bool32 textureCompressionASTC_LDR() const
	{
		return m_struct.textureCompressionASTC_LDR;
	}
	PhysicalDeviceFeatures &textureCompressionASTC_LDR(Bool32 textureCompressionASTC_LDR)
	{
		m_struct.textureCompressionASTC_LDR = textureCompressionASTC_LDR;
		return *this;
	}
	Bool32 textureCompressionBC() const
	{
		return m_struct.textureCompressionBC;
	}
	PhysicalDeviceFeatures &textureCompressionBC(Bool32 textureCompressionBC)
	{
		m_struct.textureCompressionBC = textureCompressionBC;
		return *this;
	}
	Bool32 occlusionQueryPrecise() const
	{
		return m_struct.occlusionQueryPrecise;
	}
	PhysicalDeviceFeatures &occlusionQueryPrecise(Bool32 occlusionQueryPrecise)
	{
		m_struct.occlusionQueryPrecise = occlusionQueryPrecise;
		return *this;
	}
	Bool32 pipelineStatisticsQuery() const
	{
		return m_struct.pipelineStatisticsQuery;
	}
	PhysicalDeviceFeatures &pipelineStatisticsQuery(Bool32 pipelineStatisticsQuery)
	{
		m_struct.pipelineStatisticsQuery = pipelineStatisticsQuery;
		return *this;
	}
	Bool32 vertexPipelineStoresAndAtomics() const
	{
		return m_struct.vertexPipelineStoresAndAtomics;
	}
	PhysicalDeviceFeatures &vertexPipelineStoresAndAtomics(Bool32 vertexPipelineStoresAndAtomics)
	{
		m_struct.vertexPipelineStoresAndAtomics = vertexPipelineStoresAndAtomics;
		return *this;
	}
	Bool32 fragmentStoresAndAtomics() const
	{
		return m_struct.fragmentStoresAndAtomics;
	}
	PhysicalDeviceFeatures &fragmentStoresAndAtomics(Bool32 fragmentStoresAndAtomics)
	{
		m_struct.fragmentStoresAndAtomics = fragmentStoresAndAtomics;
		return *this;
	}
	Bool32 shaderTessellationAndGeometryPointSize() const
	{
		return m_struct.shaderTessellationAndGeometryPointSize;
	}
	PhysicalDeviceFeatures &shaderTessellationAndGeometryPointSize(Bool32 shaderTessellationAndGeometryPointSize)
	{
		m_struct.shaderTessellationAndGeometryPointSize = shaderTessellationAndGeometryPointSize;
		return *this;
	}
	Bool32 shaderImageGatherExtended() const
	{
		return m_struct.shaderImageGatherExtended;
	}
	PhysicalDeviceFeatures &shaderImageGatherExtended(Bool32 shaderImageGatherExtended)
	{
		m_struct.shaderImageGatherExtended = shaderImageGatherExtended;
		return *this;
	}
	Bool32 shaderStorageImageExtendedFormats() const
	{
		return m_struct.shaderStorageImageExtendedFormats;
	}
	PhysicalDeviceFeatures &shaderStorageImageExtendedFormats(Bool32 shaderStorageImageExtendedFormats)
	{
		m_struct.shaderStorageImageExtendedFormats = shaderStorageImageExtendedFormats;
		return *this;
	}
	Bool32 shaderStorageImageMultisample() const
	{
		return m_struct.shaderStorageImageMultisample;
	}
	PhysicalDeviceFeatures &shaderStorageImageMultisample(Bool32 shaderStorageImageMultisample)
	{
		m_struct.shaderStorageImageMultisample = shaderStorageImageMultisample;
		return *this;
	}
	Bool32 shaderStorageImageReadWithoutFormat() const
	{
		return m_struct.shaderStorageImageReadWithoutFormat;
	}
	PhysicalDeviceFeatures &shaderStorageImageReadWithoutFormat(Bool32 shaderStorageImageReadWithoutFormat)
	{
		m_struct.shaderStorageImageReadWithoutFormat = shaderStorageImageReadWithoutFormat;
		return *this;
	}
	Bool32 shaderStorageImageWriteWithoutFormat() const
	{
		return m_struct.shaderStorageImageWriteWithoutFormat;
	}
	PhysicalDeviceFeatures &shaderStorageImageWriteWithoutFormat(Bool32 shaderStorageImageWriteWithoutFormat)
	{
		m_struct.shaderStorageImageWriteWithoutFormat = shaderStorageImageWriteWithoutFormat;
		return *this;
	}
	Bool32 shaderUniformBufferArrayDynamicIndexing() const
	{
		return m_struct.shaderUniformBufferArrayDynamicIndexing;
	}
	PhysicalDeviceFeatures &shaderUniformBufferArrayDynamicIndexing(Bool32 shaderUniformBufferArrayDynamicIndexing)
	{
		m_struct.shaderUniformBufferArrayDynamicIndexing = shaderUniformBufferArrayDynamicIndexing;
		return *this;
	}
	Bool32 shaderSampledImageArrayDynamicIndexing() const
	{
		return m_struct.shaderSampledImageArrayDynamicIndexing;
	}
	PhysicalDeviceFeatures &shaderSampledImageArrayDynamicIndexing(Bool32 shaderSampledImageArrayDynamicIndexing)
	{
		m_struct.shaderSampledImageArrayDynamicIndexing = shaderSampledImageArrayDynamicIndexing;
		return *this;
	}
	Bool32 shaderStorageBufferArrayDynamicIndexing() const
	{
		return m_struct.shaderStorageBufferArrayDynamicIndexing;
	}
	PhysicalDeviceFeatures &shaderStorageBufferArrayDynamicIndexing(Bool32 shaderStorageBufferArrayDynamicIndexing)
	{
		m_struct.shaderStorageBufferArrayDynamicIndexing = shaderStorageBufferArrayDynamicIndexing;
		return *this;
	}
	Bool32 shaderStorageImageArrayDynamicIndexing() const
	{
		return m_struct.shaderStorageImageArrayDynamicIndexing;
	}
	PhysicalDeviceFeatures &shaderStorageImageArrayDynamicIndexing(Bool32 shaderStorageImageArrayDynamicIndexing)
	{
		m_struct.shaderStorageImageArrayDynamicIndexing = shaderStorageImageArrayDynamicIndexing;
		return *this;
	}
	Bool32 shaderClipDistance() const
	{
		return m_struct.shaderClipDistance;
	}
	PhysicalDeviceFeatures &shaderClipDistance(Bool32 shaderClipDistance)
	{
		m_struct.shaderClipDistance = shaderClipDistance;
		return *this;
	}
	Bool32 shaderCullDistance() const
	{
		return m_struct.shaderCullDistance;
	}
	PhysicalDeviceFeatures &shaderCullDistance(Bool32 shaderCullDistance)
	{
		m_struct.shaderCullDistance = shaderCullDistance;
		return *this;
	}
	Bool32 shaderFloat64() const
	{
		return m_struct.shaderFloat64;
	}
	PhysicalDeviceFeatures &shaderFloat64(Bool32 shaderFloat64)
	{
		m_struct.shaderFloat64 = shaderFloat64;
		return *this;
	}
	Bool32 shaderInt64() const
	{
		return m_struct.shaderInt64;
	}
	PhysicalDeviceFeatures &shaderInt64(Bool32 shaderInt64)
	{
		m_struct.shaderInt64 = shaderInt64;
		return *this;
	}
	Bool32 shaderInt16() const
	{
		return m_struct.shaderInt16;
	}
	PhysicalDeviceFeatures &shaderInt16(Bool32 shaderInt16)
	{
		m_struct.shaderInt16 = shaderInt16;
		return *this;
	}
	Bool32 shaderResourceResidency() const
	{
		return m_struct.shaderResourceResidency;
	}
	PhysicalDeviceFeatures &shaderResourceResidency(Bool32 shaderResourceResidency)
	{
		m_struct.shaderResourceResidency = shaderResourceResidency;
		return *this;
	}
	Bool32 shaderResourceMinLod() const
	{
		return m_struct.shaderResourceMinLod;
	}
	PhysicalDeviceFeatures &shaderResourceMinLod(Bool32 shaderResourceMinLod)
	{
		m_struct.shaderResourceMinLod = shaderResourceMinLod;
		return *this;
	}
	Bool32 sparseBinding() const
	{
		return m_struct.sparseBinding;
	}
	PhysicalDeviceFeatures &sparseBinding(Bool32 sparseBinding)
	{
		m_struct.sparseBinding = sparseBinding;
		return *this;
	}
	Bool32 sparseResidencyBuffer() const
	{
		return m_struct.sparseResidencyBuffer;
	}
	PhysicalDeviceFeatures &sparseResidencyBuffer(Bool32 sparseResidencyBuffer)
	{
		m_struct.sparseResidencyBuffer = sparseResidencyBuffer;
		return *this;
	}
	Bool32 sparseResidencyImage2D() const
	{
		return m_struct.sparseResidencyImage2D;
	}
	PhysicalDeviceFeatures &sparseResidencyImage2D(Bool32 sparseResidencyImage2D)
	{
		m_struct.sparseResidencyImage2D = sparseResidencyImage2D;
		return *this;
	}
	Bool32 sparseResidencyImage3D() const
	{
		return m_struct.sparseResidencyImage3D;
	}
	PhysicalDeviceFeatures &sparseResidencyImage3D(Bool32 sparseResidencyImage3D)
	{
		m_struct.sparseResidencyImage3D = sparseResidencyImage3D;
		return *this;
	}
	Bool32 sparseResidency2Samples() const
	{
		return m_struct.sparseResidency2Samples;
	}
	PhysicalDeviceFeatures &sparseResidency2Samples(Bool32 sparseResidency2Samples)
	{
		m_struct.sparseResidency2Samples = sparseResidency2Samples;
		return *this;
	}
	Bool32 sparseResidency4Samples() const
	{
		return m_struct.sparseResidency4Samples;
	}
	PhysicalDeviceFeatures &sparseResidency4Samples(Bool32 sparseResidency4Samples)
	{
		m_struct.sparseResidency4Samples = sparseResidency4Samples;
		return *this;
	}
	Bool32 sparseResidency8Samples() const
	{
		return m_struct.sparseResidency8Samples;
	}
	PhysicalDeviceFeatures &sparseResidency8Samples(Bool32 sparseResidency8Samples)
	{
		m_struct.sparseResidency8Samples = sparseResidency8Samples;
		return *this;
	}
	Bool32 sparseResidency16Samples() const
	{
		return m_struct.sparseResidency16Samples;
	}
	PhysicalDeviceFeatures &sparseResidency16Samples(Bool32 sparseResidency16Samples)
	{
		m_struct.sparseResidency16Samples = sparseResidency16Samples;
		return *this;
	}
	Bool32 sparseResidencyAliased() const
	{
		return m_struct.sparseResidencyAliased;
	}
	PhysicalDeviceFeatures &sparseResidencyAliased(Bool32 sparseResidencyAliased)
	{
		m_struct.sparseResidencyAliased = sparseResidencyAliased;
		return *this;
	}
	Bool32 variableMultisampleRate() const
	{
		return m_struct.variableMultisampleRate;
	}
	PhysicalDeviceFeatures &variableMultisampleRate(Bool32 variableMultisampleRate)
	{
		m_struct.variableMultisampleRate = variableMultisampleRate;
		return *this;
	}
	Bool32 inheritedQueries() const
	{
		return m_struct.inheritedQueries;
	}
	PhysicalDeviceFeatures &inheritedQueries(Bool32 inheritedQueries)
	{
		m_struct.inheritedQueries = inheritedQueries;
		return *this;
	}

	VkPhysicalDeviceFeatures *c_ptr() { return &m_struct; }
	const VkPhysicalDeviceFeatures *c_ptr() const { return &m_struct; }

	operator const VkPhysicalDeviceFeatures&() const { return m_struct; }
};

class PhysicalDeviceLimits {
	VkPhysicalDeviceLimits m_struct;
public:
	PhysicalDeviceLimits()
	{
		std::memset(&m_struct, 0, sizeof(VkPhysicalDeviceLimits));
		
	}
	PhysicalDeviceLimits(const VkPhysicalDeviceLimits &r): m_struct(r) {}

	
	uint32_t maxImageDimension1D() const
	{
		return m_struct.maxImageDimension1D;
	}
	
	uint32_t maxImageDimension2D() const
	{
		return m_struct.maxImageDimension2D;
	}
	
	uint32_t maxImageDimension3D() const
	{
		return m_struct.maxImageDimension3D;
	}
	
	uint32_t maxImageDimensionCube() const
	{
		return m_struct.maxImageDimensionCube;
	}
	
	uint32_t maxImageArrayLayers() const
	{
		return m_struct.maxImageArrayLayers;
	}
	
	uint32_t maxTexelBufferElements() const
	{
		return m_struct.maxTexelBufferElements;
	}
	
	uint32_t maxUniformBufferRange() const
	{
		return m_struct.maxUniformBufferRange;
	}
	
	uint32_t maxStorageBufferRange() const
	{
		return m_struct.maxStorageBufferRange;
	}
	
	uint32_t maxPushConstantsSize() const
	{
		return m_struct.maxPushConstantsSize;
	}
	
	uint32_t maxMemoryAllocationCount() const
	{
		return m_struct.maxMemoryAllocationCount;
	}
	
	uint32_t maxSamplerAllocationCount() const
	{
		return m_struct.maxSamplerAllocationCount;
	}
	
	DeviceSize bufferImageGranularity() const
	{
		return m_struct.bufferImageGranularity;
	}
	
	DeviceSize sparseAddressSpaceSize() const
	{
		return m_struct.sparseAddressSpaceSize;
	}
	
	uint32_t maxBoundDescriptorSets() const
	{
		return m_struct.maxBoundDescriptorSets;
	}
	
	uint32_t maxPerStageDescriptorSamplers() const
	{
		return m_struct.maxPerStageDescriptorSamplers;
	}
	
	uint32_t maxPerStageDescriptorUniformBuffers() const
	{
		return m_struct.maxPerStageDescriptorUniformBuffers;
	}
	
	uint32_t maxPerStageDescriptorStorageBuffers() const
	{
		return m_struct.maxPerStageDescriptorStorageBuffers;
	}
	
	uint32_t maxPerStageDescriptorSampledImages() const
	{
		return m_struct.maxPerStageDescriptorSampledImages;
	}
	
	uint32_t maxPerStageDescriptorStorageImages() const
	{
		return m_struct.maxPerStageDescriptorStorageImages;
	}
	
	uint32_t maxPerStageDescriptorInputAttachments() const
	{
		return m_struct.maxPerStageDescriptorInputAttachments;
	}
	
	uint32_t maxPerStageResources() const
	{
		return m_struct.maxPerStageResources;
	}
	
	uint32_t maxDescriptorSetSamplers() const
	{
		return m_struct.maxDescriptorSetSamplers;
	}
	
	uint32_t maxDescriptorSetUniformBuffers() const
	{
		return m_struct.maxDescriptorSetUniformBuffers;
	}
	
	uint32_t maxDescriptorSetUniformBuffersDynamic() const
	{
		return m_struct.maxDescriptorSetUniformBuffersDynamic;
	}
	
	uint32_t maxDescriptorSetStorageBuffers() const
	{
		return m_struct.maxDescriptorSetStorageBuffers;
	}
	
	uint32_t maxDescriptorSetStorageBuffersDynamic() const
	{
		return m_struct.maxDescriptorSetStorageBuffersDynamic;
	}
	
	uint32_t maxDescriptorSetSampledImages() const
	{
		return m_struct.maxDescriptorSetSampledImages;
	}
	
	uint32_t maxDescriptorSetStorageImages() const
	{
		return m_struct.maxDescriptorSetStorageImages;
	}
	
	uint32_t maxDescriptorSetInputAttachments() const
	{
		return m_struct.maxDescriptorSetInputAttachments;
	}
	
	uint32_t maxVertexInputAttributes() const
	{
		return m_struct.maxVertexInputAttributes;
	}
	
	uint32_t maxVertexInputBindings() const
	{
		return m_struct.maxVertexInputBindings;
	}
	
	uint32_t maxVertexInputAttributeOffset() const
	{
		return m_struct.maxVertexInputAttributeOffset;
	}
	
	uint32_t maxVertexInputBindingStride() const
	{
		return m_struct.maxVertexInputBindingStride;
	}
	
	uint32_t maxVertexOutputComponents() const
	{
		return m_struct.maxVertexOutputComponents;
	}
	
	uint32_t maxTessellationGenerationLevel() const
	{
		return m_struct.maxTessellationGenerationLevel;
	}
	
	uint32_t maxTessellationPatchSize() const
	{
		return m_struct.maxTessellationPatchSize;
	}
	
	uint32_t maxTessellationControlPerVertexInputComponents() const
	{
		return m_struct.maxTessellationControlPerVertexInputComponents;
	}
	
	uint32_t maxTessellationControlPerVertexOutputComponents() const
	{
		return m_struct.maxTessellationControlPerVertexOutputComponents;
	}
	
	uint32_t maxTessellationControlPerPatchOutputComponents() const
	{
		return m_struct.maxTessellationControlPerPatchOutputComponents;
	}
	
	uint32_t maxTessellationControlTotalOutputComponents() const
	{
		return m_struct.maxTessellationControlTotalOutputComponents;
	}
	
	uint32_t maxTessellationEvaluationInputComponents() const
	{
		return m_struct.maxTessellationEvaluationInputComponents;
	}
	
	uint32_t maxTessellationEvaluationOutputComponents() const
	{
		return m_struct.maxTessellationEvaluationOutputComponents;
	}
	
	uint32_t maxGeometryShaderInvocations() const
	{
		return m_struct.maxGeometryShaderInvocations;
	}
	
	uint32_t maxGeometryInputComponents() const
	{
		return m_struct.maxGeometryInputComponents;
	}
	
	uint32_t maxGeometryOutputComponents() const
	{
		return m_struct.maxGeometryOutputComponents;
	}
	
	uint32_t maxGeometryOutputVertices() const
	{
		return m_struct.maxGeometryOutputVertices;
	}
	
	uint32_t maxGeometryTotalOutputComponents() const
	{
		return m_struct.maxGeometryTotalOutputComponents;
	}
	
	uint32_t maxFragmentInputComponents() const
	{
		return m_struct.maxFragmentInputComponents;
	}
	
	uint32_t maxFragmentOutputAttachments() const
	{
		return m_struct.maxFragmentOutputAttachments;
	}
	
	uint32_t maxFragmentDualSrcAttachments() const
	{
		return m_struct.maxFragmentDualSrcAttachments;
	}
	
	uint32_t maxFragmentCombinedOutputResources() const
	{
		return m_struct.maxFragmentCombinedOutputResources;
	}
	
	uint32_t maxComputeSharedMemorySize() const
	{
		return m_struct.maxComputeSharedMemorySize;
	}
	
	const uint32_t* maxComputeWorkGroupCount() const
	{
		return reinterpret_cast<const uint32_t*>(m_struct.maxComputeWorkGroupCount);
	}
	
	uint32_t maxComputeWorkGroupInvocations() const
	{
		return m_struct.maxComputeWorkGroupInvocations;
	}
	
	const uint32_t* maxComputeWorkGroupSize() const
	{
		return reinterpret_cast<const uint32_t*>(m_struct.maxComputeWorkGroupSize);
	}
	
	uint32_t subPixelPrecisionBits() const
	{
		return m_struct.subPixelPrecisionBits;
	}
	
	uint32_t subTexelPrecisionBits() const
	{
		return m_struct.subTexelPrecisionBits;
	}
	
	uint32_t mipmapPrecisionBits() const
	{
		return m_struct.mipmapPrecisionBits;
	}
	
	uint32_t maxDrawIndexedIndexValue() const
	{
		return m_struct.maxDrawIndexedIndexValue;
	}
	
	uint32_t maxDrawIndirectCount() const
	{
		return m_struct.maxDrawIndirectCount;
	}
	
	float maxSamplerLodBias() const
	{
		return m_struct.maxSamplerLodBias;
	}
	
	float maxSamplerAnisotropy() const
	{
		return m_struct.maxSamplerAnisotropy;
	}
	
	uint32_t maxViewports() const
	{
		return m_struct.maxViewports;
	}
	
	const uint32_t* maxViewportDimensions() const
	{
		return reinterpret_cast<const uint32_t*>(m_struct.maxViewportDimensions);
	}
	
	const float* viewportBoundsRange() const
	{
		return reinterpret_cast<const float*>(m_struct.viewportBoundsRange);
	}
	
	uint32_t viewportSubPixelBits() const
	{
		return m_struct.viewportSubPixelBits;
	}
	
	size_t minMemoryMapAlignment() const
	{
		return m_struct.minMemoryMapAlignment;
	}
	
	DeviceSize minTexelBufferOffsetAlignment() const
	{
		return m_struct.minTexelBufferOffsetAlignment;
	}
	
	DeviceSize minUniformBufferOffsetAlignment() const
	{
		return m_struct.minUniformBufferOffsetAlignment;
	}
	
	DeviceSize minStorageBufferOffsetAlignment() const
	{
		return m_struct.minStorageBufferOffsetAlignment;
	}
	
	int32_t minTexelOffset() const
	{
		return m_struct.minTexelOffset;
	}
	
	uint32_t maxTexelOffset() const
	{
		return m_struct.maxTexelOffset;
	}
	
	int32_t minTexelGatherOffset() const
	{
		return m_struct.minTexelGatherOffset;
	}
	
	uint32_t maxTexelGatherOffset() const
	{
		return m_struct.maxTexelGatherOffset;
	}
	
	float minInterpolationOffset() const
	{
		return m_struct.minInterpolationOffset;
	}
	
	float maxInterpolationOffset() const
	{
		return m_struct.maxInterpolationOffset;
	}
	
	uint32_t subPixelInterpolationOffsetBits() const
	{
		return m_struct.subPixelInterpolationOffsetBits;
	}
	
	uint32_t maxFramebufferWidth() const
	{
		return m_struct.maxFramebufferWidth;
	}
	
	uint32_t maxFramebufferHeight() const
	{
		return m_struct.maxFramebufferHeight;
	}
	
	uint32_t maxFramebufferLayers() const
	{
		return m_struct.maxFramebufferLayers;
	}
	
	SampleCountFlags framebufferColorSampleCounts() const
	{
		return SampleCountFlags(m_struct.framebufferColorSampleCounts);
	}
	
	SampleCountFlags framebufferDepthSampleCounts() const
	{
		return SampleCountFlags(m_struct.framebufferDepthSampleCounts);
	}
	
	SampleCountFlags framebufferStencilSampleCounts() const
	{
		return SampleCountFlags(m_struct.framebufferStencilSampleCounts);
	}
	
	SampleCountFlags framebufferNoAttachmentsSampleCounts() const
	{
		return SampleCountFlags(m_struct.framebufferNoAttachmentsSampleCounts);
	}
	
	uint32_t maxColorAttachments() const
	{
		return m_struct.maxColorAttachments;
	}
	
	SampleCountFlags sampledImageColorSampleCounts() const
	{
		return SampleCountFlags(m_struct.sampledImageColorSampleCounts);
	}
	
	SampleCountFlags sampledImageIntegerSampleCounts() const
	{
		return SampleCountFlags(m_struct.sampledImageIntegerSampleCounts);
	}
	
	SampleCountFlags sampledImageDepthSampleCounts() const
	{
		return SampleCountFlags(m_struct.sampledImageDepthSampleCounts);
	}
	
	SampleCountFlags sampledImageStencilSampleCounts() const
	{
		return SampleCountFlags(m_struct.sampledImageStencilSampleCounts);
	}
	
	SampleCountFlags storageImageSampleCounts() const
	{
		return SampleCountFlags(m_struct.storageImageSampleCounts);
	}
	
	uint32_t maxSampleMaskWords() const
	{
		return m_struct.maxSampleMaskWords;
	}
	
	Bool32 timestampComputeAndGraphics() const
	{
		return m_struct.timestampComputeAndGraphics;
	}
	
	float timestampPeriod() const
	{
		return m_struct.timestampPeriod;
	}
	
	uint32_t maxClipDistances() const
	{
		return m_struct.maxClipDistances;
	}
	
	uint32_t maxCullDistances() const
	{
		return m_struct.maxCullDistances;
	}
	
	uint32_t maxCombinedClipAndCullDistances() const
	{
		return m_struct.maxCombinedClipAndCullDistances;
	}
	
	uint32_t discreteQueuePriorities() const
	{
		return m_struct.discreteQueuePriorities;
	}
	
	const float* pointSizeRange() const
	{
		return reinterpret_cast<const float*>(m_struct.pointSizeRange);
	}
	
	const float* lineWidthRange() const
	{
		return reinterpret_cast<const float*>(m_struct.lineWidthRange);
	}
	
	float pointSizeGranularity() const
	{
		return m_struct.pointSizeGranularity;
	}
	
	float lineWidthGranularity() const
	{
		return m_struct.lineWidthGranularity;
	}
	
	Bool32 strictLines() const
	{
		return m_struct.strictLines;
	}
	
	Bool32 standardSampleLocations() const
	{
		return m_struct.standardSampleLocations;
	}
	
	DeviceSize optimalBufferCopyOffsetAlignment() const
	{
		return m_struct.optimalBufferCopyOffsetAlignment;
	}
	
	DeviceSize optimalBufferCopyRowPitchAlignment() const
	{
		return m_struct.optimalBufferCopyRowPitchAlignment;
	}
	
	DeviceSize nonCoherentAtomSize() const
	{
		return m_struct.nonCoherentAtomSize;
	}
	

	VkPhysicalDeviceLimits *c_ptr() { return &m_struct; }
	const VkPhysicalDeviceLimits *c_ptr() const { return &m_struct; }

	operator const VkPhysicalDeviceLimits&() const { return m_struct; }
};

class PhysicalDeviceSparseProperties {
	VkPhysicalDeviceSparseProperties m_struct;
public:
	PhysicalDeviceSparseProperties()
	{
		std::memset(&m_struct, 0, sizeof(VkPhysicalDeviceSparseProperties));
		
	}
	PhysicalDeviceSparseProperties(const VkPhysicalDeviceSparseProperties &r): m_struct(r) {}

	
	Bool32 residencyStandard2DBlockShape() const
	{
		return m_struct.residencyStandard2DBlockShape;
	}
	
	Bool32 residencyStandard2DMultisampleBlockShape() const
	{
		return m_struct.residencyStandard2DMultisampleBlockShape;
	}
	
	Bool32 residencyStandard3DBlockShape() const
	{
		return m_struct.residencyStandard3DBlockShape;
	}
	
	Bool32 residencyAlignedMipSize() const
	{
		return m_struct.residencyAlignedMipSize;
	}
	
	Bool32 residencyNonResidentStrict() const
	{
		return m_struct.residencyNonResidentStrict;
	}
	

	VkPhysicalDeviceSparseProperties *c_ptr() { return &m_struct; }
	const VkPhysicalDeviceSparseProperties *c_ptr() const { return &m_struct; }

	operator const VkPhysicalDeviceSparseProperties&() const { return m_struct; }
};

class PipelineCacheCreateInfo {
	VkPipelineCacheCreateInfo m_struct;
public:
	PipelineCacheCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkPipelineCacheCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
	}
	PipelineCacheCreateInfo(const VkPipelineCacheCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	PipelineCacheCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	PipelineCacheCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	PipelineCacheCreateFlags flags() const
	{
		return PipelineCacheCreateFlags(m_struct.flags);
	}
	PipelineCacheCreateInfo &flags(PipelineCacheCreateFlags flags)
	{
		m_struct.flags = static_cast<VkPipelineCacheCreateFlags>(flags);
		return *this;
	}
	size_t initialDataSize() const
	{
		return m_struct.initialDataSize;
	}
	PipelineCacheCreateInfo &initialDataSize(size_t initialDataSize)
	{
		m_struct.initialDataSize = initialDataSize;
		return *this;
	}
	const void* pInitialData() const
	{
		return m_struct.pInitialData;
	}
	PipelineCacheCreateInfo &pInitialData(const void* pInitialData)
	{
		m_struct.pInitialData = pInitialData;
		return *this;
	}

	VkPipelineCacheCreateInfo *c_ptr() { return &m_struct; }
	const VkPipelineCacheCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkPipelineCacheCreateInfo&() const { return m_struct; }
};

class PipelineColorBlendAttachmentState {
	VkPipelineColorBlendAttachmentState m_struct;
public:
	PipelineColorBlendAttachmentState()
	{
		std::memset(&m_struct, 0, sizeof(VkPipelineColorBlendAttachmentState));
		
	}
	PipelineColorBlendAttachmentState(const VkPipelineColorBlendAttachmentState &r): m_struct(r) {}

	
	Bool32 blendEnable() const
	{
		return m_struct.blendEnable;
	}
	PipelineColorBlendAttachmentState &blendEnable(Bool32 blendEnable)
	{
		m_struct.blendEnable = blendEnable;
		return *this;
	}
	BlendFactor srcColorBlendFactor() const
	{
		return static_cast<BlendFactor>(m_struct.srcColorBlendFactor);
	}
	PipelineColorBlendAttachmentState &srcColorBlendFactor(BlendFactor srcColorBlendFactor)
	{
		m_struct.srcColorBlendFactor = static_cast<VkBlendFactor>(srcColorBlendFactor);
		return *this;
	}
	BlendFactor dstColorBlendFactor() const
	{
		return static_cast<BlendFactor>(m_struct.dstColorBlendFactor);
	}
	PipelineColorBlendAttachmentState &dstColorBlendFactor(BlendFactor dstColorBlendFactor)
	{
		m_struct.dstColorBlendFactor = static_cast<VkBlendFactor>(dstColorBlendFactor);
		return *this;
	}
	BlendOp colorBlendOp() const
	{
		return static_cast<BlendOp>(m_struct.colorBlendOp);
	}
	PipelineColorBlendAttachmentState &colorBlendOp(BlendOp colorBlendOp)
	{
		m_struct.colorBlendOp = static_cast<VkBlendOp>(colorBlendOp);
		return *this;
	}
	BlendFactor srcAlphaBlendFactor() const
	{
		return static_cast<BlendFactor>(m_struct.srcAlphaBlendFactor);
	}
	PipelineColorBlendAttachmentState &srcAlphaBlendFactor(BlendFactor srcAlphaBlendFactor)
	{
		m_struct.srcAlphaBlendFactor = static_cast<VkBlendFactor>(srcAlphaBlendFactor);
		return *this;
	}
	BlendFactor dstAlphaBlendFactor() const
	{
		return static_cast<BlendFactor>(m_struct.dstAlphaBlendFactor);
	}
	PipelineColorBlendAttachmentState &dstAlphaBlendFactor(BlendFactor dstAlphaBlendFactor)
	{
		m_struct.dstAlphaBlendFactor = static_cast<VkBlendFactor>(dstAlphaBlendFactor);
		return *this;
	}
	BlendOp alphaBlendOp() const
	{
		return static_cast<BlendOp>(m_struct.alphaBlendOp);
	}
	PipelineColorBlendAttachmentState &alphaBlendOp(BlendOp alphaBlendOp)
	{
		m_struct.alphaBlendOp = static_cast<VkBlendOp>(alphaBlendOp);
		return *this;
	}
	ColorComponentFlags colorWriteMask() const
	{
		return ColorComponentFlags(m_struct.colorWriteMask);
	}
	PipelineColorBlendAttachmentState &colorWriteMask(ColorComponentFlags colorWriteMask)
	{
		m_struct.colorWriteMask = static_cast<VkColorComponentFlags>(colorWriteMask);
		return *this;
	}

	VkPipelineColorBlendAttachmentState *c_ptr() { return &m_struct; }
	const VkPipelineColorBlendAttachmentState *c_ptr() const { return &m_struct; }

	operator const VkPipelineColorBlendAttachmentState&() const { return m_struct; }
};

class PipelineDynamicStateCreateInfo {
	VkPipelineDynamicStateCreateInfo m_struct;
public:
	PipelineDynamicStateCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkPipelineDynamicStateCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
	}
	PipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	PipelineDynamicStateCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	PipelineDynamicStateCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	PipelineDynamicStateCreateFlags flags() const
	{
		return PipelineDynamicStateCreateFlags(m_struct.flags);
	}
	PipelineDynamicStateCreateInfo &flags(PipelineDynamicStateCreateFlags flags)
	{
		m_struct.flags = static_cast<VkPipelineDynamicStateCreateFlags>(flags);
		return *this;
	}
	uint32_t dynamicStateCount() const
	{
		return m_struct.dynamicStateCount;
	}
	PipelineDynamicStateCreateInfo &dynamicStateCount(uint32_t dynamicStateCount)
	{
		m_struct.dynamicStateCount = dynamicStateCount;
		return *this;
	}
	const DynamicState* pDynamicStates() const
	{
		return reinterpret_cast<const DynamicState*>(m_struct.pDynamicStates);
	}
	PipelineDynamicStateCreateInfo &pDynamicStates(const DynamicState* pDynamicStates)
	{
		m_struct.pDynamicStates = reinterpret_cast<const VkDynamicState*>(pDynamicStates);
		return *this;
	}

	VkPipelineDynamicStateCreateInfo *c_ptr() { return &m_struct; }
	const VkPipelineDynamicStateCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkPipelineDynamicStateCreateInfo&() const { return m_struct; }
};

class PipelineInputAssemblyStateCreateInfo {
	VkPipelineInputAssemblyStateCreateInfo m_struct;
public:
	PipelineInputAssemblyStateCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkPipelineInputAssemblyStateCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
	}
	PipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	PipelineInputAssemblyStateCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	PipelineInputAssemblyStateCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	PipelineInputAssemblyStateCreateFlags flags() const
	{
		return PipelineInputAssemblyStateCreateFlags(m_struct.flags);
	}
	PipelineInputAssemblyStateCreateInfo &flags(PipelineInputAssemblyStateCreateFlags flags)
	{
		m_struct.flags = static_cast<VkPipelineInputAssemblyStateCreateFlags>(flags);
		return *this;
	}
	PrimitiveTopology topology() const
	{
		return static_cast<PrimitiveTopology>(m_struct.topology);
	}
	PipelineInputAssemblyStateCreateInfo &topology(PrimitiveTopology topology)
	{
		m_struct.topology = static_cast<VkPrimitiveTopology>(topology);
		return *this;
	}
	Bool32 primitiveRestartEnable() const
	{
		return m_struct.primitiveRestartEnable;
	}
	PipelineInputAssemblyStateCreateInfo &primitiveRestartEnable(Bool32 primitiveRestartEnable)
	{
		m_struct.primitiveRestartEnable = primitiveRestartEnable;
		return *this;
	}

	VkPipelineInputAssemblyStateCreateInfo *c_ptr() { return &m_struct; }
	const VkPipelineInputAssemblyStateCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkPipelineInputAssemblyStateCreateInfo&() const { return m_struct; }
};

class PipelineMultisampleStateCreateInfo {
	VkPipelineMultisampleStateCreateInfo m_struct;
public:
	PipelineMultisampleStateCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkPipelineMultisampleStateCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
	}
	PipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	PipelineMultisampleStateCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	PipelineMultisampleStateCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	PipelineMultisampleStateCreateFlags flags() const
	{
		return PipelineMultisampleStateCreateFlags(m_struct.flags);
	}
	PipelineMultisampleStateCreateInfo &flags(PipelineMultisampleStateCreateFlags flags)
	{
		m_struct.flags = static_cast<VkPipelineMultisampleStateCreateFlags>(flags);
		return *this;
	}
	SampleCountFlagBits rasterizationSamples() const
	{
		return static_cast<SampleCountFlagBits>(m_struct.rasterizationSamples);
	}
	PipelineMultisampleStateCreateInfo &rasterizationSamples(SampleCountFlagBits rasterizationSamples)
	{
		m_struct.rasterizationSamples = static_cast<VkSampleCountFlagBits>(rasterizationSamples);
		return *this;
	}
	Bool32 sampleShadingEnable() const
	{
		return m_struct.sampleShadingEnable;
	}
	PipelineMultisampleStateCreateInfo &sampleShadingEnable(Bool32 sampleShadingEnable)
	{
		m_struct.sampleShadingEnable = sampleShadingEnable;
		return *this;
	}
	float minSampleShading() const
	{
		return m_struct.minSampleShading;
	}
	PipelineMultisampleStateCreateInfo &minSampleShading(float minSampleShading)
	{
		m_struct.minSampleShading = minSampleShading;
		return *this;
	}
	const SampleMask* pSampleMask() const
	{
		return m_struct.pSampleMask;
	}
	PipelineMultisampleStateCreateInfo &pSampleMask(const SampleMask* pSampleMask)
	{
		m_struct.pSampleMask = pSampleMask;
		return *this;
	}
	Bool32 alphaToCoverageEnable() const
	{
		return m_struct.alphaToCoverageEnable;
	}
	PipelineMultisampleStateCreateInfo &alphaToCoverageEnable(Bool32 alphaToCoverageEnable)
	{
		m_struct.alphaToCoverageEnable = alphaToCoverageEnable;
		return *this;
	}
	Bool32 alphaToOneEnable() const
	{
		return m_struct.alphaToOneEnable;
	}
	PipelineMultisampleStateCreateInfo &alphaToOneEnable(Bool32 alphaToOneEnable)
	{
		m_struct.alphaToOneEnable = alphaToOneEnable;
		return *this;
	}

	VkPipelineMultisampleStateCreateInfo *c_ptr() { return &m_struct; }
	const VkPipelineMultisampleStateCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkPipelineMultisampleStateCreateInfo&() const { return m_struct; }
};

class PipelineRasterizationStateCreateInfo {
	VkPipelineRasterizationStateCreateInfo m_struct;
public:
	PipelineRasterizationStateCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkPipelineRasterizationStateCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
	}
	PipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	PipelineRasterizationStateCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	PipelineRasterizationStateCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	PipelineRasterizationStateCreateFlags flags() const
	{
		return PipelineRasterizationStateCreateFlags(m_struct.flags);
	}
	PipelineRasterizationStateCreateInfo &flags(PipelineRasterizationStateCreateFlags flags)
	{
		m_struct.flags = static_cast<VkPipelineRasterizationStateCreateFlags>(flags);
		return *this;
	}
	Bool32 depthClampEnable() const
	{
		return m_struct.depthClampEnable;
	}
	PipelineRasterizationStateCreateInfo &depthClampEnable(Bool32 depthClampEnable)
	{
		m_struct.depthClampEnable = depthClampEnable;
		return *this;
	}
	Bool32 rasterizerDiscardEnable() const
	{
		return m_struct.rasterizerDiscardEnable;
	}
	PipelineRasterizationStateCreateInfo &rasterizerDiscardEnable(Bool32 rasterizerDiscardEnable)
	{
		m_struct.rasterizerDiscardEnable = rasterizerDiscardEnable;
		return *this;
	}
	PolygonMode polygonMode() const
	{
		return static_cast<PolygonMode>(m_struct.polygonMode);
	}
	PipelineRasterizationStateCreateInfo &polygonMode(PolygonMode polygonMode)
	{
		m_struct.polygonMode = static_cast<VkPolygonMode>(polygonMode);
		return *this;
	}
	CullModeFlags cullMode() const
	{
		return CullModeFlags(m_struct.cullMode);
	}
	PipelineRasterizationStateCreateInfo &cullMode(CullModeFlags cullMode)
	{
		m_struct.cullMode = static_cast<VkCullModeFlags>(cullMode);
		return *this;
	}
	FrontFace frontFace() const
	{
		return static_cast<FrontFace>(m_struct.frontFace);
	}
	PipelineRasterizationStateCreateInfo &frontFace(FrontFace frontFace)
	{
		m_struct.frontFace = static_cast<VkFrontFace>(frontFace);
		return *this;
	}
	Bool32 depthBiasEnable() const
	{
		return m_struct.depthBiasEnable;
	}
	PipelineRasterizationStateCreateInfo &depthBiasEnable(Bool32 depthBiasEnable)
	{
		m_struct.depthBiasEnable = depthBiasEnable;
		return *this;
	}
	float depthBiasConstantFactor() const
	{
		return m_struct.depthBiasConstantFactor;
	}
	PipelineRasterizationStateCreateInfo &depthBiasConstantFactor(float depthBiasConstantFactor)
	{
		m_struct.depthBiasConstantFactor = depthBiasConstantFactor;
		return *this;
	}
	float depthBiasClamp() const
	{
		return m_struct.depthBiasClamp;
	}
	PipelineRasterizationStateCreateInfo &depthBiasClamp(float depthBiasClamp)
	{
		m_struct.depthBiasClamp = depthBiasClamp;
		return *this;
	}
	float depthBiasSlopeFactor() const
	{
		return m_struct.depthBiasSlopeFactor;
	}
	PipelineRasterizationStateCreateInfo &depthBiasSlopeFactor(float depthBiasSlopeFactor)
	{
		m_struct.depthBiasSlopeFactor = depthBiasSlopeFactor;
		return *this;
	}
	float lineWidth() const
	{
		return m_struct.lineWidth;
	}
	PipelineRasterizationStateCreateInfo &lineWidth(float lineWidth)
	{
		m_struct.lineWidth = lineWidth;
		return *this;
	}

	VkPipelineRasterizationStateCreateInfo *c_ptr() { return &m_struct; }
	const VkPipelineRasterizationStateCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkPipelineRasterizationStateCreateInfo&() const { return m_struct; }
};

class PipelineTessellationStateCreateInfo {
	VkPipelineTessellationStateCreateInfo m_struct;
public:
	PipelineTessellationStateCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkPipelineTessellationStateCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO;
	}
	PipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	PipelineTessellationStateCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	PipelineTessellationStateCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	PipelineTessellationStateCreateFlags flags() const
	{
		return PipelineTessellationStateCreateFlags(m_struct.flags);
	}
	PipelineTessellationStateCreateInfo &flags(PipelineTessellationStateCreateFlags flags)
	{
		m_struct.flags = static_cast<VkPipelineTessellationStateCreateFlags>(flags);
		return *this;
	}
	uint32_t patchControlPoints() const
	{
		return m_struct.patchControlPoints;
	}
	PipelineTessellationStateCreateInfo &patchControlPoints(uint32_t patchControlPoints)
	{
		m_struct.patchControlPoints = patchControlPoints;
		return *this;
	}

	VkPipelineTessellationStateCreateInfo *c_ptr() { return &m_struct; }
	const VkPipelineTessellationStateCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkPipelineTessellationStateCreateInfo&() const { return m_struct; }
};

class PresentInfoKHR {
	VkPresentInfoKHR m_struct;
public:
	PresentInfoKHR()
	{
		std::memset(&m_struct, 0, sizeof(VkPresentInfoKHR));
		m_struct.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
	}
	PresentInfoKHR(const VkPresentInfoKHR &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	PresentInfoKHR &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	PresentInfoKHR &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	uint32_t waitSemaphoreCount() const
	{
		return m_struct.waitSemaphoreCount;
	}
	PresentInfoKHR &waitSemaphoreCount(uint32_t waitSemaphoreCount)
	{
		m_struct.waitSemaphoreCount = waitSemaphoreCount;
		return *this;
	}
	const Semaphore* pWaitSemaphores() const
	{
		return reinterpret_cast<const Semaphore*>(m_struct.pWaitSemaphores);
	}
	PresentInfoKHR &pWaitSemaphores(const Semaphore* pWaitSemaphores)
	{
		m_struct.pWaitSemaphores = reinterpret_cast<const VkSemaphore*>(pWaitSemaphores);
		return *this;
	}
	uint32_t swapchainCount() const
	{
		return m_struct.swapchainCount;
	}
	PresentInfoKHR &swapchainCount(uint32_t swapchainCount)
	{
		m_struct.swapchainCount = swapchainCount;
		return *this;
	}
	const SwapchainKHR* pSwapchains() const
	{
		return reinterpret_cast<const SwapchainKHR*>(m_struct.pSwapchains);
	}
	PresentInfoKHR &pSwapchains(const SwapchainKHR* pSwapchains)
	{
		m_struct.pSwapchains = reinterpret_cast<const VkSwapchainKHR*>(pSwapchains);
		return *this;
	}
	const uint32_t* pImageIndices() const
	{
		return m_struct.pImageIndices;
	}
	PresentInfoKHR &pImageIndices(const uint32_t* pImageIndices)
	{
		m_struct.pImageIndices = pImageIndices;
		return *this;
	}
	const Result* pResults() const
	{
		return reinterpret_cast<Result*>(m_struct.pResults);
	}
	PresentInfoKHR &pResults(Result* pResults)
	{
		m_struct.pResults = reinterpret_cast<VkResult*>(pResults);
		return *this;
	}

	VkPresentInfoKHR *c_ptr() { return &m_struct; }
	const VkPresentInfoKHR *c_ptr() const { return &m_struct; }

	operator const VkPresentInfoKHR&() const { return m_struct; }
};

class PushConstantRange {
	VkPushConstantRange m_struct;
public:
	PushConstantRange()
	{
		std::memset(&m_struct, 0, sizeof(VkPushConstantRange));
		
	}
	PushConstantRange(const VkPushConstantRange &r): m_struct(r) {}

	
	ShaderStageFlags stageFlags() const
	{
		return ShaderStageFlags(m_struct.stageFlags);
	}
	PushConstantRange &stageFlags(ShaderStageFlags stageFlags)
	{
		m_struct.stageFlags = static_cast<VkShaderStageFlags>(stageFlags);
		return *this;
	}
	uint32_t offset() const
	{
		return m_struct.offset;
	}
	PushConstantRange &offset(uint32_t offset)
	{
		m_struct.offset = offset;
		return *this;
	}
	uint32_t size() const
	{
		return m_struct.size;
	}
	PushConstantRange &size(uint32_t size)
	{
		m_struct.size = size;
		return *this;
	}

	VkPushConstantRange *c_ptr() { return &m_struct; }
	const VkPushConstantRange *c_ptr() const { return &m_struct; }

	operator const VkPushConstantRange&() const { return m_struct; }
};

class QueryPoolCreateInfo {
	VkQueryPoolCreateInfo m_struct;
public:
	QueryPoolCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkQueryPoolCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
	}
	QueryPoolCreateInfo(const VkQueryPoolCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	QueryPoolCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	QueryPoolCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	QueryPoolCreateFlags flags() const
	{
		return QueryPoolCreateFlags(m_struct.flags);
	}
	QueryPoolCreateInfo &flags(QueryPoolCreateFlags flags)
	{
		m_struct.flags = static_cast<VkQueryPoolCreateFlags>(flags);
		return *this;
	}
	QueryType queryType() const
	{
		return static_cast<QueryType>(m_struct.queryType);
	}
	QueryPoolCreateInfo &queryType(QueryType queryType)
	{
		m_struct.queryType = static_cast<VkQueryType>(queryType);
		return *this;
	}
	uint32_t queryCount() const
	{
		return m_struct.queryCount;
	}
	QueryPoolCreateInfo &queryCount(uint32_t queryCount)
	{
		m_struct.queryCount = queryCount;
		return *this;
	}
	QueryPipelineStatisticFlags pipelineStatistics() const
	{
		return QueryPipelineStatisticFlags(m_struct.pipelineStatistics);
	}
	QueryPoolCreateInfo &pipelineStatistics(QueryPipelineStatisticFlags pipelineStatistics)
	{
		m_struct.pipelineStatistics = static_cast<VkQueryPipelineStatisticFlags>(pipelineStatistics);
		return *this;
	}

	VkQueryPoolCreateInfo *c_ptr() { return &m_struct; }
	const VkQueryPoolCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkQueryPoolCreateInfo&() const { return m_struct; }
};

class SamplerCreateInfo {
	VkSamplerCreateInfo m_struct;
public:
	SamplerCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkSamplerCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
	}
	SamplerCreateInfo(const VkSamplerCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	SamplerCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	SamplerCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	SamplerCreateFlags flags() const
	{
		return SamplerCreateFlags(m_struct.flags);
	}
	SamplerCreateInfo &flags(SamplerCreateFlags flags)
	{
		m_struct.flags = static_cast<VkSamplerCreateFlags>(flags);
		return *this;
	}
	Filter magFilter() const
	{
		return static_cast<Filter>(m_struct.magFilter);
	}
	SamplerCreateInfo &magFilter(Filter magFilter)
	{
		m_struct.magFilter = static_cast<VkFilter>(magFilter);
		return *this;
	}
	Filter minFilter() const
	{
		return static_cast<Filter>(m_struct.minFilter);
	}
	SamplerCreateInfo &minFilter(Filter minFilter)
	{
		m_struct.minFilter = static_cast<VkFilter>(minFilter);
		return *this;
	}
	SamplerMipmapMode mipmapMode() const
	{
		return static_cast<SamplerMipmapMode>(m_struct.mipmapMode);
	}
	SamplerCreateInfo &mipmapMode(SamplerMipmapMode mipmapMode)
	{
		m_struct.mipmapMode = static_cast<VkSamplerMipmapMode>(mipmapMode);
		return *this;
	}
	SamplerAddressMode addressModeU() const
	{
		return static_cast<SamplerAddressMode>(m_struct.addressModeU);
	}
	SamplerCreateInfo &addressModeU(SamplerAddressMode addressModeU)
	{
		m_struct.addressModeU = static_cast<VkSamplerAddressMode>(addressModeU);
		return *this;
	}
	SamplerAddressMode addressModeV() const
	{
		return static_cast<SamplerAddressMode>(m_struct.addressModeV);
	}
	SamplerCreateInfo &addressModeV(SamplerAddressMode addressModeV)
	{
		m_struct.addressModeV = static_cast<VkSamplerAddressMode>(addressModeV);
		return *this;
	}
	SamplerAddressMode addressModeW() const
	{
		return static_cast<SamplerAddressMode>(m_struct.addressModeW);
	}
	SamplerCreateInfo &addressModeW(SamplerAddressMode addressModeW)
	{
		m_struct.addressModeW = static_cast<VkSamplerAddressMode>(addressModeW);
		return *this;
	}
	float mipLodBias() const
	{
		return m_struct.mipLodBias;
	}
	SamplerCreateInfo &mipLodBias(float mipLodBias)
	{
		m_struct.mipLodBias = mipLodBias;
		return *this;
	}
	Bool32 anisotropyEnable() const
	{
		return m_struct.anisotropyEnable;
	}
	SamplerCreateInfo &anisotropyEnable(Bool32 anisotropyEnable)
	{
		m_struct.anisotropyEnable = anisotropyEnable;
		return *this;
	}
	float maxAnisotropy() const
	{
		return m_struct.maxAnisotropy;
	}
	SamplerCreateInfo &maxAnisotropy(float maxAnisotropy)
	{
		m_struct.maxAnisotropy = maxAnisotropy;
		return *this;
	}
	Bool32 compareEnable() const
	{
		return m_struct.compareEnable;
	}
	SamplerCreateInfo &compareEnable(Bool32 compareEnable)
	{
		m_struct.compareEnable = compareEnable;
		return *this;
	}
	CompareOp compareOp() const
	{
		return static_cast<CompareOp>(m_struct.compareOp);
	}
	SamplerCreateInfo &compareOp(CompareOp compareOp)
	{
		m_struct.compareOp = static_cast<VkCompareOp>(compareOp);
		return *this;
	}
	float minLod() const
	{
		return m_struct.minLod;
	}
	SamplerCreateInfo &minLod(float minLod)
	{
		m_struct.minLod = minLod;
		return *this;
	}
	float maxLod() const
	{
		return m_struct.maxLod;
	}
	SamplerCreateInfo &maxLod(float maxLod)
	{
		m_struct.maxLod = maxLod;
		return *this;
	}
	BorderColor borderColor() const
	{
		return static_cast<BorderColor>(m_struct.borderColor);
	}
	SamplerCreateInfo &borderColor(BorderColor borderColor)
	{
		m_struct.borderColor = static_cast<VkBorderColor>(borderColor);
		return *this;
	}
	Bool32 unnormalizedCoordinates() const
	{
		return m_struct.unnormalizedCoordinates;
	}
	SamplerCreateInfo &unnormalizedCoordinates(Bool32 unnormalizedCoordinates)
	{
		m_struct.unnormalizedCoordinates = unnormalizedCoordinates;
		return *this;
	}

	VkSamplerCreateInfo *c_ptr() { return &m_struct; }
	const VkSamplerCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkSamplerCreateInfo&() const { return m_struct; }
};

class SemaphoreCreateInfo {
	VkSemaphoreCreateInfo m_struct;
public:
	SemaphoreCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkSemaphoreCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
	}
	SemaphoreCreateInfo(const VkSemaphoreCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	SemaphoreCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	SemaphoreCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	SemaphoreCreateFlags flags() const
	{
		return SemaphoreCreateFlags(m_struct.flags);
	}
	SemaphoreCreateInfo &flags(SemaphoreCreateFlags flags)
	{
		m_struct.flags = static_cast<VkSemaphoreCreateFlags>(flags);
		return *this;
	}

	VkSemaphoreCreateInfo *c_ptr() { return &m_struct; }
	const VkSemaphoreCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkSemaphoreCreateInfo&() const { return m_struct; }
};

class ShaderModuleCreateInfo {
	VkShaderModuleCreateInfo m_struct;
public:
	ShaderModuleCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkShaderModuleCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
	}
	ShaderModuleCreateInfo(const VkShaderModuleCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	ShaderModuleCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	ShaderModuleCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	ShaderModuleCreateFlags flags() const
	{
		return ShaderModuleCreateFlags(m_struct.flags);
	}
	ShaderModuleCreateInfo &flags(ShaderModuleCreateFlags flags)
	{
		m_struct.flags = static_cast<VkShaderModuleCreateFlags>(flags);
		return *this;
	}
	size_t codeSize() const
	{
		return m_struct.codeSize;
	}
	ShaderModuleCreateInfo &codeSize(size_t codeSize)
	{
		m_struct.codeSize = codeSize;
		return *this;
	}
	const uint32_t* pCode() const
	{
		return m_struct.pCode;
	}
	ShaderModuleCreateInfo &pCode(const uint32_t* pCode)
	{
		m_struct.pCode = pCode;
		return *this;
	}

	VkShaderModuleCreateInfo *c_ptr() { return &m_struct; }
	const VkShaderModuleCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkShaderModuleCreateInfo&() const { return m_struct; }
};

class SparseMemoryBind {
	VkSparseMemoryBind m_struct;
public:
	SparseMemoryBind()
	{
		std::memset(&m_struct, 0, sizeof(VkSparseMemoryBind));
		
	}
	SparseMemoryBind(const VkSparseMemoryBind &r): m_struct(r) {}

	
	DeviceSize resourceOffset() const
	{
		return m_struct.resourceOffset;
	}
	SparseMemoryBind &resourceOffset(DeviceSize resourceOffset)
	{
		m_struct.resourceOffset = resourceOffset;
		return *this;
	}
	DeviceSize size() const
	{
		return m_struct.size;
	}
	SparseMemoryBind &size(DeviceSize size)
	{
		m_struct.size = size;
		return *this;
	}
	DeviceMemory memory() const
	{
		return DeviceMemory(m_struct.memory);
	}
	SparseMemoryBind &memory(DeviceMemory memory)
	{
		m_struct.memory = static_cast<VkDeviceMemory>(memory);
		return *this;
	}
	DeviceSize memoryOffset() const
	{
		return m_struct.memoryOffset;
	}
	SparseMemoryBind &memoryOffset(DeviceSize memoryOffset)
	{
		m_struct.memoryOffset = memoryOffset;
		return *this;
	}
	SparseMemoryBindFlags flags() const
	{
		return SparseMemoryBindFlags(m_struct.flags);
	}
	SparseMemoryBind &flags(SparseMemoryBindFlags flags)
	{
		m_struct.flags = static_cast<VkSparseMemoryBindFlags>(flags);
		return *this;
	}

	VkSparseMemoryBind *c_ptr() { return &m_struct; }
	const VkSparseMemoryBind *c_ptr() const { return &m_struct; }

	operator const VkSparseMemoryBind&() const { return m_struct; }
};

class SpecializationMapEntry {
	VkSpecializationMapEntry m_struct;
public:
	SpecializationMapEntry()
	{
		std::memset(&m_struct, 0, sizeof(VkSpecializationMapEntry));
		
	}
	SpecializationMapEntry(const VkSpecializationMapEntry &r): m_struct(r) {}

	
	uint32_t constantID() const
	{
		return m_struct.constantID;
	}
	SpecializationMapEntry &constantID(uint32_t constantID)
	{
		m_struct.constantID = constantID;
		return *this;
	}
	uint32_t offset() const
	{
		return m_struct.offset;
	}
	SpecializationMapEntry &offset(uint32_t offset)
	{
		m_struct.offset = offset;
		return *this;
	}
	size_t size() const
	{
		return m_struct.size;
	}
	SpecializationMapEntry &size(size_t size)
	{
		m_struct.size = size;
		return *this;
	}

	VkSpecializationMapEntry *c_ptr() { return &m_struct; }
	const VkSpecializationMapEntry *c_ptr() const { return &m_struct; }

	operator const VkSpecializationMapEntry&() const { return m_struct; }
};

class StencilOpState {
	VkStencilOpState m_struct;
public:
	StencilOpState()
	{
		std::memset(&m_struct, 0, sizeof(VkStencilOpState));
		
	}
	StencilOpState(const VkStencilOpState &r): m_struct(r) {}

	
	StencilOp failOp() const
	{
		return static_cast<StencilOp>(m_struct.failOp);
	}
	StencilOpState &failOp(StencilOp failOp)
	{
		m_struct.failOp = static_cast<VkStencilOp>(failOp);
		return *this;
	}
	StencilOp passOp() const
	{
		return static_cast<StencilOp>(m_struct.passOp);
	}
	StencilOpState &passOp(StencilOp passOp)
	{
		m_struct.passOp = static_cast<VkStencilOp>(passOp);
		return *this;
	}
	StencilOp depthFailOp() const
	{
		return static_cast<StencilOp>(m_struct.depthFailOp);
	}
	StencilOpState &depthFailOp(StencilOp depthFailOp)
	{
		m_struct.depthFailOp = static_cast<VkStencilOp>(depthFailOp);
		return *this;
	}
	CompareOp compareOp() const
	{
		return static_cast<CompareOp>(m_struct.compareOp);
	}
	StencilOpState &compareOp(CompareOp compareOp)
	{
		m_struct.compareOp = static_cast<VkCompareOp>(compareOp);
		return *this;
	}
	uint32_t compareMask() const
	{
		return m_struct.compareMask;
	}
	StencilOpState &compareMask(uint32_t compareMask)
	{
		m_struct.compareMask = compareMask;
		return *this;
	}
	uint32_t writeMask() const
	{
		return m_struct.writeMask;
	}
	StencilOpState &writeMask(uint32_t writeMask)
	{
		m_struct.writeMask = writeMask;
		return *this;
	}
	uint32_t reference() const
	{
		return m_struct.reference;
	}
	StencilOpState &reference(uint32_t reference)
	{
		m_struct.reference = reference;
		return *this;
	}

	VkStencilOpState *c_ptr() { return &m_struct; }
	const VkStencilOpState *c_ptr() const { return &m_struct; }

	operator const VkStencilOpState&() const { return m_struct; }
};

class SubmitInfo {
	VkSubmitInfo m_struct;
public:
	SubmitInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkSubmitInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
	}
	SubmitInfo(const VkSubmitInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	SubmitInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	SubmitInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	uint32_t waitSemaphoreCount() const
	{
		return m_struct.waitSemaphoreCount;
	}
	SubmitInfo &waitSemaphoreCount(uint32_t waitSemaphoreCount)
	{
		m_struct.waitSemaphoreCount = waitSemaphoreCount;
		return *this;
	}
	const Semaphore* pWaitSemaphores() const
	{
		return reinterpret_cast<const Semaphore*>(m_struct.pWaitSemaphores);
	}
	SubmitInfo &pWaitSemaphores(const Semaphore* pWaitSemaphores)
	{
		m_struct.pWaitSemaphores = reinterpret_cast<const VkSemaphore*>(pWaitSemaphores);
		return *this;
	}
	const PipelineStageFlags* pWaitDstStageMask() const
	{
		return reinterpret_cast<const PipelineStageFlags*>(m_struct.pWaitDstStageMask);
	}
	SubmitInfo &pWaitDstStageMask(const PipelineStageFlags* pWaitDstStageMask)
	{
		m_struct.pWaitDstStageMask = reinterpret_cast<const VkPipelineStageFlags*>(pWaitDstStageMask);
		return *this;
	}
	uint32_t commandBufferCount() const
	{
		return m_struct.commandBufferCount;
	}
	SubmitInfo &commandBufferCount(uint32_t commandBufferCount)
	{
		m_struct.commandBufferCount = commandBufferCount;
		return *this;
	}
	const CommandBuffer* pCommandBuffers() const
	{
		return reinterpret_cast<const CommandBuffer*>(m_struct.pCommandBuffers);
	}
	SubmitInfo &pCommandBuffers(const CommandBuffer* pCommandBuffers)
	{
		m_struct.pCommandBuffers = reinterpret_cast<const VkCommandBuffer*>(pCommandBuffers);
		return *this;
	}
	uint32_t signalSemaphoreCount() const
	{
		return m_struct.signalSemaphoreCount;
	}
	SubmitInfo &signalSemaphoreCount(uint32_t signalSemaphoreCount)
	{
		m_struct.signalSemaphoreCount = signalSemaphoreCount;
		return *this;
	}
	const Semaphore* pSignalSemaphores() const
	{
		return reinterpret_cast<const Semaphore*>(m_struct.pSignalSemaphores);
	}
	SubmitInfo &pSignalSemaphores(const Semaphore* pSignalSemaphores)
	{
		m_struct.pSignalSemaphores = reinterpret_cast<const VkSemaphore*>(pSignalSemaphores);
		return *this;
	}

	VkSubmitInfo *c_ptr() { return &m_struct; }
	const VkSubmitInfo *c_ptr() const { return &m_struct; }

	operator const VkSubmitInfo&() const { return m_struct; }
};

class SubpassDependency {
	VkSubpassDependency m_struct;
public:
	SubpassDependency()
	{
		std::memset(&m_struct, 0, sizeof(VkSubpassDependency));
		
	}
	SubpassDependency(const VkSubpassDependency &r): m_struct(r) {}

	
	uint32_t srcSubpass() const
	{
		return m_struct.srcSubpass;
	}
	SubpassDependency &srcSubpass(uint32_t srcSubpass)
	{
		m_struct.srcSubpass = srcSubpass;
		return *this;
	}
	uint32_t dstSubpass() const
	{
		return m_struct.dstSubpass;
	}
	SubpassDependency &dstSubpass(uint32_t dstSubpass)
	{
		m_struct.dstSubpass = dstSubpass;
		return *this;
	}
	PipelineStageFlags srcStageMask() const
	{
		return PipelineStageFlags(m_struct.srcStageMask);
	}
	SubpassDependency &srcStageMask(PipelineStageFlags srcStageMask)
	{
		m_struct.srcStageMask = static_cast<VkPipelineStageFlags>(srcStageMask);
		return *this;
	}
	PipelineStageFlags dstStageMask() const
	{
		return PipelineStageFlags(m_struct.dstStageMask);
	}
	SubpassDependency &dstStageMask(PipelineStageFlags dstStageMask)
	{
		m_struct.dstStageMask = static_cast<VkPipelineStageFlags>(dstStageMask);
		return *this;
	}
	AccessFlags srcAccessMask() const
	{
		return AccessFlags(m_struct.srcAccessMask);
	}
	SubpassDependency &srcAccessMask(AccessFlags srcAccessMask)
	{
		m_struct.srcAccessMask = static_cast<VkAccessFlags>(srcAccessMask);
		return *this;
	}
	AccessFlags dstAccessMask() const
	{
		return AccessFlags(m_struct.dstAccessMask);
	}
	SubpassDependency &dstAccessMask(AccessFlags dstAccessMask)
	{
		m_struct.dstAccessMask = static_cast<VkAccessFlags>(dstAccessMask);
		return *this;
	}
	DependencyFlags dependencyFlags() const
	{
		return DependencyFlags(m_struct.dependencyFlags);
	}
	SubpassDependency &dependencyFlags(DependencyFlags dependencyFlags)
	{
		m_struct.dependencyFlags = static_cast<VkDependencyFlags>(dependencyFlags);
		return *this;
	}

	VkSubpassDependency *c_ptr() { return &m_struct; }
	const VkSubpassDependency *c_ptr() const { return &m_struct; }

	operator const VkSubpassDependency&() const { return m_struct; }
};

class SubresourceLayout {
	VkSubresourceLayout m_struct;
public:
	SubresourceLayout()
	{
		std::memset(&m_struct, 0, sizeof(VkSubresourceLayout));
		
	}
	SubresourceLayout(const VkSubresourceLayout &r): m_struct(r) {}

	
	DeviceSize offset() const
	{
		return m_struct.offset;
	}
	SubresourceLayout &offset(DeviceSize offset)
	{
		m_struct.offset = offset;
		return *this;
	}
	DeviceSize size() const
	{
		return m_struct.size;
	}
	SubresourceLayout &size(DeviceSize size)
	{
		m_struct.size = size;
		return *this;
	}
	DeviceSize rowPitch() const
	{
		return m_struct.rowPitch;
	}
	SubresourceLayout &rowPitch(DeviceSize rowPitch)
	{
		m_struct.rowPitch = rowPitch;
		return *this;
	}
	DeviceSize arrayPitch() const
	{
		return m_struct.arrayPitch;
	}
	SubresourceLayout &arrayPitch(DeviceSize arrayPitch)
	{
		m_struct.arrayPitch = arrayPitch;
		return *this;
	}
	DeviceSize depthPitch() const
	{
		return m_struct.depthPitch;
	}
	SubresourceLayout &depthPitch(DeviceSize depthPitch)
	{
		m_struct.depthPitch = depthPitch;
		return *this;
	}

	VkSubresourceLayout *c_ptr() { return &m_struct; }
	const VkSubresourceLayout *c_ptr() const { return &m_struct; }

	operator const VkSubresourceLayout&() const { return m_struct; }
};

class SurfaceFormatKHR {
	VkSurfaceFormatKHR m_struct;
public:
	SurfaceFormatKHR()
	{
		std::memset(&m_struct, 0, sizeof(VkSurfaceFormatKHR));
		
	}
	SurfaceFormatKHR(const VkSurfaceFormatKHR &r): m_struct(r) {}

	
	Format format() const
	{
		return static_cast<Format>(m_struct.format);
	}
	SurfaceFormatKHR &format(Format format)
	{
		m_struct.format = static_cast<VkFormat>(format);
		return *this;
	}
	ColorSpaceKHR colorSpace() const
	{
		return static_cast<ColorSpaceKHR>(m_struct.colorSpace);
	}
	SurfaceFormatKHR &colorSpace(ColorSpaceKHR colorSpace)
	{
		m_struct.colorSpace = static_cast<VkColorSpaceKHR>(colorSpace);
		return *this;
	}

	VkSurfaceFormatKHR *c_ptr() { return &m_struct; }
	const VkSurfaceFormatKHR *c_ptr() const { return &m_struct; }

	operator const VkSurfaceFormatKHR&() const { return m_struct; }
};

class VertexInputAttributeDescription {
	VkVertexInputAttributeDescription m_struct;
public:
	VertexInputAttributeDescription()
	{
		std::memset(&m_struct, 0, sizeof(VkVertexInputAttributeDescription));
		
	}
	VertexInputAttributeDescription(const VkVertexInputAttributeDescription &r): m_struct(r) {}

	
	uint32_t location() const
	{
		return m_struct.location;
	}
	VertexInputAttributeDescription &location(uint32_t location)
	{
		m_struct.location = location;
		return *this;
	}
	uint32_t binding() const
	{
		return m_struct.binding;
	}
	VertexInputAttributeDescription &binding(uint32_t binding)
	{
		m_struct.binding = binding;
		return *this;
	}
	Format format() const
	{
		return static_cast<Format>(m_struct.format);
	}
	VertexInputAttributeDescription &format(Format format)
	{
		m_struct.format = static_cast<VkFormat>(format);
		return *this;
	}
	uint32_t offset() const
	{
		return m_struct.offset;
	}
	VertexInputAttributeDescription &offset(uint32_t offset)
	{
		m_struct.offset = offset;
		return *this;
	}

	VkVertexInputAttributeDescription *c_ptr() { return &m_struct; }
	const VkVertexInputAttributeDescription *c_ptr() const { return &m_struct; }

	operator const VkVertexInputAttributeDescription&() const { return m_struct; }
};

class VertexInputBindingDescription {
	VkVertexInputBindingDescription m_struct;
public:
	VertexInputBindingDescription()
	{
		std::memset(&m_struct, 0, sizeof(VkVertexInputBindingDescription));
		
	}
	VertexInputBindingDescription(const VkVertexInputBindingDescription &r): m_struct(r) {}

	
	uint32_t binding() const
	{
		return m_struct.binding;
	}
	VertexInputBindingDescription &binding(uint32_t binding)
	{
		m_struct.binding = binding;
		return *this;
	}
	uint32_t stride() const
	{
		return m_struct.stride;
	}
	VertexInputBindingDescription &stride(uint32_t stride)
	{
		m_struct.stride = stride;
		return *this;
	}
	VertexInputRate inputRate() const
	{
		return static_cast<VertexInputRate>(m_struct.inputRate);
	}
	VertexInputBindingDescription &inputRate(VertexInputRate inputRate)
	{
		m_struct.inputRate = static_cast<VkVertexInputRate>(inputRate);
		return *this;
	}

	VkVertexInputBindingDescription *c_ptr() { return &m_struct; }
	const VkVertexInputBindingDescription *c_ptr() const { return &m_struct; }

	operator const VkVertexInputBindingDescription&() const { return m_struct; }
};

class Viewport {
	VkViewport m_struct;
public:
	Viewport()
	{
		std::memset(&m_struct, 0, sizeof(VkViewport));
		
	}
	Viewport(const VkViewport &r): m_struct(r) {}

	
	float x() const
	{
		return m_struct.x;
	}
	Viewport &x(float x)
	{
		m_struct.x = x;
		return *this;
	}
	float y() const
	{
		return m_struct.y;
	}
	Viewport &y(float y)
	{
		m_struct.y = y;
		return *this;
	}
	float width() const
	{
		return m_struct.width;
	}
	Viewport &width(float width)
	{
		m_struct.width = width;
		return *this;
	}
	float height() const
	{
		return m_struct.height;
	}
	Viewport &height(float height)
	{
		m_struct.height = height;
		return *this;
	}
	float minDepth() const
	{
		return m_struct.minDepth;
	}
	Viewport &minDepth(float minDepth)
	{
		m_struct.minDepth = minDepth;
		return *this;
	}
	float maxDepth() const
	{
		return m_struct.maxDepth;
	}
	Viewport &maxDepth(float maxDepth)
	{
		m_struct.maxDepth = maxDepth;
		return *this;
	}

	VkViewport *c_ptr() { return &m_struct; }
	const VkViewport *c_ptr() const { return &m_struct; }

	operator const VkViewport&() const { return m_struct; }
};

#ifdef VK_USE_PLATFORM_WAYLAND_KHR
class WaylandSurfaceCreateInfoKHR {
	VkWaylandSurfaceCreateInfoKHR m_struct;
public:
	WaylandSurfaceCreateInfoKHR()
	{
		std::memset(&m_struct, 0, sizeof(VkWaylandSurfaceCreateInfoKHR));
		m_struct.sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR;
	}
	WaylandSurfaceCreateInfoKHR(const VkWaylandSurfaceCreateInfoKHR &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	WaylandSurfaceCreateInfoKHR &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	WaylandSurfaceCreateInfoKHR &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	WaylandSurfaceCreateFlagsKHR flags() const
	{
		return WaylandSurfaceCreateFlagsKHR(m_struct.flags);
	}
	WaylandSurfaceCreateInfoKHR &flags(WaylandSurfaceCreateFlagsKHR flags)
	{
		m_struct.flags = static_cast<VkWaylandSurfaceCreateFlagsKHR>(flags);
		return *this;
	}
	const wl_displaystruct * display() const
	{
		return m_struct.display;
	}
	WaylandSurfaceCreateInfoKHR &display(wl_displaystruct * display)
	{
		m_struct.display = display;
		return *this;
	}
	const wl_surfacestruct * surface() const
	{
		return m_struct.surface;
	}
	WaylandSurfaceCreateInfoKHR &surface(wl_surfacestruct * surface)
	{
		m_struct.surface = surface;
		return *this;
	}

	VkWaylandSurfaceCreateInfoKHR *c_ptr() { return &m_struct; }
	const VkWaylandSurfaceCreateInfoKHR *c_ptr() const { return &m_struct; }

	operator const VkWaylandSurfaceCreateInfoKHR&() const { return m_struct; }
};
#endif
#ifdef VK_USE_PLATFORM_WIN32_KHR
class Win32SurfaceCreateInfoKHR {
	VkWin32SurfaceCreateInfoKHR m_struct;
public:
	Win32SurfaceCreateInfoKHR()
	{
		std::memset(&m_struct, 0, sizeof(VkWin32SurfaceCreateInfoKHR));
		m_struct.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
	}
	Win32SurfaceCreateInfoKHR(const VkWin32SurfaceCreateInfoKHR &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	Win32SurfaceCreateInfoKHR &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	Win32SurfaceCreateInfoKHR &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	Win32SurfaceCreateFlagsKHR flags() const
	{
		return Win32SurfaceCreateFlagsKHR(m_struct.flags);
	}
	Win32SurfaceCreateInfoKHR &flags(Win32SurfaceCreateFlagsKHR flags)
	{
		m_struct.flags = static_cast<VkWin32SurfaceCreateFlagsKHR>(flags);
		return *this;
	}
	HINSTANCE hinstance() const
	{
		return m_struct.hinstance;
	}
	Win32SurfaceCreateInfoKHR &hinstance(HINSTANCE hinstance)
	{
		m_struct.hinstance = hinstance;
		return *this;
	}
	HWND hwnd() const
	{
		return m_struct.hwnd;
	}
	Win32SurfaceCreateInfoKHR &hwnd(HWND hwnd)
	{
		m_struct.hwnd = hwnd;
		return *this;
	}

	VkWin32SurfaceCreateInfoKHR *c_ptr() { return &m_struct; }
	const VkWin32SurfaceCreateInfoKHR *c_ptr() const { return &m_struct; }

	operator const VkWin32SurfaceCreateInfoKHR&() const { return m_struct; }
};
#endif
#ifdef VK_USE_PLATFORM_XCB_KHR
class XcbSurfaceCreateInfoKHR {
	VkXcbSurfaceCreateInfoKHR m_struct;
public:
	XcbSurfaceCreateInfoKHR()
	{
		std::memset(&m_struct, 0, sizeof(VkXcbSurfaceCreateInfoKHR));
		m_struct.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
	}
	XcbSurfaceCreateInfoKHR(const VkXcbSurfaceCreateInfoKHR &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	XcbSurfaceCreateInfoKHR &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	XcbSurfaceCreateInfoKHR &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	XcbSurfaceCreateFlagsKHR flags() const
	{
		return XcbSurfaceCreateFlagsKHR(m_struct.flags);
	}
	XcbSurfaceCreateInfoKHR &flags(XcbSurfaceCreateFlagsKHR flags)
	{
		m_struct.flags = static_cast<VkXcbSurfaceCreateFlagsKHR>(flags);
		return *this;
	}
	const xcb_connection_t* connection() const
	{
		return m_struct.connection;
	}
	XcbSurfaceCreateInfoKHR &connection(xcb_connection_t* connection)
	{
		m_struct.connection = connection;
		return *this;
	}
	xcb_window_t window() const
	{
		return m_struct.window;
	}
	XcbSurfaceCreateInfoKHR &window(xcb_window_t window)
	{
		m_struct.window = window;
		return *this;
	}

	VkXcbSurfaceCreateInfoKHR *c_ptr() { return &m_struct; }
	const VkXcbSurfaceCreateInfoKHR *c_ptr() const { return &m_struct; }

	operator const VkXcbSurfaceCreateInfoKHR&() const { return m_struct; }
};
#endif
#ifdef VK_USE_PLATFORM_XLIB_KHR
class XlibSurfaceCreateInfoKHR {
	VkXlibSurfaceCreateInfoKHR m_struct;
public:
	XlibSurfaceCreateInfoKHR()
	{
		std::memset(&m_struct, 0, sizeof(VkXlibSurfaceCreateInfoKHR));
		m_struct.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
	}
	XlibSurfaceCreateInfoKHR(const VkXlibSurfaceCreateInfoKHR &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	XlibSurfaceCreateInfoKHR &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	XlibSurfaceCreateInfoKHR &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	XlibSurfaceCreateFlagsKHR flags() const
	{
		return XlibSurfaceCreateFlagsKHR(m_struct.flags);
	}
	XlibSurfaceCreateInfoKHR &flags(XlibSurfaceCreateFlagsKHR flags)
	{
		m_struct.flags = static_cast<VkXlibSurfaceCreateFlagsKHR>(flags);
		return *this;
	}
	const Display* dpy() const
	{
		return m_struct.dpy;
	}
	XlibSurfaceCreateInfoKHR &dpy(Display* dpy)
	{
		m_struct.dpy = dpy;
		return *this;
	}
	Window window() const
	{
		return m_struct.window;
	}
	XlibSurfaceCreateInfoKHR &window(Window window)
	{
		m_struct.window = window;
		return *this;
	}

	VkXlibSurfaceCreateInfoKHR *c_ptr() { return &m_struct; }
	const VkXlibSurfaceCreateInfoKHR *c_ptr() const { return &m_struct; }

	operator const VkXlibSurfaceCreateInfoKHR&() const { return m_struct; }
};
#endif
class BufferImageCopy {
	VkBufferImageCopy m_struct;
public:
	BufferImageCopy()
	{
		std::memset(&m_struct, 0, sizeof(VkBufferImageCopy));
		
	}
	BufferImageCopy(const VkBufferImageCopy &r): m_struct(r) {}

	
	DeviceSize bufferOffset() const
	{
		return m_struct.bufferOffset;
	}
	BufferImageCopy &bufferOffset(DeviceSize bufferOffset)
	{
		m_struct.bufferOffset = bufferOffset;
		return *this;
	}
	uint32_t bufferRowLength() const
	{
		return m_struct.bufferRowLength;
	}
	BufferImageCopy &bufferRowLength(uint32_t bufferRowLength)
	{
		m_struct.bufferRowLength = bufferRowLength;
		return *this;
	}
	uint32_t bufferImageHeight() const
	{
		return m_struct.bufferImageHeight;
	}
	BufferImageCopy &bufferImageHeight(uint32_t bufferImageHeight)
	{
		m_struct.bufferImageHeight = bufferImageHeight;
		return *this;
	}
	ImageSubresourceLayers imageSubresource() const
	{
		return static_cast<ImageSubresourceLayers>(m_struct.imageSubresource);
	}
	BufferImageCopy &imageSubresource(ImageSubresourceLayers imageSubresource)
	{
		m_struct.imageSubresource = static_cast<VkImageSubresourceLayers>(imageSubresource);
		return *this;
	}
	Offset3D imageOffset() const
	{
		return static_cast<Offset3D>(m_struct.imageOffset);
	}
	BufferImageCopy &imageOffset(Offset3D imageOffset)
	{
		m_struct.imageOffset = static_cast<VkOffset3D>(imageOffset);
		return *this;
	}
	Extent3D imageExtent() const
	{
		return static_cast<Extent3D>(m_struct.imageExtent);
	}
	BufferImageCopy &imageExtent(Extent3D imageExtent)
	{
		m_struct.imageExtent = static_cast<VkExtent3D>(imageExtent);
		return *this;
	}

	VkBufferImageCopy *c_ptr() { return &m_struct; }
	const VkBufferImageCopy *c_ptr() const { return &m_struct; }

	operator const VkBufferImageCopy&() const { return m_struct; }
};

class ClearValue {
	VkClearValue m_struct;
public:
	ClearValue()
	{
		std::memset(&m_struct, 0, sizeof(VkClearValue));
		
	}
	ClearValue(const VkClearValue &r): m_struct(r) {}

	
	ClearColorValue color() const
	{
		return static_cast<ClearColorValue>(m_struct.color);
	}
	ClearValue &color(ClearColorValue color)
	{
		m_struct.color = static_cast<VkClearColorValue>(color);
		return *this;
	}
	ClearDepthStencilValue depthStencil() const
	{
		return static_cast<ClearDepthStencilValue>(m_struct.depthStencil);
	}
	ClearValue &depthStencil(ClearDepthStencilValue depthStencil)
	{
		m_struct.depthStencil = static_cast<VkClearDepthStencilValue>(depthStencil);
		return *this;
	}

	VkClearValue *c_ptr() { return &m_struct; }
	const VkClearValue *c_ptr() const { return &m_struct; }

	operator const VkClearValue&() const { return m_struct; }
};

class CommandBufferBeginInfo {
	VkCommandBufferBeginInfo m_struct;
public:
	CommandBufferBeginInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkCommandBufferBeginInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
	}
	CommandBufferBeginInfo(const VkCommandBufferBeginInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	CommandBufferBeginInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	CommandBufferBeginInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	CommandBufferUsageFlags flags() const
	{
		return CommandBufferUsageFlags(m_struct.flags);
	}
	CommandBufferBeginInfo &flags(CommandBufferUsageFlags flags)
	{
		m_struct.flags = static_cast<VkCommandBufferUsageFlags>(flags);
		return *this;
	}
	const CommandBufferInheritanceInfo* pInheritanceInfo() const
	{
		return reinterpret_cast<const CommandBufferInheritanceInfo*>(m_struct.pInheritanceInfo);
	}
	CommandBufferBeginInfo &pInheritanceInfo(const CommandBufferInheritanceInfo* pInheritanceInfo)
	{
		m_struct.pInheritanceInfo = reinterpret_cast<const VkCommandBufferInheritanceInfo*>(pInheritanceInfo);
		return *this;
	}

	VkCommandBufferBeginInfo *c_ptr() { return &m_struct; }
	const VkCommandBufferBeginInfo *c_ptr() const { return &m_struct; }

	operator const VkCommandBufferBeginInfo&() const { return m_struct; }
};

class DescriptorPoolCreateInfo {
	VkDescriptorPoolCreateInfo m_struct;
public:
	DescriptorPoolCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkDescriptorPoolCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
	}
	DescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	DescriptorPoolCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	DescriptorPoolCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	DescriptorPoolCreateFlags flags() const
	{
		return DescriptorPoolCreateFlags(m_struct.flags);
	}
	DescriptorPoolCreateInfo &flags(DescriptorPoolCreateFlags flags)
	{
		m_struct.flags = static_cast<VkDescriptorPoolCreateFlags>(flags);
		return *this;
	}
	uint32_t maxSets() const
	{
		return m_struct.maxSets;
	}
	DescriptorPoolCreateInfo &maxSets(uint32_t maxSets)
	{
		m_struct.maxSets = maxSets;
		return *this;
	}
	uint32_t poolSizeCount() const
	{
		return m_struct.poolSizeCount;
	}
	DescriptorPoolCreateInfo &poolSizeCount(uint32_t poolSizeCount)
	{
		m_struct.poolSizeCount = poolSizeCount;
		return *this;
	}
	const DescriptorPoolSize* pPoolSizes() const
	{
		return reinterpret_cast<const DescriptorPoolSize*>(m_struct.pPoolSizes);
	}
	DescriptorPoolCreateInfo &pPoolSizes(const DescriptorPoolSize* pPoolSizes)
	{
		m_struct.pPoolSizes = reinterpret_cast<const VkDescriptorPoolSize*>(pPoolSizes);
		return *this;
	}

	VkDescriptorPoolCreateInfo *c_ptr() { return &m_struct; }
	const VkDescriptorPoolCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkDescriptorPoolCreateInfo&() const { return m_struct; }
};

class DescriptorSetLayoutCreateInfo {
	VkDescriptorSetLayoutCreateInfo m_struct;
public:
	DescriptorSetLayoutCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkDescriptorSetLayoutCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
	}
	DescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	DescriptorSetLayoutCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	DescriptorSetLayoutCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	DescriptorSetLayoutCreateFlags flags() const
	{
		return DescriptorSetLayoutCreateFlags(m_struct.flags);
	}
	DescriptorSetLayoutCreateInfo &flags(DescriptorSetLayoutCreateFlags flags)
	{
		m_struct.flags = static_cast<VkDescriptorSetLayoutCreateFlags>(flags);
		return *this;
	}
	uint32_t bindingCount() const
	{
		return m_struct.bindingCount;
	}
	DescriptorSetLayoutCreateInfo &bindingCount(uint32_t bindingCount)
	{
		m_struct.bindingCount = bindingCount;
		return *this;
	}
	const DescriptorSetLayoutBinding* pBindings() const
	{
		return reinterpret_cast<const DescriptorSetLayoutBinding*>(m_struct.pBindings);
	}
	DescriptorSetLayoutCreateInfo &pBindings(const DescriptorSetLayoutBinding* pBindings)
	{
		m_struct.pBindings = reinterpret_cast<const VkDescriptorSetLayoutBinding*>(pBindings);
		return *this;
	}

	VkDescriptorSetLayoutCreateInfo *c_ptr() { return &m_struct; }
	const VkDescriptorSetLayoutCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkDescriptorSetLayoutCreateInfo&() const { return m_struct; }
};

class DeviceCreateInfo {
	VkDeviceCreateInfo m_struct;
public:
	DeviceCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkDeviceCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
	}
	DeviceCreateInfo(const VkDeviceCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	DeviceCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	DeviceCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	DeviceCreateFlags flags() const
	{
		return DeviceCreateFlags(m_struct.flags);
	}
	DeviceCreateInfo &flags(DeviceCreateFlags flags)
	{
		m_struct.flags = static_cast<VkDeviceCreateFlags>(flags);
		return *this;
	}
	uint32_t queueCreateInfoCount() const
	{
		return m_struct.queueCreateInfoCount;
	}
	DeviceCreateInfo &queueCreateInfoCount(uint32_t queueCreateInfoCount)
	{
		m_struct.queueCreateInfoCount = queueCreateInfoCount;
		return *this;
	}
	const DeviceQueueCreateInfo* pQueueCreateInfos() const
	{
		return reinterpret_cast<const DeviceQueueCreateInfo*>(m_struct.pQueueCreateInfos);
	}
	DeviceCreateInfo &pQueueCreateInfos(const DeviceQueueCreateInfo* pQueueCreateInfos)
	{
		m_struct.pQueueCreateInfos = reinterpret_cast<const VkDeviceQueueCreateInfo*>(pQueueCreateInfos);
		return *this;
	}
	uint32_t enabledLayerCount() const
	{
		return m_struct.enabledLayerCount;
	}
	DeviceCreateInfo &enabledLayerCount(uint32_t enabledLayerCount)
	{
		m_struct.enabledLayerCount = enabledLayerCount;
		return *this;
	}
	const char* const* ppEnabledLayerNames() const
	{
		return m_struct.ppEnabledLayerNames;
	}
	DeviceCreateInfo &ppEnabledLayerNames(const char* const* ppEnabledLayerNames)
	{
		m_struct.ppEnabledLayerNames = ppEnabledLayerNames;
		return *this;
	}
	uint32_t enabledExtensionCount() const
	{
		return m_struct.enabledExtensionCount;
	}
	DeviceCreateInfo &enabledExtensionCount(uint32_t enabledExtensionCount)
	{
		m_struct.enabledExtensionCount = enabledExtensionCount;
		return *this;
	}
	const char* const* ppEnabledExtensionNames() const
	{
		return m_struct.ppEnabledExtensionNames;
	}
	DeviceCreateInfo &ppEnabledExtensionNames(const char* const* ppEnabledExtensionNames)
	{
		m_struct.ppEnabledExtensionNames = ppEnabledExtensionNames;
		return *this;
	}
	const PhysicalDeviceFeatures* pEnabledFeatures() const
	{
		return reinterpret_cast<const PhysicalDeviceFeatures*>(m_struct.pEnabledFeatures);
	}
	DeviceCreateInfo &pEnabledFeatures(const PhysicalDeviceFeatures* pEnabledFeatures)
	{
		m_struct.pEnabledFeatures = reinterpret_cast<const VkPhysicalDeviceFeatures*>(pEnabledFeatures);
		return *this;
	}

	VkDeviceCreateInfo *c_ptr() { return &m_struct; }
	const VkDeviceCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkDeviceCreateInfo&() const { return m_struct; }
};

class DisplayModeParametersKHR {
	VkDisplayModeParametersKHR m_struct;
public:
	DisplayModeParametersKHR()
	{
		std::memset(&m_struct, 0, sizeof(VkDisplayModeParametersKHR));
		
	}
	DisplayModeParametersKHR(const VkDisplayModeParametersKHR &r): m_struct(r) {}

	
	Extent2D visibleRegion() const
	{
		return static_cast<Extent2D>(m_struct.visibleRegion);
	}
	DisplayModeParametersKHR &visibleRegion(Extent2D visibleRegion)
	{
		m_struct.visibleRegion = static_cast<VkExtent2D>(visibleRegion);
		return *this;
	}
	uint32_t refreshRate() const
	{
		return m_struct.refreshRate;
	}
	DisplayModeParametersKHR &refreshRate(uint32_t refreshRate)
	{
		m_struct.refreshRate = refreshRate;
		return *this;
	}

	VkDisplayModeParametersKHR *c_ptr() { return &m_struct; }
	const VkDisplayModeParametersKHR *c_ptr() const { return &m_struct; }

	operator const VkDisplayModeParametersKHR&() const { return m_struct; }
};

class DisplayPlaneCapabilitiesKHR {
	VkDisplayPlaneCapabilitiesKHR m_struct;
public:
	DisplayPlaneCapabilitiesKHR()
	{
		std::memset(&m_struct, 0, sizeof(VkDisplayPlaneCapabilitiesKHR));
		
	}
	DisplayPlaneCapabilitiesKHR(const VkDisplayPlaneCapabilitiesKHR &r): m_struct(r) {}

	
	DisplayPlaneAlphaFlagsKHR supportedAlpha() const
	{
		return DisplayPlaneAlphaFlagsKHR(m_struct.supportedAlpha);
	}
	DisplayPlaneCapabilitiesKHR &supportedAlpha(DisplayPlaneAlphaFlagsKHR supportedAlpha)
	{
		m_struct.supportedAlpha = static_cast<VkDisplayPlaneAlphaFlagsKHR>(supportedAlpha);
		return *this;
	}
	Offset2D minSrcPosition() const
	{
		return static_cast<Offset2D>(m_struct.minSrcPosition);
	}
	DisplayPlaneCapabilitiesKHR &minSrcPosition(Offset2D minSrcPosition)
	{
		m_struct.minSrcPosition = static_cast<VkOffset2D>(minSrcPosition);
		return *this;
	}
	Offset2D maxSrcPosition() const
	{
		return static_cast<Offset2D>(m_struct.maxSrcPosition);
	}
	DisplayPlaneCapabilitiesKHR &maxSrcPosition(Offset2D maxSrcPosition)
	{
		m_struct.maxSrcPosition = static_cast<VkOffset2D>(maxSrcPosition);
		return *this;
	}
	Extent2D minSrcExtent() const
	{
		return static_cast<Extent2D>(m_struct.minSrcExtent);
	}
	DisplayPlaneCapabilitiesKHR &minSrcExtent(Extent2D minSrcExtent)
	{
		m_struct.minSrcExtent = static_cast<VkExtent2D>(minSrcExtent);
		return *this;
	}
	Extent2D maxSrcExtent() const
	{
		return static_cast<Extent2D>(m_struct.maxSrcExtent);
	}
	DisplayPlaneCapabilitiesKHR &maxSrcExtent(Extent2D maxSrcExtent)
	{
		m_struct.maxSrcExtent = static_cast<VkExtent2D>(maxSrcExtent);
		return *this;
	}
	Offset2D minDstPosition() const
	{
		return static_cast<Offset2D>(m_struct.minDstPosition);
	}
	DisplayPlaneCapabilitiesKHR &minDstPosition(Offset2D minDstPosition)
	{
		m_struct.minDstPosition = static_cast<VkOffset2D>(minDstPosition);
		return *this;
	}
	Offset2D maxDstPosition() const
	{
		return static_cast<Offset2D>(m_struct.maxDstPosition);
	}
	DisplayPlaneCapabilitiesKHR &maxDstPosition(Offset2D maxDstPosition)
	{
		m_struct.maxDstPosition = static_cast<VkOffset2D>(maxDstPosition);
		return *this;
	}
	Extent2D minDstExtent() const
	{
		return static_cast<Extent2D>(m_struct.minDstExtent);
	}
	DisplayPlaneCapabilitiesKHR &minDstExtent(Extent2D minDstExtent)
	{
		m_struct.minDstExtent = static_cast<VkExtent2D>(minDstExtent);
		return *this;
	}
	Extent2D maxDstExtent() const
	{
		return static_cast<Extent2D>(m_struct.maxDstExtent);
	}
	DisplayPlaneCapabilitiesKHR &maxDstExtent(Extent2D maxDstExtent)
	{
		m_struct.maxDstExtent = static_cast<VkExtent2D>(maxDstExtent);
		return *this;
	}

	VkDisplayPlaneCapabilitiesKHR *c_ptr() { return &m_struct; }
	const VkDisplayPlaneCapabilitiesKHR *c_ptr() const { return &m_struct; }

	operator const VkDisplayPlaneCapabilitiesKHR&() const { return m_struct; }
};

class DisplayPropertiesKHR {
	VkDisplayPropertiesKHR m_struct;
public:
	DisplayPropertiesKHR()
	{
		std::memset(&m_struct, 0, sizeof(VkDisplayPropertiesKHR));
		
	}
	DisplayPropertiesKHR(const VkDisplayPropertiesKHR &r): m_struct(r) {}

	
	DisplayKHR display() const
	{
		return DisplayKHR(m_struct.display);
	}
	DisplayPropertiesKHR &display(DisplayKHR display)
	{
		m_struct.display = static_cast<VkDisplayKHR>(display);
		return *this;
	}
	const char* displayName() const
	{
		return m_struct.displayName;
	}
	DisplayPropertiesKHR &displayName(const char* displayName)
	{
		m_struct.displayName = displayName;
		return *this;
	}
	Extent2D physicalDimensions() const
	{
		return static_cast<Extent2D>(m_struct.physicalDimensions);
	}
	DisplayPropertiesKHR &physicalDimensions(Extent2D physicalDimensions)
	{
		m_struct.physicalDimensions = static_cast<VkExtent2D>(physicalDimensions);
		return *this;
	}
	Extent2D physicalResolution() const
	{
		return static_cast<Extent2D>(m_struct.physicalResolution);
	}
	DisplayPropertiesKHR &physicalResolution(Extent2D physicalResolution)
	{
		m_struct.physicalResolution = static_cast<VkExtent2D>(physicalResolution);
		return *this;
	}
	SurfaceTransformFlagsKHR supportedTransforms() const
	{
		return SurfaceTransformFlagsKHR(m_struct.supportedTransforms);
	}
	DisplayPropertiesKHR &supportedTransforms(SurfaceTransformFlagsKHR supportedTransforms)
	{
		m_struct.supportedTransforms = static_cast<VkSurfaceTransformFlagsKHR>(supportedTransforms);
		return *this;
	}
	Bool32 planeReorderPossible() const
	{
		return m_struct.planeReorderPossible;
	}
	DisplayPropertiesKHR &planeReorderPossible(Bool32 planeReorderPossible)
	{
		m_struct.planeReorderPossible = planeReorderPossible;
		return *this;
	}
	Bool32 persistentContent() const
	{
		return m_struct.persistentContent;
	}
	DisplayPropertiesKHR &persistentContent(Bool32 persistentContent)
	{
		m_struct.persistentContent = persistentContent;
		return *this;
	}

	VkDisplayPropertiesKHR *c_ptr() { return &m_struct; }
	const VkDisplayPropertiesKHR *c_ptr() const { return &m_struct; }

	operator const VkDisplayPropertiesKHR&() const { return m_struct; }
};

class DisplaySurfaceCreateInfoKHR {
	VkDisplaySurfaceCreateInfoKHR m_struct;
public:
	DisplaySurfaceCreateInfoKHR()
	{
		std::memset(&m_struct, 0, sizeof(VkDisplaySurfaceCreateInfoKHR));
		m_struct.sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
	}
	DisplaySurfaceCreateInfoKHR(const VkDisplaySurfaceCreateInfoKHR &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	DisplaySurfaceCreateInfoKHR &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	DisplaySurfaceCreateInfoKHR &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	DisplaySurfaceCreateFlagsKHR flags() const
	{
		return DisplaySurfaceCreateFlagsKHR(m_struct.flags);
	}
	DisplaySurfaceCreateInfoKHR &flags(DisplaySurfaceCreateFlagsKHR flags)
	{
		m_struct.flags = static_cast<VkDisplaySurfaceCreateFlagsKHR>(flags);
		return *this;
	}
	DisplayModeKHR displayMode() const
	{
		return DisplayModeKHR(m_struct.displayMode);
	}
	DisplaySurfaceCreateInfoKHR &displayMode(DisplayModeKHR displayMode)
	{
		m_struct.displayMode = static_cast<VkDisplayModeKHR>(displayMode);
		return *this;
	}
	uint32_t planeIndex() const
	{
		return m_struct.planeIndex;
	}
	DisplaySurfaceCreateInfoKHR &planeIndex(uint32_t planeIndex)
	{
		m_struct.planeIndex = planeIndex;
		return *this;
	}
	uint32_t planeStackIndex() const
	{
		return m_struct.planeStackIndex;
	}
	DisplaySurfaceCreateInfoKHR &planeStackIndex(uint32_t planeStackIndex)
	{
		m_struct.planeStackIndex = planeStackIndex;
		return *this;
	}
	SurfaceTransformFlagBitsKHR transform() const
	{
		return static_cast<SurfaceTransformFlagBitsKHR>(m_struct.transform);
	}
	DisplaySurfaceCreateInfoKHR &transform(SurfaceTransformFlagBitsKHR transform)
	{
		m_struct.transform = static_cast<VkSurfaceTransformFlagBitsKHR>(transform);
		return *this;
	}
	float globalAlpha() const
	{
		return m_struct.globalAlpha;
	}
	DisplaySurfaceCreateInfoKHR &globalAlpha(float globalAlpha)
	{
		m_struct.globalAlpha = globalAlpha;
		return *this;
	}
	DisplayPlaneAlphaFlagBitsKHR alphaMode() const
	{
		return static_cast<DisplayPlaneAlphaFlagBitsKHR>(m_struct.alphaMode);
	}
	DisplaySurfaceCreateInfoKHR &alphaMode(DisplayPlaneAlphaFlagBitsKHR alphaMode)
	{
		m_struct.alphaMode = static_cast<VkDisplayPlaneAlphaFlagBitsKHR>(alphaMode);
		return *this;
	}
	Extent2D imageExtent() const
	{
		return static_cast<Extent2D>(m_struct.imageExtent);
	}
	DisplaySurfaceCreateInfoKHR &imageExtent(Extent2D imageExtent)
	{
		m_struct.imageExtent = static_cast<VkExtent2D>(imageExtent);
		return *this;
	}

	VkDisplaySurfaceCreateInfoKHR *c_ptr() { return &m_struct; }
	const VkDisplaySurfaceCreateInfoKHR *c_ptr() const { return &m_struct; }

	operator const VkDisplaySurfaceCreateInfoKHR&() const { return m_struct; }
};

class ImageBlit {
	VkImageBlit m_struct;
public:
	ImageBlit()
	{
		std::memset(&m_struct, 0, sizeof(VkImageBlit));
		
	}
	ImageBlit(const VkImageBlit &r): m_struct(r) {}

	
	ImageSubresourceLayers srcSubresource() const
	{
		return static_cast<ImageSubresourceLayers>(m_struct.srcSubresource);
	}
	ImageBlit &srcSubresource(ImageSubresourceLayers srcSubresource)
	{
		m_struct.srcSubresource = static_cast<VkImageSubresourceLayers>(srcSubresource);
		return *this;
	}
	const Offset3D* srcOffsets() const
	{
		return reinterpret_cast<const Offset3D*>(m_struct.srcOffsets);
	}
	ImageBlit &srcOffsets(Offset3D* srcOffsets)
	{
		std::memcpy(m_struct.srcOffsets, srcOffsets, 2 * sizeof(VkOffset3D));
		return *this;
	}
	ImageSubresourceLayers dstSubresource() const
	{
		return static_cast<ImageSubresourceLayers>(m_struct.dstSubresource);
	}
	ImageBlit &dstSubresource(ImageSubresourceLayers dstSubresource)
	{
		m_struct.dstSubresource = static_cast<VkImageSubresourceLayers>(dstSubresource);
		return *this;
	}
	const Offset3D* dstOffsets() const
	{
		return reinterpret_cast<const Offset3D*>(m_struct.dstOffsets);
	}
	ImageBlit &dstOffsets(Offset3D* dstOffsets)
	{
		std::memcpy(m_struct.dstOffsets, dstOffsets, 2 * sizeof(VkOffset3D));
		return *this;
	}

	VkImageBlit *c_ptr() { return &m_struct; }
	const VkImageBlit *c_ptr() const { return &m_struct; }

	operator const VkImageBlit&() const { return m_struct; }
};

class ImageCopy {
	VkImageCopy m_struct;
public:
	ImageCopy()
	{
		std::memset(&m_struct, 0, sizeof(VkImageCopy));
		
	}
	ImageCopy(const VkImageCopy &r): m_struct(r) {}

	
	ImageSubresourceLayers srcSubresource() const
	{
		return static_cast<ImageSubresourceLayers>(m_struct.srcSubresource);
	}
	ImageCopy &srcSubresource(ImageSubresourceLayers srcSubresource)
	{
		m_struct.srcSubresource = static_cast<VkImageSubresourceLayers>(srcSubresource);
		return *this;
	}
	Offset3D srcOffset() const
	{
		return static_cast<Offset3D>(m_struct.srcOffset);
	}
	ImageCopy &srcOffset(Offset3D srcOffset)
	{
		m_struct.srcOffset = static_cast<VkOffset3D>(srcOffset);
		return *this;
	}
	ImageSubresourceLayers dstSubresource() const
	{
		return static_cast<ImageSubresourceLayers>(m_struct.dstSubresource);
	}
	ImageCopy &dstSubresource(ImageSubresourceLayers dstSubresource)
	{
		m_struct.dstSubresource = static_cast<VkImageSubresourceLayers>(dstSubresource);
		return *this;
	}
	Offset3D dstOffset() const
	{
		return static_cast<Offset3D>(m_struct.dstOffset);
	}
	ImageCopy &dstOffset(Offset3D dstOffset)
	{
		m_struct.dstOffset = static_cast<VkOffset3D>(dstOffset);
		return *this;
	}
	Extent3D extent() const
	{
		return static_cast<Extent3D>(m_struct.extent);
	}
	ImageCopy &extent(Extent3D extent)
	{
		m_struct.extent = static_cast<VkExtent3D>(extent);
		return *this;
	}

	VkImageCopy *c_ptr() { return &m_struct; }
	const VkImageCopy *c_ptr() const { return &m_struct; }

	operator const VkImageCopy&() const { return m_struct; }
};

class ImageCreateInfo {
	VkImageCreateInfo m_struct;
public:
	ImageCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkImageCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
	}
	ImageCreateInfo(const VkImageCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	ImageCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	ImageCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	ImageCreateFlags flags() const
	{
		return ImageCreateFlags(m_struct.flags);
	}
	ImageCreateInfo &flags(ImageCreateFlags flags)
	{
		m_struct.flags = static_cast<VkImageCreateFlags>(flags);
		return *this;
	}
	ImageType imageType() const
	{
		return static_cast<ImageType>(m_struct.imageType);
	}
	ImageCreateInfo &imageType(ImageType imageType)
	{
		m_struct.imageType = static_cast<VkImageType>(imageType);
		return *this;
	}
	Format format() const
	{
		return static_cast<Format>(m_struct.format);
	}
	ImageCreateInfo &format(Format format)
	{
		m_struct.format = static_cast<VkFormat>(format);
		return *this;
	}
	Extent3D extent() const
	{
		return static_cast<Extent3D>(m_struct.extent);
	}
	ImageCreateInfo &extent(Extent3D extent)
	{
		m_struct.extent = static_cast<VkExtent3D>(extent);
		return *this;
	}
	uint32_t mipLevels() const
	{
		return m_struct.mipLevels;
	}
	ImageCreateInfo &mipLevels(uint32_t mipLevels)
	{
		m_struct.mipLevels = mipLevels;
		return *this;
	}
	uint32_t arrayLayers() const
	{
		return m_struct.arrayLayers;
	}
	ImageCreateInfo &arrayLayers(uint32_t arrayLayers)
	{
		m_struct.arrayLayers = arrayLayers;
		return *this;
	}
	SampleCountFlagBits samples() const
	{
		return static_cast<SampleCountFlagBits>(m_struct.samples);
	}
	ImageCreateInfo &samples(SampleCountFlagBits samples)
	{
		m_struct.samples = static_cast<VkSampleCountFlagBits>(samples);
		return *this;
	}
	ImageTiling tiling() const
	{
		return static_cast<ImageTiling>(m_struct.tiling);
	}
	ImageCreateInfo &tiling(ImageTiling tiling)
	{
		m_struct.tiling = static_cast<VkImageTiling>(tiling);
		return *this;
	}
	ImageUsageFlags usage() const
	{
		return ImageUsageFlags(m_struct.usage);
	}
	ImageCreateInfo &usage(ImageUsageFlags usage)
	{
		m_struct.usage = static_cast<VkImageUsageFlags>(usage);
		return *this;
	}
	SharingMode sharingMode() const
	{
		return static_cast<SharingMode>(m_struct.sharingMode);
	}
	ImageCreateInfo &sharingMode(SharingMode sharingMode)
	{
		m_struct.sharingMode = static_cast<VkSharingMode>(sharingMode);
		return *this;
	}
	uint32_t queueFamilyIndexCount() const
	{
		return m_struct.queueFamilyIndexCount;
	}
	ImageCreateInfo &queueFamilyIndexCount(uint32_t queueFamilyIndexCount)
	{
		m_struct.queueFamilyIndexCount = queueFamilyIndexCount;
		return *this;
	}
	const uint32_t* pQueueFamilyIndices() const
	{
		return m_struct.pQueueFamilyIndices;
	}
	ImageCreateInfo &pQueueFamilyIndices(const uint32_t* pQueueFamilyIndices)
	{
		m_struct.pQueueFamilyIndices = pQueueFamilyIndices;
		return *this;
	}
	ImageLayout initialLayout() const
	{
		return static_cast<ImageLayout>(m_struct.initialLayout);
	}
	ImageCreateInfo &initialLayout(ImageLayout initialLayout)
	{
		m_struct.initialLayout = static_cast<VkImageLayout>(initialLayout);
		return *this;
	}

	VkImageCreateInfo *c_ptr() { return &m_struct; }
	const VkImageCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkImageCreateInfo&() const { return m_struct; }
};

class ImageFormatProperties {
	VkImageFormatProperties m_struct;
public:
	ImageFormatProperties()
	{
		std::memset(&m_struct, 0, sizeof(VkImageFormatProperties));
		
	}
	ImageFormatProperties(const VkImageFormatProperties &r): m_struct(r) {}

	
	Extent3D maxExtent() const
	{
		return static_cast<Extent3D>(m_struct.maxExtent);
	}
	
	uint32_t maxMipLevels() const
	{
		return m_struct.maxMipLevels;
	}
	
	uint32_t maxArrayLayers() const
	{
		return m_struct.maxArrayLayers;
	}
	
	SampleCountFlags sampleCounts() const
	{
		return SampleCountFlags(m_struct.sampleCounts);
	}
	
	DeviceSize maxResourceSize() const
	{
		return m_struct.maxResourceSize;
	}
	

	VkImageFormatProperties *c_ptr() { return &m_struct; }
	const VkImageFormatProperties *c_ptr() const { return &m_struct; }

	operator const VkImageFormatProperties&() const { return m_struct; }
};

class ImageMemoryBarrier {
	VkImageMemoryBarrier m_struct;
public:
	ImageMemoryBarrier()
	{
		std::memset(&m_struct, 0, sizeof(VkImageMemoryBarrier));
		m_struct.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
	}
	ImageMemoryBarrier(const VkImageMemoryBarrier &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	ImageMemoryBarrier &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	ImageMemoryBarrier &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	AccessFlags srcAccessMask() const
	{
		return AccessFlags(m_struct.srcAccessMask);
	}
	ImageMemoryBarrier &srcAccessMask(AccessFlags srcAccessMask)
	{
		m_struct.srcAccessMask = static_cast<VkAccessFlags>(srcAccessMask);
		return *this;
	}
	AccessFlags dstAccessMask() const
	{
		return AccessFlags(m_struct.dstAccessMask);
	}
	ImageMemoryBarrier &dstAccessMask(AccessFlags dstAccessMask)
	{
		m_struct.dstAccessMask = static_cast<VkAccessFlags>(dstAccessMask);
		return *this;
	}
	ImageLayout oldLayout() const
	{
		return static_cast<ImageLayout>(m_struct.oldLayout);
	}
	ImageMemoryBarrier &oldLayout(ImageLayout oldLayout)
	{
		m_struct.oldLayout = static_cast<VkImageLayout>(oldLayout);
		return *this;
	}
	ImageLayout newLayout() const
	{
		return static_cast<ImageLayout>(m_struct.newLayout);
	}
	ImageMemoryBarrier &newLayout(ImageLayout newLayout)
	{
		m_struct.newLayout = static_cast<VkImageLayout>(newLayout);
		return *this;
	}
	uint32_t srcQueueFamilyIndex() const
	{
		return m_struct.srcQueueFamilyIndex;
	}
	ImageMemoryBarrier &srcQueueFamilyIndex(uint32_t srcQueueFamilyIndex)
	{
		m_struct.srcQueueFamilyIndex = srcQueueFamilyIndex;
		return *this;
	}
	uint32_t dstQueueFamilyIndex() const
	{
		return m_struct.dstQueueFamilyIndex;
	}
	ImageMemoryBarrier &dstQueueFamilyIndex(uint32_t dstQueueFamilyIndex)
	{
		m_struct.dstQueueFamilyIndex = dstQueueFamilyIndex;
		return *this;
	}
	Image image() const
	{
		return Image(m_struct.image);
	}
	ImageMemoryBarrier &image(Image image)
	{
		m_struct.image = static_cast<VkImage>(image);
		return *this;
	}
	ImageSubresourceRange subresourceRange() const
	{
		return static_cast<ImageSubresourceRange>(m_struct.subresourceRange);
	}
	ImageMemoryBarrier &subresourceRange(ImageSubresourceRange subresourceRange)
	{
		m_struct.subresourceRange = static_cast<VkImageSubresourceRange>(subresourceRange);
		return *this;
	}

	VkImageMemoryBarrier *c_ptr() { return &m_struct; }
	const VkImageMemoryBarrier *c_ptr() const { return &m_struct; }

	operator const VkImageMemoryBarrier&() const { return m_struct; }
};

class ImageResolve {
	VkImageResolve m_struct;
public:
	ImageResolve()
	{
		std::memset(&m_struct, 0, sizeof(VkImageResolve));
		
	}
	ImageResolve(const VkImageResolve &r): m_struct(r) {}

	
	ImageSubresourceLayers srcSubresource() const
	{
		return static_cast<ImageSubresourceLayers>(m_struct.srcSubresource);
	}
	ImageResolve &srcSubresource(ImageSubresourceLayers srcSubresource)
	{
		m_struct.srcSubresource = static_cast<VkImageSubresourceLayers>(srcSubresource);
		return *this;
	}
	Offset3D srcOffset() const
	{
		return static_cast<Offset3D>(m_struct.srcOffset);
	}
	ImageResolve &srcOffset(Offset3D srcOffset)
	{
		m_struct.srcOffset = static_cast<VkOffset3D>(srcOffset);
		return *this;
	}
	ImageSubresourceLayers dstSubresource() const
	{
		return static_cast<ImageSubresourceLayers>(m_struct.dstSubresource);
	}
	ImageResolve &dstSubresource(ImageSubresourceLayers dstSubresource)
	{
		m_struct.dstSubresource = static_cast<VkImageSubresourceLayers>(dstSubresource);
		return *this;
	}
	Offset3D dstOffset() const
	{
		return static_cast<Offset3D>(m_struct.dstOffset);
	}
	ImageResolve &dstOffset(Offset3D dstOffset)
	{
		m_struct.dstOffset = static_cast<VkOffset3D>(dstOffset);
		return *this;
	}
	Extent3D extent() const
	{
		return static_cast<Extent3D>(m_struct.extent);
	}
	ImageResolve &extent(Extent3D extent)
	{
		m_struct.extent = static_cast<VkExtent3D>(extent);
		return *this;
	}

	VkImageResolve *c_ptr() { return &m_struct; }
	const VkImageResolve *c_ptr() const { return &m_struct; }

	operator const VkImageResolve&() const { return m_struct; }
};

class ImageViewCreateInfo {
	VkImageViewCreateInfo m_struct;
public:
	ImageViewCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkImageViewCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
	}
	ImageViewCreateInfo(const VkImageViewCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	ImageViewCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	ImageViewCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	ImageViewCreateFlags flags() const
	{
		return ImageViewCreateFlags(m_struct.flags);
	}
	ImageViewCreateInfo &flags(ImageViewCreateFlags flags)
	{
		m_struct.flags = static_cast<VkImageViewCreateFlags>(flags);
		return *this;
	}
	Image image() const
	{
		return Image(m_struct.image);
	}
	ImageViewCreateInfo &image(Image image)
	{
		m_struct.image = static_cast<VkImage>(image);
		return *this;
	}
	ImageViewType viewType() const
	{
		return static_cast<ImageViewType>(m_struct.viewType);
	}
	ImageViewCreateInfo &viewType(ImageViewType viewType)
	{
		m_struct.viewType = static_cast<VkImageViewType>(viewType);
		return *this;
	}
	Format format() const
	{
		return static_cast<Format>(m_struct.format);
	}
	ImageViewCreateInfo &format(Format format)
	{
		m_struct.format = static_cast<VkFormat>(format);
		return *this;
	}
	ComponentMapping components() const
	{
		return static_cast<ComponentMapping>(m_struct.components);
	}
	ImageViewCreateInfo &components(ComponentMapping components)
	{
		m_struct.components = static_cast<VkComponentMapping>(components);
		return *this;
	}
	ImageSubresourceRange subresourceRange() const
	{
		return static_cast<ImageSubresourceRange>(m_struct.subresourceRange);
	}
	ImageViewCreateInfo &subresourceRange(ImageSubresourceRange subresourceRange)
	{
		m_struct.subresourceRange = static_cast<VkImageSubresourceRange>(subresourceRange);
		return *this;
	}

	VkImageViewCreateInfo *c_ptr() { return &m_struct; }
	const VkImageViewCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkImageViewCreateInfo&() const { return m_struct; }
};

class InstanceCreateInfo {
	VkInstanceCreateInfo m_struct;
public:
	InstanceCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkInstanceCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
	}
	InstanceCreateInfo(const VkInstanceCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	InstanceCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	InstanceCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	InstanceCreateFlags flags() const
	{
		return InstanceCreateFlags(m_struct.flags);
	}
	InstanceCreateInfo &flags(InstanceCreateFlags flags)
	{
		m_struct.flags = static_cast<VkInstanceCreateFlags>(flags);
		return *this;
	}
	const ApplicationInfo* pApplicationInfo() const
	{
		return reinterpret_cast<const ApplicationInfo*>(m_struct.pApplicationInfo);
	}
	InstanceCreateInfo &pApplicationInfo(const ApplicationInfo* pApplicationInfo)
	{
		m_struct.pApplicationInfo = reinterpret_cast<const VkApplicationInfo*>(pApplicationInfo);
		return *this;
	}
	uint32_t enabledLayerCount() const
	{
		return m_struct.enabledLayerCount;
	}
	InstanceCreateInfo &enabledLayerCount(uint32_t enabledLayerCount)
	{
		m_struct.enabledLayerCount = enabledLayerCount;
		return *this;
	}
	const char* const* ppEnabledLayerNames() const
	{
		return m_struct.ppEnabledLayerNames;
	}
	InstanceCreateInfo &ppEnabledLayerNames(const char* const* ppEnabledLayerNames)
	{
		m_struct.ppEnabledLayerNames = ppEnabledLayerNames;
		return *this;
	}
	uint32_t enabledExtensionCount() const
	{
		return m_struct.enabledExtensionCount;
	}
	InstanceCreateInfo &enabledExtensionCount(uint32_t enabledExtensionCount)
	{
		m_struct.enabledExtensionCount = enabledExtensionCount;
		return *this;
	}
	const char* const* ppEnabledExtensionNames() const
	{
		return m_struct.ppEnabledExtensionNames;
	}
	InstanceCreateInfo &ppEnabledExtensionNames(const char* const* ppEnabledExtensionNames)
	{
		m_struct.ppEnabledExtensionNames = ppEnabledExtensionNames;
		return *this;
	}

	VkInstanceCreateInfo *c_ptr() { return &m_struct; }
	const VkInstanceCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkInstanceCreateInfo&() const { return m_struct; }
};

class PhysicalDeviceMemoryProperties {
	VkPhysicalDeviceMemoryProperties m_struct;
public:
	PhysicalDeviceMemoryProperties()
	{
		std::memset(&m_struct, 0, sizeof(VkPhysicalDeviceMemoryProperties));
		
	}
	PhysicalDeviceMemoryProperties(const VkPhysicalDeviceMemoryProperties &r): m_struct(r) {}

	
	uint32_t memoryTypeCount() const
	{
		return m_struct.memoryTypeCount;
	}
	
	const MemoryType* memoryTypes() const
	{
		return reinterpret_cast<const MemoryType*>(m_struct.memoryTypes);
	}
	
	uint32_t memoryHeapCount() const
	{
		return m_struct.memoryHeapCount;
	}
	
	const MemoryHeap* memoryHeaps() const
	{
		return reinterpret_cast<const MemoryHeap*>(m_struct.memoryHeaps);
	}
	

	VkPhysicalDeviceMemoryProperties *c_ptr() { return &m_struct; }
	const VkPhysicalDeviceMemoryProperties *c_ptr() const { return &m_struct; }

	operator const VkPhysicalDeviceMemoryProperties&() const { return m_struct; }
};

class PhysicalDeviceProperties {
	VkPhysicalDeviceProperties m_struct;
public:
	PhysicalDeviceProperties()
	{
		std::memset(&m_struct, 0, sizeof(VkPhysicalDeviceProperties));
		
	}
	PhysicalDeviceProperties(const VkPhysicalDeviceProperties &r): m_struct(r) {}

	
	uint32_t apiVersion() const
	{
		return m_struct.apiVersion;
	}
	
	uint32_t driverVersion() const
	{
		return m_struct.driverVersion;
	}
	
	uint32_t vendorID() const
	{
		return m_struct.vendorID;
	}
	
	uint32_t deviceID() const
	{
		return m_struct.deviceID;
	}
	
	PhysicalDeviceType deviceType() const
	{
		return static_cast<PhysicalDeviceType>(m_struct.deviceType);
	}
	
	const char* deviceName() const
	{
		return reinterpret_cast<const char*>(m_struct.deviceName);
	}
	
	const uint8_t* pipelineCacheUUID() const
	{
		return reinterpret_cast<const uint8_t*>(m_struct.pipelineCacheUUID);
	}
	
	PhysicalDeviceLimits limits() const
	{
		return static_cast<PhysicalDeviceLimits>(m_struct.limits);
	}
	
	PhysicalDeviceSparseProperties sparseProperties() const
	{
		return static_cast<PhysicalDeviceSparseProperties>(m_struct.sparseProperties);
	}
	

	VkPhysicalDeviceProperties *c_ptr() { return &m_struct; }
	const VkPhysicalDeviceProperties *c_ptr() const { return &m_struct; }

	operator const VkPhysicalDeviceProperties&() const { return m_struct; }
};

class PipelineColorBlendStateCreateInfo {
	VkPipelineColorBlendStateCreateInfo m_struct;
public:
	PipelineColorBlendStateCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkPipelineColorBlendStateCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
	}
	PipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	PipelineColorBlendStateCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	PipelineColorBlendStateCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	PipelineColorBlendStateCreateFlags flags() const
	{
		return PipelineColorBlendStateCreateFlags(m_struct.flags);
	}
	PipelineColorBlendStateCreateInfo &flags(PipelineColorBlendStateCreateFlags flags)
	{
		m_struct.flags = static_cast<VkPipelineColorBlendStateCreateFlags>(flags);
		return *this;
	}
	Bool32 logicOpEnable() const
	{
		return m_struct.logicOpEnable;
	}
	PipelineColorBlendStateCreateInfo &logicOpEnable(Bool32 logicOpEnable)
	{
		m_struct.logicOpEnable = logicOpEnable;
		return *this;
	}
	LogicOp logicOp() const
	{
		return static_cast<LogicOp>(m_struct.logicOp);
	}
	PipelineColorBlendStateCreateInfo &logicOp(LogicOp logicOp)
	{
		m_struct.logicOp = static_cast<VkLogicOp>(logicOp);
		return *this;
	}
	uint32_t attachmentCount() const
	{
		return m_struct.attachmentCount;
	}
	PipelineColorBlendStateCreateInfo &attachmentCount(uint32_t attachmentCount)
	{
		m_struct.attachmentCount = attachmentCount;
		return *this;
	}
	const PipelineColorBlendAttachmentState* pAttachments() const
	{
		return reinterpret_cast<const PipelineColorBlendAttachmentState*>(m_struct.pAttachments);
	}
	PipelineColorBlendStateCreateInfo &pAttachments(const PipelineColorBlendAttachmentState* pAttachments)
	{
		m_struct.pAttachments = reinterpret_cast<const VkPipelineColorBlendAttachmentState*>(pAttachments);
		return *this;
	}
	const float* blendConstants() const
	{
		return reinterpret_cast<const float*>(m_struct.blendConstants);
	}
	PipelineColorBlendStateCreateInfo &blendConstants(float* blendConstants)
	{
		std::memcpy(m_struct.blendConstants, blendConstants, 4 * sizeof(float));
		return *this;
	}

	VkPipelineColorBlendStateCreateInfo *c_ptr() { return &m_struct; }
	const VkPipelineColorBlendStateCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkPipelineColorBlendStateCreateInfo&() const { return m_struct; }
};

class PipelineDepthStencilStateCreateInfo {
	VkPipelineDepthStencilStateCreateInfo m_struct;
public:
	PipelineDepthStencilStateCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkPipelineDepthStencilStateCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
	}
	PipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	PipelineDepthStencilStateCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	PipelineDepthStencilStateCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	PipelineDepthStencilStateCreateFlags flags() const
	{
		return PipelineDepthStencilStateCreateFlags(m_struct.flags);
	}
	PipelineDepthStencilStateCreateInfo &flags(PipelineDepthStencilStateCreateFlags flags)
	{
		m_struct.flags = static_cast<VkPipelineDepthStencilStateCreateFlags>(flags);
		return *this;
	}
	Bool32 depthTestEnable() const
	{
		return m_struct.depthTestEnable;
	}
	PipelineDepthStencilStateCreateInfo &depthTestEnable(Bool32 depthTestEnable)
	{
		m_struct.depthTestEnable = depthTestEnable;
		return *this;
	}
	Bool32 depthWriteEnable() const
	{
		return m_struct.depthWriteEnable;
	}
	PipelineDepthStencilStateCreateInfo &depthWriteEnable(Bool32 depthWriteEnable)
	{
		m_struct.depthWriteEnable = depthWriteEnable;
		return *this;
	}
	CompareOp depthCompareOp() const
	{
		return static_cast<CompareOp>(m_struct.depthCompareOp);
	}
	PipelineDepthStencilStateCreateInfo &depthCompareOp(CompareOp depthCompareOp)
	{
		m_struct.depthCompareOp = static_cast<VkCompareOp>(depthCompareOp);
		return *this;
	}
	Bool32 depthBoundsTestEnable() const
	{
		return m_struct.depthBoundsTestEnable;
	}
	PipelineDepthStencilStateCreateInfo &depthBoundsTestEnable(Bool32 depthBoundsTestEnable)
	{
		m_struct.depthBoundsTestEnable = depthBoundsTestEnable;
		return *this;
	}
	Bool32 stencilTestEnable() const
	{
		return m_struct.stencilTestEnable;
	}
	PipelineDepthStencilStateCreateInfo &stencilTestEnable(Bool32 stencilTestEnable)
	{
		m_struct.stencilTestEnable = stencilTestEnable;
		return *this;
	}
	StencilOpState front() const
	{
		return static_cast<StencilOpState>(m_struct.front);
	}
	PipelineDepthStencilStateCreateInfo &front(StencilOpState front)
	{
		m_struct.front = static_cast<VkStencilOpState>(front);
		return *this;
	}
	StencilOpState back() const
	{
		return static_cast<StencilOpState>(m_struct.back);
	}
	PipelineDepthStencilStateCreateInfo &back(StencilOpState back)
	{
		m_struct.back = static_cast<VkStencilOpState>(back);
		return *this;
	}
	float minDepthBounds() const
	{
		return m_struct.minDepthBounds;
	}
	PipelineDepthStencilStateCreateInfo &minDepthBounds(float minDepthBounds)
	{
		m_struct.minDepthBounds = minDepthBounds;
		return *this;
	}
	float maxDepthBounds() const
	{
		return m_struct.maxDepthBounds;
	}
	PipelineDepthStencilStateCreateInfo &maxDepthBounds(float maxDepthBounds)
	{
		m_struct.maxDepthBounds = maxDepthBounds;
		return *this;
	}

	VkPipelineDepthStencilStateCreateInfo *c_ptr() { return &m_struct; }
	const VkPipelineDepthStencilStateCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkPipelineDepthStencilStateCreateInfo&() const { return m_struct; }
};

class PipelineLayoutCreateInfo {
	VkPipelineLayoutCreateInfo m_struct;
public:
	PipelineLayoutCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkPipelineLayoutCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
	}
	PipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	PipelineLayoutCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	PipelineLayoutCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	PipelineLayoutCreateFlags flags() const
	{
		return PipelineLayoutCreateFlags(m_struct.flags);
	}
	PipelineLayoutCreateInfo &flags(PipelineLayoutCreateFlags flags)
	{
		m_struct.flags = static_cast<VkPipelineLayoutCreateFlags>(flags);
		return *this;
	}
	uint32_t setLayoutCount() const
	{
		return m_struct.setLayoutCount;
	}
	PipelineLayoutCreateInfo &setLayoutCount(uint32_t setLayoutCount)
	{
		m_struct.setLayoutCount = setLayoutCount;
		return *this;
	}
	const DescriptorSetLayout* pSetLayouts() const
	{
		return reinterpret_cast<const DescriptorSetLayout*>(m_struct.pSetLayouts);
	}
	PipelineLayoutCreateInfo &pSetLayouts(const DescriptorSetLayout* pSetLayouts)
	{
		m_struct.pSetLayouts = reinterpret_cast<const VkDescriptorSetLayout*>(pSetLayouts);
		return *this;
	}
	uint32_t pushConstantRangeCount() const
	{
		return m_struct.pushConstantRangeCount;
	}
	PipelineLayoutCreateInfo &pushConstantRangeCount(uint32_t pushConstantRangeCount)
	{
		m_struct.pushConstantRangeCount = pushConstantRangeCount;
		return *this;
	}
	const PushConstantRange* pPushConstantRanges() const
	{
		return reinterpret_cast<const PushConstantRange*>(m_struct.pPushConstantRanges);
	}
	PipelineLayoutCreateInfo &pPushConstantRanges(const PushConstantRange* pPushConstantRanges)
	{
		m_struct.pPushConstantRanges = reinterpret_cast<const VkPushConstantRange*>(pPushConstantRanges);
		return *this;
	}

	VkPipelineLayoutCreateInfo *c_ptr() { return &m_struct; }
	const VkPipelineLayoutCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkPipelineLayoutCreateInfo&() const { return m_struct; }
};

class PipelineVertexInputStateCreateInfo {
	VkPipelineVertexInputStateCreateInfo m_struct;
public:
	PipelineVertexInputStateCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkPipelineVertexInputStateCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
	}
	PipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	PipelineVertexInputStateCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	PipelineVertexInputStateCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	PipelineVertexInputStateCreateFlags flags() const
	{
		return PipelineVertexInputStateCreateFlags(m_struct.flags);
	}
	PipelineVertexInputStateCreateInfo &flags(PipelineVertexInputStateCreateFlags flags)
	{
		m_struct.flags = static_cast<VkPipelineVertexInputStateCreateFlags>(flags);
		return *this;
	}
	uint32_t vertexBindingDescriptionCount() const
	{
		return m_struct.vertexBindingDescriptionCount;
	}
	PipelineVertexInputStateCreateInfo &vertexBindingDescriptionCount(uint32_t vertexBindingDescriptionCount)
	{
		m_struct.vertexBindingDescriptionCount = vertexBindingDescriptionCount;
		return *this;
	}
	const VertexInputBindingDescription* pVertexBindingDescriptions() const
	{
		return reinterpret_cast<const VertexInputBindingDescription*>(m_struct.pVertexBindingDescriptions);
	}
	PipelineVertexInputStateCreateInfo &pVertexBindingDescriptions(const VertexInputBindingDescription* pVertexBindingDescriptions)
	{
		m_struct.pVertexBindingDescriptions = reinterpret_cast<const VkVertexInputBindingDescription*>(pVertexBindingDescriptions);
		return *this;
	}
	uint32_t vertexAttributeDescriptionCount() const
	{
		return m_struct.vertexAttributeDescriptionCount;
	}
	PipelineVertexInputStateCreateInfo &vertexAttributeDescriptionCount(uint32_t vertexAttributeDescriptionCount)
	{
		m_struct.vertexAttributeDescriptionCount = vertexAttributeDescriptionCount;
		return *this;
	}
	const VertexInputAttributeDescription* pVertexAttributeDescriptions() const
	{
		return reinterpret_cast<const VertexInputAttributeDescription*>(m_struct.pVertexAttributeDescriptions);
	}
	PipelineVertexInputStateCreateInfo &pVertexAttributeDescriptions(const VertexInputAttributeDescription* pVertexAttributeDescriptions)
	{
		m_struct.pVertexAttributeDescriptions = reinterpret_cast<const VkVertexInputAttributeDescription*>(pVertexAttributeDescriptions);
		return *this;
	}

	VkPipelineVertexInputStateCreateInfo *c_ptr() { return &m_struct; }
	const VkPipelineVertexInputStateCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkPipelineVertexInputStateCreateInfo&() const { return m_struct; }
};

class QueueFamilyProperties {
	VkQueueFamilyProperties m_struct;
public:
	QueueFamilyProperties()
	{
		std::memset(&m_struct, 0, sizeof(VkQueueFamilyProperties));
		
	}
	QueueFamilyProperties(const VkQueueFamilyProperties &r): m_struct(r) {}

	
	QueueFlags queueFlags() const
	{
		return QueueFlags(m_struct.queueFlags);
	}
	
	uint32_t queueCount() const
	{
		return m_struct.queueCount;
	}
	
	uint32_t timestampValidBits() const
	{
		return m_struct.timestampValidBits;
	}
	
	Extent3D minImageTransferGranularity() const
	{
		return static_cast<Extent3D>(m_struct.minImageTransferGranularity);
	}
	

	VkQueueFamilyProperties *c_ptr() { return &m_struct; }
	const VkQueueFamilyProperties *c_ptr() const { return &m_struct; }

	operator const VkQueueFamilyProperties&() const { return m_struct; }
};

class Rect2D {
	VkRect2D m_struct;
public:
	Rect2D()
	{
		std::memset(&m_struct, 0, sizeof(VkRect2D));
		
	}
	Rect2D(const VkRect2D &r): m_struct(r) {}

	
	Offset2D offset() const
	{
		return static_cast<Offset2D>(m_struct.offset);
	}
	Rect2D &offset(Offset2D offset)
	{
		m_struct.offset = static_cast<VkOffset2D>(offset);
		return *this;
	}
	Extent2D extent() const
	{
		return static_cast<Extent2D>(m_struct.extent);
	}
	Rect2D &extent(Extent2D extent)
	{
		m_struct.extent = static_cast<VkExtent2D>(extent);
		return *this;
	}

	VkRect2D *c_ptr() { return &m_struct; }
	const VkRect2D *c_ptr() const { return &m_struct; }

	operator const VkRect2D&() const { return m_struct; }
};

class SparseBufferMemoryBindInfo {
	VkSparseBufferMemoryBindInfo m_struct;
public:
	SparseBufferMemoryBindInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkSparseBufferMemoryBindInfo));
		
	}
	SparseBufferMemoryBindInfo(const VkSparseBufferMemoryBindInfo &r): m_struct(r) {}

	
	Buffer buffer() const
	{
		return Buffer(m_struct.buffer);
	}
	SparseBufferMemoryBindInfo &buffer(Buffer buffer)
	{
		m_struct.buffer = static_cast<VkBuffer>(buffer);
		return *this;
	}
	uint32_t bindCount() const
	{
		return m_struct.bindCount;
	}
	SparseBufferMemoryBindInfo &bindCount(uint32_t bindCount)
	{
		m_struct.bindCount = bindCount;
		return *this;
	}
	const SparseMemoryBind* pBinds() const
	{
		return reinterpret_cast<const SparseMemoryBind*>(m_struct.pBinds);
	}
	SparseBufferMemoryBindInfo &pBinds(const SparseMemoryBind* pBinds)
	{
		m_struct.pBinds = reinterpret_cast<const VkSparseMemoryBind*>(pBinds);
		return *this;
	}

	VkSparseBufferMemoryBindInfo *c_ptr() { return &m_struct; }
	const VkSparseBufferMemoryBindInfo *c_ptr() const { return &m_struct; }

	operator const VkSparseBufferMemoryBindInfo&() const { return m_struct; }
};

class SparseImageFormatProperties {
	VkSparseImageFormatProperties m_struct;
public:
	SparseImageFormatProperties()
	{
		std::memset(&m_struct, 0, sizeof(VkSparseImageFormatProperties));
		
	}
	SparseImageFormatProperties(const VkSparseImageFormatProperties &r): m_struct(r) {}

	
	ImageAspectFlags aspectMask() const
	{
		return ImageAspectFlags(m_struct.aspectMask);
	}
	
	Extent3D imageGranularity() const
	{
		return static_cast<Extent3D>(m_struct.imageGranularity);
	}
	
	SparseImageFormatFlags flags() const
	{
		return SparseImageFormatFlags(m_struct.flags);
	}
	

	VkSparseImageFormatProperties *c_ptr() { return &m_struct; }
	const VkSparseImageFormatProperties *c_ptr() const { return &m_struct; }

	operator const VkSparseImageFormatProperties&() const { return m_struct; }
};

class SparseImageMemoryBind {
	VkSparseImageMemoryBind m_struct;
public:
	SparseImageMemoryBind()
	{
		std::memset(&m_struct, 0, sizeof(VkSparseImageMemoryBind));
		
	}
	SparseImageMemoryBind(const VkSparseImageMemoryBind &r): m_struct(r) {}

	
	ImageSubresource subresource() const
	{
		return static_cast<ImageSubresource>(m_struct.subresource);
	}
	SparseImageMemoryBind &subresource(ImageSubresource subresource)
	{
		m_struct.subresource = static_cast<VkImageSubresource>(subresource);
		return *this;
	}
	Offset3D offset() const
	{
		return static_cast<Offset3D>(m_struct.offset);
	}
	SparseImageMemoryBind &offset(Offset3D offset)
	{
		m_struct.offset = static_cast<VkOffset3D>(offset);
		return *this;
	}
	Extent3D extent() const
	{
		return static_cast<Extent3D>(m_struct.extent);
	}
	SparseImageMemoryBind &extent(Extent3D extent)
	{
		m_struct.extent = static_cast<VkExtent3D>(extent);
		return *this;
	}
	DeviceMemory memory() const
	{
		return DeviceMemory(m_struct.memory);
	}
	SparseImageMemoryBind &memory(DeviceMemory memory)
	{
		m_struct.memory = static_cast<VkDeviceMemory>(memory);
		return *this;
	}
	DeviceSize memoryOffset() const
	{
		return m_struct.memoryOffset;
	}
	SparseImageMemoryBind &memoryOffset(DeviceSize memoryOffset)
	{
		m_struct.memoryOffset = memoryOffset;
		return *this;
	}
	SparseMemoryBindFlags flags() const
	{
		return SparseMemoryBindFlags(m_struct.flags);
	}
	SparseImageMemoryBind &flags(SparseMemoryBindFlags flags)
	{
		m_struct.flags = static_cast<VkSparseMemoryBindFlags>(flags);
		return *this;
	}

	VkSparseImageMemoryBind *c_ptr() { return &m_struct; }
	const VkSparseImageMemoryBind *c_ptr() const { return &m_struct; }

	operator const VkSparseImageMemoryBind&() const { return m_struct; }
};

class SparseImageOpaqueMemoryBindInfo {
	VkSparseImageOpaqueMemoryBindInfo m_struct;
public:
	SparseImageOpaqueMemoryBindInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkSparseImageOpaqueMemoryBindInfo));
		
	}
	SparseImageOpaqueMemoryBindInfo(const VkSparseImageOpaqueMemoryBindInfo &r): m_struct(r) {}

	
	Image image() const
	{
		return Image(m_struct.image);
	}
	SparseImageOpaqueMemoryBindInfo &image(Image image)
	{
		m_struct.image = static_cast<VkImage>(image);
		return *this;
	}
	uint32_t bindCount() const
	{
		return m_struct.bindCount;
	}
	SparseImageOpaqueMemoryBindInfo &bindCount(uint32_t bindCount)
	{
		m_struct.bindCount = bindCount;
		return *this;
	}
	const SparseMemoryBind* pBinds() const
	{
		return reinterpret_cast<const SparseMemoryBind*>(m_struct.pBinds);
	}
	SparseImageOpaqueMemoryBindInfo &pBinds(const SparseMemoryBind* pBinds)
	{
		m_struct.pBinds = reinterpret_cast<const VkSparseMemoryBind*>(pBinds);
		return *this;
	}

	VkSparseImageOpaqueMemoryBindInfo *c_ptr() { return &m_struct; }
	const VkSparseImageOpaqueMemoryBindInfo *c_ptr() const { return &m_struct; }

	operator const VkSparseImageOpaqueMemoryBindInfo&() const { return m_struct; }
};

class SpecializationInfo {
	VkSpecializationInfo m_struct;
public:
	SpecializationInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkSpecializationInfo));
		
	}
	SpecializationInfo(const VkSpecializationInfo &r): m_struct(r) {}

	
	uint32_t mapEntryCount() const
	{
		return m_struct.mapEntryCount;
	}
	SpecializationInfo &mapEntryCount(uint32_t mapEntryCount)
	{
		m_struct.mapEntryCount = mapEntryCount;
		return *this;
	}
	const SpecializationMapEntry* pMapEntries() const
	{
		return reinterpret_cast<const SpecializationMapEntry*>(m_struct.pMapEntries);
	}
	SpecializationInfo &pMapEntries(const SpecializationMapEntry* pMapEntries)
	{
		m_struct.pMapEntries = reinterpret_cast<const VkSpecializationMapEntry*>(pMapEntries);
		return *this;
	}
	size_t dataSize() const
	{
		return m_struct.dataSize;
	}
	SpecializationInfo &dataSize(size_t dataSize)
	{
		m_struct.dataSize = dataSize;
		return *this;
	}
	const void* pData() const
	{
		return m_struct.pData;
	}
	SpecializationInfo &pData(const void* pData)
	{
		m_struct.pData = pData;
		return *this;
	}

	VkSpecializationInfo *c_ptr() { return &m_struct; }
	const VkSpecializationInfo *c_ptr() const { return &m_struct; }

	operator const VkSpecializationInfo&() const { return m_struct; }
};

class SubpassDescription {
	VkSubpassDescription m_struct;
public:
	SubpassDescription()
	{
		std::memset(&m_struct, 0, sizeof(VkSubpassDescription));
		
	}
	SubpassDescription(const VkSubpassDescription &r): m_struct(r) {}

	
	SubpassDescriptionFlags flags() const
	{
		return SubpassDescriptionFlags(m_struct.flags);
	}
	SubpassDescription &flags(SubpassDescriptionFlags flags)
	{
		m_struct.flags = static_cast<VkSubpassDescriptionFlags>(flags);
		return *this;
	}
	PipelineBindPoint pipelineBindPoint() const
	{
		return static_cast<PipelineBindPoint>(m_struct.pipelineBindPoint);
	}
	SubpassDescription &pipelineBindPoint(PipelineBindPoint pipelineBindPoint)
	{
		m_struct.pipelineBindPoint = static_cast<VkPipelineBindPoint>(pipelineBindPoint);
		return *this;
	}
	uint32_t inputAttachmentCount() const
	{
		return m_struct.inputAttachmentCount;
	}
	SubpassDescription &inputAttachmentCount(uint32_t inputAttachmentCount)
	{
		m_struct.inputAttachmentCount = inputAttachmentCount;
		return *this;
	}
	const AttachmentReference* pInputAttachments() const
	{
		return reinterpret_cast<const AttachmentReference*>(m_struct.pInputAttachments);
	}
	SubpassDescription &pInputAttachments(const AttachmentReference* pInputAttachments)
	{
		m_struct.pInputAttachments = reinterpret_cast<const VkAttachmentReference*>(pInputAttachments);
		return *this;
	}
	uint32_t colorAttachmentCount() const
	{
		return m_struct.colorAttachmentCount;
	}
	SubpassDescription &colorAttachmentCount(uint32_t colorAttachmentCount)
	{
		m_struct.colorAttachmentCount = colorAttachmentCount;
		return *this;
	}
	const AttachmentReference* pColorAttachments() const
	{
		return reinterpret_cast<const AttachmentReference*>(m_struct.pColorAttachments);
	}
	SubpassDescription &pColorAttachments(const AttachmentReference* pColorAttachments)
	{
		m_struct.pColorAttachments = reinterpret_cast<const VkAttachmentReference*>(pColorAttachments);
		return *this;
	}
	const AttachmentReference* pResolveAttachments() const
	{
		return reinterpret_cast<const AttachmentReference*>(m_struct.pResolveAttachments);
	}
	SubpassDescription &pResolveAttachments(const AttachmentReference* pResolveAttachments)
	{
		m_struct.pResolveAttachments = reinterpret_cast<const VkAttachmentReference*>(pResolveAttachments);
		return *this;
	}
	const AttachmentReference* pDepthStencilAttachment() const
	{
		return reinterpret_cast<const AttachmentReference*>(m_struct.pDepthStencilAttachment);
	}
	SubpassDescription &pDepthStencilAttachment(const AttachmentReference* pDepthStencilAttachment)
	{
		m_struct.pDepthStencilAttachment = reinterpret_cast<const VkAttachmentReference*>(pDepthStencilAttachment);
		return *this;
	}
	uint32_t preserveAttachmentCount() const
	{
		return m_struct.preserveAttachmentCount;
	}
	SubpassDescription &preserveAttachmentCount(uint32_t preserveAttachmentCount)
	{
		m_struct.preserveAttachmentCount = preserveAttachmentCount;
		return *this;
	}
	const uint32_t* pPreserveAttachments() const
	{
		return m_struct.pPreserveAttachments;
	}
	SubpassDescription &pPreserveAttachments(const uint32_t* pPreserveAttachments)
	{
		m_struct.pPreserveAttachments = pPreserveAttachments;
		return *this;
	}

	VkSubpassDescription *c_ptr() { return &m_struct; }
	const VkSubpassDescription *c_ptr() const { return &m_struct; }

	operator const VkSubpassDescription&() const { return m_struct; }
};

class SurfaceCapabilitiesKHR {
	VkSurfaceCapabilitiesKHR m_struct;
public:
	SurfaceCapabilitiesKHR()
	{
		std::memset(&m_struct, 0, sizeof(VkSurfaceCapabilitiesKHR));
		
	}
	SurfaceCapabilitiesKHR(const VkSurfaceCapabilitiesKHR &r): m_struct(r) {}

	
	uint32_t minImageCount() const
	{
		return m_struct.minImageCount;
	}
	SurfaceCapabilitiesKHR &minImageCount(uint32_t minImageCount)
	{
		m_struct.minImageCount = minImageCount;
		return *this;
	}
	uint32_t maxImageCount() const
	{
		return m_struct.maxImageCount;
	}
	SurfaceCapabilitiesKHR &maxImageCount(uint32_t maxImageCount)
	{
		m_struct.maxImageCount = maxImageCount;
		return *this;
	}
	Extent2D currentExtent() const
	{
		return static_cast<Extent2D>(m_struct.currentExtent);
	}
	SurfaceCapabilitiesKHR &currentExtent(Extent2D currentExtent)
	{
		m_struct.currentExtent = static_cast<VkExtent2D>(currentExtent);
		return *this;
	}
	Extent2D minImageExtent() const
	{
		return static_cast<Extent2D>(m_struct.minImageExtent);
	}
	SurfaceCapabilitiesKHR &minImageExtent(Extent2D minImageExtent)
	{
		m_struct.minImageExtent = static_cast<VkExtent2D>(minImageExtent);
		return *this;
	}
	Extent2D maxImageExtent() const
	{
		return static_cast<Extent2D>(m_struct.maxImageExtent);
	}
	SurfaceCapabilitiesKHR &maxImageExtent(Extent2D maxImageExtent)
	{
		m_struct.maxImageExtent = static_cast<VkExtent2D>(maxImageExtent);
		return *this;
	}
	uint32_t maxImageArrayLayers() const
	{
		return m_struct.maxImageArrayLayers;
	}
	SurfaceCapabilitiesKHR &maxImageArrayLayers(uint32_t maxImageArrayLayers)
	{
		m_struct.maxImageArrayLayers = maxImageArrayLayers;
		return *this;
	}
	SurfaceTransformFlagsKHR supportedTransforms() const
	{
		return SurfaceTransformFlagsKHR(m_struct.supportedTransforms);
	}
	SurfaceCapabilitiesKHR &supportedTransforms(SurfaceTransformFlagsKHR supportedTransforms)
	{
		m_struct.supportedTransforms = static_cast<VkSurfaceTransformFlagsKHR>(supportedTransforms);
		return *this;
	}
	SurfaceTransformFlagBitsKHR currentTransform() const
	{
		return static_cast<SurfaceTransformFlagBitsKHR>(m_struct.currentTransform);
	}
	SurfaceCapabilitiesKHR &currentTransform(SurfaceTransformFlagBitsKHR currentTransform)
	{
		m_struct.currentTransform = static_cast<VkSurfaceTransformFlagBitsKHR>(currentTransform);
		return *this;
	}
	CompositeAlphaFlagsKHR supportedCompositeAlpha() const
	{
		return CompositeAlphaFlagsKHR(m_struct.supportedCompositeAlpha);
	}
	SurfaceCapabilitiesKHR &supportedCompositeAlpha(CompositeAlphaFlagsKHR supportedCompositeAlpha)
	{
		m_struct.supportedCompositeAlpha = static_cast<VkCompositeAlphaFlagsKHR>(supportedCompositeAlpha);
		return *this;
	}
	ImageUsageFlags supportedUsageFlags() const
	{
		return ImageUsageFlags(m_struct.supportedUsageFlags);
	}
	SurfaceCapabilitiesKHR &supportedUsageFlags(ImageUsageFlags supportedUsageFlags)
	{
		m_struct.supportedUsageFlags = static_cast<VkImageUsageFlags>(supportedUsageFlags);
		return *this;
	}

	VkSurfaceCapabilitiesKHR *c_ptr() { return &m_struct; }
	const VkSurfaceCapabilitiesKHR *c_ptr() const { return &m_struct; }

	operator const VkSurfaceCapabilitiesKHR&() const { return m_struct; }
};

class SwapchainCreateInfoKHR {
	VkSwapchainCreateInfoKHR m_struct;
public:
	SwapchainCreateInfoKHR()
	{
		std::memset(&m_struct, 0, sizeof(VkSwapchainCreateInfoKHR));
		m_struct.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
	}
	SwapchainCreateInfoKHR(const VkSwapchainCreateInfoKHR &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	SwapchainCreateInfoKHR &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	SwapchainCreateInfoKHR &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	SwapchainCreateFlagsKHR flags() const
	{
		return SwapchainCreateFlagsKHR(m_struct.flags);
	}
	SwapchainCreateInfoKHR &flags(SwapchainCreateFlagsKHR flags)
	{
		m_struct.flags = static_cast<VkSwapchainCreateFlagsKHR>(flags);
		return *this;
	}
	SurfaceKHR surface() const
	{
		return SurfaceKHR(m_struct.surface);
	}
	SwapchainCreateInfoKHR &surface(SurfaceKHR surface)
	{
		m_struct.surface = static_cast<VkSurfaceKHR>(surface);
		return *this;
	}
	uint32_t minImageCount() const
	{
		return m_struct.minImageCount;
	}
	SwapchainCreateInfoKHR &minImageCount(uint32_t minImageCount)
	{
		m_struct.minImageCount = minImageCount;
		return *this;
	}
	Format imageFormat() const
	{
		return static_cast<Format>(m_struct.imageFormat);
	}
	SwapchainCreateInfoKHR &imageFormat(Format imageFormat)
	{
		m_struct.imageFormat = static_cast<VkFormat>(imageFormat);
		return *this;
	}
	ColorSpaceKHR imageColorSpace() const
	{
		return static_cast<ColorSpaceKHR>(m_struct.imageColorSpace);
	}
	SwapchainCreateInfoKHR &imageColorSpace(ColorSpaceKHR imageColorSpace)
	{
		m_struct.imageColorSpace = static_cast<VkColorSpaceKHR>(imageColorSpace);
		return *this;
	}
	Extent2D imageExtent() const
	{
		return static_cast<Extent2D>(m_struct.imageExtent);
	}
	SwapchainCreateInfoKHR &imageExtent(Extent2D imageExtent)
	{
		m_struct.imageExtent = static_cast<VkExtent2D>(imageExtent);
		return *this;
	}
	uint32_t imageArrayLayers() const
	{
		return m_struct.imageArrayLayers;
	}
	SwapchainCreateInfoKHR &imageArrayLayers(uint32_t imageArrayLayers)
	{
		m_struct.imageArrayLayers = imageArrayLayers;
		return *this;
	}
	ImageUsageFlags imageUsage() const
	{
		return ImageUsageFlags(m_struct.imageUsage);
	}
	SwapchainCreateInfoKHR &imageUsage(ImageUsageFlags imageUsage)
	{
		m_struct.imageUsage = static_cast<VkImageUsageFlags>(imageUsage);
		return *this;
	}
	SharingMode imageSharingMode() const
	{
		return static_cast<SharingMode>(m_struct.imageSharingMode);
	}
	SwapchainCreateInfoKHR &imageSharingMode(SharingMode imageSharingMode)
	{
		m_struct.imageSharingMode = static_cast<VkSharingMode>(imageSharingMode);
		return *this;
	}
	uint32_t queueFamilyIndexCount() const
	{
		return m_struct.queueFamilyIndexCount;
	}
	SwapchainCreateInfoKHR &queueFamilyIndexCount(uint32_t queueFamilyIndexCount)
	{
		m_struct.queueFamilyIndexCount = queueFamilyIndexCount;
		return *this;
	}
	const uint32_t* pQueueFamilyIndices() const
	{
		return m_struct.pQueueFamilyIndices;
	}
	SwapchainCreateInfoKHR &pQueueFamilyIndices(const uint32_t* pQueueFamilyIndices)
	{
		m_struct.pQueueFamilyIndices = pQueueFamilyIndices;
		return *this;
	}
	SurfaceTransformFlagBitsKHR preTransform() const
	{
		return static_cast<SurfaceTransformFlagBitsKHR>(m_struct.preTransform);
	}
	SwapchainCreateInfoKHR &preTransform(SurfaceTransformFlagBitsKHR preTransform)
	{
		m_struct.preTransform = static_cast<VkSurfaceTransformFlagBitsKHR>(preTransform);
		return *this;
	}
	CompositeAlphaFlagBitsKHR compositeAlpha() const
	{
		return static_cast<CompositeAlphaFlagBitsKHR>(m_struct.compositeAlpha);
	}
	SwapchainCreateInfoKHR &compositeAlpha(CompositeAlphaFlagBitsKHR compositeAlpha)
	{
		m_struct.compositeAlpha = static_cast<VkCompositeAlphaFlagBitsKHR>(compositeAlpha);
		return *this;
	}
	PresentModeKHR presentMode() const
	{
		return static_cast<PresentModeKHR>(m_struct.presentMode);
	}
	SwapchainCreateInfoKHR &presentMode(PresentModeKHR presentMode)
	{
		m_struct.presentMode = static_cast<VkPresentModeKHR>(presentMode);
		return *this;
	}
	Bool32 clipped() const
	{
		return m_struct.clipped;
	}
	SwapchainCreateInfoKHR &clipped(Bool32 clipped)
	{
		m_struct.clipped = clipped;
		return *this;
	}
	SwapchainKHR oldSwapchain() const
	{
		return SwapchainKHR(m_struct.oldSwapchain);
	}
	SwapchainCreateInfoKHR &oldSwapchain(SwapchainKHR oldSwapchain)
	{
		m_struct.oldSwapchain = static_cast<VkSwapchainKHR>(oldSwapchain);
		return *this;
	}

	VkSwapchainCreateInfoKHR *c_ptr() { return &m_struct; }
	const VkSwapchainCreateInfoKHR *c_ptr() const { return &m_struct; }

	operator const VkSwapchainCreateInfoKHR&() const { return m_struct; }
};

class WriteDescriptorSet {
	VkWriteDescriptorSet m_struct;
public:
	WriteDescriptorSet()
	{
		std::memset(&m_struct, 0, sizeof(VkWriteDescriptorSet));
		m_struct.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
	}
	WriteDescriptorSet(const VkWriteDescriptorSet &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	WriteDescriptorSet &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	WriteDescriptorSet &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	DescriptorSet dstSet() const
	{
		return DescriptorSet(m_struct.dstSet);
	}
	WriteDescriptorSet &dstSet(DescriptorSet dstSet)
	{
		m_struct.dstSet = static_cast<VkDescriptorSet>(dstSet);
		return *this;
	}
	uint32_t dstBinding() const
	{
		return m_struct.dstBinding;
	}
	WriteDescriptorSet &dstBinding(uint32_t dstBinding)
	{
		m_struct.dstBinding = dstBinding;
		return *this;
	}
	uint32_t dstArrayElement() const
	{
		return m_struct.dstArrayElement;
	}
	WriteDescriptorSet &dstArrayElement(uint32_t dstArrayElement)
	{
		m_struct.dstArrayElement = dstArrayElement;
		return *this;
	}
	uint32_t descriptorCount() const
	{
		return m_struct.descriptorCount;
	}
	WriteDescriptorSet &descriptorCount(uint32_t descriptorCount)
	{
		m_struct.descriptorCount = descriptorCount;
		return *this;
	}
	DescriptorType descriptorType() const
	{
		return static_cast<DescriptorType>(m_struct.descriptorType);
	}
	WriteDescriptorSet &descriptorType(DescriptorType descriptorType)
	{
		m_struct.descriptorType = static_cast<VkDescriptorType>(descriptorType);
		return *this;
	}
	const DescriptorImageInfo* pImageInfo() const
	{
		return reinterpret_cast<const DescriptorImageInfo*>(m_struct.pImageInfo);
	}
	WriteDescriptorSet &pImageInfo(const DescriptorImageInfo* pImageInfo)
	{
		m_struct.pImageInfo = reinterpret_cast<const VkDescriptorImageInfo*>(pImageInfo);
		return *this;
	}
	const DescriptorBufferInfo* pBufferInfo() const
	{
		return reinterpret_cast<const DescriptorBufferInfo*>(m_struct.pBufferInfo);
	}
	WriteDescriptorSet &pBufferInfo(const DescriptorBufferInfo* pBufferInfo)
	{
		m_struct.pBufferInfo = reinterpret_cast<const VkDescriptorBufferInfo*>(pBufferInfo);
		return *this;
	}
	const BufferView* pTexelBufferView() const
	{
		return reinterpret_cast<const BufferView*>(m_struct.pTexelBufferView);
	}
	WriteDescriptorSet &pTexelBufferView(const BufferView* pTexelBufferView)
	{
		m_struct.pTexelBufferView = reinterpret_cast<const VkBufferView*>(pTexelBufferView);
		return *this;
	}

	VkWriteDescriptorSet *c_ptr() { return &m_struct; }
	const VkWriteDescriptorSet *c_ptr() const { return &m_struct; }

	operator const VkWriteDescriptorSet&() const { return m_struct; }
};

class ClearAttachment {
	VkClearAttachment m_struct;
public:
	ClearAttachment()
	{
		std::memset(&m_struct, 0, sizeof(VkClearAttachment));
		
	}
	ClearAttachment(const VkClearAttachment &r): m_struct(r) {}

	
	ImageAspectFlags aspectMask() const
	{
		return ImageAspectFlags(m_struct.aspectMask);
	}
	ClearAttachment &aspectMask(ImageAspectFlags aspectMask)
	{
		m_struct.aspectMask = static_cast<VkImageAspectFlags>(aspectMask);
		return *this;
	}
	uint32_t colorAttachment() const
	{
		return m_struct.colorAttachment;
	}
	ClearAttachment &colorAttachment(uint32_t colorAttachment)
	{
		m_struct.colorAttachment = colorAttachment;
		return *this;
	}
	ClearValue clearValue() const
	{
		return static_cast<ClearValue>(m_struct.clearValue);
	}
	ClearAttachment &clearValue(ClearValue clearValue)
	{
		m_struct.clearValue = static_cast<VkClearValue>(clearValue);
		return *this;
	}

	VkClearAttachment *c_ptr() { return &m_struct; }
	const VkClearAttachment *c_ptr() const { return &m_struct; }

	operator const VkClearAttachment&() const { return m_struct; }
};

class ClearRect {
	VkClearRect m_struct;
public:
	ClearRect()
	{
		std::memset(&m_struct, 0, sizeof(VkClearRect));
		
	}
	ClearRect(const VkClearRect &r): m_struct(r) {}

	
	Rect2D rect() const
	{
		return static_cast<Rect2D>(m_struct.rect);
	}
	ClearRect &rect(Rect2D rect)
	{
		m_struct.rect = static_cast<VkRect2D>(rect);
		return *this;
	}
	uint32_t baseArrayLayer() const
	{
		return m_struct.baseArrayLayer;
	}
	ClearRect &baseArrayLayer(uint32_t baseArrayLayer)
	{
		m_struct.baseArrayLayer = baseArrayLayer;
		return *this;
	}
	uint32_t layerCount() const
	{
		return m_struct.layerCount;
	}
	ClearRect &layerCount(uint32_t layerCount)
	{
		m_struct.layerCount = layerCount;
		return *this;
	}

	VkClearRect *c_ptr() { return &m_struct; }
	const VkClearRect *c_ptr() const { return &m_struct; }

	operator const VkClearRect&() const { return m_struct; }
};

class DisplayModeCreateInfoKHR {
	VkDisplayModeCreateInfoKHR m_struct;
public:
	DisplayModeCreateInfoKHR()
	{
		std::memset(&m_struct, 0, sizeof(VkDisplayModeCreateInfoKHR));
		m_struct.sType = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR;
	}
	DisplayModeCreateInfoKHR(const VkDisplayModeCreateInfoKHR &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	DisplayModeCreateInfoKHR &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	DisplayModeCreateInfoKHR &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	DisplayModeCreateFlagsKHR flags() const
	{
		return DisplayModeCreateFlagsKHR(m_struct.flags);
	}
	DisplayModeCreateInfoKHR &flags(DisplayModeCreateFlagsKHR flags)
	{
		m_struct.flags = static_cast<VkDisplayModeCreateFlagsKHR>(flags);
		return *this;
	}
	DisplayModeParametersKHR parameters() const
	{
		return static_cast<DisplayModeParametersKHR>(m_struct.parameters);
	}
	DisplayModeCreateInfoKHR &parameters(DisplayModeParametersKHR parameters)
	{
		m_struct.parameters = static_cast<VkDisplayModeParametersKHR>(parameters);
		return *this;
	}

	VkDisplayModeCreateInfoKHR *c_ptr() { return &m_struct; }
	const VkDisplayModeCreateInfoKHR *c_ptr() const { return &m_struct; }

	operator const VkDisplayModeCreateInfoKHR&() const { return m_struct; }
};

class DisplayModePropertiesKHR {
	VkDisplayModePropertiesKHR m_struct;
public:
	DisplayModePropertiesKHR()
	{
		std::memset(&m_struct, 0, sizeof(VkDisplayModePropertiesKHR));
		
	}
	DisplayModePropertiesKHR(const VkDisplayModePropertiesKHR &r): m_struct(r) {}

	
	DisplayModeKHR displayMode() const
	{
		return DisplayModeKHR(m_struct.displayMode);
	}
	DisplayModePropertiesKHR &displayMode(DisplayModeKHR displayMode)
	{
		m_struct.displayMode = static_cast<VkDisplayModeKHR>(displayMode);
		return *this;
	}
	DisplayModeParametersKHR parameters() const
	{
		return static_cast<DisplayModeParametersKHR>(m_struct.parameters);
	}
	DisplayModePropertiesKHR &parameters(DisplayModeParametersKHR parameters)
	{
		m_struct.parameters = static_cast<VkDisplayModeParametersKHR>(parameters);
		return *this;
	}

	VkDisplayModePropertiesKHR *c_ptr() { return &m_struct; }
	const VkDisplayModePropertiesKHR *c_ptr() const { return &m_struct; }

	operator const VkDisplayModePropertiesKHR&() const { return m_struct; }
};

class DisplayPresentInfoKHR {
	VkDisplayPresentInfoKHR m_struct;
public:
	DisplayPresentInfoKHR()
	{
		std::memset(&m_struct, 0, sizeof(VkDisplayPresentInfoKHR));
		m_struct.sType = VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR;
	}
	DisplayPresentInfoKHR(const VkDisplayPresentInfoKHR &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	DisplayPresentInfoKHR &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	DisplayPresentInfoKHR &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	Rect2D srcRect() const
	{
		return static_cast<Rect2D>(m_struct.srcRect);
	}
	DisplayPresentInfoKHR &srcRect(Rect2D srcRect)
	{
		m_struct.srcRect = static_cast<VkRect2D>(srcRect);
		return *this;
	}
	Rect2D dstRect() const
	{
		return static_cast<Rect2D>(m_struct.dstRect);
	}
	DisplayPresentInfoKHR &dstRect(Rect2D dstRect)
	{
		m_struct.dstRect = static_cast<VkRect2D>(dstRect);
		return *this;
	}
	Bool32 persistent() const
	{
		return m_struct.persistent;
	}
	DisplayPresentInfoKHR &persistent(Bool32 persistent)
	{
		m_struct.persistent = persistent;
		return *this;
	}

	VkDisplayPresentInfoKHR *c_ptr() { return &m_struct; }
	const VkDisplayPresentInfoKHR *c_ptr() const { return &m_struct; }

	operator const VkDisplayPresentInfoKHR&() const { return m_struct; }
};

class PipelineShaderStageCreateInfo {
	VkPipelineShaderStageCreateInfo m_struct;
public:
	PipelineShaderStageCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkPipelineShaderStageCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
	}
	PipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	PipelineShaderStageCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	PipelineShaderStageCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	PipelineShaderStageCreateFlags flags() const
	{
		return PipelineShaderStageCreateFlags(m_struct.flags);
	}
	PipelineShaderStageCreateInfo &flags(PipelineShaderStageCreateFlags flags)
	{
		m_struct.flags = static_cast<VkPipelineShaderStageCreateFlags>(flags);
		return *this;
	}
	ShaderStageFlagBits stage() const
	{
		return static_cast<ShaderStageFlagBits>(m_struct.stage);
	}
	PipelineShaderStageCreateInfo &stage(ShaderStageFlagBits stage)
	{
		m_struct.stage = static_cast<VkShaderStageFlagBits>(stage);
		return *this;
	}
	ShaderModule module() const
	{
		return ShaderModule(m_struct.module);
	}
	PipelineShaderStageCreateInfo &module(ShaderModule module)
	{
		m_struct.module = static_cast<VkShaderModule>(module);
		return *this;
	}
	const char* pName() const
	{
		return m_struct.pName;
	}
	PipelineShaderStageCreateInfo &pName(const char* pName)
	{
		m_struct.pName = pName;
		return *this;
	}
	const SpecializationInfo* pSpecializationInfo() const
	{
		return reinterpret_cast<const SpecializationInfo*>(m_struct.pSpecializationInfo);
	}
	PipelineShaderStageCreateInfo &pSpecializationInfo(const SpecializationInfo* pSpecializationInfo)
	{
		m_struct.pSpecializationInfo = reinterpret_cast<const VkSpecializationInfo*>(pSpecializationInfo);
		return *this;
	}

	VkPipelineShaderStageCreateInfo *c_ptr() { return &m_struct; }
	const VkPipelineShaderStageCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkPipelineShaderStageCreateInfo&() const { return m_struct; }
};

class PipelineViewportStateCreateInfo {
	VkPipelineViewportStateCreateInfo m_struct;
public:
	PipelineViewportStateCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkPipelineViewportStateCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
	}
	PipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	PipelineViewportStateCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	PipelineViewportStateCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	PipelineViewportStateCreateFlags flags() const
	{
		return PipelineViewportStateCreateFlags(m_struct.flags);
	}
	PipelineViewportStateCreateInfo &flags(PipelineViewportStateCreateFlags flags)
	{
		m_struct.flags = static_cast<VkPipelineViewportStateCreateFlags>(flags);
		return *this;
	}
	uint32_t viewportCount() const
	{
		return m_struct.viewportCount;
	}
	PipelineViewportStateCreateInfo &viewportCount(uint32_t viewportCount)
	{
		m_struct.viewportCount = viewportCount;
		return *this;
	}
	const Viewport* pViewports() const
	{
		return reinterpret_cast<const Viewport*>(m_struct.pViewports);
	}
	PipelineViewportStateCreateInfo &pViewports(const Viewport* pViewports)
	{
		m_struct.pViewports = reinterpret_cast<const VkViewport*>(pViewports);
		return *this;
	}
	uint32_t scissorCount() const
	{
		return m_struct.scissorCount;
	}
	PipelineViewportStateCreateInfo &scissorCount(uint32_t scissorCount)
	{
		m_struct.scissorCount = scissorCount;
		return *this;
	}
	const Rect2D* pScissors() const
	{
		return reinterpret_cast<const Rect2D*>(m_struct.pScissors);
	}
	PipelineViewportStateCreateInfo &pScissors(const Rect2D* pScissors)
	{
		m_struct.pScissors = reinterpret_cast<const VkRect2D*>(pScissors);
		return *this;
	}

	VkPipelineViewportStateCreateInfo *c_ptr() { return &m_struct; }
	const VkPipelineViewportStateCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkPipelineViewportStateCreateInfo&() const { return m_struct; }
};

class RenderPassBeginInfo {
	VkRenderPassBeginInfo m_struct;
public:
	RenderPassBeginInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkRenderPassBeginInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
	}
	RenderPassBeginInfo(const VkRenderPassBeginInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	RenderPassBeginInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	RenderPassBeginInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	RenderPass renderPass() const
	{
		return RenderPass(m_struct.renderPass);
	}
	RenderPassBeginInfo &renderPass(RenderPass renderPass)
	{
		m_struct.renderPass = static_cast<VkRenderPass>(renderPass);
		return *this;
	}
	Framebuffer framebuffer() const
	{
		return Framebuffer(m_struct.framebuffer);
	}
	RenderPassBeginInfo &framebuffer(Framebuffer framebuffer)
	{
		m_struct.framebuffer = static_cast<VkFramebuffer>(framebuffer);
		return *this;
	}
	Rect2D renderArea() const
	{
		return static_cast<Rect2D>(m_struct.renderArea);
	}
	RenderPassBeginInfo &renderArea(Rect2D renderArea)
	{
		m_struct.renderArea = static_cast<VkRect2D>(renderArea);
		return *this;
	}
	uint32_t clearValueCount() const
	{
		return m_struct.clearValueCount;
	}
	RenderPassBeginInfo &clearValueCount(uint32_t clearValueCount)
	{
		m_struct.clearValueCount = clearValueCount;
		return *this;
	}
	const ClearValue* pClearValues() const
	{
		return reinterpret_cast<const ClearValue*>(m_struct.pClearValues);
	}
	RenderPassBeginInfo &pClearValues(const ClearValue* pClearValues)
	{
		m_struct.pClearValues = reinterpret_cast<const VkClearValue*>(pClearValues);
		return *this;
	}

	VkRenderPassBeginInfo *c_ptr() { return &m_struct; }
	const VkRenderPassBeginInfo *c_ptr() const { return &m_struct; }

	operator const VkRenderPassBeginInfo&() const { return m_struct; }
};

class RenderPassCreateInfo {
	VkRenderPassCreateInfo m_struct;
public:
	RenderPassCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkRenderPassCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
	}
	RenderPassCreateInfo(const VkRenderPassCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	RenderPassCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	RenderPassCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	RenderPassCreateFlags flags() const
	{
		return RenderPassCreateFlags(m_struct.flags);
	}
	RenderPassCreateInfo &flags(RenderPassCreateFlags flags)
	{
		m_struct.flags = static_cast<VkRenderPassCreateFlags>(flags);
		return *this;
	}
	uint32_t attachmentCount() const
	{
		return m_struct.attachmentCount;
	}
	RenderPassCreateInfo &attachmentCount(uint32_t attachmentCount)
	{
		m_struct.attachmentCount = attachmentCount;
		return *this;
	}
	const AttachmentDescription* pAttachments() const
	{
		return reinterpret_cast<const AttachmentDescription*>(m_struct.pAttachments);
	}
	RenderPassCreateInfo &pAttachments(const AttachmentDescription* pAttachments)
	{
		m_struct.pAttachments = reinterpret_cast<const VkAttachmentDescription*>(pAttachments);
		return *this;
	}
	uint32_t subpassCount() const
	{
		return m_struct.subpassCount;
	}
	RenderPassCreateInfo &subpassCount(uint32_t subpassCount)
	{
		m_struct.subpassCount = subpassCount;
		return *this;
	}
	const SubpassDescription* pSubpasses() const
	{
		return reinterpret_cast<const SubpassDescription*>(m_struct.pSubpasses);
	}
	RenderPassCreateInfo &pSubpasses(const SubpassDescription* pSubpasses)
	{
		m_struct.pSubpasses = reinterpret_cast<const VkSubpassDescription*>(pSubpasses);
		return *this;
	}
	uint32_t dependencyCount() const
	{
		return m_struct.dependencyCount;
	}
	RenderPassCreateInfo &dependencyCount(uint32_t dependencyCount)
	{
		m_struct.dependencyCount = dependencyCount;
		return *this;
	}
	const SubpassDependency* pDependencies() const
	{
		return reinterpret_cast<const SubpassDependency*>(m_struct.pDependencies);
	}
	RenderPassCreateInfo &pDependencies(const SubpassDependency* pDependencies)
	{
		m_struct.pDependencies = reinterpret_cast<const VkSubpassDependency*>(pDependencies);
		return *this;
	}

	VkRenderPassCreateInfo *c_ptr() { return &m_struct; }
	const VkRenderPassCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkRenderPassCreateInfo&() const { return m_struct; }
};

class SparseImageMemoryBindInfo {
	VkSparseImageMemoryBindInfo m_struct;
public:
	SparseImageMemoryBindInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkSparseImageMemoryBindInfo));
		
	}
	SparseImageMemoryBindInfo(const VkSparseImageMemoryBindInfo &r): m_struct(r) {}

	
	Image image() const
	{
		return Image(m_struct.image);
	}
	SparseImageMemoryBindInfo &image(Image image)
	{
		m_struct.image = static_cast<VkImage>(image);
		return *this;
	}
	uint32_t bindCount() const
	{
		return m_struct.bindCount;
	}
	SparseImageMemoryBindInfo &bindCount(uint32_t bindCount)
	{
		m_struct.bindCount = bindCount;
		return *this;
	}
	const SparseImageMemoryBind* pBinds() const
	{
		return reinterpret_cast<const SparseImageMemoryBind*>(m_struct.pBinds);
	}
	SparseImageMemoryBindInfo &pBinds(const SparseImageMemoryBind* pBinds)
	{
		m_struct.pBinds = reinterpret_cast<const VkSparseImageMemoryBind*>(pBinds);
		return *this;
	}

	VkSparseImageMemoryBindInfo *c_ptr() { return &m_struct; }
	const VkSparseImageMemoryBindInfo *c_ptr() const { return &m_struct; }

	operator const VkSparseImageMemoryBindInfo&() const { return m_struct; }
};

class SparseImageMemoryRequirements {
	VkSparseImageMemoryRequirements m_struct;
public:
	SparseImageMemoryRequirements()
	{
		std::memset(&m_struct, 0, sizeof(VkSparseImageMemoryRequirements));
		
	}
	SparseImageMemoryRequirements(const VkSparseImageMemoryRequirements &r): m_struct(r) {}

	
	SparseImageFormatProperties formatProperties() const
	{
		return static_cast<SparseImageFormatProperties>(m_struct.formatProperties);
	}
	
	uint32_t imageMipTailFirstLod() const
	{
		return m_struct.imageMipTailFirstLod;
	}
	
	DeviceSize imageMipTailSize() const
	{
		return m_struct.imageMipTailSize;
	}
	
	DeviceSize imageMipTailOffset() const
	{
		return m_struct.imageMipTailOffset;
	}
	
	DeviceSize imageMipTailStride() const
	{
		return m_struct.imageMipTailStride;
	}
	

	VkSparseImageMemoryRequirements *c_ptr() { return &m_struct; }
	const VkSparseImageMemoryRequirements *c_ptr() const { return &m_struct; }

	operator const VkSparseImageMemoryRequirements&() const { return m_struct; }
};

class BindSparseInfo {
	VkBindSparseInfo m_struct;
public:
	BindSparseInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkBindSparseInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_BIND_SPARSE_INFO;
	}
	BindSparseInfo(const VkBindSparseInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	BindSparseInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	BindSparseInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	uint32_t waitSemaphoreCount() const
	{
		return m_struct.waitSemaphoreCount;
	}
	BindSparseInfo &waitSemaphoreCount(uint32_t waitSemaphoreCount)
	{
		m_struct.waitSemaphoreCount = waitSemaphoreCount;
		return *this;
	}
	const Semaphore* pWaitSemaphores() const
	{
		return reinterpret_cast<const Semaphore*>(m_struct.pWaitSemaphores);
	}
	BindSparseInfo &pWaitSemaphores(const Semaphore* pWaitSemaphores)
	{
		m_struct.pWaitSemaphores = reinterpret_cast<const VkSemaphore*>(pWaitSemaphores);
		return *this;
	}
	uint32_t bufferBindCount() const
	{
		return m_struct.bufferBindCount;
	}
	BindSparseInfo &bufferBindCount(uint32_t bufferBindCount)
	{
		m_struct.bufferBindCount = bufferBindCount;
		return *this;
	}
	const SparseBufferMemoryBindInfo* pBufferBinds() const
	{
		return reinterpret_cast<const SparseBufferMemoryBindInfo*>(m_struct.pBufferBinds);
	}
	BindSparseInfo &pBufferBinds(const SparseBufferMemoryBindInfo* pBufferBinds)
	{
		m_struct.pBufferBinds = reinterpret_cast<const VkSparseBufferMemoryBindInfo*>(pBufferBinds);
		return *this;
	}
	uint32_t imageOpaqueBindCount() const
	{
		return m_struct.imageOpaqueBindCount;
	}
	BindSparseInfo &imageOpaqueBindCount(uint32_t imageOpaqueBindCount)
	{
		m_struct.imageOpaqueBindCount = imageOpaqueBindCount;
		return *this;
	}
	const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds() const
	{
		return reinterpret_cast<const SparseImageOpaqueMemoryBindInfo*>(m_struct.pImageOpaqueBinds);
	}
	BindSparseInfo &pImageOpaqueBinds(const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds)
	{
		m_struct.pImageOpaqueBinds = reinterpret_cast<const VkSparseImageOpaqueMemoryBindInfo*>(pImageOpaqueBinds);
		return *this;
	}
	uint32_t imageBindCount() const
	{
		return m_struct.imageBindCount;
	}
	BindSparseInfo &imageBindCount(uint32_t imageBindCount)
	{
		m_struct.imageBindCount = imageBindCount;
		return *this;
	}
	const SparseImageMemoryBindInfo* pImageBinds() const
	{
		return reinterpret_cast<const SparseImageMemoryBindInfo*>(m_struct.pImageBinds);
	}
	BindSparseInfo &pImageBinds(const SparseImageMemoryBindInfo* pImageBinds)
	{
		m_struct.pImageBinds = reinterpret_cast<const VkSparseImageMemoryBindInfo*>(pImageBinds);
		return *this;
	}
	uint32_t signalSemaphoreCount() const
	{
		return m_struct.signalSemaphoreCount;
	}
	BindSparseInfo &signalSemaphoreCount(uint32_t signalSemaphoreCount)
	{
		m_struct.signalSemaphoreCount = signalSemaphoreCount;
		return *this;
	}
	const Semaphore* pSignalSemaphores() const
	{
		return reinterpret_cast<const Semaphore*>(m_struct.pSignalSemaphores);
	}
	BindSparseInfo &pSignalSemaphores(const Semaphore* pSignalSemaphores)
	{
		m_struct.pSignalSemaphores = reinterpret_cast<const VkSemaphore*>(pSignalSemaphores);
		return *this;
	}

	VkBindSparseInfo *c_ptr() { return &m_struct; }
	const VkBindSparseInfo *c_ptr() const { return &m_struct; }

	operator const VkBindSparseInfo&() const { return m_struct; }
};

class ComputePipelineCreateInfo {
	VkComputePipelineCreateInfo m_struct;
public:
	ComputePipelineCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkComputePipelineCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
	}
	ComputePipelineCreateInfo(const VkComputePipelineCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	ComputePipelineCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	ComputePipelineCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	PipelineCreateFlags flags() const
	{
		return PipelineCreateFlags(m_struct.flags);
	}
	ComputePipelineCreateInfo &flags(PipelineCreateFlags flags)
	{
		m_struct.flags = static_cast<VkPipelineCreateFlags>(flags);
		return *this;
	}
	PipelineShaderStageCreateInfo stage() const
	{
		return static_cast<PipelineShaderStageCreateInfo>(m_struct.stage);
	}
	ComputePipelineCreateInfo &stage(PipelineShaderStageCreateInfo stage)
	{
		m_struct.stage = static_cast<VkPipelineShaderStageCreateInfo>(stage);
		return *this;
	}
	PipelineLayout layout() const
	{
		return PipelineLayout(m_struct.layout);
	}
	ComputePipelineCreateInfo &layout(PipelineLayout layout)
	{
		m_struct.layout = static_cast<VkPipelineLayout>(layout);
		return *this;
	}
	Pipeline basePipelineHandle() const
	{
		return Pipeline(m_struct.basePipelineHandle);
	}
	ComputePipelineCreateInfo &basePipelineHandle(Pipeline basePipelineHandle)
	{
		m_struct.basePipelineHandle = static_cast<VkPipeline>(basePipelineHandle);
		return *this;
	}
	int32_t basePipelineIndex() const
	{
		return m_struct.basePipelineIndex;
	}
	ComputePipelineCreateInfo &basePipelineIndex(int32_t basePipelineIndex)
	{
		m_struct.basePipelineIndex = basePipelineIndex;
		return *this;
	}

	VkComputePipelineCreateInfo *c_ptr() { return &m_struct; }
	const VkComputePipelineCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkComputePipelineCreateInfo&() const { return m_struct; }
};

class GraphicsPipelineCreateInfo {
	VkGraphicsPipelineCreateInfo m_struct;
public:
	GraphicsPipelineCreateInfo()
	{
		std::memset(&m_struct, 0, sizeof(VkGraphicsPipelineCreateInfo));
		m_struct.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
	}
	GraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo &r): m_struct(r) {}

	
	StructureType sType() const
	{
		return static_cast<StructureType>(m_struct.sType);
	}
	GraphicsPipelineCreateInfo &sType(StructureType sType)
	{
		m_struct.sType = static_cast<VkStructureType>(sType);
		return *this;
	}
	const void* pNext() const
	{
		return m_struct.pNext;
	}
	GraphicsPipelineCreateInfo &pNext(const void* pNext)
	{
		m_struct.pNext = pNext;
		return *this;
	}
	PipelineCreateFlags flags() const
	{
		return PipelineCreateFlags(m_struct.flags);
	}
	GraphicsPipelineCreateInfo &flags(PipelineCreateFlags flags)
	{
		m_struct.flags = static_cast<VkPipelineCreateFlags>(flags);
		return *this;
	}
	uint32_t stageCount() const
	{
		return m_struct.stageCount;
	}
	GraphicsPipelineCreateInfo &stageCount(uint32_t stageCount)
	{
		m_struct.stageCount = stageCount;
		return *this;
	}
	const PipelineShaderStageCreateInfo* pStages() const
	{
		return reinterpret_cast<const PipelineShaderStageCreateInfo*>(m_struct.pStages);
	}
	GraphicsPipelineCreateInfo &pStages(const PipelineShaderStageCreateInfo* pStages)
	{
		m_struct.pStages = reinterpret_cast<const VkPipelineShaderStageCreateInfo*>(pStages);
		return *this;
	}
	const PipelineVertexInputStateCreateInfo* pVertexInputState() const
	{
		return reinterpret_cast<const PipelineVertexInputStateCreateInfo*>(m_struct.pVertexInputState);
	}
	GraphicsPipelineCreateInfo &pVertexInputState(const PipelineVertexInputStateCreateInfo* pVertexInputState)
	{
		m_struct.pVertexInputState = reinterpret_cast<const VkPipelineVertexInputStateCreateInfo*>(pVertexInputState);
		return *this;
	}
	const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState() const
	{
		return reinterpret_cast<const PipelineInputAssemblyStateCreateInfo*>(m_struct.pInputAssemblyState);
	}
	GraphicsPipelineCreateInfo &pInputAssemblyState(const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState)
	{
		m_struct.pInputAssemblyState = reinterpret_cast<const VkPipelineInputAssemblyStateCreateInfo*>(pInputAssemblyState);
		return *this;
	}
	const PipelineTessellationStateCreateInfo* pTessellationState() const
	{
		return reinterpret_cast<const PipelineTessellationStateCreateInfo*>(m_struct.pTessellationState);
	}
	GraphicsPipelineCreateInfo &pTessellationState(const PipelineTessellationStateCreateInfo* pTessellationState)
	{
		m_struct.pTessellationState = reinterpret_cast<const VkPipelineTessellationStateCreateInfo*>(pTessellationState);
		return *this;
	}
	const PipelineViewportStateCreateInfo* pViewportState() const
	{
		return reinterpret_cast<const PipelineViewportStateCreateInfo*>(m_struct.pViewportState);
	}
	GraphicsPipelineCreateInfo &pViewportState(const PipelineViewportStateCreateInfo* pViewportState)
	{
		m_struct.pViewportState = reinterpret_cast<const VkPipelineViewportStateCreateInfo*>(pViewportState);
		return *this;
	}
	const PipelineRasterizationStateCreateInfo* pRasterizationState() const
	{
		return reinterpret_cast<const PipelineRasterizationStateCreateInfo*>(m_struct.pRasterizationState);
	}
	GraphicsPipelineCreateInfo &pRasterizationState(const PipelineRasterizationStateCreateInfo* pRasterizationState)
	{
		m_struct.pRasterizationState = reinterpret_cast<const VkPipelineRasterizationStateCreateInfo*>(pRasterizationState);
		return *this;
	}
	const PipelineMultisampleStateCreateInfo* pMultisampleState() const
	{
		return reinterpret_cast<const PipelineMultisampleStateCreateInfo*>(m_struct.pMultisampleState);
	}
	GraphicsPipelineCreateInfo &pMultisampleState(const PipelineMultisampleStateCreateInfo* pMultisampleState)
	{
		m_struct.pMultisampleState = reinterpret_cast<const VkPipelineMultisampleStateCreateInfo*>(pMultisampleState);
		return *this;
	}
	const PipelineDepthStencilStateCreateInfo* pDepthStencilState() const
	{
		return reinterpret_cast<const PipelineDepthStencilStateCreateInfo*>(m_struct.pDepthStencilState);
	}
	GraphicsPipelineCreateInfo &pDepthStencilState(const PipelineDepthStencilStateCreateInfo* pDepthStencilState)
	{
		m_struct.pDepthStencilState = reinterpret_cast<const VkPipelineDepthStencilStateCreateInfo*>(pDepthStencilState);
		return *this;
	}
	const PipelineColorBlendStateCreateInfo* pColorBlendState() const
	{
		return reinterpret_cast<const PipelineColorBlendStateCreateInfo*>(m_struct.pColorBlendState);
	}
	GraphicsPipelineCreateInfo &pColorBlendState(const PipelineColorBlendStateCreateInfo* pColorBlendState)
	{
		m_struct.pColorBlendState = reinterpret_cast<const VkPipelineColorBlendStateCreateInfo*>(pColorBlendState);
		return *this;
	}
	const PipelineDynamicStateCreateInfo* pDynamicState() const
	{
		return reinterpret_cast<const PipelineDynamicStateCreateInfo*>(m_struct.pDynamicState);
	}
	GraphicsPipelineCreateInfo &pDynamicState(const PipelineDynamicStateCreateInfo* pDynamicState)
	{
		m_struct.pDynamicState = reinterpret_cast<const VkPipelineDynamicStateCreateInfo*>(pDynamicState);
		return *this;
	}
	PipelineLayout layout() const
	{
		return PipelineLayout(m_struct.layout);
	}
	GraphicsPipelineCreateInfo &layout(PipelineLayout layout)
	{
		m_struct.layout = static_cast<VkPipelineLayout>(layout);
		return *this;
	}
	RenderPass renderPass() const
	{
		return RenderPass(m_struct.renderPass);
	}
	GraphicsPipelineCreateInfo &renderPass(RenderPass renderPass)
	{
		m_struct.renderPass = static_cast<VkRenderPass>(renderPass);
		return *this;
	}
	uint32_t subpass() const
	{
		return m_struct.subpass;
	}
	GraphicsPipelineCreateInfo &subpass(uint32_t subpass)
	{
		m_struct.subpass = subpass;
		return *this;
	}
	Pipeline basePipelineHandle() const
	{
		return Pipeline(m_struct.basePipelineHandle);
	}
	GraphicsPipelineCreateInfo &basePipelineHandle(Pipeline basePipelineHandle)
	{
		m_struct.basePipelineHandle = static_cast<VkPipeline>(basePipelineHandle);
		return *this;
	}
	int32_t basePipelineIndex() const
	{
		return m_struct.basePipelineIndex;
	}
	GraphicsPipelineCreateInfo &basePipelineIndex(int32_t basePipelineIndex)
	{
		m_struct.basePipelineIndex = basePipelineIndex;
		return *this;
	}

	VkGraphicsPipelineCreateInfo *c_ptr() { return &m_struct; }
	const VkGraphicsPipelineCreateInfo *c_ptr() const { return &m_struct; }

	operator const VkGraphicsPipelineCreateInfo&() const { return m_struct; }
};



inline Result createInstance(const InstanceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Instance* pInstance)
{
	return Result(vkCreateInstance(reinterpret_cast<const VkInstanceCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkInstance*>(pInstance)));
}

inline void destroyInstance(Instance instance, const AllocationCallbacks* pAllocator)
{
	vkDestroyInstance(static_cast<VkInstance>(instance), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
}

inline Result enumeratePhysicalDevices(Instance instance, uint32_t* pPhysicalDeviceCount, PhysicalDevice* pPhysicalDevices)
{
	return Result(vkEnumeratePhysicalDevices(static_cast<VkInstance>(instance), pPhysicalDeviceCount, reinterpret_cast<VkPhysicalDevice*>(pPhysicalDevices)));
}

inline PFN_vkVoidFunction getDeviceProcAddr(Device device, const char* pName)
{
	return vkGetDeviceProcAddr(static_cast<VkDevice>(device), pName);
}

inline PFN_vkVoidFunction getInstanceProcAddr(Instance instance, const char* pName)
{
	return vkGetInstanceProcAddr(static_cast<VkInstance>(instance), pName);
}

inline void getPhysicalDeviceProperties(PhysicalDevice physicalDevice, PhysicalDeviceProperties* pProperties)
{
	vkGetPhysicalDeviceProperties(static_cast<VkPhysicalDevice>(physicalDevice), reinterpret_cast<VkPhysicalDeviceProperties*>(pProperties));
}

inline void getPhysicalDeviceQueueFamilyProperties(PhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties* pQueueFamilyProperties)
{
	vkGetPhysicalDeviceQueueFamilyProperties(static_cast<VkPhysicalDevice>(physicalDevice), pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties*>(pQueueFamilyProperties));
}

inline void getPhysicalDeviceMemoryProperties(PhysicalDevice physicalDevice, PhysicalDeviceMemoryProperties* pMemoryProperties)
{
	vkGetPhysicalDeviceMemoryProperties(static_cast<VkPhysicalDevice>(physicalDevice), reinterpret_cast<VkPhysicalDeviceMemoryProperties*>(pMemoryProperties));
}

inline void getPhysicalDeviceFeatures(PhysicalDevice physicalDevice, PhysicalDeviceFeatures* pFeatures)
{
	vkGetPhysicalDeviceFeatures(static_cast<VkPhysicalDevice>(physicalDevice), reinterpret_cast<VkPhysicalDeviceFeatures*>(pFeatures));
}

inline void getPhysicalDeviceFormatProperties(PhysicalDevice physicalDevice, Format format, FormatProperties* pFormatProperties)
{
	vkGetPhysicalDeviceFormatProperties(static_cast<VkPhysicalDevice>(physicalDevice), static_cast<VkFormat>(format), reinterpret_cast<VkFormatProperties*>(pFormatProperties));
}

inline Result getPhysicalDeviceImageFormatProperties(PhysicalDevice physicalDevice, Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ImageFormatProperties* pImageFormatProperties)
{
	return Result(vkGetPhysicalDeviceImageFormatProperties(static_cast<VkPhysicalDevice>(physicalDevice), static_cast<VkFormat>(format), static_cast<VkImageType>(type), static_cast<VkImageTiling>(tiling), static_cast<VkImageUsageFlags>(usage), static_cast<VkImageCreateFlags>(flags), reinterpret_cast<VkImageFormatProperties*>(pImageFormatProperties)));
}

inline Result createDevice(PhysicalDevice physicalDevice, const DeviceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Device* pDevice)
{
	return Result(vkCreateDevice(static_cast<VkPhysicalDevice>(physicalDevice), reinterpret_cast<const VkDeviceCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkDevice*>(pDevice)));
}

inline void destroyDevice(Device device, const AllocationCallbacks* pAllocator)
{
	vkDestroyDevice(static_cast<VkDevice>(device), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
}

inline Result enumerateInstanceLayerProperties(uint32_t* pPropertyCount, LayerProperties* pProperties)
{
	return Result(vkEnumerateInstanceLayerProperties(pPropertyCount, reinterpret_cast<VkLayerProperties*>(pProperties)));
}

inline Result enumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties)
{
	return Result(vkEnumerateInstanceExtensionProperties(pLayerName, pPropertyCount, reinterpret_cast<VkExtensionProperties*>(pProperties)));
}

inline Result enumerateDeviceLayerProperties(PhysicalDevice physicalDevice, uint32_t* pPropertyCount, LayerProperties* pProperties)
{
	return Result(vkEnumerateDeviceLayerProperties(static_cast<VkPhysicalDevice>(physicalDevice), pPropertyCount, reinterpret_cast<VkLayerProperties*>(pProperties)));
}

inline Result enumerateDeviceExtensionProperties(PhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties)
{
	return Result(vkEnumerateDeviceExtensionProperties(static_cast<VkPhysicalDevice>(physicalDevice), pLayerName, pPropertyCount, reinterpret_cast<VkExtensionProperties*>(pProperties)));
}

inline void getDeviceQueue(Device device, uint32_t queueFamilyIndex, uint32_t queueIndex, Queue* pQueue)
{
	vkGetDeviceQueue(static_cast<VkDevice>(device), queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue*>(pQueue));
}

inline Result queueSubmit(Queue queue, uint32_t submitCount, const SubmitInfo* pSubmits, Fence fence)
{
	return Result(vkQueueSubmit(static_cast<VkQueue>(queue), submitCount, reinterpret_cast<const VkSubmitInfo*>(pSubmits), static_cast<VkFence>(fence)));
}

inline Result queueWaitIdle(Queue queue)
{
	return Result(vkQueueWaitIdle(static_cast<VkQueue>(queue)));
}

inline Result deviceWaitIdle(Device device)
{
	return Result(vkDeviceWaitIdle(static_cast<VkDevice>(device)));
}

inline Result allocateMemory(Device device, const MemoryAllocateInfo* pAllocateInfo, const AllocationCallbacks* pAllocator, DeviceMemory* pMemory)
{
	return Result(vkAllocateMemory(static_cast<VkDevice>(device), reinterpret_cast<const VkMemoryAllocateInfo*>(pAllocateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkDeviceMemory*>(pMemory)));
}

inline void freeMemory(Device device, DeviceMemory memory, const AllocationCallbacks* pAllocator)
{
	vkFreeMemory(static_cast<VkDevice>(device), static_cast<VkDeviceMemory>(memory), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
}

inline Result mapMemory(Device device, DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, void** ppData)
{
	return Result(vkMapMemory(static_cast<VkDevice>(device), static_cast<VkDeviceMemory>(memory), offset, size, static_cast<VkMemoryMapFlags>(flags), ppData));
}

inline void unmapMemory(Device device, DeviceMemory memory)
{
	vkUnmapMemory(static_cast<VkDevice>(device), static_cast<VkDeviceMemory>(memory));
}

inline Result flushMappedMemoryRanges(Device device, uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges)
{
	return Result(vkFlushMappedMemoryRanges(static_cast<VkDevice>(device), memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange*>(pMemoryRanges)));
}

inline Result invalidateMappedMemoryRanges(Device device, uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges)
{
	return Result(vkInvalidateMappedMemoryRanges(static_cast<VkDevice>(device), memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange*>(pMemoryRanges)));
}

inline void getDeviceMemoryCommitment(Device device, DeviceMemory memory, DeviceSize* pCommittedMemoryInBytes)
{
	vkGetDeviceMemoryCommitment(static_cast<VkDevice>(device), static_cast<VkDeviceMemory>(memory), pCommittedMemoryInBytes);
}

inline void getBufferMemoryRequirements(Device device, Buffer buffer, MemoryRequirements* pMemoryRequirements)
{
	vkGetBufferMemoryRequirements(static_cast<VkDevice>(device), static_cast<VkBuffer>(buffer), reinterpret_cast<VkMemoryRequirements*>(pMemoryRequirements));
}

inline Result bindBufferMemory(Device device, Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset)
{
	return Result(vkBindBufferMemory(static_cast<VkDevice>(device), static_cast<VkBuffer>(buffer), static_cast<VkDeviceMemory>(memory), memoryOffset));
}

inline void getImageMemoryRequirements(Device device, Image image, MemoryRequirements* pMemoryRequirements)
{
	vkGetImageMemoryRequirements(static_cast<VkDevice>(device), static_cast<VkImage>(image), reinterpret_cast<VkMemoryRequirements*>(pMemoryRequirements));
}

inline Result bindImageMemory(Device device, Image image, DeviceMemory memory, DeviceSize memoryOffset)
{
	return Result(vkBindImageMemory(static_cast<VkDevice>(device), static_cast<VkImage>(image), static_cast<VkDeviceMemory>(memory), memoryOffset));
}

inline void getImageSparseMemoryRequirements(Device device, Image image, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements* pSparseMemoryRequirements)
{
	vkGetImageSparseMemoryRequirements(static_cast<VkDevice>(device), static_cast<VkImage>(image), pSparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements*>(pSparseMemoryRequirements));
}

inline void getPhysicalDeviceSparseImageFormatProperties(PhysicalDevice physicalDevice, Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, uint32_t* pPropertyCount, SparseImageFormatProperties* pProperties)
{
	vkGetPhysicalDeviceSparseImageFormatProperties(static_cast<VkPhysicalDevice>(physicalDevice), static_cast<VkFormat>(format), static_cast<VkImageType>(type), static_cast<VkSampleCountFlagBits>(samples), static_cast<VkImageUsageFlags>(usage), static_cast<VkImageTiling>(tiling), pPropertyCount, reinterpret_cast<VkSparseImageFormatProperties*>(pProperties));
}

inline Result queueBindSparse(Queue queue, uint32_t bindInfoCount, const BindSparseInfo* pBindInfo, Fence fence)
{
	return Result(vkQueueBindSparse(static_cast<VkQueue>(queue), bindInfoCount, reinterpret_cast<const VkBindSparseInfo*>(pBindInfo), static_cast<VkFence>(fence)));
}

inline Result createFence(Device device, const FenceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Fence* pFence)
{
	return Result(vkCreateFence(static_cast<VkDevice>(device), reinterpret_cast<const VkFenceCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkFence*>(pFence)));
}

inline void destroyFence(Device device, Fence fence, const AllocationCallbacks* pAllocator)
{
	vkDestroyFence(static_cast<VkDevice>(device), static_cast<VkFence>(fence), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
}

inline Result resetFences(Device device, uint32_t fenceCount, const Fence* pFences)
{
	return Result(vkResetFences(static_cast<VkDevice>(device), fenceCount, reinterpret_cast<const VkFence*>(pFences)));
}

inline Result getFenceStatus(Device device, Fence fence)
{
	return Result(vkGetFenceStatus(static_cast<VkDevice>(device), static_cast<VkFence>(fence)));
}

inline Result waitForFences(Device device, uint32_t fenceCount, const Fence* pFences, Bool32 waitAll, uint64_t timeout)
{
	return Result(vkWaitForFences(static_cast<VkDevice>(device), fenceCount, reinterpret_cast<const VkFence*>(pFences), waitAll, timeout));
}

inline Result createSemaphore(Device device, const SemaphoreCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Semaphore* pSemaphore)
{
	return Result(vkCreateSemaphore(static_cast<VkDevice>(device), reinterpret_cast<const VkSemaphoreCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkSemaphore*>(pSemaphore)));
}

inline void destroySemaphore(Device device, Semaphore semaphore, const AllocationCallbacks* pAllocator)
{
	vkDestroySemaphore(static_cast<VkDevice>(device), static_cast<VkSemaphore>(semaphore), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
}

inline Result createEvent(Device device, const EventCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Event* pEvent)
{
	return Result(vkCreateEvent(static_cast<VkDevice>(device), reinterpret_cast<const VkEventCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkEvent*>(pEvent)));
}

inline void destroyEvent(Device device, Event event, const AllocationCallbacks* pAllocator)
{
	vkDestroyEvent(static_cast<VkDevice>(device), static_cast<VkEvent>(event), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
}

inline Result getEventStatus(Device device, Event event)
{
	return Result(vkGetEventStatus(static_cast<VkDevice>(device), static_cast<VkEvent>(event)));
}

inline Result setEvent(Device device, Event event)
{
	return Result(vkSetEvent(static_cast<VkDevice>(device), static_cast<VkEvent>(event)));
}

inline Result resetEvent(Device device, Event event)
{
	return Result(vkResetEvent(static_cast<VkDevice>(device), static_cast<VkEvent>(event)));
}

inline Result createQueryPool(Device device, const QueryPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, QueryPool* pQueryPool)
{
	return Result(vkCreateQueryPool(static_cast<VkDevice>(device), reinterpret_cast<const VkQueryPoolCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkQueryPool*>(pQueryPool)));
}

inline void destroyQueryPool(Device device, QueryPool queryPool, const AllocationCallbacks* pAllocator)
{
	vkDestroyQueryPool(static_cast<VkDevice>(device), static_cast<VkQueryPool>(queryPool), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
}

inline Result getQueryPoolResults(Device device, QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, DeviceSize stride, QueryResultFlags flags)
{
	return Result(vkGetQueryPoolResults(static_cast<VkDevice>(device), static_cast<VkQueryPool>(queryPool), firstQuery, queryCount, dataSize, pData, stride, static_cast<VkQueryResultFlags>(flags)));
}

inline Result createBuffer(Device device, const BufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Buffer* pBuffer)
{
	return Result(vkCreateBuffer(static_cast<VkDevice>(device), reinterpret_cast<const VkBufferCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkBuffer*>(pBuffer)));
}

inline void destroyBuffer(Device device, Buffer buffer, const AllocationCallbacks* pAllocator)
{
	vkDestroyBuffer(static_cast<VkDevice>(device), static_cast<VkBuffer>(buffer), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
}

inline Result createBufferView(Device device, const BufferViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, BufferView* pView)
{
	return Result(vkCreateBufferView(static_cast<VkDevice>(device), reinterpret_cast<const VkBufferViewCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkBufferView*>(pView)));
}

inline void destroyBufferView(Device device, BufferView bufferView, const AllocationCallbacks* pAllocator)
{
	vkDestroyBufferView(static_cast<VkDevice>(device), static_cast<VkBufferView>(bufferView), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
}

inline Result createImage(Device device, const ImageCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Image* pImage)
{
	return Result(vkCreateImage(static_cast<VkDevice>(device), reinterpret_cast<const VkImageCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkImage*>(pImage)));
}

inline void destroyImage(Device device, Image image, const AllocationCallbacks* pAllocator)
{
	vkDestroyImage(static_cast<VkDevice>(device), static_cast<VkImage>(image), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
}

inline void getImageSubresourceLayout(Device device, Image image, const ImageSubresource* pSubresource, SubresourceLayout* pLayout)
{
	vkGetImageSubresourceLayout(static_cast<VkDevice>(device), static_cast<VkImage>(image), reinterpret_cast<const VkImageSubresource*>(pSubresource), reinterpret_cast<VkSubresourceLayout*>(pLayout));
}

inline Result createImageView(Device device, const ImageViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ImageView* pView)
{
	return Result(vkCreateImageView(static_cast<VkDevice>(device), reinterpret_cast<const VkImageViewCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkImageView*>(pView)));
}

inline void destroyImageView(Device device, ImageView imageView, const AllocationCallbacks* pAllocator)
{
	vkDestroyImageView(static_cast<VkDevice>(device), static_cast<VkImageView>(imageView), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
}

inline Result createShaderModule(Device device, const ShaderModuleCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ShaderModule* pShaderModule)
{
	return Result(vkCreateShaderModule(static_cast<VkDevice>(device), reinterpret_cast<const VkShaderModuleCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkShaderModule*>(pShaderModule)));
}

inline void destroyShaderModule(Device device, ShaderModule shaderModule, const AllocationCallbacks* pAllocator)
{
	vkDestroyShaderModule(static_cast<VkDevice>(device), static_cast<VkShaderModule>(shaderModule), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
}

inline Result createPipelineCache(Device device, const PipelineCacheCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineCache* pPipelineCache)
{
	return Result(vkCreatePipelineCache(static_cast<VkDevice>(device), reinterpret_cast<const VkPipelineCacheCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkPipelineCache*>(pPipelineCache)));
}

inline void destroyPipelineCache(Device device, PipelineCache pipelineCache, const AllocationCallbacks* pAllocator)
{
	vkDestroyPipelineCache(static_cast<VkDevice>(device), static_cast<VkPipelineCache>(pipelineCache), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
}

inline Result getPipelineCacheData(Device device, PipelineCache pipelineCache, size_t* pDataSize, void* pData)
{
	return Result(vkGetPipelineCacheData(static_cast<VkDevice>(device), static_cast<VkPipelineCache>(pipelineCache), pDataSize, pData));
}

inline Result mergePipelineCaches(Device device, PipelineCache dstCache, uint32_t srcCacheCount, const PipelineCache* pSrcCaches)
{
	return Result(vkMergePipelineCaches(static_cast<VkDevice>(device), static_cast<VkPipelineCache>(dstCache), srcCacheCount, reinterpret_cast<const VkPipelineCache*>(pSrcCaches)));
}

inline Result createGraphicsPipelines(Device device, PipelineCache pipelineCache, uint32_t createInfoCount, const GraphicsPipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines)
{
	return Result(vkCreateGraphicsPipelines(static_cast<VkDevice>(device), static_cast<VkPipelineCache>(pipelineCache), createInfoCount, reinterpret_cast<const VkGraphicsPipelineCreateInfo*>(pCreateInfos), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkPipeline*>(pPipelines)));
}

inline Result createComputePipelines(Device device, PipelineCache pipelineCache, uint32_t createInfoCount, const ComputePipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines)
{
	return Result(vkCreateComputePipelines(static_cast<VkDevice>(device), static_cast<VkPipelineCache>(pipelineCache), createInfoCount, reinterpret_cast<const VkComputePipelineCreateInfo*>(pCreateInfos), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkPipeline*>(pPipelines)));
}

inline void destroyPipeline(Device device, Pipeline pipeline, const AllocationCallbacks* pAllocator)
{
	vkDestroyPipeline(static_cast<VkDevice>(device), static_cast<VkPipeline>(pipeline), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
}

inline Result createPipelineLayout(Device device, const PipelineLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineLayout* pPipelineLayout)
{
	return Result(vkCreatePipelineLayout(static_cast<VkDevice>(device), reinterpret_cast<const VkPipelineLayoutCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkPipelineLayout*>(pPipelineLayout)));
}

inline void destroyPipelineLayout(Device device, PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator)
{
	vkDestroyPipelineLayout(static_cast<VkDevice>(device), static_cast<VkPipelineLayout>(pipelineLayout), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
}

inline Result createSampler(Device device, const SamplerCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Sampler* pSampler)
{
	return Result(vkCreateSampler(static_cast<VkDevice>(device), reinterpret_cast<const VkSamplerCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkSampler*>(pSampler)));
}

inline void destroySampler(Device device, Sampler sampler, const AllocationCallbacks* pAllocator)
{
	vkDestroySampler(static_cast<VkDevice>(device), static_cast<VkSampler>(sampler), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
}

inline Result createDescriptorSetLayout(Device device, const DescriptorSetLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorSetLayout* pSetLayout)
{
	return Result(vkCreateDescriptorSetLayout(static_cast<VkDevice>(device), reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkDescriptorSetLayout*>(pSetLayout)));
}

inline void destroyDescriptorSetLayout(Device device, DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator)
{
	vkDestroyDescriptorSetLayout(static_cast<VkDevice>(device), static_cast<VkDescriptorSetLayout>(descriptorSetLayout), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
}

inline Result createDescriptorPool(Device device, const DescriptorPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorPool* pDescriptorPool)
{
	return Result(vkCreateDescriptorPool(static_cast<VkDevice>(device), reinterpret_cast<const VkDescriptorPoolCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkDescriptorPool*>(pDescriptorPool)));
}

inline void destroyDescriptorPool(Device device, DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator)
{
	vkDestroyDescriptorPool(static_cast<VkDevice>(device), static_cast<VkDescriptorPool>(descriptorPool), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
}

inline Result resetDescriptorPool(Device device, DescriptorPool descriptorPool, DescriptorPoolResetFlags flags)
{
	return Result(vkResetDescriptorPool(static_cast<VkDevice>(device), static_cast<VkDescriptorPool>(descriptorPool), static_cast<VkDescriptorPoolResetFlags>(flags)));
}

inline Result allocateDescriptorSets(Device device, const DescriptorSetAllocateInfo* pAllocateInfo, DescriptorSet* pDescriptorSets)
{
	return Result(vkAllocateDescriptorSets(static_cast<VkDevice>(device), reinterpret_cast<const VkDescriptorSetAllocateInfo*>(pAllocateInfo), reinterpret_cast<VkDescriptorSet*>(pDescriptorSets)));
}

inline Result freeDescriptorSets(Device device, DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets)
{
	return Result(vkFreeDescriptorSets(static_cast<VkDevice>(device), static_cast<VkDescriptorPool>(descriptorPool), descriptorSetCount, reinterpret_cast<const VkDescriptorSet*>(pDescriptorSets)));
}

inline void updateDescriptorSets(Device device, uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const CopyDescriptorSet* pDescriptorCopies)
{
	vkUpdateDescriptorSets(static_cast<VkDevice>(device), descriptorWriteCount, reinterpret_cast<const VkWriteDescriptorSet*>(pDescriptorWrites), descriptorCopyCount, reinterpret_cast<const VkCopyDescriptorSet*>(pDescriptorCopies));
}

inline Result createFramebuffer(Device device, const FramebufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Framebuffer* pFramebuffer)
{
	return Result(vkCreateFramebuffer(static_cast<VkDevice>(device), reinterpret_cast<const VkFramebufferCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkFramebuffer*>(pFramebuffer)));
}

inline void destroyFramebuffer(Device device, Framebuffer framebuffer, const AllocationCallbacks* pAllocator)
{
	vkDestroyFramebuffer(static_cast<VkDevice>(device), static_cast<VkFramebuffer>(framebuffer), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
}

inline Result createRenderPass(Device device, const RenderPassCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass)
{
	return Result(vkCreateRenderPass(static_cast<VkDevice>(device), reinterpret_cast<const VkRenderPassCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkRenderPass*>(pRenderPass)));
}

inline void destroyRenderPass(Device device, RenderPass renderPass, const AllocationCallbacks* pAllocator)
{
	vkDestroyRenderPass(static_cast<VkDevice>(device), static_cast<VkRenderPass>(renderPass), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
}

inline void getRenderAreaGranularity(Device device, RenderPass renderPass, Extent2D* pGranularity)
{
	vkGetRenderAreaGranularity(static_cast<VkDevice>(device), static_cast<VkRenderPass>(renderPass), reinterpret_cast<VkExtent2D*>(pGranularity));
}

inline Result createCommandPool(Device device, const CommandPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, CommandPool* pCommandPool)
{
	return Result(vkCreateCommandPool(static_cast<VkDevice>(device), reinterpret_cast<const VkCommandPoolCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkCommandPool*>(pCommandPool)));
}

inline void destroyCommandPool(Device device, CommandPool commandPool, const AllocationCallbacks* pAllocator)
{
	vkDestroyCommandPool(static_cast<VkDevice>(device), static_cast<VkCommandPool>(commandPool), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
}

inline Result resetCommandPool(Device device, CommandPool commandPool, CommandPoolResetFlags flags)
{
	return Result(vkResetCommandPool(static_cast<VkDevice>(device), static_cast<VkCommandPool>(commandPool), static_cast<VkCommandPoolResetFlags>(flags)));
}

inline Result allocateCommandBuffers(Device device, const CommandBufferAllocateInfo* pAllocateInfo, CommandBuffer* pCommandBuffers)
{
	return Result(vkAllocateCommandBuffers(static_cast<VkDevice>(device), reinterpret_cast<const VkCommandBufferAllocateInfo*>(pAllocateInfo), reinterpret_cast<VkCommandBuffer*>(pCommandBuffers)));
}

inline void freeCommandBuffers(Device device, CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers)
{
	vkFreeCommandBuffers(static_cast<VkDevice>(device), static_cast<VkCommandPool>(commandPool), commandBufferCount, reinterpret_cast<const VkCommandBuffer*>(pCommandBuffers));
}

inline Result beginCommandBuffer(CommandBuffer commandBuffer, const CommandBufferBeginInfo* pBeginInfo)
{
	return Result(vkBeginCommandBuffer(static_cast<VkCommandBuffer>(commandBuffer), reinterpret_cast<const VkCommandBufferBeginInfo*>(pBeginInfo)));
}

inline Result endCommandBuffer(CommandBuffer commandBuffer)
{
	return Result(vkEndCommandBuffer(static_cast<VkCommandBuffer>(commandBuffer)));
}

inline Result resetCommandBuffer(CommandBuffer commandBuffer, CommandBufferResetFlags flags)
{
	return Result(vkResetCommandBuffer(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkCommandBufferResetFlags>(flags)));
}

inline void cmdBindPipeline(CommandBuffer commandBuffer, PipelineBindPoint pipelineBindPoint, Pipeline pipeline)
{
	vkCmdBindPipeline(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkPipelineBindPoint>(pipelineBindPoint), static_cast<VkPipeline>(pipeline));
}

inline void cmdSetViewport(CommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const Viewport* pViewports)
{
	vkCmdSetViewport(static_cast<VkCommandBuffer>(commandBuffer), firstViewport, viewportCount, reinterpret_cast<const VkViewport*>(pViewports));
}

inline void cmdSetScissor(CommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const Rect2D* pScissors)
{
	vkCmdSetScissor(static_cast<VkCommandBuffer>(commandBuffer), firstScissor, scissorCount, reinterpret_cast<const VkRect2D*>(pScissors));
}

inline void cmdSetLineWidth(CommandBuffer commandBuffer, float lineWidth)
{
	vkCmdSetLineWidth(static_cast<VkCommandBuffer>(commandBuffer), lineWidth);
}

inline void cmdSetDepthBias(CommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
{
	vkCmdSetDepthBias(static_cast<VkCommandBuffer>(commandBuffer), depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
}

inline void cmdSetBlendConstants(CommandBuffer commandBuffer, const float* blendConstants)
{
	vkCmdSetBlendConstants(static_cast<VkCommandBuffer>(commandBuffer), blendConstants);
}

inline void cmdSetDepthBounds(CommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
{
	vkCmdSetDepthBounds(static_cast<VkCommandBuffer>(commandBuffer), minDepthBounds, maxDepthBounds);
}

inline void cmdSetStencilCompareMask(CommandBuffer commandBuffer, StencilFaceFlags faceMask, uint32_t compareMask)
{
	vkCmdSetStencilCompareMask(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkStencilFaceFlags>(faceMask), compareMask);
}

inline void cmdSetStencilWriteMask(CommandBuffer commandBuffer, StencilFaceFlags faceMask, uint32_t writeMask)
{
	vkCmdSetStencilWriteMask(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkStencilFaceFlags>(faceMask), writeMask);
}

inline void cmdSetStencilReference(CommandBuffer commandBuffer, StencilFaceFlags faceMask, uint32_t reference)
{
	vkCmdSetStencilReference(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkStencilFaceFlags>(faceMask), reference);
}

inline void cmdBindDescriptorSets(CommandBuffer commandBuffer, PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
{
	vkCmdBindDescriptorSets(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkPipelineBindPoint>(pipelineBindPoint), static_cast<VkPipelineLayout>(layout), firstSet, descriptorSetCount, reinterpret_cast<const VkDescriptorSet*>(pDescriptorSets), dynamicOffsetCount, pDynamicOffsets);
}

inline void cmdBindIndexBuffer(CommandBuffer commandBuffer, Buffer buffer, DeviceSize offset, IndexType indexType)
{
	vkCmdBindIndexBuffer(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkBuffer>(buffer), offset, static_cast<VkIndexType>(indexType));
}

inline void cmdBindVertexBuffers(CommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets)
{
	vkCmdBindVertexBuffers(static_cast<VkCommandBuffer>(commandBuffer), firstBinding, bindingCount, reinterpret_cast<const VkBuffer*>(pBuffers), pOffsets);
}

inline void cmdDraw(CommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
{
	vkCmdDraw(static_cast<VkCommandBuffer>(commandBuffer), vertexCount, instanceCount, firstVertex, firstInstance);
}

inline void cmdDrawIndexed(CommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
{
	vkCmdDrawIndexed(static_cast<VkCommandBuffer>(commandBuffer), indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
}

inline void cmdDrawIndirect(CommandBuffer commandBuffer, Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride)
{
	vkCmdDrawIndirect(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkBuffer>(buffer), offset, drawCount, stride);
}

inline void cmdDrawIndexedIndirect(CommandBuffer commandBuffer, Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride)
{
	vkCmdDrawIndexedIndirect(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkBuffer>(buffer), offset, drawCount, stride);
}

inline void cmdDispatch(CommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z)
{
	vkCmdDispatch(static_cast<VkCommandBuffer>(commandBuffer), x, y, z);
}

inline void cmdDispatchIndirect(CommandBuffer commandBuffer, Buffer buffer, DeviceSize offset)
{
	vkCmdDispatchIndirect(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkBuffer>(buffer), offset);
}

inline void cmdCopyBuffer(CommandBuffer commandBuffer, Buffer srcBuffer, Buffer dstBuffer, uint32_t regionCount, const BufferCopy* pRegions)
{
	vkCmdCopyBuffer(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkBuffer>(srcBuffer), static_cast<VkBuffer>(dstBuffer), regionCount, reinterpret_cast<const VkBufferCopy*>(pRegions));
}

inline void cmdCopyImage(CommandBuffer commandBuffer, Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageCopy* pRegions)
{
	vkCmdCopyImage(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkImage>(srcImage), static_cast<VkImageLayout>(srcImageLayout), static_cast<VkImage>(dstImage), static_cast<VkImageLayout>(dstImageLayout), regionCount, reinterpret_cast<const VkImageCopy*>(pRegions));
}

inline void cmdBlitImage(CommandBuffer commandBuffer, Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageBlit* pRegions, Filter filter)
{
	vkCmdBlitImage(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkImage>(srcImage), static_cast<VkImageLayout>(srcImageLayout), static_cast<VkImage>(dstImage), static_cast<VkImageLayout>(dstImageLayout), regionCount, reinterpret_cast<const VkImageBlit*>(pRegions), static_cast<VkFilter>(filter));
}

inline void cmdCopyBufferToImage(CommandBuffer commandBuffer, Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const BufferImageCopy* pRegions)
{
	vkCmdCopyBufferToImage(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkBuffer>(srcBuffer), static_cast<VkImage>(dstImage), static_cast<VkImageLayout>(dstImageLayout), regionCount, reinterpret_cast<const VkBufferImageCopy*>(pRegions));
}

inline void cmdCopyImageToBuffer(CommandBuffer commandBuffer, Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, uint32_t regionCount, const BufferImageCopy* pRegions)
{
	vkCmdCopyImageToBuffer(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkImage>(srcImage), static_cast<VkImageLayout>(srcImageLayout), static_cast<VkBuffer>(dstBuffer), regionCount, reinterpret_cast<const VkBufferImageCopy*>(pRegions));
}

inline void cmdUpdateBuffer(CommandBuffer commandBuffer, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize dataSize, const uint32_t* pData)
{
	vkCmdUpdateBuffer(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkBuffer>(dstBuffer), dstOffset, dataSize, pData);
}

inline void cmdFillBuffer(CommandBuffer commandBuffer, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data)
{
	vkCmdFillBuffer(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkBuffer>(dstBuffer), dstOffset, size, data);
}

inline void cmdClearColorImage(CommandBuffer commandBuffer, Image image, ImageLayout imageLayout, const ClearColorValue* pColor, uint32_t rangeCount, const ImageSubresourceRange* pRanges)
{
	vkCmdClearColorImage(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkImage>(image), static_cast<VkImageLayout>(imageLayout), reinterpret_cast<const VkClearColorValue*>(pColor), rangeCount, reinterpret_cast<const VkImageSubresourceRange*>(pRanges));
}

inline void cmdClearDepthStencilImage(CommandBuffer commandBuffer, Image image, ImageLayout imageLayout, const ClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const ImageSubresourceRange* pRanges)
{
	vkCmdClearDepthStencilImage(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkImage>(image), static_cast<VkImageLayout>(imageLayout), reinterpret_cast<const VkClearDepthStencilValue*>(pDepthStencil), rangeCount, reinterpret_cast<const VkImageSubresourceRange*>(pRanges));
}

inline void cmdClearAttachments(CommandBuffer commandBuffer, uint32_t attachmentCount, const ClearAttachment* pAttachments, uint32_t rectCount, const ClearRect* pRects)
{
	vkCmdClearAttachments(static_cast<VkCommandBuffer>(commandBuffer), attachmentCount, reinterpret_cast<const VkClearAttachment*>(pAttachments), rectCount, reinterpret_cast<const VkClearRect*>(pRects));
}

inline void cmdResolveImage(CommandBuffer commandBuffer, Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageResolve* pRegions)
{
	vkCmdResolveImage(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkImage>(srcImage), static_cast<VkImageLayout>(srcImageLayout), static_cast<VkImage>(dstImage), static_cast<VkImageLayout>(dstImageLayout), regionCount, reinterpret_cast<const VkImageResolve*>(pRegions));
}

inline void cmdSetEvent(CommandBuffer commandBuffer, Event event, PipelineStageFlags stageMask)
{
	vkCmdSetEvent(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkEvent>(event), static_cast<VkPipelineStageFlags>(stageMask));
}

inline void cmdResetEvent(CommandBuffer commandBuffer, Event event, PipelineStageFlags stageMask)
{
	vkCmdResetEvent(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkEvent>(event), static_cast<VkPipelineStageFlags>(stageMask));
}

inline void cmdWaitEvents(CommandBuffer commandBuffer, uint32_t eventCount, const Event* pEvents, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers)
{
	vkCmdWaitEvents(static_cast<VkCommandBuffer>(commandBuffer), eventCount, reinterpret_cast<const VkEvent*>(pEvents), static_cast<VkPipelineStageFlags>(srcStageMask), static_cast<VkPipelineStageFlags>(dstStageMask), memoryBarrierCount, reinterpret_cast<const VkMemoryBarrier*>(pMemoryBarriers), bufferMemoryBarrierCount, reinterpret_cast<const VkBufferMemoryBarrier*>(pBufferMemoryBarriers), imageMemoryBarrierCount, reinterpret_cast<const VkImageMemoryBarrier*>(pImageMemoryBarriers));
}

inline void cmdPipelineBarrier(CommandBuffer commandBuffer, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers)
{
	vkCmdPipelineBarrier(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkPipelineStageFlags>(srcStageMask), static_cast<VkPipelineStageFlags>(dstStageMask), static_cast<VkDependencyFlags>(dependencyFlags), memoryBarrierCount, reinterpret_cast<const VkMemoryBarrier*>(pMemoryBarriers), bufferMemoryBarrierCount, reinterpret_cast<const VkBufferMemoryBarrier*>(pBufferMemoryBarriers), imageMemoryBarrierCount, reinterpret_cast<const VkImageMemoryBarrier*>(pImageMemoryBarriers));
}

inline void cmdBeginQuery(CommandBuffer commandBuffer, QueryPool queryPool, uint32_t query, QueryControlFlags flags)
{
	vkCmdBeginQuery(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkQueryPool>(queryPool), query, static_cast<VkQueryControlFlags>(flags));
}

inline void cmdEndQuery(CommandBuffer commandBuffer, QueryPool queryPool, uint32_t query)
{
	vkCmdEndQuery(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkQueryPool>(queryPool), query);
}

inline void cmdResetQueryPool(CommandBuffer commandBuffer, QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
{
	vkCmdResetQueryPool(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkQueryPool>(queryPool), firstQuery, queryCount);
}

inline void cmdWriteTimestamp(CommandBuffer commandBuffer, PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query)
{
	vkCmdWriteTimestamp(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkPipelineStageFlagBits>(pipelineStage), static_cast<VkQueryPool>(queryPool), query);
}

inline void cmdCopyQueryPoolResults(CommandBuffer commandBuffer, QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags)
{
	vkCmdCopyQueryPoolResults(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkQueryPool>(queryPool), firstQuery, queryCount, static_cast<VkBuffer>(dstBuffer), dstOffset, stride, static_cast<VkQueryResultFlags>(flags));
}

inline void cmdPushConstants(CommandBuffer commandBuffer, PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues)
{
	vkCmdPushConstants(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkPipelineLayout>(layout), static_cast<VkShaderStageFlags>(stageFlags), offset, size, pValues);
}

inline void cmdBeginRenderPass(CommandBuffer commandBuffer, const RenderPassBeginInfo* pRenderPassBegin, SubpassContents contents)
{
	vkCmdBeginRenderPass(static_cast<VkCommandBuffer>(commandBuffer), reinterpret_cast<const VkRenderPassBeginInfo*>(pRenderPassBegin), static_cast<VkSubpassContents>(contents));
}

inline void cmdNextSubpass(CommandBuffer commandBuffer, SubpassContents contents)
{
	vkCmdNextSubpass(static_cast<VkCommandBuffer>(commandBuffer), static_cast<VkSubpassContents>(contents));
}

inline void cmdEndRenderPass(CommandBuffer commandBuffer)
{
	vkCmdEndRenderPass(static_cast<VkCommandBuffer>(commandBuffer));
}

inline void cmdExecuteCommands(CommandBuffer commandBuffer, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers)
{
	vkCmdExecuteCommands(static_cast<VkCommandBuffer>(commandBuffer), commandBufferCount, reinterpret_cast<const VkCommandBuffer*>(pCommandBuffers));
}

#ifdef VK_USE_PLATFORM_ANDROID_KHR
inline Result createAndroidSurfaceKHR(Instance instance, const AndroidSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface)
{
	return Result(vkCreateAndroidSurfaceKHR(static_cast<VkInstance>(instance), reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkSurfaceKHR*>(pSurface)));
}
#endif

inline Result getPhysicalDeviceDisplayPropertiesKHR(PhysicalDevice physicalDevice, uint32_t* pPropertyCount, DisplayPropertiesKHR* pProperties)
{
	return Result(vkGetPhysicalDeviceDisplayPropertiesKHR(static_cast<VkPhysicalDevice>(physicalDevice), pPropertyCount, reinterpret_cast<VkDisplayPropertiesKHR*>(pProperties)));
}

inline Result getPhysicalDeviceDisplayPlanePropertiesKHR(PhysicalDevice physicalDevice, uint32_t* pPropertyCount, DisplayPlanePropertiesKHR* pProperties)
{
	return Result(vkGetPhysicalDeviceDisplayPlanePropertiesKHR(static_cast<VkPhysicalDevice>(physicalDevice), pPropertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR*>(pProperties)));
}

inline Result getDisplayPlaneSupportedDisplaysKHR(PhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, DisplayKHR* pDisplays)
{
	return Result(vkGetDisplayPlaneSupportedDisplaysKHR(static_cast<VkPhysicalDevice>(physicalDevice), planeIndex, pDisplayCount, reinterpret_cast<VkDisplayKHR*>(pDisplays)));
}

inline Result getDisplayModePropertiesKHR(PhysicalDevice physicalDevice, DisplayKHR display, uint32_t* pPropertyCount, DisplayModePropertiesKHR* pProperties)
{
	return Result(vkGetDisplayModePropertiesKHR(static_cast<VkPhysicalDevice>(physicalDevice), static_cast<VkDisplayKHR>(display), pPropertyCount, reinterpret_cast<VkDisplayModePropertiesKHR*>(pProperties)));
}

inline Result createDisplayModeKHR(PhysicalDevice physicalDevice, DisplayKHR display, const DisplayModeCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, DisplayModeKHR* pMode)
{
	return Result(vkCreateDisplayModeKHR(static_cast<VkPhysicalDevice>(physicalDevice), static_cast<VkDisplayKHR>(display), reinterpret_cast<const VkDisplayModeCreateInfoKHR*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkDisplayModeKHR*>(pMode)));
}

inline Result getDisplayPlaneCapabilitiesKHR(PhysicalDevice physicalDevice, DisplayModeKHR mode, uint32_t planeIndex, DisplayPlaneCapabilitiesKHR* pCapabilities)
{
	return Result(vkGetDisplayPlaneCapabilitiesKHR(static_cast<VkPhysicalDevice>(physicalDevice), static_cast<VkDisplayModeKHR>(mode), planeIndex, reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>(pCapabilities)));
}

inline Result createDisplayPlaneSurfaceKHR(Instance instance, const DisplaySurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface)
{
	return Result(vkCreateDisplayPlaneSurfaceKHR(static_cast<VkInstance>(instance), reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkSurfaceKHR*>(pSurface)));
}

inline Result createSharedSwapchainsKHR(Device device, uint32_t swapchainCount, const SwapchainCreateInfoKHR* pCreateInfos, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchains)
{
	return Result(vkCreateSharedSwapchainsKHR(static_cast<VkDevice>(device), swapchainCount, reinterpret_cast<const VkSwapchainCreateInfoKHR*>(pCreateInfos), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkSwapchainKHR*>(pSwapchains)));
}

#ifdef VK_USE_PLATFORM_MIR_KHR
inline Result createMirSurfaceKHR(Instance instance, const MirSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface)
{
	return Result(vkCreateMirSurfaceKHR(static_cast<VkInstance>(instance), reinterpret_cast<const VkMirSurfaceCreateInfoKHR*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkSurfaceKHR*>(pSurface)));
}
#endif

#ifdef VK_USE_PLATFORM_MIR_KHR
inline Bool32 getPhysicalDeviceMirPresentationSupportKHR(PhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection)
{
	return vkGetPhysicalDeviceMirPresentationSupportKHR(static_cast<VkPhysicalDevice>(physicalDevice), queueFamilyIndex, connection);
}
#endif

inline void destroySurfaceKHR(Instance instance, SurfaceKHR surface, const AllocationCallbacks* pAllocator)
{
	vkDestroySurfaceKHR(static_cast<VkInstance>(instance), static_cast<VkSurfaceKHR>(surface), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
}

inline Result getPhysicalDeviceSurfaceSupportKHR(PhysicalDevice physicalDevice, uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32* pSupported)
{
	return Result(vkGetPhysicalDeviceSurfaceSupportKHR(static_cast<VkPhysicalDevice>(physicalDevice), queueFamilyIndex, static_cast<VkSurfaceKHR>(surface), pSupported));
}

inline Result getPhysicalDeviceSurfaceCapabilitiesKHR(PhysicalDevice physicalDevice, SurfaceKHR surface, SurfaceCapabilitiesKHR* pSurfaceCapabilities)
{
	return Result(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(static_cast<VkPhysicalDevice>(physicalDevice), static_cast<VkSurfaceKHR>(surface), reinterpret_cast<VkSurfaceCapabilitiesKHR*>(pSurfaceCapabilities)));
}

inline Result getPhysicalDeviceSurfaceFormatsKHR(PhysicalDevice physicalDevice, SurfaceKHR surface, uint32_t* pSurfaceFormatCount, SurfaceFormatKHR* pSurfaceFormats)
{
	return Result(vkGetPhysicalDeviceSurfaceFormatsKHR(static_cast<VkPhysicalDevice>(physicalDevice), static_cast<VkSurfaceKHR>(surface), pSurfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR*>(pSurfaceFormats)));
}

inline Result getPhysicalDeviceSurfacePresentModesKHR(PhysicalDevice physicalDevice, SurfaceKHR surface, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes)
{
	return Result(vkGetPhysicalDeviceSurfacePresentModesKHR(static_cast<VkPhysicalDevice>(physicalDevice), static_cast<VkSurfaceKHR>(surface), pPresentModeCount, reinterpret_cast<VkPresentModeKHR*>(pPresentModes)));
}

inline Result createSwapchainKHR(Device device, const SwapchainCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchain)
{
	return Result(vkCreateSwapchainKHR(static_cast<VkDevice>(device), reinterpret_cast<const VkSwapchainCreateInfoKHR*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkSwapchainKHR*>(pSwapchain)));
}

inline void destroySwapchainKHR(Device device, SwapchainKHR swapchain, const AllocationCallbacks* pAllocator)
{
	vkDestroySwapchainKHR(static_cast<VkDevice>(device), static_cast<VkSwapchainKHR>(swapchain), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
}

inline Result getSwapchainImagesKHR(Device device, SwapchainKHR swapchain, uint32_t* pSwapchainImageCount, Image* pSwapchainImages)
{
	return Result(vkGetSwapchainImagesKHR(static_cast<VkDevice>(device), static_cast<VkSwapchainKHR>(swapchain), pSwapchainImageCount, reinterpret_cast<VkImage*>(pSwapchainImages)));
}

inline Result acquireNextImageKHR(Device device, SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, uint32_t* pImageIndex)
{
	return Result(vkAcquireNextImageKHR(static_cast<VkDevice>(device), static_cast<VkSwapchainKHR>(swapchain), timeout, static_cast<VkSemaphore>(semaphore), static_cast<VkFence>(fence), pImageIndex));
}

inline Result queuePresentKHR(Queue queue, const PresentInfoKHR* pPresentInfo)
{
	return Result(vkQueuePresentKHR(static_cast<VkQueue>(queue), reinterpret_cast<const VkPresentInfoKHR*>(pPresentInfo)));
}

#ifdef VK_USE_PLATFORM_WAYLAND_KHR
inline Result createWaylandSurfaceKHR(Instance instance, const WaylandSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface)
{
	return Result(vkCreateWaylandSurfaceKHR(static_cast<VkInstance>(instance), reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkSurfaceKHR*>(pSurface)));
}
#endif

#ifdef VK_USE_PLATFORM_WAYLAND_KHR
inline Bool32 getPhysicalDeviceWaylandPresentationSupportKHR(PhysicalDevice physicalDevice, uint32_t queueFamilyIndex, wl_displaystruct * display)
{
	return vkGetPhysicalDeviceWaylandPresentationSupportKHR(static_cast<VkPhysicalDevice>(physicalDevice), queueFamilyIndex, display);
}
#endif

#ifdef VK_USE_PLATFORM_WIN32_KHR
inline Result createWin32SurfaceKHR(Instance instance, const Win32SurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface)
{
	return Result(vkCreateWin32SurfaceKHR(static_cast<VkInstance>(instance), reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkSurfaceKHR*>(pSurface)));
}
#endif

#ifdef VK_USE_PLATFORM_WIN32_KHR
inline Bool32 getPhysicalDeviceWin32PresentationSupportKHR(PhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
{
	return vkGetPhysicalDeviceWin32PresentationSupportKHR(static_cast<VkPhysicalDevice>(physicalDevice), queueFamilyIndex);
}
#endif

#ifdef VK_USE_PLATFORM_XLIB_KHR
inline Result createXlibSurfaceKHR(Instance instance, const XlibSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface)
{
	return Result(vkCreateXlibSurfaceKHR(static_cast<VkInstance>(instance), reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkSurfaceKHR*>(pSurface)));
}
#endif

#ifdef VK_USE_PLATFORM_XLIB_KHR
inline Bool32 getPhysicalDeviceXlibPresentationSupportKHR(PhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID)
{
	return vkGetPhysicalDeviceXlibPresentationSupportKHR(static_cast<VkPhysicalDevice>(physicalDevice), queueFamilyIndex, dpy, visualID);
}
#endif

#ifdef VK_USE_PLATFORM_XCB_KHR
inline Result createXcbSurfaceKHR(Instance instance, const XcbSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface)
{
	return Result(vkCreateXcbSurfaceKHR(static_cast<VkInstance>(instance), reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkSurfaceKHR*>(pSurface)));
}
#endif

#ifdef VK_USE_PLATFORM_XCB_KHR
inline Bool32 getPhysicalDeviceXcbPresentationSupportKHR(PhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id)
{
	return vkGetPhysicalDeviceXcbPresentationSupportKHR(static_cast<VkPhysicalDevice>(physicalDevice), queueFamilyIndex, connection, visual_id);
}
#endif

inline Result createDebugReportCallbackEXT(Instance instance, const DebugReportCallbackCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugReportCallbackEXT* pCallback)
{
	return Result(vkCreateDebugReportCallbackEXT(static_cast<VkInstance>(instance), reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkDebugReportCallbackEXT*>(pCallback)));
}

inline void destroyDebugReportCallbackEXT(Instance instance, DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator)
{
	vkDestroyDebugReportCallbackEXT(static_cast<VkInstance>(instance), static_cast<VkDebugReportCallbackEXT>(callback), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
}

inline void debugReportMessageEXT(Instance instance, DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage)
{
	vkDebugReportMessageEXT(static_cast<VkInstance>(instance), static_cast<VkDebugReportFlagsEXT>(flags), static_cast<VkDebugReportObjectTypeEXT>(objectType), object, location, messageCode, pLayerPrefix, pMessage);
}




} // namespace vk