Added template class scoped_handle, which supports auto deletion of the objects, after they have been released (must!) and gone out of scope. Also added #ifndefs for Macro called VULKAN_HPP_DISABLE_SCOPED_HANDLING, which allows disabling of default enabled scoped handling.

vulkan/vulkan.hpp

@@ -39,6 +39,9 @@
 # include <memory>
 # include <vector>
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#ifdef VULKAN_HPP_DISABLE_SCOPED_HANDLING
+#include <functional>
+#endif
 
 static_assert(VK_HEADER_VERSION == 21, "Wrong VK_HEADER_VERSION!");
 
@@ -344,7 +347,6 @@ namespace vk
 		default: return "invalid";
 		}
 	}
-
 #if defined(_MSC_VER) && (_MSC_VER == 1800)
 # define noexcept _NOEXCEPT
 #endif
@@ -910,6 +912,171 @@ namespace vk
 	}
 #endif /*VK_USE_PLATFORM_XCB_KHR*/
 
+#ifndef VULKAN_HPP_DISABLE_SCOPED_HANDLING
+	template<class T, typename... _ARGS>
+	auto ptrMemberFnc(void(T::*p)(_ARGS...) const) {
+		return p;
+	};
+
+	class Instance;
+	class Device;
+	class DescriptorPool;
+	class DescriptorSet;
+	class CommandPool;
+	class CommandBuffer;
+	template<typename T>
+	class Optional;
+	class AllocationCallbacks;
+
+	template<class T>
+	class scoped_handle {
+	protected:
+		T object{ VK_NULL_HANDLE };
+		std::function<void(T object)> delete_func;
+
+#ifndef	VULKAN_HPP_DISABLE_ENHANCED_MODE
+		bool released = false, auto_release_copies = false;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+		using INS = vk::Instance; using DEV = vk::Device;
+	public:
+
+		scoped_handle(const scoped_handle<T>& s) {
+			std::cout << "copy constructor" << std::endl;
+			this->object = s.object;
+			this->delete_func = s.delete_func;
+			this->released = s.auto_release_copies;
+		}
+
+		template<typename Fnc, typename alloc>
+		std::function<void(T, alloc)> bindFnc(void(Fnc::*p)(T, alloc) const, scoped_handle<Fnc>&v) {
+			using namespace std;
+			return bind(p, v.get(), placeholders::_1, placeholders::_2);
+		}
+
+		template<typename Fnc, typename alloc>
+		std::function<void(T, alloc)> bindFnc(void(Fnc::*p)(T, alloc) const, const Fnc& v) {
+			using namespace std;
+			return bind(p, v, placeholders::_1, placeholders::_2);
+		}
+
+		scoped_handle(std::function<void(T)> fnc = [](T obj) {}, T obj = T()) {
+			this->delete_func = fnc;
+			this->object = obj;
+		}
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+		scoped_handle(void(INS::*p)(T, Optional<const AllocationCallbacks>) const,
+			scoped_handle<INS>& i, Optional<const AllocationCallbacks> alloc = nullptr, T obj = T()) {
+			if (alloc != nullptr) this->delete_func = [p, &i, &alloc, this](T o) {this->bindFnc<INS, Optional<const AllocationCallbacks>>(p, i)(o, alloc); };
+			else this->delete_func = [p, &i, this](T obj) {this->bindFnc<INS, Optional<const AllocationCallbacks>>(p, i)(obj, nullptr); };
+			this->object = obj;
+		}
+
+		scoped_handle(void(INS::*p)(T, Optional<const AllocationCallbacks>) const,
+			const INS& i, Optional<const AllocationCallbacks> alloc = nullptr, T obj = T()) {
+			if (alloc != nullptr) this->delete_func = [p, &i, &alloc, this](T o) {this->bindFnc<INS, Optional<const AllocationCallbacks>>(p, i)(o, alloc); };
+			else this->delete_func = [p, &i, this](T obj) {this->bindFnc<INS, Optional<const AllocationCallbacks>>(p, i)(obj, nullptr); };
+			this->object = obj;
+		}
+
+		scoped_handle(void(DEV::*p)(T, Optional<const AllocationCallbacks>) const, scoped_handle<DEV>& d, Optional<const AllocationCallbacks> alloc = nullptr, T obj = T())
+		{
+			if (alloc != nullptr)this->delete_func = [p, &d, &alloc, this](T o) {this->bindFnc<DEV, Optional<const AllocationCallbacks>>(p, d)(o, alloc); };
+			else this->delete_func = [p, &d, this](T o) {this->bindFnc<DEV, Optional<const AllocationCallbacks>>(p, d)(o, nullptr); };
+			this->object = obj;
+		}
+
+		scoped_handle(void(DEV::*p)(T, Optional<const AllocationCallbacks>) const, const DEV& d, Optional<const AllocationCallbacks> alloc = nullptr, T obj = T())
+		{
+			if (alloc != nullptr)this->delete_func = [p, d, &alloc, this](T o) {this->bindFnc<DEV, Optional<const AllocationCallbacks>>(p, d)(o, alloc); };
+			else this->delete_func = [p, &d, this](T o) {this->bindFnc<DEV, Optional<const AllocationCallbacks>>(p, d)(o, nullptr); };
+			this->object = obj;
+		}
+#endif
+		scoped_handle(void(INS::*p)(T,const AllocationCallbacks*) const,
+			scoped_handle<INS>& i, const AllocationCallbacks* alloc = nullptr, T obj = T()) {
+			if (alloc != nullptr) this->delete_func = [p, &i, &alloc, this](T o) {this->bindFnc<INS, const AllocationCallbacks*>(p, i)(o, alloc); };
+			else this->delete_func = [p, &i, this](T obj) {this->bindFnc<INS, const AllocationCallbacks*>(p, i)(obj, nullptr); };
+			this->object = obj;
+		}
+
+		scoped_handle(void(INS::*p)(T, const AllocationCallbacks*) const,
+			const INS& i, const AllocationCallbacks* alloc = nullptr, T obj = T()) {
+			if (alloc != nullptr) this->delete_func = [p, &i, &alloc, this](T o) {this->bindFnc<INS, const AllocationCallbacks*>(p, i)(o, alloc); };
+			else this->delete_func = [p, &i, this](T obj) {this->bindFnc<INS, const AllocationCallbacks*>(p, i)(obj, nullptr); };
+			this->object = obj;
+		}
+
+		scoped_handle(void(DEV::*p)(T, const AllocationCallbacks*) const, scoped_handle<DEV>& d, const AllocationCallbacks* alloc = nullptr, T obj = T())
+		{
+			if (alloc != nullptr)this->delete_func = [p, &d, &alloc, this](T o) {this->bindFnc<DEV, const AllocationCallbacks*>(p, d)(o, alloc); };
+			else this->delete_func = [p, &d, this](T o) {this->bindFnc<DEV, const AllocationCallbacks*>(p, d)(o, nullptr); };
+			this->object = obj;
+		}
+
+		scoped_handle(void(DEV::*p)(T, const AllocationCallbacks*) const, const DEV& d, const AllocationCallbacks* alloc = nullptr, T obj = T())
+		{
+			if (alloc != nullptr)this->delete_func = [p, &d, &alloc, this](T o) {this->bindFnc<DEV, AllocationCallbacks*>(p, d)(o, alloc); };
+			else this->delete_func = [p, &d, this](T o) {this->bindFnc<DEV, AllocationCallbacks*>(p, d)(o, nullptr); };
+			this->object = obj;
+		}
+
+		operator T() const {
+			return object;
+		}
+
+		void operator= (T obj) {
+			destroy();
+			this->object = obj;
+		}
+
+		T& get() {
+			return object;
+		}
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+		void destroy() {
+			if (this->object)
+				this->delete_func(this->object);
+			this->object = VK_NULL_HANDLE;
+		}
+#else
+		void release() {
+			released = true;
+			auto_release_copies = true;
+		}
+
+		void doAutoReleaseCopies(bool state) {
+			auto_release_copies = state;
+		}
+
+		bool isAutoReleasingCopies() {
+			return auto_release_copies;
+		}
+
+		void destroy() {
+			if (this->object && released) {
+				std::cout << "Deleting object of type " << typeid(object).name() << std::endl;
+				this->delete_func(this->object);
+			}
+
+			this->object = VK_NULL_HANDLE;
+		}
+#endif
+		bool isEmpty() {
+			return this->object;
+		}
+
+		T* operator &() {
+			return &object;
+		}
+
+		~scoped_handle() {
+			destroy();
+		}
+	};
+
+#endif
 	class DeviceMemory
 	{
 	public:
@@ -1537,6 +1704,8 @@ namespace vk
 	};
 	static_assert(sizeof(DescriptorSet) == sizeof(VkDescriptorSet), "handle and wrapper have different size!");
 
+
+
 	class DescriptorSetLayout
 	{
 	public:
@@ -15720,8 +15889,9 @@ namespace vk
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
 		Queue getQueue(uint32_t queueFamilyIndex, uint32_t queueIndex) const
 		{
-      Queue queue;
+			Queue queue = Queue();
 			vkGetDeviceQueue(m_device, queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue*>(&queue));
+			if (&queue == nullptr)std::cout << "fail" << std::endl;
 			return queue;
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -15740,7 +15910,7 @@ namespace vk
 			return createResultValue(result, "vk::Device::waitIdle");
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
+#ifdef VULKAN_HPP_DISABLE_SCOPED_HANDLING
 		Result allocateMemory(const MemoryAllocateInfo* pAllocateInfo, const AllocationCallbacks* pAllocator, DeviceMemory* pMemory) const
 		{
 			return static_cast<Result>(vkAllocateMemory(m_device, reinterpret_cast<const VkMemoryAllocateInfo*>(pAllocateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkDeviceMemory*>(pMemory)));
@@ -15754,6 +15924,21 @@ namespace vk
 			return createResultValue(result, memory, "vk::Device::allocateMemory");
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#else
+		Result allocateMemory(const MemoryAllocateInfo* pAllocateInfo, const AllocationCallbacks* pAllocator, scoped_handle<DeviceMemory>* pMemory) const
+		{
+			return static_cast<Result>(vkAllocateMemory(m_device, reinterpret_cast<const VkMemoryAllocateInfo*>(pAllocateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkDeviceMemory*>(&pMemory->get())));
+		}
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+		ResultValueType<scoped_handle<DeviceMemory>>::type allocateMemory(const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator = nullptr) const
+		{
+			scoped_handle<DeviceMemory> memory(ptrMemberFnc < Device, DeviceMemory, Optional<const AllocationCallbacks>>(&Device::freeMemory), *this, allocator);
+			Result result = static_cast<Result>(vkAllocateMemory(m_device, reinterpret_cast<const VkMemoryAllocateInfo*>(&allocateInfo), reinterpret_cast<const VkAllocationCallbacks*>(static_cast<const AllocationCallbacks*>(allocator)), reinterpret_cast<VkDeviceMemory*>(&memory)));
+			return createResultValue(result, memory, "vk::Device::allocateMemory");
+		}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VULKAN_HPP_DISABLE_SCOPED_HANDLING*/
 
 		void freeMemory(DeviceMemory memory, const AllocationCallbacks* pAllocator) const
 		{
@@ -15913,6 +16098,7 @@ namespace vk
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_SCOPED_HANDLING
 		Result createFence(const FenceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Fence* pFence) const
 		{
 			return static_cast<Result>(vkCreateFence(m_device, reinterpret_cast<const VkFenceCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkFence*>(pFence)));
@@ -15926,6 +16112,21 @@ namespace vk
 			return createResultValue(result, fence, "vk::Device::createFence");
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#else
+		Result createFence(const FenceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Fence* pFence) const
+		{
+			return static_cast<Result>(vkCreateFence(m_device, reinterpret_cast<const VkFenceCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkFence*>(pFence)));
+		}
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+		ResultValueType<scoped_handle<Fence>>::type createFence(const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr) const
+		{
+			scoped_handle<Fence> fence(ptrMemberFnc<Device, Fence, Optional<const AllocationCallbacks>>(&Device::destroyFence), *this, allocator);
+			Result result = static_cast<Result>(vkCreateFence(m_device, reinterpret_cast<const VkFenceCreateInfo*>(&createInfo), reinterpret_cast<const VkAllocationCallbacks*>(static_cast<const AllocationCallbacks*>(allocator)), reinterpret_cast<VkFence*>(&fence)));
+			return createResultValue(result, fence, "vk::Device::createFence");
+		}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VULKAN_HPP_DISABLE_SCOPED_HANDLING*/
 
 		void destroyFence(Fence fence, const AllocationCallbacks* pAllocator) const
 		{
@@ -15980,6 +16181,7 @@ namespace vk
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_SCOPED_HANDLING
 		Result createSemaphore(const SemaphoreCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Semaphore* pSemaphore) const
 		{
 			return static_cast<Result>(vkCreateSemaphore(m_device, reinterpret_cast<const VkSemaphoreCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkSemaphore*>(pSemaphore)));
@@ -15993,6 +16195,21 @@ namespace vk
 			return createResultValue(result, semaphore, "vk::Device::createSemaphore");
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#else
+		Result createSemaphore(const SemaphoreCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, scoped_handle<Semaphore>* pSemaphore) const
+		{
+			return static_cast<Result>(vkCreateSemaphore(m_device, reinterpret_cast<const VkSemaphoreCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkSemaphore*>(pSemaphore)));
+		}
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+		ResultValueType<scoped_handle<Semaphore>>::type createSemaphore(const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr) const
+		{
+			scoped_handle<Semaphore> semaphore(ptrMemberFnc<Device, Semaphore, Optional<const AllocationCallbacks>>(&Device::destroySemaphore), *this, allocator);
+			Result result = static_cast<Result>(vkCreateSemaphore(m_device, reinterpret_cast<const VkSemaphoreCreateInfo*>(&createInfo), reinterpret_cast<const VkAllocationCallbacks*>(static_cast<const AllocationCallbacks*>(allocator)), reinterpret_cast<VkSemaphore*>(&semaphore)));
+			return createResultValue(result, semaphore, "vk::Device::createSemaphore");
+		}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VULKAN_HPP_DISABLE_SCOPED_HANDLING*/
 
 		void destroySemaphore(Semaphore semaphore, const AllocationCallbacks* pAllocator) const
 		{
@@ -16006,6 +16223,7 @@ namespace vk
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_SCOPED_HANDLING
 		Result createEvent(const EventCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Event* pEvent) const
 		{
 			return static_cast<Result>(vkCreateEvent(m_device, reinterpret_cast<const VkEventCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkEvent*>(pEvent)));
@@ -16019,6 +16237,21 @@ namespace vk
 			return createResultValue(result, event, "vk::Device::createEvent");
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#else
+		Result createEvent(const EventCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, scoped_handle<Event>* pEvent) const
+		{
+			return static_cast<Result>(vkCreateEvent(m_device, reinterpret_cast<const VkEventCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkEvent*>(pEvent)));
+		}
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+		ResultValueType<scoped_handle<Event>>::type createEvent(const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr) const
+		{
+			scoped_handle<Event> event(ptrMemberFnc<Device, Event, Optional<const AllocationCallbacks>>(&Device::destroyEvent), *this, allocator);
+			Result result = static_cast<Result>(vkCreateEvent(m_device, reinterpret_cast<const VkEventCreateInfo*>(&createInfo), reinterpret_cast<const VkAllocationCallbacks*>(static_cast<const AllocationCallbacks*>(allocator)), reinterpret_cast<VkEvent*>(&event)));
+			return createResultValue(result, event, "vk::Device::createEvent");
+		}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VULKAN_HPP_DISABLE_SCOPED_HANDLING*/
 
 		void destroyEvent(Event event, const AllocationCallbacks* pAllocator) const
 		{
@@ -16077,6 +16310,7 @@ namespace vk
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_SCOPED_HANDLING
 		Result createQueryPool(const QueryPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, QueryPool* pQueryPool) const
 		{
 			return static_cast<Result>(vkCreateQueryPool(m_device, reinterpret_cast<const VkQueryPoolCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkQueryPool*>(pQueryPool)));
@@ -16090,6 +16324,21 @@ namespace vk
 			return createResultValue(result, queryPool, "vk::Device::createQueryPool");
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#else
+		Result createQueryPool(const QueryPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, scoped_handle<QueryPool>* pQueryPool) const
+		{
+			return static_cast<Result>(vkCreateQueryPool(m_device, reinterpret_cast<const VkQueryPoolCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkQueryPool*>(pQueryPool)));
+		}
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+		ResultValueType<scoped_handle<QueryPool>>::type createQueryPool(const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr) const
+		{
+			scoped_handle<QueryPool> queryPool(ptrMemberFnc<Device, QueryPool, Optional<const AllocationCallbacks>>(&Device::destroyQueryPool), *this, allocator);
+			Result result = static_cast<Result>(vkCreateQueryPool(m_device, reinterpret_cast<const VkQueryPoolCreateInfo*>(&createInfo), reinterpret_cast<const VkAllocationCallbacks*>(static_cast<const AllocationCallbacks*>(allocator)), reinterpret_cast<VkQueryPool*>(&queryPool)));
+			return createResultValue(result, queryPool, "vk::Device::createQueryPool");
+		}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VULKAN_HPP_DISABLE_SCOPED_HANDLING*/
 
 		void destroyQueryPool(QueryPool queryPool, const AllocationCallbacks* pAllocator) const
 		{
@@ -16116,7 +16365,7 @@ namespace vk
 			return createResultValue(result, "vk::Device::getQueryPoolResults", { Result::eSuccess, Result::eNotReady });
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
+#ifdef VULKAN_HPP_DISABLE_SCOPED_HANDLING
 		Result createBuffer(const BufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Buffer* pBuffer) const
 		{
 			return static_cast<Result>(vkCreateBuffer(m_device, reinterpret_cast<const VkBufferCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkBuffer*>(pBuffer)));
@@ -16130,7 +16379,20 @@ namespace vk
 			return createResultValue(result, buffer, "vk::Device::createBuffer");
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#else
+		Result createBuffer(const BufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, scoped_handle<Buffer>* buffer) const
+		{
+			return static_cast<Result>(vkCreateBuffer(m_device, reinterpret_cast<const VkBufferCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkBuffer*>(&buffer->get())));
+		}
 
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+		ResultValueType<Buffer>::type createBuffer(const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr) const
+		{
+			auto buffer = scoped_handle<Buffer>(ptrMemberFnc<Device, Buffer, Optional<const AllocationCallbacks>>(&Device::destroyBuffer), *this, allocator);
+			Result result = static_cast<Result>(vkCreateBuffer(m_device, reinterpret_cast<const VkBufferCreateInfo*>(&createInfo), reinterpret_cast<const VkAllocationCallbacks*>(static_cast<const AllocationCallbacks*>(allocator)), reinterpret_cast<VkBuffer*>(&buffer)));
+			return createResultValue(result, buffer, "vk::Device::createBuffer");
+		}
+#endif
 		void destroyBuffer(Buffer buffer, const AllocationCallbacks* pAllocator) const
 		{
 			vkDestroyBuffer(m_device, static_cast<VkBuffer>(buffer), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
@@ -16142,7 +16404,8 @@ namespace vk
 			vkDestroyBuffer(m_device, static_cast<VkBuffer>(buffer), reinterpret_cast<const VkAllocationCallbacks*>(static_cast<const AllocationCallbacks*>(allocator)));
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
+#endif /*VULKAN_HPP_DISABLE_SCOPED_HANDLING*/
+#ifdef VULKAN_HPP_DISABLE_SCOPED_HANDLING
 		Result createBufferView(const BufferViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, BufferView* pView) const
 		{
 			return static_cast<Result>(vkCreateBufferView(m_device, reinterpret_cast<const VkBufferViewCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkBufferView*>(pView)));
@@ -16156,7 +16419,21 @@ namespace vk
 			return createResultValue(result, view, "vk::Device::createBufferView");
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#else
+		Result createBufferView(const BufferViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, scoped_handle<BufferView>* pView) const
+		{
+			return static_cast<Result>(vkCreateBufferView(m_device, reinterpret_cast<const VkBufferViewCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkBufferView*>(&pView->get())));
+		}
 
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+		ResultValueType<scoped_handle<BufferView>>::type createBufferView(const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr) const
+		{
+			scoped_handle<BufferView> view(ptrMemberFnc<Device, BufferView, Optional<const AllocationCallbacks>>(&Device::destroyBufferView), *this, allocator);
+			Result result = static_cast<Result>(vkCreateBufferView(m_device, reinterpret_cast<const VkBufferViewCreateInfo*>(&createInfo), reinterpret_cast<const VkAllocationCallbacks*>(static_cast<const AllocationCallbacks*>(allocator)), reinterpret_cast<VkBufferView*>(&view)));
+			return createResultValue(result, view, "vk::Device::createBufferView");
+		}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VULKAN_HPP_DISABLE_SCOPED_HANDLING*/
 		void destroyBufferView(BufferView bufferView, const AllocationCallbacks* pAllocator) const
 		{
 			vkDestroyBufferView(m_device, static_cast<VkBufferView>(bufferView), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
@@ -16169,6 +16446,7 @@ namespace vk
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_SCOPED_HANDLING
 		Result createImage(const ImageCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Image* pImage) const
 		{
 			return static_cast<Result>(vkCreateImage(m_device, reinterpret_cast<const VkImageCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkImage*>(pImage)));
@@ -16182,6 +16460,22 @@ namespace vk
 			return createResultValue(result, image, "vk::Device::createImage");
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#else
+		Result createImage(const ImageCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, scoped_handle<Image>& image) const
+		{
+			return static_cast<Result>(vkCreateImage(m_device, reinterpret_cast<const VkImageCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkImage*>(&image)));
+		}
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+		ResultValueType<scoped_handle<Image>>::type createImage(const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr) const
+		{
+			scoped_handle<Image> image(ptrMemberFnc<Device, Image, Optional<const AllocationCallbacks>>(&Device::destroyImage), *this, allocator);
+			Result result = static_cast<Result>(vkCreateImage(m_device, reinterpret_cast<const VkImageCreateInfo*>(&createInfo), reinterpret_cast<const VkAllocationCallbacks*>(static_cast<const AllocationCallbacks*>(allocator)), reinterpret_cast<VkImage*>(&image)));
+			return createResultValue(result, image, "vk::Device::createImage");
+		}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#endif
 
 		void destroyImage(Image image, const AllocationCallbacks* pAllocator) const
 		{
@@ -16209,6 +16503,7 @@ namespace vk
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_SCOPED_HANDLING
 		Result createImageView(const ImageViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ImageView* pView) const
 		{
 			return static_cast<Result>(vkCreateImageView(m_device, reinterpret_cast<const VkImageViewCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkImageView*>(pView)));
@@ -16222,7 +16517,21 @@ namespace vk
 			return createResultValue(result, view, "vk::Device::createImageView");
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#else
+		Result createImageView(const ImageViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, scoped_handle<ImageView>& view) const
+		{
+			return static_cast<Result>(vkCreateImageView(m_device, reinterpret_cast<const VkImageViewCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkImageView*>(&view)));
+		}
 
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+		ResultValueType<scoped_handle<ImageView>>::type createImageView(const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr) const
+		{
+			auto view = scoped_handle<ImageView>(ptrMemberFnc<Device, ImageView, Optional<const AllocationCallbacks>>(&Device::destroyImageView), *this, allocator);
+			Result result = static_cast<Result>(vkCreateImageView(m_device, reinterpret_cast<const VkImageViewCreateInfo*>(&createInfo), reinterpret_cast<const VkAllocationCallbacks*>(static_cast<const AllocationCallbacks*>(allocator)), reinterpret_cast<VkImageView*>(&view)));
+			return createResultValue(result, view, "vk::Device::createImageView");
+		}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VULKAN_HPP_DISABLE_SCOPED_HANDLING*/
 		void destroyImageView(ImageView imageView, const AllocationCallbacks* pAllocator) const
 		{
 			vkDestroyImageView(m_device, static_cast<VkImageView>(imageView), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
@@ -16235,6 +16544,7 @@ namespace vk
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_SCOPED_HANDLING
 		Result createShaderModule(const ShaderModuleCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ShaderModule* pShaderModule) const
 		{
 			return static_cast<Result>(vkCreateShaderModule(m_device, reinterpret_cast<const VkShaderModuleCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkShaderModule*>(pShaderModule)));
@@ -16248,7 +16558,21 @@ namespace vk
 			return createResultValue(result, shaderModule, "vk::Device::createShaderModule");
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#else
+		Result createShaderModule(const ShaderModuleCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, scoped_handle<ShaderModule>* pShaderModule) const
+		{
+			return static_cast<Result>(vkCreateShaderModule(m_device, reinterpret_cast<const VkShaderModuleCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkShaderModule*>(pShaderModule)));
+		}
 
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+		ResultValueType<scoped_handle<ShaderModule>>::type createShaderModule(const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr) const
+		{
+			scoped_handle<ShaderModule> shaderModule(ptrMemberFnc<Device, ShaderModule, Optional<const AllocationCallbacks>>(&Device::destroyShaderModule), *this, allocator);
+			Result result = static_cast<Result>(vkCreateShaderModule(m_device, reinterpret_cast<const VkShaderModuleCreateInfo*>(&createInfo), reinterpret_cast<const VkAllocationCallbacks*>(static_cast<const AllocationCallbacks*>(allocator)), reinterpret_cast<VkShaderModule*>(&shaderModule)));
+			return createResultValue(result, shaderModule, "vk::Device::createShaderModule");
+		}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VULKAN_HPP_DISABLE_SCOPED_HANDLING*/
 		void destroyShaderModule(ShaderModule shaderModule, const AllocationCallbacks* pAllocator) const
 		{
 			vkDestroyShaderModule(m_device, static_cast<VkShaderModule>(shaderModule), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
@@ -16260,7 +16584,7 @@ namespace vk
 			vkDestroyShaderModule(m_device, static_cast<VkShaderModule>(shaderModule), reinterpret_cast<const VkAllocationCallbacks*>(static_cast<const AllocationCallbacks*>(allocator)));
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
+#ifdef VULKAN_HPP_DISABLE_SCOPED_HANDLING
 		Result createPipelineCache(const PipelineCacheCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineCache* pPipelineCache) const
 		{
 			return static_cast<Result>(vkCreatePipelineCache(m_device, reinterpret_cast<const VkPipelineCacheCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkPipelineCache*>(pPipelineCache)));
@@ -16274,7 +16598,21 @@ namespace vk
 			return createResultValue(result, pipelineCache, "vk::Device::createPipelineCache");
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#else
+		Result createPipelineCache(const PipelineCacheCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, scoped_handle<PipelineCache>* pPipelineCache) const
+		{
+			return static_cast<Result>(vkCreatePipelineCache(m_device, reinterpret_cast<const VkPipelineCacheCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkPipelineCache*>(pPipelineCache)));
+		}
 
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+		ResultValueType<scoped_handle<PipelineCache>>::type createPipelineCache(const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr) const
+		{
+			scoped_handle<PipelineCache> pipelineCache(ptrMemberFnc<Device, PipelineCache, Optional<const AllocationCallbacks>>(&Device::destroyPipelineCache), *this, allocator);
+			Result result = static_cast<Result>(vkCreatePipelineCache(m_device, reinterpret_cast<const VkPipelineCacheCreateInfo*>(&createInfo), reinterpret_cast<const VkAllocationCallbacks*>(static_cast<const AllocationCallbacks*>(allocator)), reinterpret_cast<VkPipelineCache*>(&pipelineCache)));
+			return createResultValue(result, pipelineCache, "vk::Device::createPipelineCache");
+		}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VULKAN_HPP_DISABLE_SCOPED_HANDLING*/
 		void destroyPipelineCache(PipelineCache pipelineCache, const AllocationCallbacks* pAllocator) const
 		{
 			vkDestroyPipelineCache(m_device, static_cast<VkPipelineCache>(pipelineCache), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
@@ -16326,10 +16664,10 @@ namespace vk
 			return createResultValue(result, "vk::Device::mergePipelineCaches");
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
+#ifdef VULKAN_HPP_DISABLE_SCOPED_HANDLING
 		Result createGraphicsPipelines(PipelineCache pipelineCache, uint32_t createInfoCount, const GraphicsPipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines) const
 		{
-      return static_cast<Result>( vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfoCount, reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipeline*>( pPipelines ) ) );
+			return static_cast<Result>(vkCreateGraphicsPipelines(m_device, static_cast<VkPipelineCache>(pipelineCache), createInfoCount, reinterpret_cast<const VkGraphicsPipelineCreateInfo*>(pCreateInfos), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkPipeline*>(pipelines)));
 		}
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
@@ -16348,7 +16686,39 @@ namespace vk
 			return createResultValue(result, pipeline, "vk::Device::createGraphicsPipeline");
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#else
+		Result createGraphicsPipelines(PipelineCache pipelineCache, uint32_t createInfoCount, const GraphicsPipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, scoped_handle<Pipeline>* pPipelines) const
+		{
+			Pipeline* pPipelinesRaw = new Pipeline[createInfoCount];
+			auto result = static_cast<Result>(vkCreateGraphicsPipelines(m_device, static_cast<VkPipelineCache>(pipelineCache), createInfoCount, reinterpret_cast<const VkGraphicsPipelineCreateInfo*>(pCreateInfos), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkPipeline*>(pPipelinesRaw)));
+			if (result == Result::eSuccess)
+				for (uint32_t i = 0; i < createInfoCount; i++)
+					pPipelines[i] = pPipelinesRaw[i];
+			delete[] pPipelinesRaw;
+			return result;
+		}
 
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+		template <typename Allocator = std::allocator<scoped_handle<Pipeline>>>
+		typename ResultValueType<std::vector<scoped_handle<Pipeline>, Allocator>>::type createGraphicsPipelines(PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr) const
+		{
+			std::vector<Pipeline> pipelinesRaw(createInfos.size());
+			Result result = static_cast<Result>(vkCreateGraphicsPipelines(m_device, static_cast<VkPipelineCache>(pipelineCache), createInfos.size(), reinterpret_cast<const VkGraphicsPipelineCreateInfo*>(createInfos.data()), reinterpret_cast<const VkAllocationCallbacks*>(static_cast<const AllocationCallbacks*>(allocator)), reinterpret_cast<VkPipeline*>(pipelinesRaw.data())));
+			std::vector<scoped_handle<Pipeline>, Allocator> pipelines(createInfos.size());
+			std::transform(pipelinesRaw.begin(), pipelinesRaw.end(), pipelines.begin(), [this, &allocator](Pipeline p) {return scoped_handle<Pipeline>(ptrMemberFnc<Device, Pipeline, Optional<const AllocationCallbacks>>(&Device::destroyPipeline), *this, allocator, p); });
+			return createResultValue(result, pipelines, "vk::Device::createGraphicsPipelines");
+		}
+
+		ResultValueType<scoped_handle<Pipeline>>::type createGraphicsPipeline(PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr) const
+		{
+			scoped_handle<Pipeline> pipeline(ptrMemberFnc<Device, Pipeline, Optional<const AllocationCallbacks>>(&Device::destroyPipeline), *this, allocator);
+			Result result = static_cast<Result>(vkCreateGraphicsPipelines(m_device, static_cast<VkPipelineCache>(pipelineCache), 1, reinterpret_cast<const VkGraphicsPipelineCreateInfo*>(&createInfo), reinterpret_cast<const VkAllocationCallbacks*>(static_cast<const AllocationCallbacks*>(allocator)), reinterpret_cast<VkPipeline*>(&pipeline)));
+			return createResultValue(result, pipeline, "vk::Device::createGraphicsPipeline");
+		}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VULKAN_HPP_DISABLE_SCOPED_HANDLING*/
+
+#ifdef VULKAN_HPP_DISABLE_SCOPED_HANDLING
 		Result createComputePipelines(PipelineCache pipelineCache, uint32_t createInfoCount, const ComputePipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines) const
 		{
 			return static_cast<Result>(vkCreateComputePipelines(m_device, static_cast<VkPipelineCache>(pipelineCache), createInfoCount, reinterpret_cast<const VkComputePipelineCreateInfo*>(pCreateInfos), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkPipeline*>(pPipelines)));
@@ -16370,6 +16740,37 @@ namespace vk
 			return createResultValue(result, pipeline, "vk::Device::createComputePipeline");
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#else
+		Result createComputePipelines(PipelineCache pipelineCache, uint32_t createInfoCount, const ComputePipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, scoped_handle<Pipeline>* pPipelines) const
+		{
+			Pipeline* pPipelinesRaw = new Pipeline[createInfoCount];
+			auto result = static_cast<Result>(vkCreateComputePipelines(m_device, static_cast<VkPipelineCache>(pipelineCache), createInfoCount, reinterpret_cast<const VkComputePipelineCreateInfo*>(pCreateInfos), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkPipeline*>(pPipelines)));
+			if (result == Result::eSuccess)
+				for (uint32_t i = 0; i < createInfoCount; i++)
+					pPipelines[i] = pPipelinesRaw[i];
+			delete[] pPipelinesRaw;
+			return result;
+		}
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+		template <typename Allocator = std::allocator<scoped_handle<Pipeline>>>
+		typename ResultValueType<std::vector<scoped_handle<Pipeline>, Allocator>>::type createComputePipelines(PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr) const
+		{
+			std::vector<Pipeline> pipelinesRaw(createInfos.size());
+			Result result = static_cast<Result>(vkCreateComputePipelines(m_device, static_cast<VkPipelineCache>(pipelineCache), createInfos.size(), reinterpret_cast<const VkComputePipelineCreateInfo*>(createInfos.data()), reinterpret_cast<const VkAllocationCallbacks*>(static_cast<const AllocationCallbacks*>(allocator)), reinterpret_cast<VkPipeline*>(pipelinesRaw.data())));
+			std::vector<scoped_handle<Pipeline>, Allocator> pipelines(createInfos.size());
+			std::transform(pipelinesRaw.begin(), pipelinesRaw.end(), pipelines.begin(), [this, &allocator](Pipeline p) {return scoped_handle<Pipeline>(ptrMemberFnc<Device, Pipeline, Optional<const AllocationCallbacks>>(&Device::destroyPipeline), *this, allocator, p); });
+			return createResultValue(result, pipelines, "vk::Device::createComputePipelines");
+		}
+
+		ResultValueType<scoped_handle<Pipeline>>::type createComputePipeline(PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr) const
+		{
+			scoped_handle<Pipeline> pipeline(ptrMemberFnc<Device, Pipeline, Optional<const AllocationCallbacks>>(&Device::destroyPipeline), *this, allocator);
+			Result result = static_cast<Result>(vkCreateComputePipelines(m_device, static_cast<VkPipelineCache>(pipelineCache), 1, reinterpret_cast<const VkComputePipelineCreateInfo*>(&createInfo), reinterpret_cast<const VkAllocationCallbacks*>(static_cast<const AllocationCallbacks*>(allocator)), reinterpret_cast<VkPipeline*>(&pipeline)));
+			return createResultValue(result, pipeline, "vk::Device::createComputePipeline");
+		}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VULKAN_HPP_DISABLE_SCOPED_HANDLING*/
 
 		void destroyPipeline(Pipeline pipeline, const AllocationCallbacks* pAllocator) const
 		{
@@ -16383,6 +16784,7 @@ namespace vk
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_SCOPED_HANDLING
 		Result createPipelineLayout(const PipelineLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineLayout* pPipelineLayout) const
 		{
 			return static_cast<Result>(vkCreatePipelineLayout(m_device, reinterpret_cast<const VkPipelineLayoutCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkPipelineLayout*>(pPipelineLayout)));
@@ -16396,6 +16798,21 @@ namespace vk
 			return createResultValue(result, pipelineLayout, "vk::Device::createPipelineLayout");
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#else
+		Result createPipelineLayout(const PipelineLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, scoped_handle<PipelineLayout>* pPipelineLayout) const
+		{
+			return static_cast<Result>(vkCreatePipelineLayout(m_device, reinterpret_cast<const VkPipelineLayoutCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkPipelineLayout*>(pPipelineLayout)));
+		}
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+		ResultValueType<scoped_handle<PipelineLayout>>::type createPipelineLayout(const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr) const
+		{
+			scoped_handle<PipelineLayout> pipelineLayout(ptrMemberFnc<Device, PipelineLayout, Optional<const AllocationCallbacks>>(&Device::destroyPipelineLayout), *this, allocator);
+			Result result = static_cast<Result>(vkCreatePipelineLayout(m_device, reinterpret_cast<const VkPipelineLayoutCreateInfo*>(&createInfo), reinterpret_cast<const VkAllocationCallbacks*>(static_cast<const AllocationCallbacks*>(allocator)), reinterpret_cast<VkPipelineLayout*>(&pipelineLayout)));
+			return createResultValue(result, pipelineLayout, "vk::Device::createPipelineLayout");
+		}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VULKAN_HPP_DISABLE_SCOPED_HANDLING*/
 
 		void destroyPipelineLayout(PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator) const
 		{
@@ -16409,6 +16826,7 @@ namespace vk
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_SCOPED_HANDLING
 		Result createSampler(const SamplerCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Sampler* pSampler) const
 		{
 			return static_cast<Result>(vkCreateSampler(m_device, reinterpret_cast<const VkSamplerCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkSampler*>(pSampler)));
@@ -16422,6 +16840,21 @@ namespace vk
 			return createResultValue(result, sampler, "vk::Device::createSampler");
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#else
+		Result createSampler(const SamplerCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, scoped_handle<Sampler>* pSampler) const
+		{
+			return static_cast<Result>(vkCreateSampler(m_device, reinterpret_cast<const VkSamplerCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkSampler*>(pSampler)));
+		}
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+		ResultValueType<scoped_handle<Sampler>>::type createSampler(const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr) const
+		{
+			scoped_handle<Sampler> sampler(ptrMemberFnc<Device, Sampler, Optional<const AllocationCallbacks>>(&Device::destroySampler), m_device, allocator);
+			Result result = static_cast<Result>(vkCreateSampler(m_device, reinterpret_cast<const VkSamplerCreateInfo*>(&createInfo), reinterpret_cast<const VkAllocationCallbacks*>(static_cast<const AllocationCallbacks*>(allocator)), reinterpret_cast<VkSampler*>(&sampler)));
+			return createResultValue(result, sampler, "vk::Device::createSampler");
+		}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif
 
 		void destroySampler(Sampler sampler, const AllocationCallbacks* pAllocator) const
 		{
@@ -16461,6 +16894,7 @@ namespace vk
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_SCOPED_HANDLING
 		Result createDescriptorPool(const DescriptorPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorPool* pDescriptorPool) const
 		{
 			return static_cast<Result>(vkCreateDescriptorPool(m_device, reinterpret_cast<const VkDescriptorPoolCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkDescriptorPool*>(pDescriptorPool)));
@@ -16474,6 +16908,21 @@ namespace vk
 			return createResultValue(result, descriptorPool, "vk::Device::createDescriptorPool");
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#else
+		Result createDescriptorPool(const DescriptorPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, scoped_handle<DescriptorPool>* pDescriptorPool) const
+		{
+			return static_cast<Result>(vkCreateDescriptorPool(m_device, reinterpret_cast<const VkDescriptorPoolCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkDescriptorPool*>(pDescriptorPool)));
+		}
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+		ResultValueType<scoped_handle<DescriptorPool>>::type createDescriptorPool(const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr) const
+		{
+			scoped_handle<DescriptorPool> descriptorPool(ptrMemberFnc<Device, DescriptorPool, Optional< const AllocationCallbacks>>(&Device::destroyDescriptorPool), m_device, allocator);
+			Result result = static_cast<Result>(vkCreateDescriptorPool(m_device, reinterpret_cast<const VkDescriptorPoolCreateInfo*>(&createInfo), reinterpret_cast<const VkAllocationCallbacks*>(static_cast<const AllocationCallbacks*>(allocator)), reinterpret_cast<VkDescriptorPool*>(&descriptorPool)));
+			return createResultValue(result, descriptorPool, "vk::Device::createDescriptorPool");
+		}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif
 
 		void destroyDescriptorPool(DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator) const
 		{
@@ -16502,6 +16951,7 @@ namespace vk
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+
 		Result allocateDescriptorSets(const DescriptorSetAllocateInfo* pAllocateInfo, DescriptorSet* pDescriptorSets) const
 		{
 			return static_cast<Result>(vkAllocateDescriptorSets(m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>(pAllocateInfo), reinterpret_cast<VkDescriptorSet*>(pDescriptorSets)));
@@ -16516,7 +16966,6 @@ namespace vk
 			return createResultValue(result, descriptorSets, "vk::Device::allocateDescriptorSets");
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
 		Result freeDescriptorSets(DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets) const
 		{
 			return static_cast<Result>(vkFreeDescriptorSets(m_device, static_cast<VkDescriptorPool>(descriptorPool), descriptorSetCount, reinterpret_cast<const VkDescriptorSet*>(pDescriptorSets)));
@@ -16542,6 +16991,7 @@ namespace vk
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_SCOPED_HANDLING
 		Result createFramebuffer(const FramebufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Framebuffer* pFramebuffer) const
 		{
 			return static_cast<Result>(vkCreateFramebuffer(m_device, reinterpret_cast<const VkFramebufferCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkFramebuffer*>(pFramebuffer)));
@@ -16555,6 +17005,21 @@ namespace vk
 			return createResultValue(result, framebuffer, "vk::Device::createFramebuffer");
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#else
+		Result createFramebuffer(const FramebufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, scoped_handle<Framebuffer> framebuffer) const
+		{
+			return static_cast<Result>(vkCreateFramebuffer(m_device, reinterpret_cast<const VkFramebufferCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkFramebuffer*>(&framebuffer)));
+		}
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+		ResultValueType<scoped_handle<Framebuffer>>::type createFramebuffer(const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr) const
+		{
+			scoped_handle<Framebuffer> framebuffer(ptrMemberFnc<Device, Framebuffer, Optional<const AllocationCallbacks>>(&Device::destroyFramebuffer), *this, allocator);
+			Result result = static_cast<Result>(vkCreateFramebuffer(m_device, reinterpret_cast<const VkFramebufferCreateInfo*>(&createInfo), reinterpret_cast<const VkAllocationCallbacks*>(static_cast<const AllocationCallbacks*>(allocator)), reinterpret_cast<VkFramebuffer*>(&framebuffer)));
+			return createResultValue(result, framebuffer, "vk::Device::createFramebuffer");
+		}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VULKAN_HPP_DISABLE_SCOPED_HANDLING*/
 
 		void destroyFramebuffer(Framebuffer framebuffer, const AllocationCallbacks* pAllocator) const
 		{
@@ -16568,6 +17033,7 @@ namespace vk
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_SCOPED_HANDLING
 		Result createRenderPass(const RenderPassCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass) const
 		{
 			return static_cast<Result>(vkCreateRenderPass(m_device, reinterpret_cast<const VkRenderPassCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkRenderPass*>(pRenderPass)));
@@ -16581,6 +17047,21 @@ namespace vk
 			return createResultValue(result, renderPass, "vk::Device::createRenderPass");
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#else
+		Result createRenderPass(const RenderPassCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, scoped_handle<RenderPass>* pRenderPass) const
+		{
+			return static_cast<Result>(vkCreateRenderPass(m_device, reinterpret_cast<const VkRenderPassCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkRenderPass*>(&pRenderPass->get())));
+		}
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+		ResultValueType<scoped_handle<RenderPass>>::type createRenderPass(const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr) const
+		{
+			scoped_handle<RenderPass> renderPass(ptrMemberFnc < Device, RenderPass, Optional<const AllocationCallbacks>>(&Device::destroyRenderPass), *this, allocator);
+			Result result = static_cast<Result>(vkCreateRenderPass(m_device, reinterpret_cast<const VkRenderPassCreateInfo*>(&createInfo), reinterpret_cast<const VkAllocationCallbacks*>(static_cast<const AllocationCallbacks*>(allocator)), reinterpret_cast<VkRenderPass*>(&renderPass)));
+			return createResultValue(result, renderPass, "vk::Device::createRenderPass");
+		}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VULKAN_HPP_DISABLE_SCOPED_HANDLING*/
 
 		void destroyRenderPass(RenderPass renderPass, const AllocationCallbacks* pAllocator) const
 		{
@@ -16608,6 +17089,7 @@ namespace vk
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_SCOPED_HANDLING
 		Result createCommandPool(const CommandPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, CommandPool* pCommandPool) const
 		{
 			return static_cast<Result>(vkCreateCommandPool(m_device, reinterpret_cast<const VkCommandPoolCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkCommandPool*>(pCommandPool)));
@@ -16621,6 +17103,21 @@ namespace vk
 			return createResultValue(result, commandPool, "vk::Device::createCommandPool");
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#else
+		Result createCommandPool(const CommandPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, scoped_handle<CommandPool>* pCommandPool) const
+		{
+			return static_cast<Result>(vkCreateCommandPool(m_device, reinterpret_cast<const VkCommandPoolCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkCommandPool*>(&pCommandPool->get())));
+		}
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+		ResultValueType<scoped_handle<CommandPool>>::type createCommandPool(const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr) const
+		{
+			scoped_handle<CommandPool> commandPool(ptrMemberFnc<Device, CommandPool, Optional<const AllocationCallbacks>>(&Device::destroyCommandPool), *this, allocator);
+			Result result = static_cast<Result>(vkCreateCommandPool(m_device, reinterpret_cast<const VkCommandPoolCreateInfo*>(&createInfo), reinterpret_cast<const VkAllocationCallbacks*>(static_cast<const AllocationCallbacks*>(allocator)), reinterpret_cast<VkCommandPool*>(&commandPool)));
+			return createResultValue(result, commandPool, "vk::Device::createCommandPool");
+		}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VULKAN_HPP_DISABLE_SCOPED_HANDLING*/
 
 		void destroyCommandPool(CommandPool commandPool, const AllocationCallbacks* pAllocator) const
 		{
@@ -16676,6 +17173,7 @@ namespace vk
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_SCOPED_HANDLING
 		Result createSharedSwapchainsKHR(uint32_t swapchainCount, const SwapchainCreateInfoKHR* pCreateInfos, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchains) const
 		{
 			return static_cast<Result>(vkCreateSharedSwapchainsKHR(m_device, swapchainCount, reinterpret_cast<const VkSwapchainCreateInfoKHR*>(pCreateInfos), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkSwapchainKHR*>(pSwapchains)));
@@ -16697,7 +17195,30 @@ namespace vk
 			return createResultValue(result, swapchain, "vk::Device::createSharedSwapchainKHR");
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#else
+		Result createSharedSwapchainsKHR(uint32_t swapchainCount, const SwapchainCreateInfoKHR* pCreateInfos, const AllocationCallbacks* pAllocator, scoped_handle<SwapchainKHR>* pSwapchains) const
+		{
+			return static_cast<Result>(vkCreateSharedSwapchainsKHR(m_device, swapchainCount, reinterpret_cast<const VkSwapchainCreateInfoKHR*>(pCreateInfos), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkSwapchainKHR*>(pSwapchains)));
+		}
 
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+		template <typename Allocator = std::allocator<scoped_handle<SwapchainKHR>>>
+		typename ResultValueType<std::vector<scoped_handle<SwapchainKHR>, Allocator>>::type createSharedSwapchainsKHR(ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator = nullptr) const
+		{
+			std::vector<scoped_handle<SwapchainKHR>, Allocator> swapchains(createInfos.size(), scoped_handle<SwapchainKHR>(ptrMemberFnc<Device, SwapchainKHR, Optional<const AllocationCallbacks>>(&Device::destroySwapchainKHR), m_device, allocator, false));
+			Result result = static_cast<Result>(vkCreateSharedSwapchainsKHR(m_device, createInfos.size(), reinterpret_cast<const VkSwapchainCreateInfoKHR*>(createInfos.data()), reinterpret_cast<const VkAllocationCallbacks*>(static_cast<const AllocationCallbacks*>(allocator)), reinterpret_cast<VkSwapchainKHR*>(swapchains.data())));
+			return createResultValue(result, swapchains, "vk::Device::createSharedSwapchainsKHR");
+		}
+
+		ResultValueType<scoped_handle<SwapchainKHR>>::type createSharedSwapchainKHR(const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr) const
+		{
+			scoped_handle<SwapchainKHR> swapchain(ptrMemberFnc<Device, SwapchainKHR, Optional<const AllocationCallbacks>>(&Device::destroySwapchainKHR), m_device, allocator);
+			Result result = static_cast<Result>(vkCreateSharedSwapchainsKHR(m_device, 1, reinterpret_cast<const VkSwapchainCreateInfoKHR*>(&createInfo), reinterpret_cast<const VkAllocationCallbacks*>(static_cast<const AllocationCallbacks*>(allocator)), reinterpret_cast<VkSwapchainKHR*>(&swapchain)));
+			return createResultValue(result, swapchain, "vk::Device::createSharedSwapchainKHR");
+		}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VULKAN_HPP_DISABLE_SCOPED_HANDLING*/
+#ifdef VULKAN_HPP_DISABLE_SCOPED_HANDLING
 		Result createSwapchainKHR(const SwapchainCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchain) const
 		{
 			return static_cast<Result>(vkCreateSwapchainKHR(m_device, reinterpret_cast<const VkSwapchainCreateInfoKHR*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkSwapchainKHR*>(pSwapchain)));
@@ -16711,7 +17232,21 @@ namespace vk
 			return createResultValue(result, swapchain, "vk::Device::createSwapchainKHR");
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#else
+		Result createSwapchainKHR(const SwapchainCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, scoped_handle<SwapchainKHR>* pSwapchain) const
+		{
+			return static_cast<Result>(vkCreateSwapchainKHR(m_device, reinterpret_cast<const VkSwapchainCreateInfoKHR*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkSwapchainKHR*>(pSwapchain)));
+		}
 
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+		ResultValueType<scoped_handle<SwapchainKHR>>::type createSwapchainKHR(const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr) const
+		{
+			scoped_handle<SwapchainKHR> swapchain(ptrMemberFnc<Device, SwapchainKHR, Optional<const AllocationCallbacks>>(&Device::destroySwapchainKHR), *this, allocator);
+			Result result = static_cast<Result>(vkCreateSwapchainKHR(m_device, reinterpret_cast<const VkSwapchainCreateInfoKHR*>(&createInfo), reinterpret_cast<const VkAllocationCallbacks*>(static_cast<const AllocationCallbacks*>(allocator)), reinterpret_cast<VkSwapchainKHR*>(&swapchain)));
+			return createResultValue(result, swapchain, "vk::Device::createSwapchainKHR");
+		}
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif /*VULKAN_HPP_DISABLE_SCOPED_HANDLING*/
 		void destroySwapchainKHR(SwapchainKHR swapchain, const AllocationCallbacks* pAllocator) const
 		{
 			vkDestroySwapchainKHR(m_device, static_cast<VkSwapchainKHR>(swapchain), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator));
@@ -16814,6 +17349,7 @@ namespace vk
 	private:
 		VkDevice m_device;
 	};
+
 	static_assert(sizeof(Device) == sizeof(VkDevice), "handle and wrapper have different size!");
 
 	class PhysicalDevice
@@ -16937,7 +17473,7 @@ namespace vk
 			return createResultValue(result, imageFormatProperties, "vk::PhysicalDevice::getImageFormatProperties");
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
+#ifdef VULKAN_HPP_DISABLE_SCOPED_HANDLING
 		Result createDevice(const DeviceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Device* pDevice) const
 		{
 			return static_cast<Result>(vkCreateDevice(m_physicalDevice, reinterpret_cast<const VkDeviceCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkDevice*>(pDevice)));
@@ -16951,7 +17487,21 @@ namespace vk
 			return createResultValue(result, device, "vk::PhysicalDevice::createDevice");
 		}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#else
+		Result createDevice(const DeviceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, scoped_handle<Device>& Device) const
+		{
+			return static_cast<Result>(vkCreateDevice(m_physicalDevice, reinterpret_cast<const VkDeviceCreateInfo*>(pCreateInfo), reinterpret_cast<const VkAllocationCallbacks*>(pAllocator), reinterpret_cast<VkDevice*>(&Device)));
+		}
 
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+		ResultValueType<scoped_handle<Device>>::type createDevice(const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr) const
+		{
+			scoped_handle<Device> device([](Device& d) {d.destroy(); });
+			Result result = static_cast<Result>(vkCreateDevice(m_physicalDevice, reinterpret_cast<const VkDeviceCreateInfo*>(&createInfo), reinterpret_cast<const VkAllocationCallbacks*>(static_cast<const AllocationCallbacks*>(allocator)), reinterpret_cast<VkDevice*>(&device)));
+			return createResultValue(result, device, "vk::PhysicalDevice::createDevice");
+		}
+#endif
+#endif /*VULKAN_HPP_DISABLE_SCOPED_HANDLING*/
 		Result enumerateDeviceLayerProperties(uint32_t* pPropertyCount, LayerProperties* pProperties) const
 		{
 			return static_cast<Result>(vkEnumerateDeviceLayerProperties(m_physicalDevice, pPropertyCount, reinterpret_cast<VkLayerProperties*>(pProperties)));
@@ -17771,6 +18321,8 @@ namespace vk
 	}
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+
+
 	inline std::string to_string(FramebufferCreateFlagBits)
 	{
 		return "(void)";