Fixed uniform offsets, removed a bunch of code from cdefines.h

This reverts commit 20636ec951.

CMakeLists.txt

@@ -9,7 +9,7 @@ option(BUILD_SHARED_LIBS "Build shared library" ON)
 # Version
 SET(LIB_MAJOR_VERSION "1")
 SET(LIB_MINOR_VERSION "15")
-SET(LIB_REVISION "0")
+SET(LIB_REVISION "4")
 SET(LIB_VERSION "${LIB_MAJOR_VERSION}.${LIB_MINOR_VERSION}.${LIB_REVISION}")
 
 # Build Type
@@ -41,6 +41,12 @@ add_definitions(
 	-DREFRESH_DRIVER_VULKAN
 )
 
+if (WIN32)
+	add_definitions(
+		-DREFRESH_DRIVER_D3D11
+	)
+endif()
+
 # Source lists
 add_library(Refresh
 	# Public Headers
@@ -49,8 +55,10 @@ add_library(Refresh
 	# Internal Headers
 	src/Refresh_Driver.h
 	src/Refresh_Driver_Vulkan_vkfuncs.h
+	Refresh_Driver_D3D11_cdefines.h
 	# Source Files
 	src/Refresh.c
+	src/Refresh_Driver_D3D11.c
 	src/Refresh_Driver_Vulkan.c
 	src/Refresh_Image.c
 )
@@ -60,6 +68,11 @@ if(NOT MSVC)
 	set_property(TARGET Refresh PROPERTY COMPILE_FLAGS "-std=gnu99 -Wall -Wno-strict-aliasing -pedantic")
 endif()
 
+# Windows is silly and we need to manually include the Vulkan SDK
+if(MSVC)
+	target_include_directories(Refresh PUBLIC $ENV{VULKAN_SDK}/include)
+endif()
+
 # Refresh folders as includes, for other targets to consume
 target_include_directories(Refresh PUBLIC
 	$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>

include/Refresh.h

@@ -56,7 +56,7 @@ extern "C" {
 
 #define REFRESH_MAJOR_VERSION   1
 #define REFRESH_MINOR_VERSION	15
-#define REFRESH_PATCH_VERSION	0
+#define REFRESH_PATCH_VERSION	4
 
 #define REFRESH_COMPILED_VERSION ( \
 	(REFRESH_MAJOR_VERSION * 100 * 100) + \
@@ -330,6 +330,7 @@ typedef enum Refresh_Backend
 {
 	REFRESH_BACKEND_DONTCARE,
 	REFRESH_BACKEND_VULKAN,
+	REFRESH_BACKEND_D3D11,
 	REFRESH_BACKEND_PS5,
 	REFRESH_BACKEND_INVALID
 } Refresh_Backend;

shadercompiler/Program.cs

@@ -200,20 +200,20 @@ partial class Program
 					WriteShaderBlob(writer, inputPath, 1);
 				}
 
+				if (data.d3d11)
+				{
+					string inputPath = Path.Combine(tempDir, $"{shaderName}.hlsl");
+					WriteShaderBlob(writer, inputPath, 2);
+				}
+
 #if PS5
 				if (data.ps5)
 				{
 					string ext = GetPS5ShaderFileExtension();
 					string inputPath = Path.Combine(tempDir, $"{shaderName}{ext}");
-					WriteShaderBlob(writer, inputPath, 2);
-				}
-#endif
-
-				if (data.d3d11)
-				{
-					string inputPath = Path.Combine(tempDir, $"{shaderName}.hlsl");
 					WriteShaderBlob(writer, inputPath, 3);
 				}
+#endif
 			}
 		}
 
@@ -238,7 +238,7 @@ partial class Program
 	{
 		Process glslc = Process.Start(
 			"glslc",
-			$"""{glslPath}"" -o ""{outputPath}"""
+			$"\"{glslPath}\" -o \"{outputPath}\""
 		);
 		glslc.WaitForExit();
 		if (glslc.ExitCode != 0)
@@ -254,7 +254,7 @@ partial class Program
 	{
 		Process spirvcross = Process.Start(
 			"spirv-cross",
-			$"""{spirvPath}"" --hlsl --shader-model 50 --output ""{outputPath}"""
+			$"\"{spirvPath}\" --hlsl --flip-vert-y --shader-model 50 --output \"{outputPath}\""
 		);
 		spirvcross.WaitForExit();
 		if (spirvcross.ExitCode != 0)

src/Refresh.c

@@ -39,6 +39,12 @@
 	#define VULKAN_DRIVER NULL
 #endif
 
+#ifdef REFRESH_DRIVER_D3D11
+	#define D3D11_DRIVER &D3D11Driver
+#else
+	#define D3D11_DRIVER NULL
+#endif
+
 #ifdef REFRESH_DRIVER_PS5
 	#define PS5_DRIVER &PS5Driver
 #else
@@ -48,6 +54,7 @@
 static const Refresh_Driver *backends[] = {
 	NULL,
 	VULKAN_DRIVER,
+	D3D11_DRIVER,
 	PS5_DRIVER
 };
 

src/Refresh_Driver.h

@@ -48,6 +48,46 @@ void Refresh_LogError(const char *fmt, ...);
 
 /* Internal Helper Utilities */
 
+static inline int32_t Texture_GetBlockSize(
+	Refresh_TextureFormat format
+) {
+	switch (format)
+	{
+		case REFRESH_TEXTUREFORMAT_BC1:
+		case REFRESH_TEXTUREFORMAT_BC2:
+		case REFRESH_TEXTUREFORMAT_BC3:
+		case REFRESH_TEXTUREFORMAT_BC7:
+			return 4;
+		case REFRESH_TEXTUREFORMAT_R8:
+		case REFRESH_TEXTUREFORMAT_R8_UINT:
+		case REFRESH_TEXTUREFORMAT_R5G6B5:
+		case REFRESH_TEXTUREFORMAT_B4G4R4A4:
+		case REFRESH_TEXTUREFORMAT_A1R5G5B5:
+		case REFRESH_TEXTUREFORMAT_R16_SFLOAT:
+		case REFRESH_TEXTUREFORMAT_R8G8_SNORM:
+		case REFRESH_TEXTUREFORMAT_R8G8_UINT:
+		case REFRESH_TEXTUREFORMAT_R16_UINT:
+		case REFRESH_TEXTUREFORMAT_R8G8B8A8:
+		case REFRESH_TEXTUREFORMAT_R32_SFLOAT:
+		case REFRESH_TEXTUREFORMAT_R16G16_SFLOAT:
+		case REFRESH_TEXTUREFORMAT_R8G8B8A8_SNORM:
+		case REFRESH_TEXTUREFORMAT_A2R10G10B10:
+		case REFRESH_TEXTUREFORMAT_R8G8B8A8_UINT:
+		case REFRESH_TEXTUREFORMAT_R16G16_UINT:
+		case REFRESH_TEXTUREFORMAT_R16G16B16A16_SFLOAT:
+		case REFRESH_TEXTUREFORMAT_R16G16B16A16:
+		case REFRESH_TEXTUREFORMAT_R32G32_SFLOAT:
+		case REFRESH_TEXTUREFORMAT_R16G16B16A16_UINT:
+		case REFRESH_TEXTUREFORMAT_R32G32B32A32_SFLOAT:
+			return 1;
+		default:
+			Refresh_LogError(
+				"Unrecognized TextureFormat!"
+			);
+			return 0;
+	}
+}
+
 static inline uint32_t Texture_GetFormatSize(
 	Refresh_TextureFormat format
 ) {
@@ -87,7 +127,7 @@ static inline uint32_t Texture_GetFormatSize(
 			return 16;
 		default:
 			Refresh_LogError(
-				"Unrecognized SurfaceFormat!"
+				"Unrecognized TextureFormat!"
 			);
 			return 0;
 	}
@@ -597,6 +637,7 @@ typedef struct Refresh_Driver
 } Refresh_Driver;
 
 extern Refresh_Driver VulkanDriver;
+extern Refresh_Driver D3D11Driver;
 extern Refresh_Driver PS5Driver;
 
 #endif /* REFRESH_DRIVER_H */

src/Refresh_Driver_D3D11_cdefines.h

@@ -0,0 +1,36 @@
+/* Refresh - XNA-inspired 3D Graphics Library with modern capabilities
+ *
+ * Copyright (c) 2020 Evan Hemsley
+ *
+ * This software is provided 'as-is', without any express or implied warranty.
+ * In no event will the authors be held liable for any damages arising from
+ * the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ * claim that you wrote the original software. If you use this software in a
+ * product, an acknowledgment in the product documentation would be
+ * appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ * misrepresented as being the original software.
+ *
+ * 3. This notice may not be removed or altered from any source distribution.
+ *
+ * Evan "cosmonaut" Hemsley <evan@moonside.games>
+ *
+ */
+
+/* Function Pointer Signatures */
+typedef HRESULT(WINAPI* PFN_CREATE_DXGI_FACTORY1)(const GUID* riid, void** ppFactory);
+
+ /* IIDs (from https://magnumdb.com) */
+
+static const IID D3D_IID_IDXGIFactory1 = { 0x770aae78,0xf26f,0x4dba,{0xa8,0x29,0x25,0x3c,0x83,0xd1,0xb3,0x87} };
+static const IID D3D_IID_IDXGIFactory6 = { 0xc1b6694f,0xff09,0x44a9,{0xb0,0x3c,0x77,0x90,0x0a,0x0a,0x1d,0x17} };
+static const IID D3D_IID_IDXGIAdapter1 = { 0x29038f61,0x3839,0x4626,{0x91,0xfd,0x08,0x68,0x79,0x01,0x1a,0x05} };
+static const IID D3D_IID_ID3D11Texture2D = { 0x6f15aaf2,0xd208,0x4e89,{0x9a,0xb4,0x48,0x95,0x35,0xd3,0x4f,0x9c} };
+static const IID D3D_IID_ID3D11Device1 = { 0xa04bfb29,0x08ef,0x43d6,{0xa4,0x9c,0xa9,0xbd,0xbd,0xcb,0xe6,0x86} };

src/Refresh_Driver_Vulkan.c

@@ -79,7 +79,8 @@ typedef struct VulkanExtensions
 #define ALLOCATION_INCREMENT 16000000           /* 16MB */
 #define TRANSFER_BUFFER_STARTING_SIZE 8000000 	/* 8MB */
 #define POOLED_TRANSFER_BUFFER_SIZE 16000000    /* 16MB */
-#define UBO_BUFFER_SIZE 16000 			        /* 16KB */
+#define UBO_BUFFER_SIZE 16777216 				/* 16MB */
+#define UBO_SECTION_SIZE 4096 			        /* 4KB */
 #define DESCRIPTOR_POOL_STARTING_SIZE 128
 #define DEFRAG_TIME 200
 #define WINDOW_DATA "Refresh_VulkanWindowData"
@@ -560,8 +561,8 @@ static const VulkanResourceAccessInfo AccessMap[RESOURCE_ACCESS_TYPES_COUNT] =
 
 	/* RESOURCE_ACCESS_ANY_SHADER_READ_SAMPLED_IMAGE */
 	{
-		VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+		VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-		VK_ACCESS_SHADER_READ_BIT,
+		VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
 		VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
 	},
 
@@ -707,6 +708,7 @@ struct VulkanBuffer
 	VulkanResourceAccessType resourceAccessType;
 	VkBufferUsageFlags usage;
 
+	uint8_t requireHostVisible;
 	uint8_t preferDeviceLocal;
 
 	SDL_atomic_t referenceCount; /* Tracks command buffer usage */
@@ -719,8 +721,8 @@ typedef struct VulkanUniformBufferPool VulkanUniformBufferPool;
 typedef struct VulkanUniformBuffer
 {
 	VulkanUniformBufferPool *pool;
-	VulkanBuffer *vulkanBuffer;
+	VkDeviceSize poolOffset; /* memory offset relative to the pool buffer */
-	VkDeviceSize offset;
+	VkDeviceSize offset; /* based on uniform pushes */
 	VkDescriptorSet descriptorSet;
 } VulkanUniformBuffer;
 
@@ -746,10 +748,13 @@ typedef struct VulkanUniformDescriptorPool
 	uint32_t availableDescriptorSetCount;
 } VulkanUniformDescriptorPool;
 
+/* This is actually just one buffer that we carve slices out of. */
 struct VulkanUniformBufferPool
 {
 	VulkanUniformBufferType type;
 	VulkanUniformDescriptorPool descriptorPool;
+	VulkanBuffer *buffer;
+	VkDeviceSize nextAvailableOffset;
 	SDL_mutex *lock;
 
 	VulkanUniformBuffer **availableBuffers;
@@ -1776,6 +1781,8 @@ typedef struct VulkanRenderer
 	VkDescriptorSetLayout vertexUniformDescriptorSetLayout;
 	VkDescriptorSetLayout fragmentUniformDescriptorSetLayout;
 	VkDescriptorSetLayout computeUniformDescriptorSetLayout;
+
+	VulkanBuffer *dummyBuffer;
 	VulkanUniformBuffer *dummyVertexUniformBuffer;
 	VulkanUniformBuffer *dummyFragmentUniformBuffer;
 	VulkanUniformBuffer *dummyComputeUniformBuffer;
@@ -1973,59 +1980,51 @@ static inline uint32_t VULKAN_INTERNAL_BytesPerPixel(VkFormat format)
 {
 	switch (format)
 	{
+		case VK_FORMAT_R8_UNORM:
+		case VK_FORMAT_R8_UINT:
+			return 1;
+		case VK_FORMAT_R5G6B5_UNORM_PACK16:
+		case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
+		case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
+		case VK_FORMAT_R16_SFLOAT:
+		case VK_FORMAT_R8G8_SNORM:
+		case VK_FORMAT_R8G8_UINT:
+		case VK_FORMAT_R16_UINT:
+		case VK_FORMAT_D16_UNORM:
+			return 2;
+		case VK_FORMAT_D16_UNORM_S8_UINT:
+			return 3;
+		case VK_FORMAT_R8G8B8A8_UNORM:
+		case VK_FORMAT_B8G8R8A8_UNORM:
+		case VK_FORMAT_R32_SFLOAT:
+		case VK_FORMAT_R16G16_UNORM:
+		case VK_FORMAT_R16G16_SFLOAT:
+		case VK_FORMAT_R8G8B8A8_SNORM:
+		case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
+		case VK_FORMAT_R8G8B8A8_UINT:
+		case VK_FORMAT_R16G16_UINT:
+		case VK_FORMAT_D32_SFLOAT:
+			return 4;
+		case VK_FORMAT_D32_SFLOAT_S8_UINT:
+			return 5;
+		case VK_FORMAT_R16G16B16A16_SFLOAT:
+		case VK_FORMAT_R16G16B16A16_UNORM:
+		case VK_FORMAT_R32G32_SFLOAT:
+		case VK_FORMAT_R16G16B16A16_UINT:
+		case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
+			return 8;
 		case VK_FORMAT_R32G32B32A32_SFLOAT:
 		case VK_FORMAT_BC2_UNORM_BLOCK:
 		case VK_FORMAT_BC3_UNORM_BLOCK:
 		case VK_FORMAT_BC7_UNORM_BLOCK:
-		case VK_FORMAT_R16G16B16A16_UINT:
 			return 16;
-
-		case VK_FORMAT_R8G8B8A8_UNORM:
-		case VK_FORMAT_R8G8B8A8_SNORM:
-		case VK_FORMAT_B8G8R8A8_UNORM:
-		case VK_FORMAT_B8G8R8A8_SNORM:
-		case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
-		case VK_FORMAT_R16G16_UNORM:
-		case VK_FORMAT_R16G16_SFLOAT:
-		case VK_FORMAT_R32_SFLOAT:
-		case VK_FORMAT_D32_SFLOAT:
-		case VK_FORMAT_R8G8B8A8_UINT:
-		case VK_FORMAT_R16G16_UINT:
-			return 4;
-
-		case VK_FORMAT_R5G6B5_UNORM_PACK16:
-		case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
-		case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
-		case VK_FORMAT_R8G8_SNORM:
-		case VK_FORMAT_R16_SFLOAT:
-		case VK_FORMAT_D16_UNORM:
-		case VK_FORMAT_R8G8_UINT:
-		case VK_FORMAT_R16_UINT:
-			return 2;
-
-		case VK_FORMAT_R16G16B16A16_UNORM:
-		case VK_FORMAT_R32G32_SFLOAT:
-		case VK_FORMAT_R16G16B16A16_SFLOAT:
-		case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
-		case VK_FORMAT_R8_UINT:
-			return 8;
-
-		case VK_FORMAT_R8_UNORM:
-			return 1;
-
-		case VK_FORMAT_D16_UNORM_S8_UINT:
-			return 3;
-
-		case VK_FORMAT_D32_SFLOAT_S8_UINT:
-			return 5;
-
 		default:
-			Refresh_LogError("Invalid texture format!");
+			Refresh_LogError("Texture format not recognized!");
 			return 0;
 	}
 }
 
-static inline uint32_t VULKAN_INTERNAL_GetTextureBlockSize(
+static inline uint32_t VULKAN_INTERNAL_TextureBlockSize(
 	VkFormat format
 ) {
 	switch (format)
@@ -2040,24 +2039,28 @@ static inline uint32_t VULKAN_INTERNAL_GetTextureBlockSize(
 	case VK_FORMAT_R5G6B5_UNORM_PACK16:
 	case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
 	case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
-	case VK_FORMAT_R8G8_SNORM:
-	case VK_FORMAT_R8G8B8A8_SNORM:
 	case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
 	case VK_FORMAT_R16G16_UNORM:
 	case VK_FORMAT_R16G16B16A16_UNORM:
 	case VK_FORMAT_R8_UNORM:
-	case VK_FORMAT_R32_SFLOAT:
+	case VK_FORMAT_R8G8_SNORM:
-	case VK_FORMAT_R32G32_SFLOAT:
+	case VK_FORMAT_R8G8B8A8_SNORM:
-	case VK_FORMAT_R32G32B32A32_SFLOAT:
 	case VK_FORMAT_R16_SFLOAT:
 	case VK_FORMAT_R16G16_SFLOAT:
 	case VK_FORMAT_R16G16B16A16_SFLOAT:
+	case VK_FORMAT_R32_SFLOAT:
+	case VK_FORMAT_R32G32_SFLOAT:
+	case VK_FORMAT_R32G32B32A32_SFLOAT:
 	case VK_FORMAT_R8_UINT:
 	case VK_FORMAT_R8G8_UINT:
 	case VK_FORMAT_R8G8B8A8_UINT:
 	case VK_FORMAT_R16_UINT:
 	case VK_FORMAT_R16G16_UINT:
 	case VK_FORMAT_R16G16B16A16_UINT:
+	case VK_FORMAT_D16_UNORM:
+	case VK_FORMAT_D32_SFLOAT:
+	case VK_FORMAT_D16_UNORM_S8_UINT:
+	case VK_FORMAT_D32_SFLOAT_S8_UINT:
 		return 1;
 	default:
 		Refresh_LogError("Unrecognized texture format!");
@@ -2070,17 +2073,8 @@ static inline VkDeviceSize VULKAN_INTERNAL_BytesPerImage(
 	uint32_t height,
 	VkFormat format
 ) {
-	uint32_t blocksPerRow = width;
+	uint32_t blockSize = VULKAN_INTERNAL_TextureBlockSize(format);
-	uint32_t blocksPerColumn = height;
+	return (width * height * VULKAN_INTERNAL_BytesPerPixel(format)) / (blockSize * blockSize);
-	uint32_t blockSize = VULKAN_INTERNAL_GetTextureBlockSize(format);
-
-	if (blockSize > 1)
-	{
-		blocksPerRow = (width + blockSize - 1) / blockSize;
-		blocksPerColumn = (height + blockSize - 1) / blockSize;
-	}
-
-	return blocksPerRow * blocksPerColumn * VULKAN_INTERNAL_BytesPerPixel(format);
 }
 
 static inline Refresh_SampleCount VULKAN_INTERNAL_GetMaxMultiSampleCount(
@@ -2398,12 +2392,6 @@ static uint8_t VULKAN_INTERNAL_FindMemoryType(
 		}
 	}
 
-	Refresh_LogWarn(
-		"Failed to find memory type %X, required %X, ignored %X",
-		typeFilter,
-		requiredProperties,
-		ignoredProperties
-	);
 	return 0;
 }
 
@@ -2587,7 +2575,6 @@ static uint8_t VULKAN_INTERNAL_AllocateMemory(
 
 		SDL_free(allocation);
 
-		Refresh_LogWarn("vkAllocateMemory: %s", VkErrorMessages(result));
 		return 0;
 	}
 
@@ -2821,7 +2808,6 @@ static uint8_t VULKAN_INTERNAL_BindResourceMemory(
 		SDL_UnlockMutex(renderer->allocatorLock);
 
 		/* Responsibility of the caller to handle being out of memory */
-		Refresh_LogWarn("Failed to allocate memory!");
 		return 2;
 	}
 
@@ -2947,7 +2933,7 @@ static uint8_t VULKAN_INTERNAL_BindMemoryForImage(
 	{
 		memoryTypeIndex = 0;
 		requiredMemoryPropertyFlags = 0;
-		ignoredMemoryPropertyFlags = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT;
+		ignoredMemoryPropertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
 
 		if (isRenderTarget)
 		{
@@ -2993,23 +2979,33 @@ static uint8_t VULKAN_INTERNAL_BindMemoryForBuffer(
 	VulkanRenderer* renderer,
 	VkBuffer buffer,
 	VkDeviceSize size,
+	uint8_t requireHostVisible,
 	uint8_t preferDeviceLocal,
-	uint8_t isTransferBuffer,
+	uint8_t dedicatedAllocation,
 	VulkanMemoryUsedRegion** usedRegion
 ) {
 	uint8_t bindResult = 0;
 	uint32_t memoryTypeIndex = 0;
-	VkMemoryPropertyFlags requiredMemoryPropertyFlags;
+	VkMemoryPropertyFlags requiredMemoryPropertyFlags = 0;
-	VkMemoryPropertyFlags ignoredMemoryPropertyFlags;
+	VkMemoryPropertyFlags ignoredMemoryPropertyFlags = 0;
 	VkMemoryRequirements2KHR memoryRequirements =
 	{
 		VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR,
 		NULL
 	};
 
-	requiredMemoryPropertyFlags =
+	if (requireHostVisible)
-		VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
+	{
-		VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+		requiredMemoryPropertyFlags =
+			VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
+			VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+	}
+	else
+	{
+		ignoredMemoryPropertyFlags =
+			VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
+			VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+	}
 
 	if (preferDeviceLocal)
 	{
@@ -3030,7 +3026,7 @@ static uint8_t VULKAN_INTERNAL_BindMemoryForBuffer(
 			renderer,
 			memoryTypeIndex,
 			&memoryRequirements,
-			isTransferBuffer,
+			dedicatedAllocation,
 			size,
 			buffer,
 			VK_NULL_HANDLE,
@@ -3051,9 +3047,17 @@ static uint8_t VULKAN_INTERNAL_BindMemoryForBuffer(
 	if (bindResult != 1 && preferDeviceLocal)
 	{
 		memoryTypeIndex = 0;
-		requiredMemoryPropertyFlags =
+
-			VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
+		requiredMemoryPropertyFlags = 0;
-			VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+
+		if (requireHostVisible)
+		{
+			requiredMemoryPropertyFlags =
+				VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
+				VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+		}
+
+		ignoredMemoryPropertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
 
 		/* Follow-up for the warning logged by FindMemoryType */
 		if (!renderer->unifiedMemoryWarning)
@@ -3074,7 +3078,7 @@ static uint8_t VULKAN_INTERNAL_BindMemoryForBuffer(
 				renderer,
 				memoryTypeIndex,
 				&memoryRequirements,
-				isTransferBuffer,
+				dedicatedAllocation,
 				size,
 				buffer,
 				VK_NULL_HANDLE,
@@ -3606,6 +3610,8 @@ static void VULKAN_INTERNAL_DestroyCommandPool(
 		SDL_free(commandBuffer->transferBuffers);
 		SDL_free(commandBuffer->boundUniformBuffers);
 		SDL_free(commandBuffer->boundDescriptorSetDatas);
+		SDL_free(commandBuffer->boundComputeBuffers);
+		SDL_free(commandBuffer->boundComputeTextures);
 		SDL_free(commandBuffer->usedBuffers);
 		SDL_free(commandBuffer->usedTextures);
 		SDL_free(commandBuffer->usedSamplers);
@@ -4109,8 +4115,9 @@ static VulkanBuffer* VULKAN_INTERNAL_CreateBuffer(
 	VkDeviceSize size,
 	VulkanResourceAccessType resourceAccessType,
 	VkBufferUsageFlags usage,
+	uint8_t requireHostVisible,
 	uint8_t preferDeviceLocal,
-	uint8_t isTransferBuffer
+	uint8_t dedicatedAllocation
 ) {
 	VulkanBuffer* buffer;
 	VkResult vulkanResult;
@@ -4122,6 +4129,7 @@ static VulkanBuffer* VULKAN_INTERNAL_CreateBuffer(
 	buffer->size = size;
 	buffer->resourceAccessType = resourceAccessType;
 	buffer->usage = usage;
+	buffer->requireHostVisible = requireHostVisible;
 	buffer->preferDeviceLocal = preferDeviceLocal;
 
 	bufferCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
@@ -4145,8 +4153,9 @@ static VulkanBuffer* VULKAN_INTERNAL_CreateBuffer(
 		renderer,
 		buffer->buffer,
 		buffer->size,
+		buffer->requireHostVisible,
 		buffer->preferDeviceLocal,
-		isTransferBuffer,
+		dedicatedAllocation,
 		&buffer->usedRegion
 	);
 
@@ -4203,6 +4212,37 @@ static VulkanUniformBufferPool* VULKAN_INTERNAL_CreateUniformBufferPool(
 	VulkanUniformBufferType uniformBufferType
 ) {
 	VulkanUniformBufferPool* uniformBufferPool = SDL_malloc(sizeof(VulkanUniformBufferPool));
+	VulkanResourceAccessType resourceAccessType;
+
+	if (uniformBufferType == UNIFORM_BUFFER_VERTEX)
+	{
+		resourceAccessType = RESOURCE_ACCESS_VERTEX_SHADER_READ_UNIFORM_BUFFER;
+	}
+	else if (uniformBufferType == UNIFORM_BUFFER_FRAGMENT)
+	{
+		resourceAccessType = RESOURCE_ACCESS_FRAGMENT_SHADER_READ_UNIFORM_BUFFER;
+	}
+	else if (uniformBufferType == UNIFORM_BUFFER_COMPUTE)
+	{
+		resourceAccessType = RESOURCE_ACCESS_COMPUTE_SHADER_READ_UNIFORM_BUFFER;
+	}
+	else
+	{
+		Refresh_LogError("Unrecognized uniform buffer type!");
+		return 0;
+	}
+
+	uniformBufferPool->buffer = VULKAN_INTERNAL_CreateBuffer(
+		renderer,
+		UBO_BUFFER_SIZE,
+		resourceAccessType,
+		VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
+		1,
+		0,
+		1
+	);
+
+	uniformBufferPool->nextAvailableOffset = 0;
 
 	uniformBufferPool->type = uniformBufferType;
 	uniformBufferPool->lock = SDL_CreateMutex();
@@ -4221,6 +4261,7 @@ static VulkanUniformBufferPool* VULKAN_INTERNAL_CreateUniformBufferPool(
 }
 
 static void VULKAN_INTERNAL_BindUniformBuffer(
+	VulkanRenderer *renderer,
 	VulkanCommandBuffer *commandBuffer,
 	VulkanUniformBuffer *uniformBuffer
 ) {
@@ -4237,26 +4278,59 @@ static void VULKAN_INTERNAL_BindUniformBuffer(
 	commandBuffer->boundUniformBufferCount += 1;
 }
 
+/* Buffer indirection so we can cleanly defrag */
+static VulkanBufferContainer* VULKAN_INTERNAL_CreateBufferContainer(
+	VulkanRenderer *renderer,
+	uint32_t sizeInBytes,
+	VulkanResourceAccessType resourceAccessType,
+	VkBufferUsageFlags usageFlags,
+	uint8_t dedicated
+) {
+	VulkanBufferContainer* bufferContainer;
+	VulkanBuffer* buffer;
+
+	/* always set transfer bits so we can defrag */
+	usageFlags |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+
+	buffer = VULKAN_INTERNAL_CreateBuffer(
+		renderer,
+		sizeInBytes,
+		resourceAccessType,
+		usageFlags,
+		0,
+		1,
+		dedicated
+	);
+
+	if (buffer == NULL)
+	{
+		Refresh_LogError("Failed to create buffer!");
+		return NULL;
+	}
+
+	bufferContainer = SDL_malloc(sizeof(VulkanBufferContainer));
+	bufferContainer->vulkanBuffer = buffer;
+	buffer->container = bufferContainer;
+
+	return (VulkanBufferContainer*) bufferContainer;
+}
+
 static uint8_t VULKAN_INTERNAL_CreateUniformBuffer(
 	VulkanRenderer *renderer,
 	VulkanUniformBufferPool *bufferPool
 ) {
-	VulkanResourceAccessType resourceAccessType;
 	VkDescriptorSetLayout descriptorSetLayout;
 
 	if (bufferPool->type == UNIFORM_BUFFER_VERTEX)
 	{
-		resourceAccessType = RESOURCE_ACCESS_VERTEX_SHADER_READ_UNIFORM_BUFFER;
 		descriptorSetLayout = renderer->vertexUniformDescriptorSetLayout;
 	}
 	else if (bufferPool->type == UNIFORM_BUFFER_FRAGMENT)
 	{
-		resourceAccessType = RESOURCE_ACCESS_FRAGMENT_SHADER_READ_UNIFORM_BUFFER;
 		descriptorSetLayout = renderer->fragmentUniformDescriptorSetLayout;
 	}
 	else if (bufferPool->type == UNIFORM_BUFFER_COMPUTE)
 	{
-		resourceAccessType = RESOURCE_ACCESS_COMPUTE_SHADER_READ_UNIFORM_BUFFER;
 		descriptorSetLayout = renderer->computeUniformDescriptorSetLayout;
 	}
 	else
@@ -4265,26 +4339,20 @@ static uint8_t VULKAN_INTERNAL_CreateUniformBuffer(
 		return 0;
 	}
 
-	VulkanUniformBuffer *buffer = SDL_malloc(sizeof(VulkanUniformBuffer));
+	VulkanUniformBuffer *uniformBuffer = SDL_malloc(sizeof(VulkanUniformBuffer));
-	buffer->pool = bufferPool;
+	uniformBuffer->pool = bufferPool;
+	uniformBuffer->poolOffset = bufferPool->nextAvailableOffset;
+	uniformBuffer->offset = 0;
 
-	buffer->vulkanBuffer = VULKAN_INTERNAL_CreateBuffer(
+	bufferPool->nextAvailableOffset += VULKAN_INTERNAL_NextHighestAlignment(UBO_SECTION_SIZE, renderer->minUBOAlignment);
-		renderer,
-		UBO_BUFFER_SIZE,
-		resourceAccessType,
-		VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
-		0,
-		0
-	);
 
-	if (buffer->vulkanBuffer == NULL)
+	if (bufferPool->nextAvailableOffset >= UBO_BUFFER_SIZE)
 	{
-		Refresh_LogError("Failed to create buffer for uniform buffer!");
+		Refresh_LogError("Uniform buffer overflow!");
+		SDL_free(uniformBuffer);
 		return 0;
 	}
 
-	buffer->offset = 0;
-
 	/* Allocate a descriptor set for the uniform buffer */
 
 	if (bufferPool->descriptorPool.availableDescriptorSetCount == 0)
@@ -4294,6 +4362,7 @@ static uint8_t VULKAN_INTERNAL_CreateUniformBuffer(
 			&bufferPool->descriptorPool
 		)) {
 			Refresh_LogError("Failed to add uniform descriptor pool!");
+			SDL_free(uniformBuffer);
 			return 0;
 		}
 	}
@@ -4303,7 +4372,7 @@ static uint8_t VULKAN_INTERNAL_CreateUniformBuffer(
 		bufferPool->descriptorPool.descriptorPools[bufferPool->descriptorPool.descriptorPoolCount - 1],
 		descriptorSetLayout,
 		1,
-		&buffer->descriptorSet
+		&uniformBuffer->descriptorSet
 	)) {
 		Refresh_LogError("Failed to allocate uniform descriptor set!");
 		return 0;
@@ -4321,7 +4390,7 @@ static uint8_t VULKAN_INTERNAL_CreateUniformBuffer(
 		);
 	}
 
-	bufferPool->availableBuffers[bufferPool->availableBufferCount] = buffer;
+	bufferPool->availableBuffers[bufferPool->availableBufferCount] = uniformBuffer;
 	bufferPool->availableBufferCount += 1;
 
 	return 1;
@@ -4331,24 +4400,20 @@ static VulkanUniformBuffer* VULKAN_INTERNAL_CreateDummyUniformBuffer(
 	VulkanRenderer *renderer,
 	VulkanUniformBufferType uniformBufferType
 ) {
-	VulkanResourceAccessType resourceAccessType;
 	VkDescriptorSetLayout descriptorSetLayout;
 	VkWriteDescriptorSet writeDescriptorSet;
 	VkDescriptorBufferInfo descriptorBufferInfo;
 
 	if (uniformBufferType == UNIFORM_BUFFER_VERTEX)
 	{
-		resourceAccessType = RESOURCE_ACCESS_VERTEX_SHADER_READ_UNIFORM_BUFFER;
 		descriptorSetLayout = renderer->vertexUniformDescriptorSetLayout;
 	}
 	else if (uniformBufferType == UNIFORM_BUFFER_FRAGMENT)
 	{
-		resourceAccessType = RESOURCE_ACCESS_FRAGMENT_SHADER_READ_UNIFORM_BUFFER;
 		descriptorSetLayout = renderer->fragmentUniformDescriptorSetLayout;
 	}
 	else if (uniformBufferType == UNIFORM_BUFFER_COMPUTE)
 	{
-		resourceAccessType = RESOURCE_ACCESS_COMPUTE_SHADER_READ_UNIFORM_BUFFER;
 		descriptorSetLayout = renderer->computeUniformDescriptorSetLayout;
 	}
 	else
@@ -4357,17 +4422,9 @@ static VulkanUniformBuffer* VULKAN_INTERNAL_CreateDummyUniformBuffer(
 		return NULL;
 	}
 
-	VulkanUniformBuffer *buffer = SDL_malloc(sizeof(VulkanUniformBuffer));
+	VulkanUniformBuffer *uniformBuffer = SDL_malloc(sizeof(VulkanUniformBuffer));
-
+	uniformBuffer->poolOffset = 0;
-	buffer->vulkanBuffer = VULKAN_INTERNAL_CreateBuffer(
+	uniformBuffer->offset = 0;
-		renderer,
-		UBO_BUFFER_SIZE,
-		resourceAccessType,
-		VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
-		0,
-		0
-	);
-	buffer->offset = 0;
 
 	/* Allocate a descriptor set for the uniform buffer */
 
@@ -4376,12 +4433,12 @@ static VulkanUniformBuffer* VULKAN_INTERNAL_CreateDummyUniformBuffer(
 		renderer->defaultDescriptorPool,
 		descriptorSetLayout,
 		1,
-		&buffer->descriptorSet
+		&uniformBuffer->descriptorSet
 	);
 
 	/* Update the descriptor set for the first and last time! */
 
-	descriptorBufferInfo.buffer = buffer->vulkanBuffer->buffer;
+	descriptorBufferInfo.buffer = renderer->dummyBuffer->buffer;
 	descriptorBufferInfo.offset = 0;
 	descriptorBufferInfo.range = VK_WHOLE_SIZE;
 
@@ -4391,7 +4448,7 @@ static VulkanUniformBuffer* VULKAN_INTERNAL_CreateDummyUniformBuffer(
 	writeDescriptorSet.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
 	writeDescriptorSet.dstArrayElement = 0;
 	writeDescriptorSet.dstBinding = 0;
-	writeDescriptorSet.dstSet = buffer->descriptorSet;
+	writeDescriptorSet.dstSet = uniformBuffer->descriptorSet;
 	writeDescriptorSet.pBufferInfo = &descriptorBufferInfo;
 	writeDescriptorSet.pImageInfo = NULL;
 	writeDescriptorSet.pTexelBufferView = NULL;
@@ -4404,9 +4461,9 @@ static VulkanUniformBuffer* VULKAN_INTERNAL_CreateDummyUniformBuffer(
 		NULL
 	);
 
-	buffer->pool = NULL; /* No pool because this is a dummy */
+	uniformBuffer->pool = NULL; /* No pool because this is a dummy */
 
-	return buffer;
+	return uniformBuffer;
 }
 
 static void VULKAN_INTERNAL_DestroyUniformBufferPool(
@@ -4428,10 +4485,11 @@ static void VULKAN_INTERNAL_DestroyUniformBufferPool(
 	/* This is always destroyed after submissions, so all buffers are available */
 	for (i = 0; i < uniformBufferPool->availableBufferCount; i += 1)
 	{
-		VULKAN_INTERNAL_DestroyBuffer(renderer, uniformBufferPool->availableBuffers[i]->vulkanBuffer);
 		SDL_free(uniformBufferPool->availableBuffers[i]);
 	}
 
+	VULKAN_INTERNAL_DestroyBuffer(renderer, uniformBufferPool->buffer);
+
 	SDL_DestroyMutex(uniformBufferPool->lock);
 	SDL_free(uniformBufferPool->availableBuffers);
 	SDL_free(uniformBufferPool);
@@ -4466,8 +4524,8 @@ static VulkanUniformBuffer* VULKAN_INTERNAL_AcquireUniformBufferFromPool(
 
 	/* Update the descriptor set with the correct range */
 
-	descriptorBufferInfo.buffer = uniformBuffer->vulkanBuffer->buffer;
+	descriptorBufferInfo.buffer = uniformBuffer->pool->buffer->buffer;
-	descriptorBufferInfo.offset = 0;
+	descriptorBufferInfo.offset = uniformBuffer->poolOffset;
 	descriptorBufferInfo.range = blockSize;
 
 	writeDescriptorSet.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
@@ -5106,6 +5164,7 @@ static void VULKAN_INTERNAL_EndCommandBuffer(
 		commandBuffer->computeUniformBuffer != NULL
 	) {
 		VULKAN_INTERNAL_BindUniformBuffer(
+			renderer,
 			commandBuffer,
 			commandBuffer->computeUniformBuffer
 		);
@@ -5146,9 +5205,7 @@ static void VULKAN_DestroyDevice(
 
 	SDL_free(renderer->submittedCommandBuffers);
 
-	VULKAN_INTERNAL_DestroyBuffer(renderer, renderer->dummyVertexUniformBuffer->vulkanBuffer);
+	VULKAN_INTERNAL_DestroyBuffer(renderer, renderer->dummyBuffer);
-	VULKAN_INTERNAL_DestroyBuffer(renderer, renderer->dummyFragmentUniformBuffer->vulkanBuffer);
-	VULKAN_INTERNAL_DestroyBuffer(renderer, renderer->dummyComputeUniformBuffer->vulkanBuffer);
 
 	SDL_free(renderer->dummyVertexUniformBuffer);
 	SDL_free(renderer->dummyFragmentUniformBuffer);
@@ -5371,6 +5428,7 @@ static void VULKAN_DestroyDevice(
 	SDL_free(renderer->computePipelinesToDestroy);
 	SDL_free(renderer->shaderModulesToDestroy);
 	SDL_free(renderer->samplersToDestroy);
+	SDL_free(renderer->framebuffersToDestroy);
 
 	SDL_DestroyMutex(renderer->allocatorLock);
 	SDL_DestroyMutex(renderer->disposeLock);
@@ -7035,8 +7093,6 @@ static Refresh_Buffer* VULKAN_CreateBuffer(
 	Refresh_BufferUsageFlags usageFlags,
 	uint32_t sizeInBytes
 ) {
-	VulkanBufferContainer* bufferContainer;
-	VulkanBuffer* buffer;
 	VulkanResourceAccessType resourceAccessType;
 	VkBufferUsageFlags vulkanUsageFlags =
 		VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
@@ -7070,26 +7126,13 @@ static Refresh_Buffer* VULKAN_CreateBuffer(
 		resourceAccessType = RESOURCE_ACCESS_INDIRECT_BUFFER;
 	}
 
-	buffer = VULKAN_INTERNAL_CreateBuffer(
+	return (Refresh_Buffer*) VULKAN_INTERNAL_CreateBufferContainer(
-		(VulkanRenderer*)driverData,
+		(VulkanRenderer*) driverData,
 		sizeInBytes,
 		resourceAccessType,
 		vulkanUsageFlags,
-		1,
 		0
 	);
-
-	if (buffer == NULL)
-	{
-		Refresh_LogError("Failed to create buffer!");
-		return NULL;
-	}
-
-	bufferContainer = SDL_malloc(sizeof(VulkanBufferContainer));
-	bufferContainer->vulkanBuffer = buffer;
-	buffer->container = bufferContainer;
-
-	return (Refresh_Buffer*) bufferContainer;
 }
 
 /* Setters */
@@ -7170,6 +7213,7 @@ static VulkanTransferBuffer* VULKAN_INTERNAL_AcquireTransferBuffer(
 		RESOURCE_ACCESS_TRANSFER_READ_WRITE,
 		VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
 		1,
+		1,
 		1
 	);
 	transferBuffer->fromPool = 0;
@@ -7209,7 +7253,7 @@ static void VULKAN_SetTextureData(
 	VulkanTransferBuffer *transferBuffer;
 	VkBufferImageCopy imageCopy;
 	uint8_t *stagingBufferPointer;
-	uint32_t blockSize = VULKAN_INTERNAL_GetTextureBlockSize(vulkanTexture->format);
+	uint32_t blockSize = VULKAN_INTERNAL_TextureBlockSize(vulkanTexture->format);
 	uint32_t bufferRowLength;
 	uint32_t bufferImageHeight;
 
@@ -7788,10 +7832,11 @@ static uint32_t VULKAN_PushVertexShaderUniforms(
 	if (
 		vulkanCommandBuffer->vertexUniformBuffer->offset +
 		graphicsPipeline->vertexUniformBlockSize >=
-		UBO_BUFFER_SIZE
+		UBO_SECTION_SIZE
 	) {
 		/* We're out of space in this buffer, bind the old one and acquire a new one */
 		VULKAN_INTERNAL_BindUniformBuffer(
+			renderer,
 			vulkanCommandBuffer,
 			vulkanCommandBuffer->vertexUniformBuffer
 		);
@@ -7805,8 +7850,8 @@ static uint32_t VULKAN_PushVertexShaderUniforms(
 	offset = vulkanCommandBuffer->vertexUniformBuffer->offset;
 
 	VULKAN_INTERNAL_SetBufferData(
-		vulkanCommandBuffer->vertexUniformBuffer->vulkanBuffer,
+		vulkanCommandBuffer->vertexUniformBuffer->pool->buffer,
-		vulkanCommandBuffer->vertexUniformBuffer->offset,
+		vulkanCommandBuffer->vertexUniformBuffer->poolOffset + vulkanCommandBuffer->vertexUniformBuffer->offset,
 		data,
 		dataLengthInBytes
 	);
@@ -7831,10 +7876,11 @@ static uint32_t VULKAN_PushFragmentShaderUniforms(
 	if (
 		vulkanCommandBuffer->fragmentUniformBuffer->offset +
 		graphicsPipeline->fragmentUniformBlockSize >=
-		UBO_BUFFER_SIZE
+		UBO_SECTION_SIZE
 	) {
 		/* We're out of space in this buffer, bind the old one and acquire a new one */
 		VULKAN_INTERNAL_BindUniformBuffer(
+			renderer,
 			vulkanCommandBuffer,
 			vulkanCommandBuffer->fragmentUniformBuffer
 		);
@@ -7848,8 +7894,8 @@ static uint32_t VULKAN_PushFragmentShaderUniforms(
 	offset = vulkanCommandBuffer->fragmentUniformBuffer->offset;
 
 	VULKAN_INTERNAL_SetBufferData(
-		vulkanCommandBuffer->fragmentUniformBuffer->vulkanBuffer,
+		vulkanCommandBuffer->fragmentUniformBuffer->pool->buffer,
-		vulkanCommandBuffer->fragmentUniformBuffer->offset,
+		vulkanCommandBuffer->fragmentUniformBuffer->poolOffset + vulkanCommandBuffer->fragmentUniformBuffer->offset,
 		data,
 		dataLengthInBytes
 	);
@@ -7873,10 +7919,11 @@ static uint32_t VULKAN_PushComputeShaderUniforms(
 	if (
 		vulkanCommandBuffer->computeUniformBuffer->offset +
 		computePipeline->uniformBlockSize >=
-		UBO_BUFFER_SIZE
+		UBO_SECTION_SIZE
 	) {
 		/* We're out of space in this buffer, bind the old one and acquire a new one */
 		VULKAN_INTERNAL_BindUniformBuffer(
+			renderer,
 			vulkanCommandBuffer,
 			vulkanCommandBuffer->computeUniformBuffer
 		);
@@ -7890,8 +7937,8 @@ static uint32_t VULKAN_PushComputeShaderUniforms(
 	offset = vulkanCommandBuffer->computeUniformBuffer->offset;
 
 	VULKAN_INTERNAL_SetBufferData(
-		vulkanCommandBuffer->computeUniformBuffer->vulkanBuffer,
+		vulkanCommandBuffer->computeUniformBuffer->pool->buffer,
-		vulkanCommandBuffer->computeUniformBuffer->offset,
+		vulkanCommandBuffer->computeUniformBuffer->poolOffset + vulkanCommandBuffer->computeUniformBuffer->offset,
 		data,
 		dataLengthInBytes
 	);
@@ -8816,7 +8863,7 @@ static void VULKAN_BeginRenderPass(
 		VULKAN_INTERNAL_ImageMemoryBarrier(
 			renderer,
 			vulkanCommandBuffer->commandBuffer,
-			RESOURCE_ACCESS_COLOR_ATTACHMENT_WRITE,
+			RESOURCE_ACCESS_COLOR_ATTACHMENT_READ_WRITE,
 			VK_IMAGE_ASPECT_COLOR_BIT,
 			0,
 			texture->layerCount,
@@ -8849,7 +8896,7 @@ static void VULKAN_BeginRenderPass(
 		VULKAN_INTERNAL_ImageMemoryBarrier(
 			renderer,
 			vulkanCommandBuffer->commandBuffer,
-			RESOURCE_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE,
+			RESOURCE_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_WRITE,
 			depthAspectFlags,
 			0,
 			texture->layerCount,
@@ -8971,6 +9018,7 @@ static void VULKAN_EndRenderPass(
 		vulkanCommandBuffer->vertexUniformBuffer != NULL
 	) {
 		VULKAN_INTERNAL_BindUniformBuffer(
+			renderer,
 			vulkanCommandBuffer,
 			vulkanCommandBuffer->vertexUniformBuffer
 		);
@@ -8981,6 +9029,7 @@ static void VULKAN_EndRenderPass(
 		vulkanCommandBuffer->fragmentUniformBuffer != NULL
 	) {
 		VULKAN_INTERNAL_BindUniformBuffer(
+			renderer,
 			vulkanCommandBuffer,
 			vulkanCommandBuffer->fragmentUniformBuffer
 		);
@@ -9066,6 +9115,7 @@ static void VULKAN_BindGraphicsPipeline(
 		vulkanCommandBuffer->vertexUniformBuffer != NULL
 	) {
 		VULKAN_INTERNAL_BindUniformBuffer(
+			renderer,
 			vulkanCommandBuffer,
 			vulkanCommandBuffer->vertexUniformBuffer
 		);
@@ -9088,6 +9138,7 @@ static void VULKAN_BindGraphicsPipeline(
 		vulkanCommandBuffer->fragmentUniformBuffer != NULL
 	) {
 		VULKAN_INTERNAL_BindUniformBuffer(
+			renderer,
 			vulkanCommandBuffer,
 			vulkanCommandBuffer->fragmentUniformBuffer
 		);
@@ -9219,6 +9270,7 @@ static void VULKAN_BindComputePipeline(
 		vulkanCommandBuffer->computeUniformBuffer != NULL
 	) {
 		VULKAN_INTERNAL_BindUniformBuffer(
+			renderer,
 			vulkanCommandBuffer,
 			vulkanCommandBuffer->computeUniformBuffer
 		);
@@ -10514,7 +10566,6 @@ static uint8_t VULKAN_INTERNAL_DefragmentMemory(
 	VkBufferCopy bufferCopy;
 	VkImageCopy *imageCopyRegions;
 	VulkanCommandBuffer *commandBuffer;
-	VkCommandBufferBeginInfo beginInfo;
 	uint32_t i, level;
 	VulkanResourceAccessType copyResourceAccessType = RESOURCE_ACCESS_NONE;
 	VulkanResourceAccessType originalResourceAccessType;
@@ -10524,11 +10575,6 @@ static uint8_t VULKAN_INTERNAL_DefragmentMemory(
 	renderer->needDefrag = 0;
 	renderer->defragInProgress = 1;
 
-	beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
-	beginInfo.pNext = NULL;
-	beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
-	beginInfo.pInheritanceInfo = NULL;
-
 	commandBuffer = (VulkanCommandBuffer*) VULKAN_AcquireCommandBuffer((Refresh_Renderer *) renderer);
 
 	if (VULKAN_INTERNAL_FindAllocationToDefragment(
@@ -10561,6 +10607,7 @@ static uint8_t VULKAN_INTERNAL_DefragmentMemory(
 					currentRegion->vulkanBuffer->size,
 					RESOURCE_ACCESS_NONE,
 					currentRegion->vulkanBuffer->usage,
+					currentRegion->vulkanBuffer->requireHostVisible,
 					currentRegion->vulkanBuffer->preferDeviceLocal,
 					0
 				);
@@ -11533,6 +11580,9 @@ static uint8_t VULKAN_INTERNAL_CreateLogicalDevice(
 
 static void VULKAN_INTERNAL_LoadEntryPoints(void)
 {
+	/* Required for MoltenVK support */
+	SDL_setenv("MVK_CONFIG_FULL_IMAGE_VIEW_SWIZZLE", "1", 1);
+
 	/* Load Vulkan entry points */
 	if (SDL_Vulkan_LoadLibrary(NULL) < 0)
 	{
@@ -11705,14 +11755,6 @@ static Refresh_Device* VULKAN_CreateDevice(
 		renderer->physicalDeviceDriverProperties.conformanceVersion.minor,
 		renderer->physicalDeviceDriverProperties.conformanceVersion.patch
 	);
-	Refresh_LogWarn(
-		"\n"
-		"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
-		"! Refresh Vulkan is still in development!	!\n"
-		"! The API is unstable and subject to change	!\n"
-		"! You have been warned!			!\n"
-		"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
-	);
 
 	if (!VULKAN_INTERNAL_CreateLogicalDevice(
 		renderer
@@ -11968,6 +12010,16 @@ static Refresh_Device* VULKAN_CreateDevice(
 
 	/* Dummy Uniform Buffers */
 
+	renderer->dummyBuffer = VULKAN_INTERNAL_CreateBuffer(
+		renderer,
+		16,
+		RESOURCE_ACCESS_GENERAL,
+		VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
+		0,
+		0,
+		1
+	);
+
 	renderer->dummyVertexUniformBuffer = VULKAN_INTERNAL_CreateDummyUniformBuffer(
 		renderer,
 		UNIFORM_BUFFER_VERTEX
@@ -12081,6 +12133,7 @@ static Refresh_Device* VULKAN_CreateDevice(
 			RESOURCE_ACCESS_TRANSFER_READ_WRITE,
 			VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
 			1,
+			1,
 			1
 		);
 

visualc/Refresh.vcxproj

@@ -61,7 +61,7 @@
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>REFRESH_DRIVER_VULKAN;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>REFRESH_DRIVER_VULKAN;REFRESH_DRIVER_D3D11;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>DebugFull</GenerateDebugInformation>
@@ -72,7 +72,7 @@
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>MaxSpeed</Optimization>
-      <PreprocessorDefinitions>REFRESH_DRIVER_VULKAN;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>REFRESH_DRIVER_VULKAN;REFRESH_DRIVER_D3D11;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
     </ClCompile>
@@ -84,6 +84,7 @@
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClCompile Include="..\src\Refresh.c" />
+    <ClCompile Include="..\src\Refresh_Driver_D3D11.c" />
     <ClCompile Include="..\src\Refresh_Driver_Vulkan.c" />
     <ClCompile Include="..\src\Refresh_Image.c" />
   </ItemGroup>
@@ -91,6 +92,7 @@
     <ClInclude Include="..\include\Refresh.h" />
     <ClInclude Include="..\include\Refresh_Image.h" />
     <ClInclude Include="..\src\Refresh_Driver.h" />
+    <ClInclude Include="..\src\Refresh_Driver_D3D11_cdefines.h" />
     <ClInclude Include="..\src\Refresh_Driver_Vulkan_vkfuncs.h" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

visualc/Refresh.vcxproj.filters

@@ -10,6 +10,9 @@
     <ClCompile Include="..\src\Refresh_Image.c">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="..\src\Refresh_Driver_D3D11.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\include\Refresh.h">
@@ -24,6 +27,9 @@
     <ClInclude Include="..\include\Refresh_Image.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="..\src\Refresh_Driver_D3D11_cdefines.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <Filter Include="Header Files">