@babylonjs/react-native 2.0.0 → 2.0.1-preview

package/shared/BabylonNative/deps/bgfx.cmake-src/bgfx/src/renderer_vk.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2025 Branimir Karadzic. All rights reserved.
+ * Copyright 2011-2026 Branimir Karadzic. All rights reserved.
  * License: https://github.com/bkaradzic/bgfx/blob/master/LICENSE
  */
 
@@ -107,120 +107,125 @@
 			VK_IMPORT_INSTANCE_FUNC(true,  vkGetPhysicalDeviceSurfaceSupportKHR);      \
 			VK_IMPORT_INSTANCE_FUNC(true,  vkDestroySurfaceKHR);                       \
 			/* VK_KHR_get_physical_device_properties2 */                               \
+			VK_IMPORT_INSTANCE_FUNC(true,  vkGetPhysicalDeviceProperties2KHR);         \
 			VK_IMPORT_INSTANCE_FUNC(true,  vkGetPhysicalDeviceFeatures2KHR);           \
 			VK_IMPORT_INSTANCE_FUNC(true,  vkGetPhysicalDeviceMemoryProperties2KHR);   \
 			/* VK_EXT_debug_report */                                                  \
 			VK_IMPORT_INSTANCE_FUNC(true,  vkCreateDebugReportCallbackEXT);            \
 			VK_IMPORT_INSTANCE_FUNC(true,  vkDestroyDebugReportCallbackEXT);           \
+			/* VK_KHR_fragment_shading_rate */                                         \
+			VK_IMPORT_INSTANCE_FUNC(true, vkGetPhysicalDeviceFragmentShadingRatesKHR); \
 			VK_IMPORT_INSTANCE_PLATFORM
 
-#define VK_IMPORT_DEVICE                                                    \
-			VK_IMPORT_DEVICE_FUNC(false, vkGetDeviceQueue);                 \
-			VK_IMPORT_DEVICE_FUNC(false, vkCreateFence);                    \
-			VK_IMPORT_DEVICE_FUNC(false, vkDestroyFence);                   \
-			VK_IMPORT_DEVICE_FUNC(false, vkCreateSemaphore);                \
-			VK_IMPORT_DEVICE_FUNC(false, vkDestroySemaphore);               \
-			VK_IMPORT_DEVICE_FUNC(false, vkResetFences);                    \
-			VK_IMPORT_DEVICE_FUNC(false, vkCreateCommandPool);              \
-			VK_IMPORT_DEVICE_FUNC(false, vkDestroyCommandPool);             \
-			VK_IMPORT_DEVICE_FUNC(false, vkResetCommandPool);               \
-			VK_IMPORT_DEVICE_FUNC(false, vkAllocateCommandBuffers);         \
-			VK_IMPORT_DEVICE_FUNC(false, vkFreeCommandBuffers);             \
-			VK_IMPORT_DEVICE_FUNC(false, vkGetBufferMemoryRequirements);    \
-			VK_IMPORT_DEVICE_FUNC(false, vkGetImageMemoryRequirements);     \
-			VK_IMPORT_DEVICE_FUNC(false, vkGetImageSubresourceLayout);      \
-			VK_IMPORT_DEVICE_FUNC(false, vkAllocateMemory);                 \
-			VK_IMPORT_DEVICE_FUNC(false, vkFreeMemory);                     \
-			VK_IMPORT_DEVICE_FUNC(false, vkCreateImage);                    \
-			VK_IMPORT_DEVICE_FUNC(false, vkDestroyImage);                   \
-			VK_IMPORT_DEVICE_FUNC(false, vkCreateImageView);                \
-			VK_IMPORT_DEVICE_FUNC(false, vkDestroyImageView);               \
-			VK_IMPORT_DEVICE_FUNC(false, vkCreateBuffer);                   \
-			VK_IMPORT_DEVICE_FUNC(false, vkDestroyBuffer);                  \
-			VK_IMPORT_DEVICE_FUNC(false, vkCreateFramebuffer);              \
-			VK_IMPORT_DEVICE_FUNC(false, vkDestroyFramebuffer);             \
-			VK_IMPORT_DEVICE_FUNC(false, vkCreateRenderPass);               \
-			VK_IMPORT_DEVICE_FUNC(false, vkDestroyRenderPass);              \
-			VK_IMPORT_DEVICE_FUNC(false, vkCreateShaderModule);             \
-			VK_IMPORT_DEVICE_FUNC(false, vkDestroyShaderModule);            \
-			VK_IMPORT_DEVICE_FUNC(false, vkCreatePipelineCache);            \
-			VK_IMPORT_DEVICE_FUNC(false, vkDestroyPipelineCache);           \
-			VK_IMPORT_DEVICE_FUNC(false, vkGetPipelineCacheData);           \
-			VK_IMPORT_DEVICE_FUNC(false, vkMergePipelineCaches);            \
-			VK_IMPORT_DEVICE_FUNC(false, vkCreateGraphicsPipelines);        \
-			VK_IMPORT_DEVICE_FUNC(false, vkCreateComputePipelines);         \
-			VK_IMPORT_DEVICE_FUNC(false, vkDestroyPipeline);                \
-			VK_IMPORT_DEVICE_FUNC(false, vkCreatePipelineLayout);           \
-			VK_IMPORT_DEVICE_FUNC(false, vkDestroyPipelineLayout);          \
-			VK_IMPORT_DEVICE_FUNC(false, vkCreateSampler);                  \
-			VK_IMPORT_DEVICE_FUNC(false, vkDestroySampler);                 \
-			VK_IMPORT_DEVICE_FUNC(false, vkCreateDescriptorSetLayout);      \
-			VK_IMPORT_DEVICE_FUNC(false, vkDestroyDescriptorSetLayout);     \
-			VK_IMPORT_DEVICE_FUNC(false, vkCreateDescriptorPool);           \
-			VK_IMPORT_DEVICE_FUNC(false, vkDestroyDescriptorPool);          \
-			VK_IMPORT_DEVICE_FUNC(false, vkResetDescriptorPool);            \
-			VK_IMPORT_DEVICE_FUNC(false, vkAllocateDescriptorSets);         \
-			VK_IMPORT_DEVICE_FUNC(false, vkFreeDescriptorSets);             \
-			VK_IMPORT_DEVICE_FUNC(false, vkUpdateDescriptorSets);           \
-			VK_IMPORT_DEVICE_FUNC(false, vkCreateQueryPool);                \
-			VK_IMPORT_DEVICE_FUNC(false, vkDestroyQueryPool);               \
-			VK_IMPORT_DEVICE_FUNC(false, vkQueueSubmit);                    \
-			VK_IMPORT_DEVICE_FUNC(false, vkQueueWaitIdle);                  \
-			VK_IMPORT_DEVICE_FUNC(false, vkDeviceWaitIdle);                 \
-			VK_IMPORT_DEVICE_FUNC(false, vkWaitForFences);                  \
-			VK_IMPORT_DEVICE_FUNC(false, vkBeginCommandBuffer);             \
-			VK_IMPORT_DEVICE_FUNC(false, vkEndCommandBuffer);               \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdPipelineBarrier);             \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdBeginRenderPass);             \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdEndRenderPass);               \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdSetViewport);                 \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdDraw);                        \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdDrawIndexed);                 \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdDrawIndirect);                \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdDrawIndexedIndirect);         \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdDispatch);                    \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdDispatchIndirect);            \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdBindPipeline);                \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdSetStencilReference);         \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdSetBlendConstants);           \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdSetScissor);                  \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdBindDescriptorSets);          \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdBindIndexBuffer);             \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdBindVertexBuffers);           \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdClearColorImage);             \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdClearDepthStencilImage);      \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdClearAttachments);            \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdResolveImage);                \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdCopyBuffer);                  \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdCopyBufferToImage);           \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdCopyImage);                   \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdCopyImageToBuffer);           \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdBlitImage);                   \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdResetQueryPool);              \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdWriteTimestamp);              \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdBeginQuery);                  \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdEndQuery);                    \
-			VK_IMPORT_DEVICE_FUNC(false, vkCmdCopyQueryPoolResults);        \
-			VK_IMPORT_DEVICE_FUNC(false, vkMapMemory);                      \
-			VK_IMPORT_DEVICE_FUNC(false, vkUnmapMemory);                    \
-			VK_IMPORT_DEVICE_FUNC(false, vkFlushMappedMemoryRanges);        \
-			VK_IMPORT_DEVICE_FUNC(false, vkInvalidateMappedMemoryRanges);   \
-			VK_IMPORT_DEVICE_FUNC(false, vkBindBufferMemory);               \
-			VK_IMPORT_DEVICE_FUNC(false, vkBindImageMemory);                \
-			/* VK_KHR_swapchain */                                          \
-			VK_IMPORT_DEVICE_FUNC(true,  vkCreateSwapchainKHR);             \
-			VK_IMPORT_DEVICE_FUNC(true,  vkDestroySwapchainKHR);            \
-			VK_IMPORT_DEVICE_FUNC(true,  vkGetSwapchainImagesKHR);          \
-			VK_IMPORT_DEVICE_FUNC(true,  vkAcquireNextImageKHR);            \
-			VK_IMPORT_DEVICE_FUNC(true,  vkQueuePresentKHR);                \
-			/* VK_EXT_debug_utils */                                        \
-			VK_IMPORT_DEVICE_FUNC(true,  vkSetDebugUtilsObjectNameEXT);     \
-			VK_IMPORT_DEVICE_FUNC(true,  vkCmdBeginDebugUtilsLabelEXT);     \
-			VK_IMPORT_DEVICE_FUNC(true,  vkCmdEndDebugUtilsLabelEXT);       \
-			VK_IMPORT_DEVICE_FUNC(true,  vkCmdInsertDebugUtilsLabelEXT);    \
-			/* VK_KHR_draw_indirect_count */                                \
-			VK_IMPORT_DEVICE_FUNC(true,  vkCmdDrawIndirectCountKHR);        \
-			VK_IMPORT_DEVICE_FUNC(true,  vkCmdDrawIndexedIndirectCountKHR); \
+#define VK_IMPORT_DEVICE                                                              \
+			VK_IMPORT_DEVICE_FUNC(false, vkGetDeviceQueue);                           \
+			VK_IMPORT_DEVICE_FUNC(false, vkCreateFence);                              \
+			VK_IMPORT_DEVICE_FUNC(false, vkDestroyFence);                             \
+			VK_IMPORT_DEVICE_FUNC(false, vkCreateSemaphore);                          \
+			VK_IMPORT_DEVICE_FUNC(false, vkDestroySemaphore);                         \
+			VK_IMPORT_DEVICE_FUNC(false, vkResetFences);                              \
+			VK_IMPORT_DEVICE_FUNC(false, vkCreateCommandPool);                        \
+			VK_IMPORT_DEVICE_FUNC(false, vkDestroyCommandPool);                       \
+			VK_IMPORT_DEVICE_FUNC(false, vkResetCommandPool);                         \
+			VK_IMPORT_DEVICE_FUNC(false, vkAllocateCommandBuffers);                   \
+			VK_IMPORT_DEVICE_FUNC(false, vkFreeCommandBuffers);                       \
+			VK_IMPORT_DEVICE_FUNC(false, vkGetBufferMemoryRequirements);              \
+			VK_IMPORT_DEVICE_FUNC(false, vkGetImageMemoryRequirements);               \
+			VK_IMPORT_DEVICE_FUNC(false, vkGetImageSubresourceLayout);                \
+			VK_IMPORT_DEVICE_FUNC(false, vkAllocateMemory);                           \
+			VK_IMPORT_DEVICE_FUNC(false, vkFreeMemory);                               \
+			VK_IMPORT_DEVICE_FUNC(false, vkCreateImage);                              \
+			VK_IMPORT_DEVICE_FUNC(false, vkDestroyImage);                             \
+			VK_IMPORT_DEVICE_FUNC(false, vkCreateImageView);                          \
+			VK_IMPORT_DEVICE_FUNC(false, vkDestroyImageView);                         \
+			VK_IMPORT_DEVICE_FUNC(false, vkCreateBuffer);                             \
+			VK_IMPORT_DEVICE_FUNC(false, vkDestroyBuffer);                            \
+			VK_IMPORT_DEVICE_FUNC(false, vkCreateFramebuffer);                        \
+			VK_IMPORT_DEVICE_FUNC(false, vkDestroyFramebuffer);                       \
+			VK_IMPORT_DEVICE_FUNC(false, vkCreateRenderPass);                         \
+			VK_IMPORT_DEVICE_FUNC(false, vkDestroyRenderPass);                        \
+			VK_IMPORT_DEVICE_FUNC(false, vkCreateShaderModule);                       \
+			VK_IMPORT_DEVICE_FUNC(false, vkDestroyShaderModule);                      \
+			VK_IMPORT_DEVICE_FUNC(false, vkCreatePipelineCache);                      \
+			VK_IMPORT_DEVICE_FUNC(false, vkDestroyPipelineCache);                     \
+			VK_IMPORT_DEVICE_FUNC(false, vkGetPipelineCacheData);                     \
+			VK_IMPORT_DEVICE_FUNC(false, vkMergePipelineCaches);                      \
+			VK_IMPORT_DEVICE_FUNC(false, vkCreateGraphicsPipelines);                  \
+			VK_IMPORT_DEVICE_FUNC(false, vkCreateComputePipelines);                   \
+			VK_IMPORT_DEVICE_FUNC(false, vkDestroyPipeline);                          \
+			VK_IMPORT_DEVICE_FUNC(false, vkCreatePipelineLayout);                     \
+			VK_IMPORT_DEVICE_FUNC(false, vkDestroyPipelineLayout);                    \
+			VK_IMPORT_DEVICE_FUNC(false, vkCreateSampler);                            \
+			VK_IMPORT_DEVICE_FUNC(false, vkDestroySampler);                           \
+			VK_IMPORT_DEVICE_FUNC(false, vkCreateDescriptorSetLayout);                \
+			VK_IMPORT_DEVICE_FUNC(false, vkDestroyDescriptorSetLayout);               \
+			VK_IMPORT_DEVICE_FUNC(false, vkCreateDescriptorPool);                     \
+			VK_IMPORT_DEVICE_FUNC(false, vkDestroyDescriptorPool);                    \
+			VK_IMPORT_DEVICE_FUNC(false, vkResetDescriptorPool);                      \
+			VK_IMPORT_DEVICE_FUNC(false, vkAllocateDescriptorSets);                   \
+			VK_IMPORT_DEVICE_FUNC(false, vkFreeDescriptorSets);                       \
+			VK_IMPORT_DEVICE_FUNC(false, vkUpdateDescriptorSets);                     \
+			VK_IMPORT_DEVICE_FUNC(false, vkCreateQueryPool);                          \
+			VK_IMPORT_DEVICE_FUNC(false, vkDestroyQueryPool);                         \
+			VK_IMPORT_DEVICE_FUNC(false, vkQueueSubmit);                              \
+			VK_IMPORT_DEVICE_FUNC(false, vkQueueWaitIdle);                            \
+			VK_IMPORT_DEVICE_FUNC(false, vkDeviceWaitIdle);                           \
+			VK_IMPORT_DEVICE_FUNC(false, vkWaitForFences);                            \
+			VK_IMPORT_DEVICE_FUNC(false, vkBeginCommandBuffer);                       \
+			VK_IMPORT_DEVICE_FUNC(false, vkEndCommandBuffer);                         \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdPipelineBarrier);                       \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdBeginRenderPass);                       \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdEndRenderPass);                         \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdSetViewport);                           \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdDraw);                                  \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdDrawIndexed);                           \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdDrawIndirect);                          \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdDrawIndexedIndirect);                   \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdDispatch);                              \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdDispatchIndirect);                      \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdBindPipeline);                          \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdSetStencilReference);                   \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdSetBlendConstants);                     \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdSetScissor);                            \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdBindDescriptorSets);                    \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdBindIndexBuffer);                       \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdBindVertexBuffers);                     \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdClearColorImage);                       \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdClearDepthStencilImage);                \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdClearAttachments);                      \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdResolveImage);                          \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdCopyBuffer);                            \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdCopyBufferToImage);                     \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdCopyImage);                             \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdCopyImageToBuffer);                     \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdBlitImage);                             \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdResetQueryPool);                        \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdWriteTimestamp);                        \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdBeginQuery);                            \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdEndQuery);                              \
+			VK_IMPORT_DEVICE_FUNC(false, vkCmdCopyQueryPoolResults);                  \
+			VK_IMPORT_DEVICE_FUNC(false, vkMapMemory);                                \
+			VK_IMPORT_DEVICE_FUNC(false, vkUnmapMemory);                              \
+			VK_IMPORT_DEVICE_FUNC(false, vkFlushMappedMemoryRanges);                  \
+			VK_IMPORT_DEVICE_FUNC(false, vkInvalidateMappedMemoryRanges);             \
+			VK_IMPORT_DEVICE_FUNC(false, vkBindBufferMemory);                         \
+			VK_IMPORT_DEVICE_FUNC(false, vkBindImageMemory);                          \
+			/* VK_KHR_swapchain */                                                    \
+			VK_IMPORT_DEVICE_FUNC(true,  vkCreateSwapchainKHR);                       \
+			VK_IMPORT_DEVICE_FUNC(true,  vkDestroySwapchainKHR);                      \
+			VK_IMPORT_DEVICE_FUNC(true,  vkGetSwapchainImagesKHR);                    \
+			VK_IMPORT_DEVICE_FUNC(true,  vkAcquireNextImageKHR);                      \
+			VK_IMPORT_DEVICE_FUNC(true,  vkQueuePresentKHR);                          \
+			/* VK_EXT_debug_utils */                                                  \
+			VK_IMPORT_DEVICE_FUNC(true,  vkSetDebugUtilsObjectNameEXT);               \
+			VK_IMPORT_DEVICE_FUNC(true,  vkCmdBeginDebugUtilsLabelEXT);               \
+			VK_IMPORT_DEVICE_FUNC(true,  vkCmdEndDebugUtilsLabelEXT);                 \
+			VK_IMPORT_DEVICE_FUNC(true,  vkCmdInsertDebugUtilsLabelEXT);              \
+			/* VK_KHR_draw_indirect_count */                                          \
+			VK_IMPORT_DEVICE_FUNC(true,  vkCmdDrawIndirectCountKHR);                  \
+			VK_IMPORT_DEVICE_FUNC(true,  vkCmdDrawIndexedIndirectCountKHR);           \
+			/* VK_KHR_fragment_shading_rate */                                        \
+			VK_IMPORT_DEVICE_FUNC(true, vkCmdSetFragmentShadingRateKHR);              \
 
 #define VK_DESTROY                                \
 			VK_DESTROY_FUNC(Buffer);              \
@@ -241,17 +246,19 @@
 			VK_DESTROY_FUNC(ShaderModule);        \
 			VK_DESTROY_FUNC(SwapchainKHR);        \
 
-#define _VK_CHECK(_check, _call)                                                                                \
-				BX_MACRO_BLOCK_BEGIN                                                                            \
-					/*BX_TRACE(#_call);*/                                                                       \
-					VkResult vkresult = _call;                                                                  \
-					_check(VK_SUCCESS == vkresult, #_call "; VK error 0x%x: %s", vkresult, getName(vkresult) ); \
+#define _VK_CHECK(_check, _call)                                                                              \
+				BX_MACRO_BLOCK_BEGIN                                                                          \
+					/*BX_TRACE(#_call);*/                                                                     \
+					VkResult vkresult = _call;                                                                \
+					_check(VK_SUCCESS == vkresult, #_call "; VK error %d: %s", vkresult, getName(vkresult) ); \
 				BX_MACRO_BLOCK_END
 
 #if BGFX_CONFIG_DEBUG
-#	define VK_CHECK(_call) _VK_CHECK(BX_ASSERT, _call)
+#	define VK_CHECK(_call)   _VK_CHECK(BX_ASSERT, _call)
+#	define VK_CHECK_W(_call) _VK_CHECK(BX_WARN, _call)
 #else
-#	define VK_CHECK(_call) _call
+#	define VK_CHECK(_call)   _call
+#	define VK_CHECK_W(_call) _call
 #endif // BGFX_CONFIG_DEBUG
 
 #if BGFX_CONFIG_DEBUG_ANNOTATION
@@ -423,14 +430,13 @@ VK_DESTROY_FUNC(DescriptorSet);
 		bool     m_isFromScratch;
 	};
 
-	class ScratchBufferVK
+	struct StagingScratchBufferVK
 	{
-	public:
-		ScratchBufferVK()
+		StagingScratchBufferVK()
 		{
 		}
 
-		~ScratchBufferVK()
+		~StagingScratchBufferVK()
 		{
 		}
 
@@ -438,7 +444,7 @@ VK_DESTROY_FUNC(DescriptorSet);
 		void createUniform(uint32_t _size, uint32_t _count);
 		void createStaging(uint32_t _size);
 		void destroy();
-		uint32_t alloc(uint32_t _size, uint32_t _minAlign = 1);
+		uint32_t alloc(uint32_t _size, uint32_t _minAlign);
 		uint32_t write(const void* _data, uint32_t _size, uint32_t _minAlign = 1);
 		void flush(bool _reset = true);
 
@@ -447,8 +453,60 @@ VK_DESTROY_FUNC(DescriptorSet);
 
 		uint8_t* m_data;
 		uint32_t m_size;
-		uint32_t m_pos;
+		uint32_t m_chunkPos;
+		uint32_t m_align;
+	};
+
+	struct ChunkedScratchBufferOffset
+	{
+		VkBuffer buffer;
+		uint32_t offsets[2];
+	};
+
+	struct ChunkedScratchBufferAlloc
+	{
+		uint32_t offset;
+		uint32_t chunkIdx;
+	};
+
+	struct ChunkedScratchBufferVK
+	{
+		ChunkedScratchBufferVK()
+			: m_chunkControl(0)
+		{
+		}
+
+		void create(uint32_t _chunkSize, uint32_t _numChunks, VkBufferUsageFlags usage, uint32_t _align);
+		void createUniform(uint32_t _chunkSize, uint32_t _numChunks);
+		void destroy();
+
+		void addChunk(uint32_t _at = UINT32_MAX);
+		ChunkedScratchBufferAlloc alloc(uint32_t _size);
+
+		void write(ChunkedScratchBufferOffset& _outSbo, const void* _vsData, uint32_t _vsSize, const void* _fsData = NULL, uint32_t _fsSize = 0);
+
+		void begin();
+		void end();
+
+		struct Chunk
+		{
+			VkBuffer buffer;
+			DeviceMemoryAllocationVK deviceMem;
+			uint8_t* data;
+		};
+
+		using ScratchBufferChunksArray = stl::vector<Chunk>;
+
+		ScratchBufferChunksArray m_chunks;
+		bx::RingBufferControl m_chunkControl;
+
+		uint32_t m_chunkPos;
+		uint32_t m_chunkSize;
 		uint32_t m_align;
+		VkBufferUsageFlags m_usage;
+
+		uint32_t m_consume[BGFX_CONFIG_MAX_FRAME_LATENCY];
+		uint32_t m_totalUsed;
 	};
 
 	struct BufferVK
@@ -677,6 +735,7 @@ VK_DESTROY_FUNC(DescriptorSet);
 	{
 		TextureVK()
 			: m_directAccessPtr(NULL)
+			, m_flags(0)
 			, m_sampler({ 1, VK_SAMPLE_COUNT_1_BIT })
 			, m_format(VK_FORMAT_UNDEFINED)
 			, m_aspectFlags(VK_IMAGE_ASPECT_NONE)
@@ -689,7 +748,7 @@ VK_DESTROY_FUNC(DescriptorSet);
 		{
 		}
 
-		void* create(VkCommandBuffer _commandBuffer, const Memory* _mem, uint64_t _flags, uint8_t _skip);
+		void* create(VkCommandBuffer _commandBuffer, const Memory* _mem, uint64_t _flags, uint8_t _skip, uint64_t _external);
 		// internal render target
 		VkResult create(VkCommandBuffer _commandBuffer, uint32_t _width, uint32_t _height, uint64_t _flags, VkFormat _format);
 
@@ -699,7 +758,7 @@ VK_DESTROY_FUNC(DescriptorSet);
 		void resolve(VkCommandBuffer _commandBuffer, uint8_t _resolve, uint32_t _layer, uint32_t _numLayers, uint32_t _mip);
 
 		void copyBufferToTexture(VkCommandBuffer _commandBuffer, VkBuffer _stagingBuffer, uint32_t _bufferImageCopyCount, VkBufferImageCopy* _bufferImageCopy);
-		VkImageLayout setImageMemoryBarrier(VkCommandBuffer _commandBuffer, VkImageLayout _newImageLayout, bool _singleMsaaImage = false);
+		void setState(VkCommandBuffer _commandBuffer, VkImageLayout _newImageLayout, bool _singleMsaaImage = false);
 
 		VkResult createView(uint32_t _layer, uint32_t _numLayers, uint32_t _mip, uint32_t _numMips, VkImageViewType _type, VkImageAspectFlags _aspectMask, bool _renderTarget, ::VkImageView* _view) const;
 
@@ -721,20 +780,20 @@ VK_DESTROY_FUNC(DescriptorSet);
 		VkComponentMapping m_components;
 		VkImageAspectFlags m_aspectFlags;
 
-		VkImage					 m_textureImage;
+		VkImage                  m_textureImage;
 		DeviceMemoryAllocationVK m_textureDeviceMem;
-		VkImageLayout			 m_currentImageLayout;
+		VkImageLayout            m_currentImageLayout;
 
-		VkImage					 m_singleMsaaImage;
+		VkImage                  m_singleMsaaImage;
 		DeviceMemoryAllocationVK m_singleMsaaDeviceMem;
-		VkImageLayout			 m_currentSingleMsaaImageLayout;
+		VkImageLayout            m_currentSingleMsaaImageLayout;
 
 		VkImageLayout m_sampledLayout;
 
 		ReadbackVK m_readback;
 
 	private:
-		VkResult createImages(VkCommandBuffer _commandBuffer);
+		VkResult createImages(VkCommandBuffer _commandBuffer, uint64_t _external = 0);
 		static VkImageAspectFlags getAspectMask(VkFormat _format);
 	};
 
@@ -876,11 +935,11 @@ VK_DESTROY_FUNC(DescriptorSet);
 
 	struct CommandQueueVK
 	{
-		VkResult init(uint32_t _queueFamily, VkQueue _queue, uint32_t _numFramesInFlight);
+		VkResult init(uint32_t _queueFamily, VkQueue _queue);
 		VkResult reset();
 		void shutdown();
 
-		VkResult alloc(VkCommandBuffer* _commandBuffer);
+		VkResult alloc(VkCommandBuffer* _outCommandBuffer);
 		void addWaitSemaphore(VkSemaphore _semaphore, VkPipelineStageFlags _waitFlags = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
 		void addSignalSemaphore(VkSemaphore _semaphore);
 		void kick(bool _wait = false);
@@ -890,11 +949,12 @@ VK_DESTROY_FUNC(DescriptorSet);
 		void recycleMemory(DeviceMemoryAllocationVK _mem);
 		void consume();
 
+		void addExternal(TextureHandle _handle);
+		void removeExternal(TextureHandle _handle);
+
 		uint32_t m_queueFamily;
 		VkQueue m_queue;
 
-		uint32_t m_numFramesInFlight;
-
 		uint32_t m_currentFrameInFlight;
 		uint32_t m_consumeIndex;
 
@@ -929,7 +989,8 @@ VK_DESTROY_FUNC(DescriptorSet);
 		typedef stl::vector<Resource> ResourceArray;
 		ResourceArray m_release[BGFX_CONFIG_MAX_FRAME_LATENCY];
 		stl::vector<DeviceMemoryAllocationVK> m_recycleAllocs[BGFX_CONFIG_MAX_FRAME_LATENCY];
-
+		typedef stl::vector<TextureHandle> ExternalTextureArray;
+		ExternalTextureArray m_external;
 
 	private:
 		template<typename Ty>