memory system tweaks

fix incorrect flag bit
force ignore device-local property if allocation failed
2024-02-11 15:56:53 -08:00 · 2024-01-31 14:47:01 -08:00 · 2024-01-31 14:36:02 -08:00 · 2024-01-31 14:26:40 -08:00 · 2024-01-19 10:19:23 -08:00 · 2024-01-15 22:34:31 -08:00
13 changed files with 8882 additions and 5305 deletions
--- a/.editorconfig
+++ b/.editorconfig
@ -0,0 +1,13 @@
+# EditorConfig is awesome: https://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+
+[*]
+indent_style = tab
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.{c,h}]
+charset = utf-8-bom
+max_line_length = 100
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -7,9 +7,9 @@ project(Refresh C)
 option(BUILD_SHARED_LIBS "Build shared library" ON)

 # Version
-SET(LIB_MAJOR_VERSION "0")
-SET(LIB_MINOR_VERSION "1")
-SET(LIB_REVISION "0")
+SET(LIB_MAJOR_VERSION "1")
+SET(LIB_MINOR_VERSION "15")
+SET(LIB_REVISION "4")
 SET(LIB_VERSION "${LIB_MAJOR_VERSION}.${LIB_MINOR_VERSION}.${LIB_REVISION}")

 # Build Type
@ -60,6 +60,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>
--- a/include/Refresh.h
+++ b/include/Refresh.h
@ -1,4 +1,4 @@
-/* Refresh - XNA-inspired 3D Graphics Library with modern capabilities
+/* Refresh - XNA-inspired 3D Graphics Library with modern capabilities
 *
 * Copyright (c) 2020 Evan Hemsley
 *
@ -52,19 +52,31 @@
 extern "C" {
 #endif /* __cplusplus */

+/* Version API */
+
+#define REFRESH_MAJOR_VERSION   1
+#define REFRESH_MINOR_VERSION	15
+#define REFRESH_PATCH_VERSION	4
+
+#define REFRESH_COMPILED_VERSION ( \
+	(REFRESH_MAJOR_VERSION * 100 * 100) + \
+	(REFRESH_MINOR_VERSION * 100) + \
+	(REFRESH_PATCH_VERSION) \
+)
+
+REFRESHAPI uint32_t Refresh_LinkedVersion(void);
+
 /* Type Declarations */

 typedef struct Refresh_Device Refresh_Device;
 typedef struct Refresh_Buffer Refresh_Buffer;
 typedef struct Refresh_Texture Refresh_Texture;
 typedef struct Refresh_Sampler Refresh_Sampler;
-typedef struct Refresh_RenderTarget Refresh_RenderTarget;
-typedef struct Refresh_Framebuffer Refresh_Framebuffer;
 typedef struct Refresh_ShaderModule Refresh_ShaderModule;
-typedef struct Refresh_RenderPass Refresh_RenderPass;
 typedef struct Refresh_ComputePipeline Refresh_ComputePipeline;
 typedef struct Refresh_GraphicsPipeline Refresh_GraphicsPipeline;
 typedef struct Refresh_CommandBuffer Refresh_CommandBuffer;
+typedef struct Refresh_Fence Refresh_Fence;

 typedef enum Refresh_PresentMode
 {
@ -96,15 +108,6 @@ typedef enum Refresh_StoreOp
 	REFRESH_STOREOP_DONT_CARE
 } Refresh_StoreOp;

-typedef enum Refresh_ClearOptionsBits
-{
-    REFRESH_CLEAROPTIONS_COLOR   = 0x00000001,
-    REFRESH_CLEAROPTIONS_DEPTH   = 0x00000002,
-    REFRESH_CLEAROPTIONS_STENCIL = 0x00000004,
-} Refresh_ClearOptionsBits;
-
-typedef uint32_t Refresh_ClearOptions;
-
 typedef enum Refresh_IndexElementSize
 {
 	REFRESH_INDEXELEMENTSIZE_16BIT,
@ -113,26 +116,38 @@ typedef enum Refresh_IndexElementSize

 typedef enum Refresh_TextureFormat
 {
-	/* Color Formats */
+	/* Unsigned Normalized Float Color Formats */
 	REFRESH_TEXTUREFORMAT_R8G8B8A8,
+	REFRESH_TEXTUREFORMAT_B8G8R8A8,
 	REFRESH_TEXTUREFORMAT_R5G6B5,
 	REFRESH_TEXTUREFORMAT_A1R5G5B5,
 	REFRESH_TEXTUREFORMAT_B4G4R4A4,
-    REFRESH_TEXTUREFORMAT_BC1,
-    REFRESH_TEXTUREFORMAT_BC2,
-    REFRESH_TEXTUREFORMAT_BC3,
-    REFRESH_TEXTUREFORMAT_R8G8_SNORM,
-    REFRESH_TEXTUREFORMAT_R8G8B8A8_SNORM,
 	REFRESH_TEXTUREFORMAT_A2R10G10B10,
 	REFRESH_TEXTUREFORMAT_R16G16,
 	REFRESH_TEXTUREFORMAT_R16G16B16A16,
 	REFRESH_TEXTUREFORMAT_R8,
-    REFRESH_TEXTUREFORMAT_R32_SFLOAT,
-    REFRESH_TEXTUREFORMAT_R32G32_SFLOAT,
-    REFRESH_TEXTUREFORMAT_R32G32B32A32_SFLOAT,
+	/* Compressed Unsigned Normalized Float Color Formats */
+	REFRESH_TEXTUREFORMAT_BC1,
+	REFRESH_TEXTUREFORMAT_BC2,
+	REFRESH_TEXTUREFORMAT_BC3,
+	REFRESH_TEXTUREFORMAT_BC7,
+	/* Signed Normalized Float Color Formats  */
+	REFRESH_TEXTUREFORMAT_R8G8_SNORM,
+	REFRESH_TEXTUREFORMAT_R8G8B8A8_SNORM,
+	/* Signed Float Color Formats */
 	REFRESH_TEXTUREFORMAT_R16_SFLOAT,
 	REFRESH_TEXTUREFORMAT_R16G16_SFLOAT,
 	REFRESH_TEXTUREFORMAT_R16G16B16A16_SFLOAT,
+	REFRESH_TEXTUREFORMAT_R32_SFLOAT,
+	REFRESH_TEXTUREFORMAT_R32G32_SFLOAT,
+	REFRESH_TEXTUREFORMAT_R32G32B32A32_SFLOAT,
+	/* Unsigned Integer Color Formats */
+	REFRESH_TEXTUREFORMAT_R8_UINT,
+	REFRESH_TEXTUREFORMAT_R8G8_UINT,
+	REFRESH_TEXTUREFORMAT_R8G8B8A8_UINT,
+	REFRESH_TEXTUREFORMAT_R16_UINT,
+	REFRESH_TEXTUREFORMAT_R16G16_UINT,
+	REFRESH_TEXTUREFORMAT_R16G16B16A16_UINT,
 	/* Depth Formats */
 	REFRESH_TEXTUREFORMAT_D16_UNORM,
 	REFRESH_TEXTUREFORMAT_D32_SFLOAT,
@ -144,7 +159,8 @@ typedef enum Refresh_TextureUsageFlagBits
 {
 	REFRESH_TEXTUREUSAGE_SAMPLER_BIT              = 0x00000001,
 	REFRESH_TEXTUREUSAGE_COLOR_TARGET_BIT         = 0x00000002,
-	REFRESH_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT = 0x00000004
+	REFRESH_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT = 0x00000004,
+	REFRESH_TEXTUREUSAGE_COMPUTE_BIT              = 0X00000008
 } Refresh_TextureUsageFlagBits;

 typedef uint32_t Refresh_TextureUsageFlags;
@ -154,10 +170,7 @@ typedef enum Refresh_SampleCount
 	REFRESH_SAMPLECOUNT_1,
 	REFRESH_SAMPLECOUNT_2,
 	REFRESH_SAMPLECOUNT_4,
-	REFRESH_SAMPLECOUNT_8,
-	REFRESH_SAMPLECOUNT_16,
-	REFRESH_SAMPLECOUNT_32,
-	REFRESH_SAMPLECOUNT_64
+	REFRESH_SAMPLECOUNT_8
 } Refresh_SampleCount;

 typedef enum Refresh_CubeMapFace
@ -174,14 +187,16 @@ typedef enum Refresh_BufferUsageFlagBits
 {
 	REFRESH_BUFFERUSAGE_VERTEX_BIT 	 = 0x00000001,
 	REFRESH_BUFFERUSAGE_INDEX_BIT  	 = 0x00000002,
-	REFRESH_BUFFERUSAGE_COMPUTE_BIT =	0x00000004
+	REFRESH_BUFFERUSAGE_COMPUTE_BIT  = 0x00000004,
+	REFRESH_BUFFERUSAGE_INDIRECT_BIT = 0x00000008
 } Refresh_BufferUsageFlagBits;

 typedef uint32_t Refresh_BufferUsageFlags;

 typedef enum Refresh_VertexElementFormat
 {
-	REFRESH_VERTEXELEMENTFORMAT_SINGLE,
+	REFRESH_VERTEXELEMENTFORMAT_UINT,
+	REFRESH_VERTEXELEMENTFORMAT_FLOAT,
 	REFRESH_VERTEXELEMENTFORMAT_VECTOR2,
 	REFRESH_VERTEXELEMENTFORMAT_VECTOR3,
 	REFRESH_VERTEXELEMENTFORMAT_VECTOR4,
@ -204,16 +219,14 @@ typedef enum Refresh_VertexInputRate
 typedef enum Refresh_FillMode
 {
 	REFRESH_FILLMODE_FILL,
-	REFRESH_FILLMODE_LINE,
-	REFRESH_FILLMODE_POINT
+	REFRESH_FILLMODE_LINE
 } Refresh_FillMode;

 typedef enum Refresh_CullMode
 {
 	REFRESH_CULLMODE_NONE,
 	REFRESH_CULLMODE_FRONT,
-	REFRESH_CULLMODE_BACK,
-	REFRESH_CULLMODE_FRONT_AND_BACK
+	REFRESH_CULLMODE_BACK
 } Refresh_CullMode;

 typedef enum Refresh_FrontFace
@ -255,47 +268,21 @@ typedef enum Refresh_BlendOp
 	REFRESH_BLENDOP_MAX
 } Refresh_BlendOp;

-typedef enum Refresh_LogicOp
-{
-	REFRESH_LOGICOP_CLEAR = 0,
-    REFRESH_LOGICOP_AND = 1,
-    REFRESH_LOGICOP_AND_REVERSE = 2,
-    REFRESH_LOGICOP_COPY = 3,
-    REFRESH_LOGICOP_AND_INVERTED = 4,
-    REFRESH_LOGICOP_NO_OP = 5,
-    REFRESH_LOGICOP_XOR = 6,
-    REFRESH_LOGICOP_OR = 7,
-    REFRESH_LOGICOP_NOR = 8,
-    REFRESH_LOGICOP_EQUIVALENT = 9,
-    REFRESH_LOGICOP_INVERT = 10,
-    REFRESH_LOGICOP_OR_REVERSE = 11,
-    REFRESH_LOGICOP_COPY_INVERTED = 12,
-    REFRESH_LOGICOP_OR_INVERTED = 13,
-    REFRESH_LOGICOP_NAND = 14,
-    REFRESH_LOGICOP_SET = 15
-} Refresh_LogicOp;
-
 typedef enum Refresh_BlendFactor
 {
-    REFRESH_BLENDFACTOR_ZERO = 0,
-    REFRESH_BLENDFACTOR_ONE = 1,
-    REFRESH_BLENDFACTOR_SRC_COLOR = 2,
-    REFRESH_BLENDFACTOR_ONE_MINUS_SRC_COLOR = 3,
-    REFRESH_BLENDFACTOR_DST_COLOR = 4,
-    REFRESH_BLENDFACTOR_ONE_MINUS_DST_COLOR = 5,
-    REFRESH_BLENDFACTOR_SRC_ALPHA = 6,
-    REFRESH_BLENDFACTOR_ONE_MINUS_SRC_ALPHA = 7,
-    REFRESH_BLENDFACTOR_DST_ALPHA = 8,
-    REFRESH_BLENDFACTOR_ONE_MINUS_DST_ALPHA = 9,
-    REFRESH_BLENDFACTOR_CONSTANT_COLOR = 10,
-    REFRESH_BLENDFACTOR_ONE_MINUS_CONSTANT_COLOR = 11,
-    REFRESH_BLENDFACTOR_CONSTANT_ALPHA = 12,
-    REFRESH_BLENDFACTOR_ONE_MINUS_CONSTANT_ALPHA = 13,
-    REFRESH_BLENDFACTOR_SRC_ALPHA_SATURATE = 14,
-    REFRESH_BLENDFACTOR_SRC1_COLOR = 15,
-    REFRESH_BLENDFACTOR_ONE_MINUS_SRC1_COLOR = 16,
-    REFRESH_BLENDFACTOR_SRC1_ALPHA = 17,
-    REFRESH_BLENDFACTOR_ONE_MINUS_SRC1_ALPHA = 18
+	REFRESH_BLENDFACTOR_ZERO,
+	REFRESH_BLENDFACTOR_ONE,
+	REFRESH_BLENDFACTOR_SRC_COLOR,
+	REFRESH_BLENDFACTOR_ONE_MINUS_SRC_COLOR,
+	REFRESH_BLENDFACTOR_DST_COLOR,
+	REFRESH_BLENDFACTOR_ONE_MINUS_DST_COLOR,
+	REFRESH_BLENDFACTOR_SRC_ALPHA,
+	REFRESH_BLENDFACTOR_ONE_MINUS_SRC_ALPHA,
+	REFRESH_BLENDFACTOR_DST_ALPHA,
+	REFRESH_BLENDFACTOR_ONE_MINUS_DST_ALPHA,
+	REFRESH_BLENDFACTOR_CONSTANT_COLOR,
+	REFRESH_BLENDFACTOR_ONE_MINUS_CONSTANT_COLOR,
+	REFRESH_BLENDFACTOR_SRC_ALPHA_SATURATE
 } Refresh_BlendFactor;

 typedef enum Refresh_ColorComponentFlagBits
@ -308,17 +295,10 @@ typedef enum Refresh_ColorComponentFlagBits

 typedef uint32_t Refresh_ColorComponentFlags;

-typedef enum Refresh_ShaderStageType
-{
-	REFRESH_SHADERSTAGE_VERTEX,
-	REFRESH_SHADERSTAGE_FRAGMENT
-} Refresh_ShaderStageType;
-
 typedef enum Refresh_Filter
 {
 	REFRESH_FILTER_NEAREST,
-	REFRESH_FILTER_LINEAR,
-	REFRESH_FILTER_CUBIC
+	REFRESH_FILTER_LINEAR
 } Refresh_Filter;

 typedef enum Refresh_SamplerMipmapMode
@ -338,14 +318,22 @@ typedef enum Refresh_SamplerAddressMode
 /* FIXME: we should probably make a library-level decision about color types */
 typedef enum Refresh_BorderColor
 {
-    REFRESH_BORDERCOLOR_FLOAT_TRANSPARENT_BLACK = 0,
-    REFRESH_BORDERCOLOR_INT_TRANSPARENT_BLACK = 1,
-    REFRESH_BORDERCOLOR_FLOAT_OPAQUE_BLACK = 2,
-    REFRESH_BORDERCOLOR_INT_OPAQUE_BLACK = 3,
-    REFRESH_BORDERCOLOR_FLOAT_OPAQUE_WHITE = 4,
-    REFRESH_BORDERCOLOR_INT_OPAQUE_WHITE = 5
+	REFRESH_BORDERCOLOR_FLOAT_TRANSPARENT_BLACK,
+	REFRESH_BORDERCOLOR_INT_TRANSPARENT_BLACK,
+	REFRESH_BORDERCOLOR_FLOAT_OPAQUE_BLACK,
+	REFRESH_BORDERCOLOR_INT_OPAQUE_BLACK,
+	REFRESH_BORDERCOLOR_FLOAT_OPAQUE_WHITE,
+	REFRESH_BORDERCOLOR_INT_OPAQUE_WHITE
 } Refresh_BorderColor;

+typedef enum Refresh_Backend
+{
+	REFRESH_BACKEND_DONTCARE,
+	REFRESH_BACKEND_VULKAN,
+	REFRESH_BACKEND_PS5,
+	REFRESH_BACKEND_INVALID
+} Refresh_Backend;
+
 /* Structures */

 typedef struct Refresh_DepthStencilValue
@ -389,11 +377,13 @@ typedef struct Refresh_TextureSlice
 	uint32_t level;
 } Refresh_TextureSlice;

-typedef struct Refresh_PresentationParameters
+typedef struct Refresh_IndirectDrawCommand
 {
-	void* deviceWindowHandle;
-	Refresh_PresentMode presentMode;
-} Refresh_PresentationParameters;
+	uint32_t vertexCount;
+	uint32_t instanceCount;
+	uint32_t firstVertex;
+	uint32_t firstInstance;
+} Refresh_IndirectDrawCommand;

 /* State structures */

@ -449,7 +439,7 @@ typedef struct Refresh_StencilOpState
 	uint32_t reference;
 } Refresh_StencilOpState;

-typedef struct Refresh_ColorTargetBlendState
+typedef struct Refresh_ColorAttachmentBlendState
 {
 	uint8_t blendEnable;
 	Refresh_BlendFactor srcColorBlendFactor;
@ -459,43 +449,7 @@ typedef struct Refresh_ColorTargetBlendState
 	Refresh_BlendFactor dstAlphaBlendFactor;
 	Refresh_BlendOp alphaBlendOp;
 	Refresh_ColorComponentFlags colorWriteMask;
-} Refresh_ColorTargetBlendState;
-
-typedef struct Refresh_ComputePipelineLayoutCreateInfo
-{
-	uint32_t bufferBindingCount;
-	uint32_t imageBindingCount;
-} Refresh_ComputePipelineLayoutCreateInfo;
-
-typedef struct Refresh_GraphicsPipelineLayoutCreateInfo
-{
-	uint32_t vertexSamplerBindingCount;
-	uint32_t fragmentSamplerBindingCount;
-} Refresh_GraphicsPipelineLayoutCreateInfo;
-
-typedef struct Refresh_ColorTargetDescription
-{
-	Refresh_TextureFormat format;
-	Refresh_SampleCount multisampleCount;
-	Refresh_LoadOp loadOp;
-	Refresh_StoreOp storeOp;
-} Refresh_ColorTargetDescription;
-
-typedef struct Refresh_DepthStencilTargetDescription
-{
-	Refresh_TextureFormat depthStencilFormat;
-	Refresh_LoadOp loadOp;
-	Refresh_StoreOp storeOp;
-	Refresh_LoadOp stencilLoadOp;
-	Refresh_StoreOp stencilStoreOp;
-} Refresh_DepthStencilTargetDescription;
-
-typedef struct Refresh_RenderPassCreateInfo
-{
-	const Refresh_ColorTargetDescription *colorTargetDescriptions;
-	uint32_t colorTargetCount;
-	const Refresh_DepthStencilTargetDescription *depthTargetDescription; /* can be NULL */
-} Refresh_RenderPassCreateInfo;
+} Refresh_ColorAttachmentBlendState;

 typedef struct Refresh_ShaderModuleCreateInfo
 {
@ -509,32 +463,33 @@ typedef struct Refresh_TextureCreateInfo
 	uint32_t height;
 	uint32_t depth;
 	uint8_t isCube;
-	Refresh_SampleCount sampleCount;
 	uint32_t levelCount;
+	Refresh_SampleCount sampleCount;
 	Refresh_TextureFormat format;
 	Refresh_TextureUsageFlags usageFlags;
 } Refresh_TextureCreateInfo;

 /* Pipeline state structures */

-typedef struct Refresh_ShaderStageState
+typedef struct Refresh_GraphicsShaderInfo
 {
 	Refresh_ShaderModule *shaderModule;
 	const char* entryPointName;
 	uint64_t uniformBufferSize;
-} Refresh_ShaderStageState;
+	uint32_t samplerBindingCount;
+} Refresh_GraphicsShaderInfo;

-typedef struct Refresh_ViewportState
+typedef struct Refresh_ComputeShaderInfo
 {
-	const Refresh_Viewport *viewports;
-	uint32_t viewportCount;
-	const Refresh_Rect *scissors;
-	uint32_t scissorCount;
-} Refresh_ViewportState;
+	Refresh_ShaderModule* shaderModule;
+	const char* entryPointName;
+	uint64_t uniformBufferSize;
+	uint32_t bufferBindingCount;
+	uint32_t imageBindingCount;
+} Refresh_ComputeShaderInfo;

 typedef struct Refresh_RasterizerState
 {
-	uint8_t depthClampEnable;
 	Refresh_FillMode fillMode;
 	Refresh_CullMode cullMode;
 	Refresh_FrontFace frontFace;
@ -542,7 +497,6 @@ typedef struct Refresh_RasterizerState
 	float depthBiasConstantFactor;
 	float depthBiasClamp;
 	float depthBiasSlopeFactor;
-	float lineWidth;
 } Refresh_RasterizerState;

 typedef struct Refresh_MultisampleState
@ -564,111 +518,58 @@ typedef struct Refresh_DepthStencilState
 	float maxDepthBounds;
 } Refresh_DepthStencilState;

-typedef struct Refresh_ColorBlendState
+typedef struct Refresh_ColorAttachmentDescription
 {
-	uint8_t logicOpEnable;
-	Refresh_LogicOp logicOp;
-	const Refresh_ColorTargetBlendState *blendStates;
-	uint32_t blendStateCount;
-	float blendConstants[4];
-} Refresh_ColorBlendState;
+	Refresh_TextureFormat format;
+	Refresh_ColorAttachmentBlendState blendState;
+} Refresh_ColorAttachmentDescription;

-typedef struct Refresh_ComputePipelineCreateInfo
+typedef struct Refresh_GraphicsPipelineAttachmentInfo
 {
-	Refresh_ShaderStageState computeShaderState;
-	Refresh_ComputePipelineLayoutCreateInfo pipelineLayoutCreateInfo;
-} Refresh_ComputePipelineCreateInfo;
+	Refresh_ColorAttachmentDescription *colorAttachmentDescriptions;
+	uint32_t colorAttachmentCount;
+	uint8_t hasDepthStencilAttachment;
+	Refresh_TextureFormat depthStencilFormat;
+} Refresh_GraphicsPipelineAttachmentInfo;

 typedef struct Refresh_GraphicsPipelineCreateInfo
 {
-	Refresh_ShaderStageState vertexShaderState;
-	Refresh_ShaderStageState fragmentShaderState;
+	Refresh_GraphicsShaderInfo vertexShaderInfo;
+	Refresh_GraphicsShaderInfo fragmentShaderInfo;
 	Refresh_VertexInputState vertexInputState;
 	Refresh_PrimitiveType primitiveType;
-	Refresh_ViewportState viewportState;
 	Refresh_RasterizerState rasterizerState;
 	Refresh_MultisampleState multisampleState;
 	Refresh_DepthStencilState depthStencilState;
-	Refresh_ColorBlendState colorBlendState;
-	Refresh_GraphicsPipelineLayoutCreateInfo pipelineLayoutCreateInfo;
-	Refresh_RenderPass *renderPass;
+	Refresh_GraphicsPipelineAttachmentInfo attachmentInfo;
+	float blendConstants[4];
 } Refresh_GraphicsPipelineCreateInfo;

-typedef struct Refresh_FramebufferCreateInfo
+/* Render pass structures */
+
+typedef struct Refresh_ColorAttachmentInfo
 {
-	Refresh_RenderPass *renderPass;
-	Refresh_RenderTarget **pColorTargets;
-	uint32_t colorTargetCount;
-	Refresh_RenderTarget *pDepthStencilTarget;
-	uint32_t width;
-	uint32_t height;
-} Refresh_FramebufferCreateInfo;
+	Refresh_Texture *texture; /* We can't use TextureSlice because render passes take a single rectangle. */
+	uint32_t depth;
+	uint32_t layer;
+	uint32_t level;
+	Refresh_Vec4 clearColor; /* Can be ignored by RenderPass */
+	Refresh_LoadOp loadOp;
+	Refresh_StoreOp storeOp;
+} Refresh_ColorAttachmentInfo;

-/* Interop Structs */
-
-typedef enum Refresh_SysRendererType
+typedef struct Refresh_DepthStencilAttachmentInfo
 {
-	REFRESH_RENDERER_TYPE_VULKAN
-} Refresh_SysRendererType;
-
-typedef struct Refresh_SysRenderer
-{
-	Refresh_SysRendererType rendererType;
-
-	union
-	{
-#if REFRESH_DRIVER_VULKAN
-		struct
-		{
-			void* instance;
-			void* physicalDevice;
-			void* logicalDevice;
-			uint32_t queueFamilyIndex;
-		} vulkan;
-#endif /* REFRESH_DRIVER_VULKAN */
-		uint8_t filler[64];
-	} renderer;
-} Refresh_SysRenderer;
-
-typedef struct Refresh_TextureHandles
-{
-	Refresh_SysRendererType rendererType;
-
-	union
-	{
-#if REFRESH_DRIVER_VULKAN
-
-#if defined(__LP64__) || defined(_WIN64) || defined(__x86_64__) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
-#define REFRESH_VULKAN_HANDLE_TYPE void*
-#else
-#define REFRESH_VULKAN_HANDLE_TYPE uint64_t
-#endif
-
-		struct
-		{
-			REFRESH_VULKAN_HANDLE_TYPE image;	/* VkImage */
-			REFRESH_VULKAN_HANDLE_TYPE view;	/* VkImageView */
-		} vulkan;
-#endif /* REFRESH_DRIVER_VULKAN */
-		uint8_t filler[64];
-	} texture;
-} Refresh_TextureHandles;
-
-/* Version API */
-
-#define REFRESH_ABI_VERSION	 0
-#define REFRESH_MAJOR_VERSION   0
-#define REFRESH_MINOR_VERSION	1
-#define REFRESH_PATCH_VERSION	0
-
-#define REFRESH_COMPILED_VERSION ( \
-	(REFRESH_ABI_VERSION * 100 * 100 * 100) + \
-	(REFRESH_MAJOR_VERSION * 100 * 100) + \
-	(REFRESH_MINOR_VERSION * 100) + \
-	(REFRESH_PATCH_VERSION) \
-)
-
-REFRESHAPI uint32_t Refresh_LinkedVersion(void);
+	Refresh_Texture *texture; /* We can't use TextureSlice because render passes take a single rectangle. */
+	uint32_t depth;
+	uint32_t layer;
+	uint32_t level;
+	Refresh_DepthStencilValue depthStencilClearValue; /* Can be ignored by RenderPass */
+	Refresh_LoadOp loadOp;
+	Refresh_StoreOp storeOp;
+	Refresh_LoadOp stencilLoadOp;
+	Refresh_StoreOp stencilStoreOp;
+} Refresh_DepthStencilAttachmentInfo;

 /* Functions */

@ -688,16 +589,29 @@ REFRESHAPI void Refresh_HookLogFunctions(
 	Refresh_LogFunc error
 );

+/* Backend selection */
+
+/* Select the graphics API backend that Refresh should use.
+ *
+ * Note that Refresh is not required to select your preferred backend
+ * if it detects an incompatibility.
+ *
+ * Returns the backend that will actually be used, and fills in a window flag bitmask.
+ * This bitmask should be used to create all windows that the device claims.
+ *
+ * preferredBackend: The preferred backend that Refresh should select.
+ * flags: A pointer to a bitflag value that will be filled in with required SDL_WindowFlags masks.
+ */
+REFRESHAPI Refresh_Backend Refresh_SelectBackend(Refresh_Backend preferredBackend, uint32_t *flags);
+
 /* Device */

 /* Create a rendering context for use on the calling thread.
+ * You MUST have called Refresh_SelectDriver prior to calling this function.
 *
- * presentationParameters:
- * 		If the windowHandle is NULL, Refresh will run in headless mode.
 * debugMode: Enable debug mode properties.
 */
 REFRESHAPI Refresh_Device* Refresh_CreateDevice(
-	Refresh_PresentationParameters *presentationParameters,
 	uint8_t debugMode
 );

@ -706,30 +620,6 @@ REFRESHAPI void Refresh_DestroyDevice(Refresh_Device *device);

 /* Drawing */

-/* Clears the targets of the currently bound framebuffer.
- * If fewer colors are passed than the number of color targets in the
- * framebuffer, this function will clear the first n color targets.
- *
- * NOTE:
- * 		It is generally recommended to clear in BeginRenderPass
- * 		rather than by calling this function unless necessary.
- *
- * clearRect:	 Area to clear.
- * options:		 Bitflags to specify color/depth/stencil buffers for clearing.
- * colors:		 An array of color values for the cleared color buffers.
- * colorCount:	 The number of colors in the above array.
- * depthStencil: Depth and stencil values for the cleared depth stencil buffer.
- */
-REFRESHAPI void Refresh_Clear(
-	Refresh_Device *device,
-	Refresh_CommandBuffer *commandBuffer,
-	Refresh_Rect *clearRect,
-	Refresh_ClearOptions options,
-	Refresh_Vec4 *colors,
-	uint32_t colorCount,
-	Refresh_DepthStencilValue depthStencil
-);
-
 /* Draws data from vertex/index buffers with instancing enabled.
 *
 * baseVertex:          The starting offset to read from the vertex buffer.
@ -784,6 +674,27 @@ REFRESHAPI void Refresh_DrawPrimitives(
 	uint32_t fragmentParamOffset
 );

+/* Similar to Refresh_DrawPrimitives, but draw parameters are set from a buffer.
+ * The buffer layout should match the layout of Refresh_IndirectDrawCommand.
+ *
+ * buffer:              A buffer containing draw parameters.
+ * offsetInBytes:       The offset to start reading from the draw buffer.
+ * drawCount:           The number of draw parameter sets that should be read from the draw buffer.
+ * stride:              The byte stride between sets of draw parameters.
+ * vertexParamOffset:   The offset of the vertex shader param data.
+ * fragmentParamOffset:	The offset of the fragment shader param data.
+ */
+REFRESHAPI void Refresh_DrawPrimitivesIndirect(
+	Refresh_Device *device,
+	Refresh_CommandBuffer *commandBuffer,
+	Refresh_Buffer *buffer,
+	uint32_t offsetInBytes,
+	uint32_t drawCount,
+	uint32_t stride,
+	uint32_t vertexParamOffset,
+	uint32_t fragmentParamOffset
+);
+
 /* Dispatches work compute items.
 *
 * groupCountX:			Number of local workgroups to dispatch in the X dimension.
@ -802,16 +713,10 @@ REFRESHAPI void Refresh_DispatchCompute(

 /* State Creation */

-/* Returns an allocated RenderPass* object. */
-REFRESHAPI Refresh_RenderPass* Refresh_CreateRenderPass(
-	Refresh_Device *device,
-	Refresh_RenderPassCreateInfo *renderPassCreateInfo
-);
-
 /* Returns an allocated ComputePipeline* object. */
 REFRESHAPI Refresh_ComputePipeline* Refresh_CreateComputePipeline(
 	Refresh_Device *device,
-	Refresh_ComputePipelineCreateInfo *pipelineCreateInfo
+	Refresh_ComputeShaderInfo *computeShaderInfo
 );

 /* Returns an allocated GraphicsPipeline* object. */
@ -826,12 +731,6 @@ REFRESHAPI Refresh_Sampler* Refresh_CreateSampler(
 	Refresh_SamplerStateCreateInfo *samplerStateCreateInfo
 );

-/* Returns an allocated Framebuffer* object. */
-REFRESHAPI Refresh_Framebuffer* Refresh_CreateFramebuffer(
-	Refresh_Device *device,
-	Refresh_FramebufferCreateInfo *framebufferCreateInfo
-);
-
 /* Returns an allocated ShaderModule* object. */
 REFRESHAPI Refresh_ShaderModule* Refresh_CreateShaderModule(
 	Refresh_Device *device,
@ -846,17 +745,6 @@ REFRESHAPI Refresh_Texture* Refresh_CreateTexture(
 	Refresh_TextureCreateInfo *textureCreateInfo
 );

-/* Creates a color target.
- *
- * textureSlice: 		The texture slice that the color target will resolve to.
- * multisampleCount:	The MSAA value for the color target.
- */
-REFRESHAPI Refresh_RenderTarget* Refresh_CreateRenderTarget(
-	Refresh_Device *device,
-	Refresh_TextureSlice *textureSlice,
-	Refresh_SampleCount multisampleCount
-);
-
 /* Creates a buffer.
 *
 * usageFlags:	Specifies how the buffer will be used.
@ -871,6 +759,11 @@ REFRESHAPI Refresh_Buffer* Refresh_CreateBuffer(
 /* Setters */

 /* Uploads image data to a texture object.
+ *
+ * NOTE:
+ *	DO NOT expect this to execute in sequence relative to other commands!
+ *	Calling SetTextureData in a command buffer that also references the
+ *	texture may result in undefined behavior.
 *
 * 	textureSlice:		The texture slice to be updated.
 * 	data:				A pointer to the image data.
@ -893,8 +786,13 @@ REFRESHAPI void Refresh_SetTextureData(
 * yHeight:      The height of the Y plane.
 * uvWidth:      The width of the U/V planes.
 * uvHeight:     The height of the U/V planes.
- * data:	A pointer to the raw YUV image data.
- * dataLength:	The size of the image data in bytes.
+ * yData:        A pointer to the raw Y image data.
+ * uData:        A pointer to the raw U image data.
+ * vData:        A pointer to the raw V image data.
+ * yDataLength:  The size of the Y image data in bytes.
+ * uvDataLength: The size of the UV image data in bytes.
+ * yStride:      The length of a Y image data row in bytes.
+ * uvStride:     The length of a UV image data row in bytes.
 */
 REFRESHAPI void Refresh_SetTextureDataYUV(
 	Refresh_Device *driverData,
@ -906,8 +804,13 @@ REFRESHAPI void Refresh_SetTextureDataYUV(
 	uint32_t yHeight,
 	uint32_t uvWidth,
 	uint32_t uvHeight,
-	void* data,
-	uint32_t dataLength
+	void *yDataPtr,
+	void *uDataPtr,
+	void *vDataPtr,
+	uint32_t yDataLength,
+	uint32_t uvDataLength,
+	uint32_t yStride,
+	uint32_t uvStride
 );

 /* Performs an asynchronous texture-to-texture copy.
@ -1065,30 +968,6 @@ REFRESHAPI void Refresh_QueueDestroyBuffer(
 	Refresh_Buffer *buffer
 );

-/* Sends a color target to be destroyed by the renderer. Note that we call it
- * "QueueDestroy" because it may not be immediately destroyed by the renderer if
- * this is not called from the main thread (for example, if a garbage collector
- * deletes the resource instead of the programmer).
- *
- * renderTarget: The Refresh_ColorTarget to be destroyed.
- */
-REFRESHAPI void Refresh_QueueDestroyRenderTarget(
-	Refresh_Device *device,
-	Refresh_RenderTarget *renderTarget
-);
-
-/* Sends a framebuffer to be destroyed by the renderer. Note that we call it
- * "QueueDestroy" because it may not be immediately destroyed by the renderer if
- * this is not called from the main thread (for example, if a garbage collector
- * deletes the resource instead of the programmer).
- *
- * framebuffer: The Refresh_Framebuffer to be destroyed.
- */
-REFRESHAPI void Refresh_QueueDestroyFramebuffer(
-	Refresh_Device *device,
-	Refresh_Framebuffer *frameBuffer
-);
-
 /* Sends a shader module to be destroyed by the renderer. Note that we call it
 * "QueueDestroy" because it may not be immediately destroyed by the renderer if
 * this is not called from the main thread (for example, if a garbage collector
@ -1101,18 +980,6 @@ REFRESHAPI void Refresh_QueueDestroyShaderModule(
 	Refresh_ShaderModule *shaderModule
 );

-/* Sends a render pass to be destroyed by the renderer. Note that we call it
- * "QueueDestroy" because it may not be immediately destroyed by the renderer if
- * this is not called from the main thread (for example, if a garbage collector
- * deletes the resource instead of the programmer).
- *
- * renderPass: The Refresh_RenderPass to be destroyed.
- */
-REFRESHAPI void Refresh_QueueDestroyRenderPass(
-	Refresh_Device *device,
-	Refresh_RenderPass *renderPass
-);
-
 /* Sends a compute pipeline to be destroyed by the renderer. Note that we call it
 * "QueueDestroy" because it may not be immediately destroyed by the renderer if
 * this is not called from the main thread (for example, if a garbage collector
@ -1140,29 +1007,20 @@ REFRESHAPI void Refresh_QueueDestroyGraphicsPipeline(
 /* Graphics State */

 /* Begins a render pass.
+ * This will also set a default viewport and scissor state.
 *
- * renderPass: The renderpass to begin.
- * framebuffer: The framebuffer to bind for the render pass.
- * renderArea:
- * 		The area affected by the render pass.
- * 		All load, store and resolve operations are restricted
- * 		to the given rectangle.
- * clearValues:
- * 		A pointer to an array of Refresh_Color structures
- * 		that contains clear values for each color target in the
- * 		framebuffer. May be NULL.
- * clearCount: The amount of color structs in the above array.
- * depthStencilClearValue: The depth/stencil clear value. May be NULL.
+ * colorAttachmentInfos:
+ * 		A pointer to an array of Refresh_ColorAttachmentInfo structures
+ * 		that contains render targets and clear values. May be NULL.
+ * colorAttachmentCount: The amount of structs in the above array.
+ * depthStencilAttachmentInfo: The depth/stencil render target and clear value. May be NULL.
 */
 REFRESHAPI void Refresh_BeginRenderPass(
 	Refresh_Device *device,
 	Refresh_CommandBuffer *commandBuffer,
-	Refresh_RenderPass *renderPass,
-	Refresh_Framebuffer *framebuffer,
-	Refresh_Rect *renderArea,
-	Refresh_Vec4 *pColorClearValues,
-	uint32_t colorClearCount,
-	Refresh_DepthStencilValue *depthStencilClearValue
+	Refresh_ColorAttachmentInfo *colorAttachmentInfos,
+	uint32_t colorAttachmentCount,
+	Refresh_DepthStencilAttachmentInfo *depthStencilAttachmentInfo
 );

 /* Ends the current render pass. */
@ -1178,7 +1036,23 @@ REFRESHAPI void Refresh_BindGraphicsPipeline(
 	Refresh_GraphicsPipeline *graphicsPipeline
 );

-/* Binds vertex buffers for use with subsequent draw calls. */
+/* Sets the current viewport state. */
+REFRESHAPI void Refresh_SetViewport(
+	Refresh_Device *device,
+	Refresh_CommandBuffer *commandBuffer,
+	Refresh_Viewport *viewport
+);
+
+/* Sets the current scissor state. */
+REFRESHAPI void Refresh_SetScissor(
+	Refresh_Device *device,
+	Refresh_CommandBuffer *commandBuffer,
+	Refresh_Rect *scissor
+);
+
+/* Binds vertex buffers for use with subsequent draw calls.
+ * Note that this may only be called after binding a graphics pipeline.
+ */
 REFRESHAPI void Refresh_BindVertexBuffers(
 	Refresh_Device *device,
 	Refresh_CommandBuffer *commandBuffer,
@ -1262,6 +1136,41 @@ REFRESHAPI void Refresh_BindComputeTextures(

 /* Submission/Presentation */

+/* Claims a window, creating a swapchain structure for it.
+ * This function MUST be called before any swapchain functions
+ * are called using the window.
+ *
+ * Returns 0 on swapchain creation failure.
+ */
+REFRESHAPI uint8_t Refresh_ClaimWindow(
+	Refresh_Device *device,
+	void *windowHandle,
+	Refresh_PresentMode presentMode
+);
+
+/* Unclaims a window, destroying the swapchain structure for it.
+ * It is good practice to call this when a window is closed to
+ * prevent memory bloat, but windows are automatically unclaimed
+ * by DestroyDevice.
+ */
+REFRESHAPI void Refresh_UnclaimWindow(
+	Refresh_Device *device,
+	void *windowHandle
+);
+
+/* Changes the present mode of the swapchain for the given window. */
+REFRESHAPI void Refresh_SetSwapchainPresentMode(
+	Refresh_Device *device,
+	void *windowHandle,
+	Refresh_PresentMode presentMode
+);
+
+/* Returns the format of the swapchain for the given window. */
+REFRESHAPI Refresh_TextureFormat Refresh_GetSwapchainFormat(
+	Refresh_Device *device,
+	void *windowHandle
+);
+
 /* Returns an allocated Refresh_CommandBuffer* object.
 * This command buffer is managed by the implementation and
 * should NOT be freed by the user.
@ -1270,49 +1179,78 @@ REFRESHAPI void Refresh_BindComputeTextures(
 * 	A command buffer may only be used on the thread that
 * 	it was acquired on. Using it on any other thread is an error.
 *
- * fixed:
- * 	If a command buffer is designated as fixed, it can be
- * 	acquired once, have commands recorded into it, and
- * 	be re-submitted indefinitely.
- *
 */
 REFRESHAPI Refresh_CommandBuffer* Refresh_AcquireCommandBuffer(
-	Refresh_Device *device,
-	uint8_t fixed
+	Refresh_Device *device
 );

-/* Queues an image to be presented to a window.
- * The image will be presented upon the next Refresh_Submit call.
+/* Acquires a texture to use for presentation.
+ * May return NULL under certain conditions.
+ * If NULL, the user must ensure to not use the texture.
+ * Once a swapchain texture is acquired,
+ * it will automatically be presented on command buffer submission.
 *
 * NOTE:
- *		It is an error to call this function in headless mode.
+ * 	It is not recommended to hold a reference to this texture long term.
 *
- * textureSlice:			The texture slice to present.
- * destinationRectangle:	The region of the window to update. Can be NULL.
- * filter:					The filter to use if scaling is required.
- * windowHandle:			The window to present to.
+ * pWidth: A pointer to a uint32 that will be filled with the texture width.
+ * pHeight: A pointer to a uint32 that will be filled with the texture height.
 */
-REFRESHAPI void Refresh_QueuePresent(
+REFRESHAPI Refresh_Texture* Refresh_AcquireSwapchainTexture(
 	Refresh_Device *device,
 	Refresh_CommandBuffer *commandBuffer,
-	Refresh_TextureSlice *textureSlice,
-	Refresh_Rect *destinationRectangle,
-	Refresh_Filter filter,
-	void *windowHandle
+	void *windowHandle,
+	uint32_t *pWidth,
+	uint32_t *pHeight
 );

 /* Submits all of the enqueued commands. */
 REFRESHAPI void Refresh_Submit(
 	Refresh_Device* device,
-	uint32_t commandBufferCount,
-	Refresh_CommandBuffer **pCommandBuffers
+	Refresh_CommandBuffer *commandBuffer
 );

-/* Waits for the previous submission to complete. */
+/* Submits a command buffer and acquires a fence.
+ * You can use the fence to check if or wait until the command buffer has finished processing.
+ * You are responsible for releasing this fence when you are done using it.
+ */
+REFRESHAPI Refresh_Fence* Refresh_SubmitAndAcquireFence(
+	Refresh_Device* device,
+	Refresh_CommandBuffer *commandBuffer
+);
+
+/* Waits for the device to become idle. */
 REFRESHAPI void Refresh_Wait(
 	Refresh_Device *device
 );

+/* Waits for given fences to be signaled.
+ *
+ * waitAll: If 0, waits for any fence to be signaled. If 1, waits for all fences to be signaled.
+ * fenceCount: The number of fences being submitted.
+ * pFences: An array of fences to be waited on.
+ */
+REFRESHAPI void Refresh_WaitForFences(
+	Refresh_Device *device,
+	uint8_t waitAll,
+	uint32_t fenceCount,
+	Refresh_Fence **pFences
+);
+
+/* Check the status of a fence. 1 means the fence is signaled. */
+REFRESHAPI int Refresh_QueryFence(
+	Refresh_Device *device,
+	Refresh_Fence *fence
+);
+
+/* Allows the fence to be reused by future command buffer submissions.
+ * If you do not release fences after acquiring them, you will cause unbounded resource growth.
+ */
+REFRESHAPI void Refresh_ReleaseFence(
+	Refresh_Device *device,
+	Refresh_Fence *fence
+);
+
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
--- a/include/Refresh_Image.h
+++ b/include/Refresh_Image.h
@ -44,42 +44,45 @@
 extern "C" {
 #endif /* __cplusplus */

-/* Decodes PNG data into raw RGBA8 texture data.
+/* Image Read API */
+
+/* Decodes image data into raw RGBA8 texture data.
 *
 * w:		    Filled with the width of the image.
 * h:		    Filled with the height of the image.
- * numChannels: Filled with the number of channels in the image.
+ * len:			Filled with the length of pixel data in bytes.
 *
 * Returns a block of memory suitable for use with Refresh_SetTextureData2D.
 * Be sure to free the memory with Refresh_Image_Free after use!
 */
 REFRESHAPI uint8_t* Refresh_Image_Load(
-    char const *filename,
+	uint8_t *bufferPtr,
+	int32_t bufferLength,
 	int32_t *w,
 	int32_t *h,
-    int32_t *numChannels
+	int32_t *len
 );

-/* Frees memory returned by Refresh_Image_Load. (Do NOT free the memory yourself!)
+/* Frees memory returned by Refresh_Image_Load. Do NOT free the memory yourself!
 *
- * mem: A pointer previously returned by Refresh_Image_Load.
+ * mem: A pointer previously returned by Refresh_Image_LoadPNG.
 */
 REFRESHAPI void Refresh_Image_Free(uint8_t *mem);

 /* Image Write API */

-/* Encodes RGBA8 image data into PNG data.
+/* Returns a buffer of PNG encoded from RGBA8 color data.
 *
- * filename:    The filename that the image will be written to.
- * w:	        The width of the PNG data.
- * h:	        The height of the PNG data.
- * data:	    The raw RGBA8 image data.
+ * data:	The raw color data.
+ * w:		The width of the color data.
+ * h:		The height of the color data.
+ * len:		Filled with the length of PNG data in bytes.
 */
 REFRESHAPI void Refresh_Image_SavePNG(
-    char const *filename,
+	const char* filename,
+	uint8_t* data,
 	int32_t w,
-    int32_t h,
-	uint8_t *data
+	int32_t h
 );

 #ifdef __cplusplus
--- a/shadercompiler/Program.cs
+++ b/shadercompiler/Program.cs
@ -0,0 +1,268 @@
+using System;
+using System.IO;
+using System.Diagnostics;
+
+partial class Program
+{
+	struct CompileShaderData
+	{
+		public string glslPath;
+		public string outputDir;
+		public bool preserveTemp;
+		public bool vulkan;
+		public bool d3d11;
+		public bool ps5;
+	}
+
+	private static void DisplayHelpText()
+	{
+		Console.WriteLine("Usage: refreshc <path-to-glsl-source | directory-with-glsl-source-files>");
+		Console.WriteLine("Options:");
+		Console.WriteLine("  --vulkan           Emit shader compatible with the Refresh Vulkan backend");
+		Console.WriteLine("  --d3d11            Emit shader compatible with the Refresh D3D11 backend");
+		Console.WriteLine("  --ps5              Emit shader compatible with the Refresh PS5 backend");
+		Console.WriteLine("  --out dir          Write output file(s) to the directory `dir`");
+		Console.WriteLine("  --preserve-temp    Do not delete the temp directory after compilation. Useful for debugging.");
+	}
+
+	public static int Main(string[] args)
+	{
+		if (args.Length == 0)
+		{
+			DisplayHelpText();
+			return 1;
+		}
+
+		CompileShaderData data = new CompileShaderData();
+		string inputPath = null;
+
+		for (int i = 0; i < args.Length; i += 1)
+		{
+			switch (args[i])
+			{
+				case "--vulkan":
+					data.vulkan = true;
+					break;
+
+				case "--d3d11":
+					data.d3d11 = true;
+					break;
+
+				case "--ps5":
+					data.ps5 = true;
+					break;
+
+				case "--out":
+					i += 1;
+					data.outputDir = args[i];
+					break;
+
+				case "--preserve-temp":
+					data.preserveTemp = true;
+					break;
+
+				default:
+					if (inputPath == null)
+					{
+						inputPath = args[i];
+					}
+					else
+					{
+						Console.WriteLine($"refreshc: Unknown parameter {args[i]}");
+						return 1;
+					}
+					break;
+			}
+		}
+
+		if (!data.vulkan && !data.d3d11 && !data.ps5)
+		{
+			Console.WriteLine($"refreshc: No Refresh platforms selected!");
+			return 1;
+		}
+
+#if !PS5
+		if (data.ps5)
+		{
+			Console.WriteLine($"refreshc: `PS5` must be defined in the to target the PS5 backend!");
+			return 1;
+		}
+#endif
+
+		if (data.outputDir == null)
+		{
+			data.outputDir = Directory.GetCurrentDirectory();
+		}
+		else if (!Directory.Exists(data.outputDir))
+		{
+			Console.WriteLine($"refreshc: Output directory {data.outputDir} does not exist");
+			return 1;
+		}
+
+		if (Directory.Exists(inputPath))
+		{
+			// Loop over and compile each file in the directory
+			string[] files = Directory.GetFiles(inputPath);
+			foreach (string file in files)
+			{
+				Console.WriteLine($"Compiling {file}");
+				data.glslPath = file;
+				int res = CompileShader(ref data);
+				if (res != 0)
+				{
+					return res;
+				}
+			}
+		}
+		else
+		{
+			if (!File.Exists(inputPath))
+			{
+				Console.WriteLine($"refreshc: glsl source file or directory ({inputPath}) does not exist");
+				return 1;
+			}
+
+			data.glslPath = inputPath;
+			int res = CompileShader(ref data);
+			if (res != 0)
+			{
+				return res;
+			}
+		}
+
+		return 0;
+	}
+
+	static int CompileShader(ref CompileShaderData data)
+	{
+		int res = 0;
+		string shaderName = Path.GetFileNameWithoutExtension(data.glslPath);
+		string shaderType = Path.GetExtension(data.glslPath);
+
+		if (shaderType != ".vert" && shaderType != ".frag" && shaderType != ".comp")
+		{
+			Console.WriteLine("refreshc: Expected glsl source file with extension '.vert', '.frag', or '.comp'");
+			return 1;
+		}
+
+		// Create the temp directory, if needed
+		string tempDir = Path.Combine(Directory.GetCurrentDirectory(), "temp");
+		if (!Directory.Exists(tempDir))
+		{
+			Directory.CreateDirectory(tempDir);
+		}
+
+		// Compile to spirv
+		string spirvPath = Path.Combine(tempDir, $"{shaderName}.spv");
+		res = CompileGlslToSpirv(data.glslPath, shaderName, spirvPath);
+		if (res != 0)
+		{
+			goto cleanup;
+		}
+
+		if (data.d3d11 || data.ps5)
+		{
+			// Transpile to hlsl
+			string hlslPath = Path.Combine(tempDir, $"{shaderName}.hlsl");
+			res = TranslateSpirvToHlsl(spirvPath, hlslPath);
+			if (res != 0)
+			{
+				goto cleanup;
+			}
+
+			// FIXME: Is there a cross-platform way to compile HLSL to DXBC?
+
+#if PS5
+			// Transpile to ps5, if requested
+			if (data.ps5)
+			{
+				res = TranslateHlslToPS5(hlslPath, shaderName, shaderType, tempDir);
+				if (res != 0)
+				{
+					goto cleanup;
+				}
+			}
+#endif
+		}
+
+		// Create the output blob file
+		string outputFilepath = Path.Combine(data.outputDir, $"{shaderName}{shaderType}.refresh");
+		using (FileStream fs = File.Create(outputFilepath))
+		{
+			using (BinaryWriter writer = new BinaryWriter(fs))
+			{
+				// Magic
+				writer.Write(new char[] { 'R', 'F', 'S', 'H'});
+
+				if (data.vulkan)
+				{
+					string inputPath = Path.Combine(tempDir, $"{shaderName}.spv");
+					WriteShaderBlob(writer, inputPath, 1);
+				}
+
+#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);
+				}
+			}
+		}
+
+	cleanup:
+		// Clean up the temp directory
+		if (!data.preserveTemp)
+		{
+			Directory.Delete(tempDir, true);
+		}
+		return res;
+	}
+
+	static void WriteShaderBlob(BinaryWriter writer, string inputPath, byte backend)
+	{
+		byte[] shaderBlob = File.ReadAllBytes(inputPath);
+		writer.Write(backend); // Corresponds to Refresh_Backend
+		writer.Write(shaderBlob.Length);
+		writer.Write(shaderBlob);
+	}
+
+	static int CompileGlslToSpirv(string glslPath, string shaderName, string outputPath)
+	{
+		Process glslc = Process.Start(
+			"glslc",
+			$"\"{glslPath}\" -o \"{outputPath}\""
+		);
+		glslc.WaitForExit();
+		if (glslc.ExitCode != 0)
+		{
+			Console.WriteLine($"refreshc: Could not compile GLSL code");
+			return 1;
+		}
+
+		return 0;
+	}
+
+	static int TranslateSpirvToHlsl(string spirvPath, string outputPath)
+	{
+		Process spirvcross = Process.Start(
+			"spirv-cross",
+			$"\"{spirvPath}\" --hlsl --shader-model 50 --output \"{outputPath}\""
+		);
+		spirvcross.WaitForExit();
+		if (spirvcross.ExitCode != 0)
+		{
+			Console.WriteLine($"refreshc: Could not translate SPIR-V to HLSL");
+			return 1;
+		}
+
+		return 0;
+	}
+}
--- a/shadercompiler/refreshc.csproj
+++ b/shadercompiler/refreshc.csproj
@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net7.0</TargetFramework>
+    <TargetName>refreshc</TargetName>
+	<PublishAot>true</PublishAot>
+  </PropertyGroup>
+
+</Project>
--- a/src/Refresh.c
+++ b/src/Refresh.c
@ -1,4 +1,4 @@
-/* Refresh - XNA-inspired 3D Graphics Library with modern capabilities
+/* Refresh - XNA-inspired 3D Graphics Library with modern capabilities
 *
 * Copyright (c) 2020 Evan Hemsley
 *
@ -33,9 +33,22 @@

 /* Drivers */

-static const Refresh_Driver *drivers[] = {
-    &VulkanDriver,
-    NULL
+#ifdef REFRESH_DRIVER_VULKAN
+	#define VULKAN_DRIVER &VulkanDriver
+#else
+	#define VULKAN_DRIVER NULL
+#endif
+
+#ifdef REFRESH_DRIVER_PS5
+	#define PS5_DRIVER &PS5Driver
+#else
+	#define PS5_DRIVER NULL
+#endif
+
+static const Refresh_Driver *backends[] = {
+	NULL,
+	VULKAN_DRIVER,
+	PS5_DRIVER
 };

 /* Logging */
@ -124,19 +137,55 @@ uint32_t Refresh_LinkedVersion(void)

 /* Driver Functions */

-static int32_t selectedDriver = 0;
+static Refresh_Backend selectedBackend = REFRESH_BACKEND_INVALID;
+
+Refresh_Backend Refresh_SelectBackend(Refresh_Backend preferredBackend, uint32_t *flags)
+{
+	uint32_t i;
+
+	if (preferredBackend != REFRESH_BACKEND_DONTCARE)
+	{
+		if (backends[preferredBackend] == NULL)
+		{
+			Refresh_LogWarn("Preferred backend was not compiled into this binary! Attempting to fall back!");
+		}
+		else if (backends[preferredBackend]->PrepareDriver(flags))
+		{
+			selectedBackend = preferredBackend;
+			return selectedBackend;
+		}
+	}
+
+	/* Iterate until we find an appropriate backend. */
+
+	for (i = 1; i < SDL_arraysize(backends); i += 1)
+	{
+		if (i != preferredBackend && backends[i] != NULL && backends[i]->PrepareDriver(flags))
+		{
+			selectedBackend = i;
+			return i;
+		}
+	}
+
+	if (backends[i] == NULL)
+	{
+		Refresh_LogError("No supported Refresh backend found!");
+	}
+
+	selectedBackend = REFRESH_BACKEND_INVALID;
+	return REFRESH_BACKEND_INVALID;
+}

 Refresh_Device* Refresh_CreateDevice(
-    Refresh_PresentationParameters *presentationParameters,
 	uint8_t debugMode
 ) {
-    if (selectedDriver < 0)
+	if (selectedBackend == REFRESH_BACKEND_INVALID)
 	{
+		Refresh_LogError("Invalid backend selection. Did you call Refresh_SelectBackend?");
 		return NULL;
 	}

-    return drivers[selectedDriver]->CreateDevice(
-        presentationParameters,
+	return backends[selectedBackend]->CreateDevice(
 		debugMode
 	);
 }
@ -147,27 +196,6 @@ void Refresh_DestroyDevice(Refresh_Device *device)
 	device->DestroyDevice(device);
 }

-void Refresh_Clear(
-    Refresh_Device *device,
-	Refresh_CommandBuffer *commandBuffer,
-	Refresh_Rect *clearRect,
-	Refresh_ClearOptions options,
-	Refresh_Vec4 *colors,
-	uint32_t colorCount,
-    Refresh_DepthStencilValue depthStencil
-) {
-    NULL_RETURN(device);
-    device->Clear(
-        device->driverData,
-        commandBuffer,
-        clearRect,
-        options,
-        colors,
-        colorCount,
-        depthStencil
-    );
-}
-
 void Refresh_DrawIndexedPrimitives(
 	Refresh_Device *device,
 	Refresh_CommandBuffer *commandBuffer,
@ -231,6 +259,29 @@ void Refresh_DrawPrimitives(
 	);
 }

+void Refresh_DrawPrimitivesIndirect(
+	Refresh_Device *device,
+	Refresh_CommandBuffer *commandBuffer,
+	Refresh_Buffer *buffer,
+	uint32_t offsetInBytes,
+	uint32_t drawCount,
+	uint32_t stride,
+	uint32_t vertexParamOffset,
+	uint32_t fragmentParamOffset
+) {
+	NULL_RETURN(device);
+	device->DrawPrimitivesIndirect(
+		device->driverData,
+		commandBuffer,
+		buffer,
+		offsetInBytes,
+		drawCount,
+		stride,
+		vertexParamOffset,
+		fragmentParamOffset
+	);
+}
+
 void Refresh_DispatchCompute(
 	Refresh_Device *device,
 	Refresh_CommandBuffer *commandBuffer,
@ -250,25 +301,14 @@ void Refresh_DispatchCompute(
 	);
 }

-Refresh_RenderPass* Refresh_CreateRenderPass(
-	Refresh_Device *device,
-	Refresh_RenderPassCreateInfo *renderPassCreateInfo
-) {
-    NULL_RETURN_NULL(device);
-    return device->CreateRenderPass(
-        device->driverData,
-        renderPassCreateInfo
-    );
-}
-
 Refresh_ComputePipeline* Refresh_CreateComputePipeline(
 	Refresh_Device *device,
-    Refresh_ComputePipelineCreateInfo *pipelineCreateInfo
+	Refresh_ComputeShaderInfo *computeShaderInfo
 ) {
 	NULL_RETURN_NULL(device);
 	return device->CreateComputePipeline(
 		device->driverData,
-        pipelineCreateInfo
+		computeShaderInfo
 	);
 }

@ -294,25 +334,56 @@ Refresh_Sampler* Refresh_CreateSampler(
 	);
 }

-Refresh_Framebuffer* Refresh_CreateFramebuffer(
-	Refresh_Device *device,
-	Refresh_FramebufferCreateInfo *framebufferCreateInfo
-) {
-    NULL_RETURN_NULL(device);
-    return device->CreateFramebuffer(
-        device->driverData,
-        framebufferCreateInfo
-    );
-}
-
 Refresh_ShaderModule* Refresh_CreateShaderModule(
 	Refresh_Device *device,
 	Refresh_ShaderModuleCreateInfo *shaderModuleCreateInfo
 ) {
+	Refresh_ShaderModuleCreateInfo driverSpecificCreateInfo = { 0, NULL };
+	uint8_t *bytes;
+	uint32_t i, size;
+
 	NULL_RETURN_NULL(device);
+
+	/* verify the magic number in the shader blob header */
+	bytes = (uint8_t*) shaderModuleCreateInfo->byteCode;
+	if (bytes[0] != 'R' || bytes[1] != 'F' || bytes[2] != 'S' || bytes[3] != 'H')
+	{
+		Refresh_LogError("Cannot parse malformed Refresh shader blob!");
+		return NULL;
+	}
+
+	/* find the code for the selected backend */
+	i = 4;
+	while (i < shaderModuleCreateInfo->codeSize)
+	{
+		size = *((uint32_t*) &bytes[i + 1]);
+
+		if (bytes[i] == (uint8_t) selectedBackend)
+		{
+			driverSpecificCreateInfo.codeSize = size;
+			driverSpecificCreateInfo.byteCode = (uint32_t*) &bytes[i + 1 + sizeof(uint32_t)];
+			break;
+		}
+		else
+		{
+			/* skip over the backend byte, the blob size, and the blob */
+			i += 1 + sizeof(uint32_t) + size;
+		}
+	}
+
+	/* verify the shader blob supports the selected backend */
+	if (driverSpecificCreateInfo.byteCode == NULL)
+	{
+		Refresh_LogError(
+			"Cannot create shader module that does not contain shader code for the selected backend! "
+			"Recompile your shader and enable this backend."
+		);
+		return NULL;
+	}
+
 	return device->CreateShaderModule(
 		device->driverData,
-        shaderModuleCreateInfo
+		&driverSpecificCreateInfo
 	);
 }

@ -327,19 +398,6 @@ Refresh_Texture* Refresh_CreateTexture(
 	);
 }

-Refresh_RenderTarget* Refresh_CreateRenderTarget(
-	Refresh_Device *device,
-	Refresh_TextureSlice *textureSlice,
-    Refresh_SampleCount multisampleCount
-) {
-    NULL_RETURN_NULL(device);
-    return device->CreateRenderTarget(
-        device->driverData,
-        textureSlice,
-        multisampleCount
-    );
-}
-
 Refresh_Buffer* Refresh_CreateBuffer(
 	Refresh_Device *device,
 	Refresh_BufferUsageFlags usageFlags,
@ -380,8 +438,13 @@ void Refresh_SetTextureDataYUV(
 	uint32_t yHeight,
 	uint32_t uvWidth,
 	uint32_t uvHeight,
-	void* data,
-	uint32_t dataLength
+	void *yDataPtr,
+	void *uDataPtr,
+	void *vDataPtr,
+	uint32_t yDataLength,
+	uint32_t uvDataLength,
+	uint32_t yStride,
+	uint32_t uvStride
 ) {
 	NULL_RETURN(device);
 	device->SetTextureDataYUV(
@ -394,8 +457,13 @@ void Refresh_SetTextureDataYUV(
 		yHeight,
 		uvWidth,
 		uvHeight,
-        data,
-        dataLength
+		yDataPtr,
+		uDataPtr,
+		vDataPtr,
+		yDataLength,
+		uvDataLength,
+		yStride,
+		uvStride
 	);
 }

@ -573,28 +641,6 @@ void Refresh_QueueDestroyBuffer(
 	);
 }

-void Refresh_QueueDestroyRenderTarget(
-	Refresh_Device *device,
-	Refresh_RenderTarget *renderTarget
-) {
-    NULL_RETURN(device);
-    device->QueueDestroyRenderTarget(
-        device->driverData,
-        renderTarget
-    );
-}
-
-void Refresh_QueueDestroyFramebuffer(
-	Refresh_Device *device,
-	Refresh_Framebuffer *frameBuffer
-) {
-    NULL_RETURN(device);
-    device->QueueDestroyFramebuffer(
-        device->driverData,
-        frameBuffer
-    );
-}
-
 void Refresh_QueueDestroyShaderModule(
 	Refresh_Device *device,
 	Refresh_ShaderModule *shaderModule
@ -606,17 +652,6 @@ void Refresh_QueueDestroyShaderModule(
 	);
 }

-void Refresh_QueueDestroyRenderPass(
-	Refresh_Device *device,
-	Refresh_RenderPass *renderPass
-) {
-    NULL_RETURN(device);
-    device->QueueDestroyRenderPass(
-        device->driverData,
-        renderPass
-    );
-}
-
 void Refresh_QueueDestroyComputePipeline(
 	Refresh_Device *device,
 	Refresh_ComputePipeline *computePipeline
@ -642,23 +677,17 @@ void Refresh_QueueDestroyGraphicsPipeline(
 void Refresh_BeginRenderPass(
 	Refresh_Device *device,
 	Refresh_CommandBuffer *commandBuffer,
-	Refresh_RenderPass *renderPass,
-	Refresh_Framebuffer *framebuffer,
-	Refresh_Rect *renderArea,
-	Refresh_Vec4 *pColorClearValues,
-	uint32_t colorClearCount,
-	Refresh_DepthStencilValue *depthStencilClearValue
+	Refresh_ColorAttachmentInfo *colorAttachmentInfos,
+	uint32_t colorAttachmentCount,
+	Refresh_DepthStencilAttachmentInfo *depthStencilAttachmentInfo
 ) {
 	NULL_RETURN(device);
 	device->BeginRenderPass(
 		device->driverData,
 		commandBuffer,
-        renderPass,
-        framebuffer,
-        renderArea,
-        pColorClearValues,
-        colorClearCount,
-        depthStencilClearValue
+		colorAttachmentInfos,
+		colorAttachmentCount,
+		depthStencilAttachmentInfo
 	);
 }

@ -673,6 +702,32 @@ void Refresh_EndRenderPass(
 	);
 }

+void Refresh_SetViewport(
+	Refresh_Device *device,
+	Refresh_CommandBuffer *commandBuffer,
+	Refresh_Viewport *viewport
+) {
+	NULL_RETURN(device)
+	device->SetViewport(
+		device->driverData,
+		commandBuffer,
+		viewport
+	);
+}
+
+void Refresh_SetScissor(
+	Refresh_Device *device,
+	Refresh_CommandBuffer *commandBuffer,
+	Refresh_Rect *scissor
+) {
+	NULL_RETURN(device)
+	device->SetScissor(
+		device->driverData,
+		commandBuffer,
+		scissor
+	);
+}
+
 void Refresh_BindGraphicsPipeline(
 	Refresh_Device *device,
 	Refresh_CommandBuffer *commandBuffer,
@ -761,46 +816,99 @@ void Refresh_BindComputeTextures(
 	);
 }

-Refresh_CommandBuffer* Refresh_AcquireCommandBuffer(
+uint8_t Refresh_ClaimWindow(
 	Refresh_Device *device,
-    uint8_t fixed
+	void *windowHandle,
+	Refresh_PresentMode presentMode
 ) {
-    NULL_RETURN_NULL(device);
-    return device->AcquireCommandBuffer(
+	if (device == NULL) { return 0; }
+	return device->ClaimWindow(
 		device->driverData,
-        fixed
+		windowHandle,
+		presentMode
 	);
 }

-void Refresh_QueuePresent(
+void Refresh_UnclaimWindow(
 	Refresh_Device *device,
-    Refresh_CommandBuffer *commandBuffer,
-    Refresh_TextureSlice* textureSlice,
-    Refresh_Rect *destinationRectangle,
-    Refresh_Filter filter,
 	void *windowHandle
 ) {
 	NULL_RETURN(device);
-    device->QueuePresent(
+	device->UnclaimWindow(
+		device->driverData,
+		windowHandle
+	);
+}
+
+Refresh_CommandBuffer* Refresh_AcquireCommandBuffer(
+	Refresh_Device *device
+) {
+	NULL_RETURN_NULL(device);
+	return device->AcquireCommandBuffer(
+		device->driverData
+	);
+}
+
+Refresh_Texture* Refresh_AcquireSwapchainTexture(
+	Refresh_Device *device,
+	Refresh_CommandBuffer *commandBuffer,
+	void *windowHandle,
+	uint32_t *pWidth,
+	uint32_t *pHeight
+) {
+	NULL_RETURN_NULL(device);
+	return device->AcquireSwapchainTexture(
 		device->driverData,
 		commandBuffer,
-        textureSlice,
-        destinationRectangle,
-        filter,
+		windowHandle,
+		pWidth,
+		pHeight
+	);
+}
+
+Refresh_TextureFormat Refresh_GetSwapchainFormat(
+	Refresh_Device *device,
+	void *windowHandle
+) {
+	if (device == NULL) { return 0; }
+	return device->GetSwapchainFormat(
+		device->driverData,
 		windowHandle
 	);
 }

+void Refresh_SetSwapchainPresentMode(
+	Refresh_Device *device,
+	void *windowHandle,
+	Refresh_PresentMode presentMode
+) {
+	NULL_RETURN(device);
+	device->SetSwapchainPresentMode(
+		device->driverData,
+		windowHandle,
+		presentMode
+	);
+}
+
 void Refresh_Submit(
 	Refresh_Device *device,
-	uint32_t commandBufferCount,
-	Refresh_CommandBuffer **pCommandBuffers
+	Refresh_CommandBuffer *commandBuffer
 ) {
 	NULL_RETURN(device);
 	device->Submit(
 		device->driverData,
-        commandBufferCount,
-        pCommandBuffers
+		commandBuffer
+	);
+}
+
+Refresh_Fence* Refresh_SubmitAndAcquireFence(
+	Refresh_Device *device,
+	Refresh_CommandBuffer *commandBuffer
+) {
+	NULL_RETURN_NULL(device);
+	return device->SubmitAndAcquireFence(
+		device->driverData,
+		commandBuffer
 	);
 }

@ -813,4 +921,44 @@ void Refresh_Wait(
 	);
 }

+void Refresh_WaitForFences(
+	Refresh_Device *device,
+	uint8_t waitAll,
+	uint32_t fenceCount,
+	Refresh_Fence **pFences
+) {
+	NULL_RETURN(device);
+	device->WaitForFences(
+		device->driverData,
+		waitAll,
+		fenceCount,
+		pFences
+	);
+}
+
+int Refresh_QueryFence(
+	Refresh_Device *device,
+	Refresh_Fence *fence
+) {
+	if (device == NULL) {
+		return 0;
+	}
+
+	return device->QueryFence(
+		device->driverData,
+		fence
+	);
+}
+
+void Refresh_ReleaseFence(
+	Refresh_Device *device,
+	Refresh_Fence *fence
+) {
+	NULL_RETURN(device);
+	device->ReleaseFence(
+		device->driverData,
+		fence
+	);
+}
+
 /* vim: set noexpandtab shiftwidth=8 tabstop=8: */
--- a/src/Refresh_Driver.h
+++ b/src/Refresh_Driver.h
@ -1,4 +1,4 @@
-/* Refresh - XNA-inspired 3D Graphics Library with modern capabilities
+/* Refresh - XNA-inspired 3D Graphics Library with modern capabilities
 *
 * Copyright (c) 2020 Evan Hemsley
 *
@ -36,9 +36,15 @@

 /* Logging */

-extern void Refresh_LogInfo(const char *fmt, ...);
-extern void Refresh_LogWarn(const char *fmt, ...);
-extern void Refresh_LogError(const char *fmt, ...);
+#ifdef __cplusplus
+extern "C" {
+#endif
+void Refresh_LogInfo(const char *fmt, ...);
+void Refresh_LogWarn(const char *fmt, ...);
+void Refresh_LogError(const char *fmt, ...);
+#ifdef __cplusplus
+}
+#endif

 /* Internal Helper Utilities */

@ -51,24 +57,31 @@ static inline uint32_t Texture_GetFormatSize(
 			return 8;
 		case REFRESH_TEXTUREFORMAT_BC2:
 		case REFRESH_TEXTUREFORMAT_BC3:
+		case REFRESH_TEXTUREFORMAT_BC7:
 			return 16;
 		case REFRESH_TEXTUREFORMAT_R8:
+		case REFRESH_TEXTUREFORMAT_R8_UINT:
 			return 1;
 		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:
 			return 2;
 		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:
 			return 4;
 		case REFRESH_TEXTUREFORMAT_R16G16B16A16_SFLOAT:
 		case REFRESH_TEXTUREFORMAT_R16G16B16A16:
 		case REFRESH_TEXTUREFORMAT_R32G32_SFLOAT:
+		case REFRESH_TEXTUREFORMAT_R16G16B16A16_UINT:
 			return 8;
 		case REFRESH_TEXTUREFORMAT_R32G32B32A32_SFLOAT:
 			return 16;
@ -117,7 +130,8 @@ static inline uint32_t BytesPerRow(

 	if (	format == REFRESH_TEXTUREFORMAT_BC1 ||
 		format == REFRESH_TEXTUREFORMAT_BC2 ||
-		format == REFRESH_TEXTUREFORMAT_BC3	)
+		format == REFRESH_TEXTUREFORMAT_BC3 ||
+		format == REFRESH_TEXTUREFORMAT_BC7	)
 	{
 		blocksPerRow = (width + 3) / 4;
 	}
@ -135,7 +149,8 @@ static inline int32_t BytesPerImage(

 	if (	format == REFRESH_TEXTUREFORMAT_BC1 ||
 		format == REFRESH_TEXTUREFORMAT_BC2 ||
-		format == REFRESH_TEXTUREFORMAT_BC3	)
+		format == REFRESH_TEXTUREFORMAT_BC3 ||
+		format == REFRESH_TEXTUREFORMAT_BC7 )
 	{
 		blocksPerRow = (width + 3) / 4;
 		blocksPerColumn = (height + 3) / 4;
@ -154,6 +169,7 @@ static inline int32_t BytesPerImage(
 #define MAX_BUFFER_BINDINGS			16

 #define MAX_COLOR_TARGET_BINDINGS	4
+#define MAX_PRESENT_COUNT			16

 /* Refresh_Device Definition */

@ -167,16 +183,6 @@ struct Refresh_Device

 	/* Drawing */

-	void (*Clear)(
-        Refresh_Renderer *driverData,
-        Refresh_CommandBuffer *commandBuffer,
-        Refresh_Rect *clearRect,
-        Refresh_ClearOptions options,
-        Refresh_Vec4 *colors,
-        uint32_t colorCount,
-        Refresh_DepthStencilValue depthStencil
-	);
-
 	void (*DrawInstancedPrimitives)(
 		Refresh_Renderer *driverData,
 		Refresh_CommandBuffer *commandBuffer,
@ -207,6 +213,17 @@ struct Refresh_Device
 		uint32_t fragmentParamOffset
 	);

+	void (*DrawPrimitivesIndirect)(
+		Refresh_Renderer *driverData,
+		Refresh_CommandBuffer *commandBuffer,
+		Refresh_Buffer *buffer,
+		uint32_t offsetInBytes,
+		uint32_t drawCount,
+		uint32_t stride,
+		uint32_t vertexParamOffset,
+		uint32_t fragmentParamOffset
+	);
+
 	void (*DispatchCompute)(
 		Refresh_Renderer *device,
 		Refresh_CommandBuffer *commandBuffer,
@ -218,14 +235,9 @@ struct Refresh_Device

 	/* State Creation */

-    Refresh_RenderPass* (*CreateRenderPass)(
-        Refresh_Renderer *driverData,
-        Refresh_RenderPassCreateInfo *renderPassCreateInfo
-    );
-
 	Refresh_ComputePipeline* (*CreateComputePipeline)(
 		Refresh_Renderer *driverData,
-        Refresh_ComputePipelineCreateInfo *pipelineCreateInfo
+		Refresh_ComputeShaderInfo *computeShaderInfo
 	);

 	Refresh_GraphicsPipeline* (*CreateGraphicsPipeline)(
@ -238,11 +250,6 @@ struct Refresh_Device
 		Refresh_SamplerStateCreateInfo *samplerStateCreateInfo
 	);

-    Refresh_Framebuffer* (*CreateFramebuffer)(
-        Refresh_Renderer *driverData,
-        Refresh_FramebufferCreateInfo *framebufferCreateInfo
-    );
-
 	Refresh_ShaderModule* (*CreateShaderModule)(
 		Refresh_Renderer *driverData,
 		Refresh_ShaderModuleCreateInfo *shaderModuleCreateInfo
@ -253,12 +260,6 @@ struct Refresh_Device
 		Refresh_TextureCreateInfo *textureCreateInfo
 	);

-    Refresh_RenderTarget* (*CreateRenderTarget)(
-        Refresh_Renderer *driverData,
-        Refresh_TextureSlice *textureSlice,
-        Refresh_SampleCount multisampleCount
-    );
-
 	Refresh_Buffer* (*CreateBuffer)(
 		Refresh_Renderer *driverData,
 		Refresh_BufferUsageFlags usageFlags,
@ -267,7 +268,7 @@ struct Refresh_Device

 	/* Setters */

-    void(*SetTextureData)(
+	void (*SetTextureData)(
 		Refresh_Renderer *driverData,
 		Refresh_CommandBuffer *commandBuffer,
 		Refresh_TextureSlice *textureSlice,
@ -275,7 +276,7 @@ struct Refresh_Device
 		uint32_t dataLengthInBytes
 	);

-    void(*SetTextureDataYUV)(
+	void (*SetTextureDataYUV)(
 		Refresh_Renderer *driverData,
 		Refresh_CommandBuffer* commandBuffer,
 		Refresh_Texture *y,
@ -285,11 +286,16 @@ struct Refresh_Device
 		uint32_t yHeight,
 		uint32_t uvWidth,
 		uint32_t uvHeight,
-        void* data,
-        uint32_t dataLength
+		void *yDataPtr,
+		void *uDataPtr,
+		void *vDataPtr,
+		uint32_t yDataLength,
+		uint32_t uvDataLength,
+		uint32_t yStride,
+		uint32_t uvStride
 	);

-    void(*CopyTextureToTexture)(
+	void (*CopyTextureToTexture)(
 		Refresh_Renderer *driverData,
 		Refresh_CommandBuffer *commandBuffer,
 		Refresh_TextureSlice *sourceTextureSlice,
@ -297,14 +303,14 @@ struct Refresh_Device
 		Refresh_Filter filter
 	);

-    void(*CopyTextureToBuffer)(
+	void (*CopyTextureToBuffer)(
 		Refresh_Renderer *driverData,
 		Refresh_CommandBuffer *commandBuffer,
 		Refresh_TextureSlice *textureSlice,
 		Refresh_Buffer *buffer
 	);

-    void(*SetBufferData)(
+	void (*SetBufferData)(
 		Refresh_Renderer *driverData,
 		Refresh_CommandBuffer *commandBuffer,
 		Refresh_Buffer *buffer,
@ -313,14 +319,14 @@ struct Refresh_Device
 		uint32_t dataLength
 	);

-    uint32_t(*PushVertexShaderUniforms)(
+	uint32_t (*PushVertexShaderUniforms)(
 		Refresh_Renderer *driverData,
 		Refresh_CommandBuffer *commandBuffer,
 		void *data,
 		uint32_t dataLengthInBytes
 	);

-    uint32_t(*PushFragmentShaderUniforms)(
+	uint32_t (*PushFragmentShaderUniforms)(
 		Refresh_Renderer *driverData,
 		Refresh_CommandBuffer *commandBuffer,
 		void *data,
@ -334,14 +340,14 @@ struct Refresh_Device
 		uint32_t dataLengthInBytes
 	);

-    void(*BindVertexSamplers)(
+	void (*BindVertexSamplers)(
 		Refresh_Renderer *driverData,
 		Refresh_CommandBuffer *commandBuffer,
 		Refresh_Texture **pTextures,
 		Refresh_Sampler **pSamplers
 	);

-    void(*BindFragmentSamplers)(
+	void (*BindFragmentSamplers)(
 		Refresh_Renderer *driverData,
 		Refresh_CommandBuffer *commandBuffer,
 		Refresh_Texture **pTextures,
@ -350,7 +356,7 @@ struct Refresh_Device

 	/* Getters */

-    void(*GetBufferData)(
+	void (*GetBufferData)(
 		Refresh_Renderer *driverData,
 		Refresh_Buffer *buffer,
 		void *data,
@ -359,76 +365,70 @@ struct Refresh_Device

 	/* Disposal */

-    void(*QueueDestroyTexture)(
+	void (*QueueDestroyTexture)(
 		Refresh_Renderer *driverData,
 		Refresh_Texture *texture
 	);

-    void(*QueueDestroySampler)(
+	void (*QueueDestroySampler)(
 		Refresh_Renderer *driverData,
 		Refresh_Sampler *sampler
 	);

-    void(*QueueDestroyBuffer)(
+	void (*QueueDestroyBuffer)(
 		Refresh_Renderer *driverData,
 		Refresh_Buffer *buffer
 	);

-    void(*QueueDestroyRenderTarget)(
-        Refresh_Renderer *driverData,
-	    Refresh_RenderTarget *renderTarget
-    );
-
-    void(*QueueDestroyFramebuffer)(
-        Refresh_Renderer *driverData,
-        Refresh_Framebuffer *frameBuffer
-    );
-
-    void(*QueueDestroyShaderModule)(
+	void (*QueueDestroyShaderModule)(
 		Refresh_Renderer *driverData,
 		Refresh_ShaderModule *shaderModule
 	);

-    void(*QueueDestroyRenderPass)(
-        Refresh_Renderer *driverData,
-        Refresh_RenderPass *renderPass
-    );
-
-    void(*QueueDestroyComputePipeline)(
+	void (*QueueDestroyComputePipeline)(
 		Refresh_Renderer *driverData,
 		Refresh_ComputePipeline *computePipeline
 	);

-    void(*QueueDestroyGraphicsPipeline)(
+	void (*QueueDestroyGraphicsPipeline)(
 		Refresh_Renderer *driverData,
 		Refresh_GraphicsPipeline *graphicsPipeline
 	);

 	/* Graphics State */

-    void(*BeginRenderPass)(
+	void (*BeginRenderPass)(
 		Refresh_Renderer *driverData,
 		Refresh_CommandBuffer *commandBuffer,
-        Refresh_RenderPass *renderPass,
-        Refresh_Framebuffer *framebuffer,
-        Refresh_Rect *renderArea,
-        Refresh_Vec4 *pColorClearValues,
-        uint32_t colorClearCount,
-        Refresh_DepthStencilValue *depthStencilClearValue
+		Refresh_ColorAttachmentInfo *colorAttachmentInfos,
+		uint32_t colorAttachmentCount,
+		Refresh_DepthStencilAttachmentInfo *depthStencilAttachmentInfo
 	);

-    void(*EndRenderPass)(
+	void (*EndRenderPass)(
 		Refresh_Renderer *driverData,
 		Refresh_CommandBuffer *commandBuffer
 	);

-    void(*BindGraphicsPipeline)(
+	void (*SetViewport)(
+		Refresh_Renderer *driverData,
+		Refresh_CommandBuffer *commandBuffer,
+		Refresh_Viewport *viewport
+	);
+
+	void (*SetScissor)(
+		Refresh_Renderer *driverData,
+		Refresh_CommandBuffer *commandBuffer,
+		Refresh_Rect *scissor
+	);
+
+	void (*BindGraphicsPipeline)(
 		Refresh_Renderer *driverData,
 		Refresh_CommandBuffer *commandBuffer,
 		Refresh_GraphicsPipeline *graphicsPipeline
 	);

-    void(*BindVertexBuffers)(
+	void (*BindVertexBuffers)(
 		Refresh_Renderer *driverData,
 		Refresh_CommandBuffer *commandBuffer,
 		uint32_t firstBinding,
@ -437,7 +437,7 @@ struct Refresh_Device
 		uint64_t *pOffsets
 	);

-    void(*BindIndexBuffer)(
+	void (*BindIndexBuffer)(
 		Refresh_Renderer *driverData,
 		Refresh_CommandBuffer *commandBuffer,
 		Refresh_Buffer *buffer,
@ -445,48 +445,89 @@ struct Refresh_Device
 		Refresh_IndexElementSize indexElementSize
 	);

-    void(*BindComputePipeline)(
+	void (*BindComputePipeline)(
 		Refresh_Renderer *driverData,
 		Refresh_CommandBuffer *commandBuffer,
 		Refresh_ComputePipeline *computePipeline
 	);

-    void(*BindComputeBuffers)(
+	void (*BindComputeBuffers)(
 		Refresh_Renderer *driverData,
 		Refresh_CommandBuffer *commandBuffer,
 		Refresh_Buffer **pBuffers
 	);

-    void(*BindComputeTextures)(
+	void (*BindComputeTextures)(
 		Refresh_Renderer *driverData,
 		Refresh_CommandBuffer *commandBuffer,
 		Refresh_Texture **pTextures
 	);

-    Refresh_CommandBuffer* (*AcquireCommandBuffer)(
+	uint8_t (*ClaimWindow)(
 		Refresh_Renderer *driverData,
-        uint8_t fixed
+		void *windowHandle,
+		Refresh_PresentMode presentMode
 	);

-    void(*QueuePresent)(
+	void (*UnclaimWindow)(
 		Refresh_Renderer *driverData,
-        Refresh_CommandBuffer *commandBuffer,
-        Refresh_TextureSlice *textureSlice,
-        Refresh_Rect *destinationRectangle,
-        Refresh_Filter filter,
 		void *windowHandle
 	);

-    void(*Submit)(
-        Refresh_Renderer *driverData,
-        uint32_t commandBufferCount,
-        Refresh_CommandBuffer **pCommandBuffers
+	Refresh_CommandBuffer* (*AcquireCommandBuffer)(
+		Refresh_Renderer *driverData
 	);

-    void(*Wait)(
+	Refresh_Texture* (*AcquireSwapchainTexture)(
+		Refresh_Renderer *driverData,
+		Refresh_CommandBuffer *commandBuffer,
+		void *windowHandle,
+		uint32_t *pWidth,
+		uint32_t *pHeight
+	);
+
+	Refresh_TextureFormat (*GetSwapchainFormat)(
+		Refresh_Renderer *driverData,
+		void *windowHandle
+	);
+
+	void (*SetSwapchainPresentMode)(
+		Refresh_Renderer *driverData,
+		void *windowHandle,
+		Refresh_PresentMode presentMode
+	);
+
+	void (*Submit)(
+		Refresh_Renderer *driverData,
+		Refresh_CommandBuffer *commandBuffer
+	);
+
+	Refresh_Fence* (*SubmitAndAcquireFence)(
+		Refresh_Renderer *driverData,
+		Refresh_CommandBuffer *commandBuffer
+	);
+
+	void (*Wait)(
 		Refresh_Renderer *driverData
 	);

+	void (*WaitForFences)(
+		Refresh_Renderer *driverData,
+		uint8_t waitAll,
+		uint32_t fenceCount,
+		Refresh_Fence **pFences
+	);
+
+	int (*QueryFence)(
+		Refresh_Renderer *driverData,
+		Refresh_Fence *fence
+	);
+
+	void (*ReleaseFence)(
+		Refresh_Renderer *driverData,
+		Refresh_Fence *fence
+	);
+
 	/* Opaque pointer for the Driver */
 	Refresh_Renderer *driverData;
 };
@ -495,19 +536,16 @@ struct Refresh_Device
 	result->func = name##_##func;
 #define ASSIGN_DRIVER(name) \
 	ASSIGN_DRIVER_FUNC(DestroyDevice, name) \
-	ASSIGN_DRIVER_FUNC(Clear, name) \
 	ASSIGN_DRIVER_FUNC(DrawIndexedPrimitives, name) \
 	ASSIGN_DRIVER_FUNC(DrawInstancedPrimitives, name) \
 	ASSIGN_DRIVER_FUNC(DrawPrimitives, name) \
+	ASSIGN_DRIVER_FUNC(DrawPrimitivesIndirect, name) \
 	ASSIGN_DRIVER_FUNC(DispatchCompute, name) \
-    ASSIGN_DRIVER_FUNC(CreateRenderPass, name) \
 	ASSIGN_DRIVER_FUNC(CreateComputePipeline, name) \
 	ASSIGN_DRIVER_FUNC(CreateGraphicsPipeline, name) \
 	ASSIGN_DRIVER_FUNC(CreateSampler, name) \
-    ASSIGN_DRIVER_FUNC(CreateFramebuffer, name) \
 	ASSIGN_DRIVER_FUNC(CreateShaderModule, name) \
 	ASSIGN_DRIVER_FUNC(CreateTexture, name) \
-    ASSIGN_DRIVER_FUNC(CreateRenderTarget, name) \
 	ASSIGN_DRIVER_FUNC(CreateBuffer, name) \
 	ASSIGN_DRIVER_FUNC(SetTextureData, name) \
 	ASSIGN_DRIVER_FUNC(SetTextureDataYUV, name) \
@ -523,35 +561,43 @@ struct Refresh_Device
 	ASSIGN_DRIVER_FUNC(QueueDestroyTexture, name) \
 	ASSIGN_DRIVER_FUNC(QueueDestroySampler, name) \
 	ASSIGN_DRIVER_FUNC(QueueDestroyBuffer, name) \
-    ASSIGN_DRIVER_FUNC(QueueDestroyRenderTarget, name) \
-    ASSIGN_DRIVER_FUNC(QueueDestroyFramebuffer, name) \
 	ASSIGN_DRIVER_FUNC(QueueDestroyShaderModule, name) \
-    ASSIGN_DRIVER_FUNC(QueueDestroyRenderPass, name) \
 	ASSIGN_DRIVER_FUNC(QueueDestroyComputePipeline, name) \
 	ASSIGN_DRIVER_FUNC(QueueDestroyGraphicsPipeline, name) \
 	ASSIGN_DRIVER_FUNC(BeginRenderPass, name) \
 	ASSIGN_DRIVER_FUNC(EndRenderPass, name) \
+	ASSIGN_DRIVER_FUNC(SetViewport, name) \
+	ASSIGN_DRIVER_FUNC(SetScissor, name) \
 	ASSIGN_DRIVER_FUNC(BindGraphicsPipeline, name) \
 	ASSIGN_DRIVER_FUNC(BindVertexBuffers, name) \
 	ASSIGN_DRIVER_FUNC(BindIndexBuffer, name) \
 	ASSIGN_DRIVER_FUNC(BindComputePipeline, name) \
 	ASSIGN_DRIVER_FUNC(BindComputeBuffers, name) \
 	ASSIGN_DRIVER_FUNC(BindComputeTextures, name) \
+	ASSIGN_DRIVER_FUNC(ClaimWindow, name) \
+	ASSIGN_DRIVER_FUNC(UnclaimWindow, name) \
 	ASSIGN_DRIVER_FUNC(AcquireCommandBuffer, name) \
-    ASSIGN_DRIVER_FUNC(QueuePresent, name) \
+	ASSIGN_DRIVER_FUNC(AcquireSwapchainTexture, name) \
+	ASSIGN_DRIVER_FUNC(GetSwapchainFormat, name) \
+	ASSIGN_DRIVER_FUNC(SetSwapchainPresentMode, name) \
 	ASSIGN_DRIVER_FUNC(Submit, name) \
-    ASSIGN_DRIVER_FUNC(Wait, name)
+	ASSIGN_DRIVER_FUNC(SubmitAndAcquireFence, name) \
+	ASSIGN_DRIVER_FUNC(Wait, name) \
+	ASSIGN_DRIVER_FUNC(WaitForFences, name) \
+	ASSIGN_DRIVER_FUNC(QueryFence, name) \
+	ASSIGN_DRIVER_FUNC(ReleaseFence, name)

 typedef struct Refresh_Driver
 {
 	const char *Name;
+	uint8_t (*PrepareDriver)(uint32_t *flags);
 	Refresh_Device* (*CreateDevice)(
-		Refresh_PresentationParameters *presentationParameters,
 		uint8_t debugMode
 	);
 } Refresh_Driver;

 extern Refresh_Driver VulkanDriver;
+extern Refresh_Driver PS5Driver;

 #endif /* REFRESH_DRIVER_H */

--- a/src/Refresh_Driver_Template.txt
+++ b/src/Refresh_Driver_Template.txt
@ -0,0 +1,707 @@
+/* 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>
+ *
+ */
+
+#if REFRESH_DRIVER_TEMPLATE
+
+#include "Refresh_Driver.h"
+
+#include <SDL.h>
+
+#define NOT_IMPLEMENTED SDL_assert(0 && "Not implemented!");
+
+/* Conversions */
+
+static TEMPLATE_SURFACE_FORMAT_TYPE RefreshToTEMPLATE_SurfaceFormat[] =
+{
+	0,	/* R8G8B8A8 */
+	0,	/* B8G8R8A8 */
+	0,	/* R5G6B5 */
+	0,	/* A1R5G5B5 */
+	0,	/* B4G4R4A4 */
+	0,	/* BC1 */
+	0,	/* BC3 */
+	0,	/* BC5 */
+	0,	/* R8G8_SNORM */
+	0,	/* R8G8B8A8_SNORM */
+	0,	/* A2R10G10B10 */
+	0,	/* R16G16 */
+	0,	/* R16G16B16A16 */
+	0,	/* R8 */
+	0,	/* R32_SFLOAT */
+	0,	/* R32G32_SFLOAT */
+	0,	/* R32G32B32A32_SFLOAT */
+	0,	/* R16_SFLOAT */
+	0,	/* R16G16_SFLOAT */
+	0,	/* R16G16B16A16_SFLOAT */
+	0,	/* D16 */
+	0,	/* D32 */
+	0,	/* D16S8 */
+	0	/* D32S8 */
+};
+
+static TEMPLATE_VERTEX_FORMAT_TYPE RefreshToTEMPLATE_VertexFormat[] =
+{
+	0,	/* SINGLE */
+	0,	/* VECTOR2 */
+	0,	/* VECTOR3 */
+	0,	/* VECTOR4 */
+	0,	/* COLOR */
+	0,	/* BYTE4 */
+	0,	/* SHORT2 */
+	0,	/* SHORT4 */
+	0,	/* NORMALIZEDSHORT2 */
+	0,	/* NORMALIZEDSHORT4 */
+	0,	/* HALFVECTOR2 */
+	0	/* HALFVECTOR4 */
+};
+
+static TEMPLATE_INDEX_TYPE RefreshToTEMPLATE_IndexType[] =
+{
+	0,	/* 16BIT */
+	0	/* 32BIT */
+};
+
+static TEMPLATE_PRIMITIVE_TYPE RefreshToTEMPLATE_PrimitiveType[] =
+{
+	0,	/* POINTLIST */
+	0,	/* LINELIST */
+	0,	/* LINESTRIP */
+	0,	/* TRIANGLELIST */
+	0	/* TRIANGLESTRIP */
+};
+
+static TEMPLATE_POLYGON_MODE_TYPE RefreshToTEMPLATE_PolygonMode[] =
+{
+	0,	/* FILL */
+	0,	/* LINE */
+};
+
+static TEMPLATE_CULL_MODE_TYPE RefreshToTEMPLATE_CullMode[] =
+{
+	0,	/* NONE */
+	0,	/* FRONT */
+	0,	/* BACK */
+};
+
+static TEMPLATE_FRONT_FACE_TYPE RefreshToTEMPLATE_FrontFace[] =
+{
+	0,	/* COUNTER_CLOCKWISE */
+	0	/* CLOCKWISE */
+};
+
+static TEMPLATE_BLEND_FACTOR_TYPE RefreshToTEMPLATE_BlendFactor[] =
+{
+	0,	/* ZERO */
+	0,	/* ONE */
+	0,	/* SRC_COLOR */
+	0,	/* ONE_MINUS_SRC_COLOR */
+	0,	/* DST_COLOR */
+	0,	/* ONE_MINUS_DST_COLOR */
+	0,	/* SRC_ALPHA */
+	0,	/* ONE_MINUS_SRC_ALPHA */
+	0,	/* DST_ALPHA */
+	0,	/* ONE_MINUS_DST_ALPHA */
+	0,	/* CONSTANT_COLOR */
+	0,	/* ONE_MINUS_CONSTANT_COLOR */
+	0	/* SRC_ALPHA_SATURATE */
+};
+
+static TEMPLATE_BLEND_OP_TYPE RefreshToTEMPLATE_BlendOp[] =
+{
+	0,	/* ADD */
+	0,	/* SUBTRACT */
+	0,	/* REVERSE_SUBTRACT */
+	0,	/* MIN */
+	0	/* MAX */
+};
+
+static TEMPLATE_COMPARE_OP_TYPE RefreshToTEMPLATE_CompareOp[] =
+{
+	0,	/* NEVER */
+	0,	/* LESS */
+	0,	/* EQUAL */
+	0,	/* LESS_OR_EQUAL */
+	0,	/* GREATER */
+	0,	/* NOT_EQUAL */
+	0,	/* GREATER_OR_EQUAL */
+	0	/* ALWAYS */
+};
+
+static TEMPLATE_STENCIL_OP_TYPE RefreshToTEMPLATE_StencilOp[] =
+{
+	0,	/* KEEP */
+	0,	/* ZERO */
+	0,	/* REPLACE */
+	0,	/* INCREMENT_AND_CLAMP */
+	0,	/* DECREMENT_AND_CLAMP */
+	0,	/* INVERT */
+	0,	/* INCREMENT_AND_WRAP */
+	0	/* DECREMENT_AND_WRAP */
+};
+
+static TEMPLATE_ATTACHMENT_LOAD_OP_TYPE RefreshToTEMPLATE_LoadOp[] =
+{
+	0,	/* LOAD */
+	0,	/* CLEAR */
+	0	/* DONT_CARE */
+};
+
+static TEMPLATE_ATTACHMENT_STORE_OP_TYPE RefreshToTEMPLATE_StoreOp[] =
+{
+	0,	/* STORE */
+	0	/* DONT_CARE */
+};
+
+static TEMPLATE_SAMPLE_COUNT_TYPE RefreshToTEMPLATE_SampleCount[] =
+{
+	0,	/* 1 */
+	0,	/* 2 */
+	0,	/* 4 */
+	0,	/* 8 */
+	0,	/* 16 */
+	0,	/* 32 */
+	0	/* 64 */
+};
+
+static TEMPLATE_VERTEX_INPUT_RATE_TYPE RefreshToTEMPLATE_VertexInputRate[] =
+{
+	0,	/* VERTEX */
+	0	/* INSTANCE */
+};
+
+static TEMPLATE_FILTER_TYPE RefreshToTEMPLATE_Filter[] =
+{
+	0,	/* NEAREST */
+	0,	/* LINEAR */
+};
+
+static TEMPLATE_SAMPLER_MIPMAP_MODE_TYPE RefreshToTEMPLATE_SamplerMipmapMode[] =
+{
+	0,	/* NEAREST */
+	0	/* LINEAR */
+};
+
+static TEMPLATE_SAMPLER_ADDRESS_MODE_TYPE RefreshToTEMPLATE_SamplerAddressMode[] =
+{
+	0,	/* REPEAT */
+	0,	/* MIRRORED_REPEAT */
+	0,	/* CLAMP_TO_EDGE */
+	0	/* CLAMP_TO_BORDER */
+};
+
+static TEMPLATE_BORDER_COLOR_TYPE RefreshToTEMPLATE_BorderColor[] =
+{
+	0,	/* FLOAT_TRANSPARENT_BLACK */
+	0,	/* INT_TRANSPARENT_BLACK */
+	0,	/* FLOAT_OPAQUE_BLACK */
+	0,	/* INT_OPAQUE_BLACK */
+	0,	/* FLOAT_OPAQUE_WHITE */
+	0	/* INT_OPAQUE_WHITE */
+};
+
+/* Quit */
+
+static void TEMPLATE_DestroyDevice(
+	Refresh_Device *device
+) {
+	NOT_IMPLEMENTED
+}
+
+/* Drawing */
+
+static void TEMPLATE_DrawInstancedPrimitives(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer,
+	uint32_t baseVertex,
+	uint32_t startIndex,
+	uint32_t primitiveCount,
+	uint32_t instanceCount,
+	uint32_t vertexParamOffset,
+	uint32_t fragmentParamOffset
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_DrawIndexedPrimitives(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer,
+	uint32_t baseVertex,
+	uint32_t startIndex,
+	uint32_t primitiveCount,
+	uint32_t vertexParamOffset,
+	uint32_t fragmentParamOffset
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_DrawPrimitives(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer,
+	uint32_t vertexStart,
+	uint32_t primitiveCount,
+	uint32_t vertexParamOffset,
+	uint32_t fragmentParamOffset
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_DrawPrimitivesIndirect(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer,
+	Refresh_Buffer *buffer,
+	uint32_t offsetInBytes,
+	uint32_t drawCount,
+	uint32_t stride,
+	uint32_t vertexParamOffset,
+	uint32_t fragmentParamOffset
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_DispatchCompute(
+	Refresh_Renderer *device,
+	Refresh_CommandBuffer *commandBuffer,
+	uint32_t groupCountX,
+	uint32_t groupCountY,
+	uint32_t groupCountZ,
+	uint32_t computeParamOffset
+) {
+	NOT_IMPLEMENTED
+}
+
+/* State Creation */
+
+
+static Refresh_ComputePipeline* TEMPLATE_CreateComputePipeline(
+	Refresh_Renderer *driverData,
+	Refresh_ComputeShaderInfo *computeShaderInfo
+) {
+	NOT_IMPLEMENTED
+}
+
+static Refresh_GraphicsPipeline* TEMPLATE_CreateGraphicsPipeline(
+	Refresh_Renderer *driverData,
+	Refresh_GraphicsPipelineCreateInfo *pipelineCreateInfo
+) {
+	NOT_IMPLEMENTED
+}
+
+static Refresh_Sampler* TEMPLATE_CreateSampler(
+	Refresh_Renderer *driverData,
+	Refresh_SamplerStateCreateInfo *samplerStateCreateInfo
+) {
+	NOT_IMPLEMENTED
+}
+
+static Refresh_ShaderModule* TEMPLATE_CreateShaderModule(
+	Refresh_Renderer *driverData,
+	Refresh_ShaderModuleCreateInfo *shaderModuleCreateInfo
+) {
+	NOT_IMPLEMENTED
+}
+
+static Refresh_Texture* TEMPLATE_CreateTexture(
+	Refresh_Renderer *driverData,
+	Refresh_TextureCreateInfo *textureCreateInfo
+) {
+	NOT_IMPLEMENTED
+}
+
+static Refresh_Buffer* TEMPLATE_CreateBuffer(
+	Refresh_Renderer *driverData,
+	Refresh_BufferUsageFlags usageFlags,
+	uint32_t sizeInBytes
+) {
+	NOT_IMPLEMENTED
+}
+
+/* Setters */
+
+static void TEMPLATE_SetTextureData(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer,
+	Refresh_TextureSlice *textureSlice,
+	void *data,
+	uint32_t dataLengthInBytes
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_SetTextureDataYUV(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer* commandBuffer,
+	Refresh_Texture *y,
+	Refresh_Texture *u,
+	Refresh_Texture *v,
+	uint32_t yWidth,
+	uint32_t yHeight,
+	uint32_t uvWidth,
+	uint32_t uvHeight,
+	void *yDataPtr,
+	void *uDataPtr,
+	void *vDataPtr,
+	uint32_t yDataLength,
+	uint32_t uvDataLength,
+	uint32_t yStride,
+	uint32_t uvStride
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_CopyTextureToTexture(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer,
+	Refresh_TextureSlice *sourceTextureSlice,
+	Refresh_TextureSlice *destinationTextureSlice,
+	Refresh_Filter filter
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_CopyTextureToBuffer(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer,
+	Refresh_TextureSlice *textureSlice,
+	Refresh_Buffer *buffer
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_SetBufferData(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer,
+	Refresh_Buffer *buffer,
+	uint32_t offsetInBytes,
+	void* data,
+	uint32_t dataLength
+) {
+	NOT_IMPLEMENTED
+}
+
+static uint32_t TEMPLATE_PushVertexShaderUniforms(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer,
+	void *data,
+	uint32_t dataLengthInBytes
+) {
+	NOT_IMPLEMENTED
+}
+
+static uint32_t TEMPLATE_PushFragmentShaderUniforms(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer,
+	void *data,
+	uint32_t dataLengthInBytes
+) {
+	NOT_IMPLEMENTED
+}
+
+static uint32_t TEMPLATE_PushComputeShaderUniforms(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer,
+	void *data,
+	uint32_t dataLengthInBytes
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_BindVertexSamplers(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer,
+	Refresh_Texture **pTextures,
+	Refresh_Sampler **pSamplers
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_BindFragmentSamplers(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer,
+	Refresh_Texture **pTextures,
+	Refresh_Sampler **pSamplers
+) {
+	NOT_IMPLEMENTED
+}
+
+/* Getters */
+
+static void TEMPLATE_GetBufferData(
+	Refresh_Renderer *driverData,
+	Refresh_Buffer *buffer,
+	void *data,
+	uint32_t dataLengthInBytes
+) {
+	NOT_IMPLEMENTED
+}
+
+/* Disposal */
+
+static void TEMPLATE_QueueDestroyTexture(
+	Refresh_Renderer *driverData,
+	Refresh_Texture *texture
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_QueueDestroySampler(
+	Refresh_Renderer *driverData,
+	Refresh_Sampler *sampler
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_QueueDestroyBuffer(
+	Refresh_Renderer *driverData,
+	Refresh_Buffer *buffer
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_QueueDestroyShaderModule(
+	Refresh_Renderer *driverData,
+	Refresh_ShaderModule *shaderModule
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_QueueDestroyComputePipeline(
+	Refresh_Renderer *driverData,
+	Refresh_ComputePipeline *computePipeline
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_QueueDestroyGraphicsPipeline(
+	Refresh_Renderer *driverData,
+	Refresh_GraphicsPipeline *graphicsPipeline
+) {
+	NOT_IMPLEMENTED
+}
+
+/* Graphics State */
+
+static Refresh_CommandBuffer* TEMPLATE_AcquireCommandBuffer(
+	Refresh_Renderer *driverData
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_BeginRenderPass(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer,
+	Refresh_ColorAttachmentInfo *colorAttachmentInfos,
+	uint32_t colorAttachmentCount,
+	Refresh_DepthStencilAttachmentInfo *depthStencilAttachmentInfo
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_EndRenderPass(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_BindGraphicsPipeline(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer,
+	Refresh_GraphicsPipeline *graphicsPipeline
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_SetViewport(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer,
+	Refresh_Viewport *viewport
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_SetScissor(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer,
+	Refresh_Rect *scissor
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_BindVertexBuffers(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer,
+	uint32_t firstBinding,
+	uint32_t bindingCount,
+	Refresh_Buffer **pBuffers,
+	uint64_t *pOffsets
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_BindIndexBuffer(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer,
+	Refresh_Buffer *buffer,
+	uint64_t offset,
+	Refresh_IndexElementSize indexElementSize
+) {
+	NOT_IMPLEMENTED
+}
+
+/* Compute State */
+
+static void TEMPLATE_BindComputePipeline(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer,
+	Refresh_ComputePipeline *computePipeline
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_BindComputeBuffers(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer,
+	Refresh_Buffer **pBuffers
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_BindComputeTextures(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer,
+	Refresh_Texture **pTextures
+) {
+	NOT_IMPLEMENTED
+}
+
+/* Window and Swapchain Management */
+
+static uint8_t TEMPLATE_ClaimWindow(
+	Refresh_Renderer *driverData,
+	void *windowHandle,
+	Refresh_PresentMode presentMode
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_UnclaimWindow(
+	Refresh_Renderer *driverData,
+	void *windowHandle
+) {
+	NOT_IMPLEMENTED
+}
+
+static Refresh_Texture* TEMPLATE_AcquireSwapchainTexture(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer,
+	void *windowHandle,
+	uint32_t *pWidth,
+	uint32_t *pHeight
+) {
+	NOT_IMPLEMENTED
+}
+
+static Refresh_TextureFormat TEMPLATE_GetSwapchainFormat(
+	Refresh_Renderer *driverData,
+	void *windowHandle
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_SetSwapchainPresentMode(
+	Refresh_Renderer *driverData,
+	void *windowHandle,
+	Refresh_PresentMode presentMode
+) {
+	NOT_IMPLEMENTED
+}
+
+/* Submission and Fences */
+
+static void TEMPLATE_Submit(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer
+) {
+	NOT_IMPLEMENTED
+}
+
+static Refresh_Fence* TEMPLATE_SubmitAndAcquireFence(
+	Refresh_Renderer *driverData,
+	Refresh_CommandBuffer *commandBuffer
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_Wait(
+	Refresh_Renderer *driverData
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_WaitForFences(
+	Refresh_Renderer *driverData,
+	uint8_t waitAll,
+	uint32_t fenceCount,
+	Refresh_Fence **pFences
+) {
+	NOT_IMPLEMENTED
+}
+
+static int TEMPLATE_QueryFence(
+	Refresh_Renderer *driverData,
+	Refresh_Fence *fence
+) {
+	NOT_IMPLEMENTED
+}
+
+static void TEMPLATE_ReleaseFence(
+	Refresh_Renderer *driverData,
+	Refresh_Fence *fence
+) {
+	NOT_IMPLEMENTED
+}
+
+/* Device Creation */
+
+static uint8_t TEMPLATE_PrepareDriver(
+	uint32_t *flags
+) {
+	NOT_IMPLEMENTED
+}
+
+static Refresh_Device* TEMPLATE_CreateDevice(
+	uint8_t debugMode
+) {
+	NOT_IMPLEMENTED
+}
+
+Refresh_Driver TEMPLATEDriver = {
+	"TEMPLATE",
+	TEMPLATE_PrepareDriver,
+	TEMPLATE_CreateDevice
+};
+
+#endif //REFRESH_DRIVER_TEMPLATE
--- a/src/Refresh_Driver_Vulkan.c
+++ b/src/Refresh_Driver_Vulkan.c
--- a/src/Refresh_Driver_Vulkan_vkfuncs.h
+++ b/src/Refresh_Driver_Vulkan_vkfuncs.h
@ -89,9 +89,11 @@ VULKAN_DEVICE_FUNCTION(BaseVK, void, vkCmdClearDepthStencilImage, (VkCommandBuff
 VULKAN_DEVICE_FUNCTION(BaseVK, void, vkCmdCopyBuffer, (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions))
 VULKAN_DEVICE_FUNCTION(BaseVK, void, vkCmdCopyBufferToImage, (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions))
 VULKAN_DEVICE_FUNCTION(BaseVK, void, vkCmdCopyImageToBuffer, (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions))
+VULKAN_DEVICE_FUNCTION(BaseVK, void, vkCmdCopyImage, (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions))
 VULKAN_DEVICE_FUNCTION(BaseVK, void, vkCmdDispatch, (VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ))
 VULKAN_DEVICE_FUNCTION(BaseVK, void, vkCmdDraw, (VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance))
 VULKAN_DEVICE_FUNCTION(BaseVK, void, vkCmdDrawIndexed, (VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance))
+VULKAN_DEVICE_FUNCTION(BaseVK, void, vkCmdDrawIndirect, (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride))
 VULKAN_DEVICE_FUNCTION(BaseVK, void, vkCmdEndRenderPass, (VkCommandBuffer commandBuffer))
 VULKAN_DEVICE_FUNCTION(BaseVK, void, vkCmdPipelineBarrier, (VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers))
 VULKAN_DEVICE_FUNCTION(BaseVK, void, vkCmdResolveImage, (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions))
--- a/src/Refresh_Image.c
+++ b/src/Refresh_Image.c
@ -48,7 +48,6 @@
 #define floorf SDL_floorf
 #define ldexp SDL_scalbn
 #define pow SDL_pow
-#define strtol SDL_strtol

 #ifdef memcmp
 #undef memcmp
@ -74,13 +73,10 @@
 #undef strlen
 #endif
 #define strlen SDL_strlen
-#ifdef strncmp
-#undef strncmp
-#endif
-#define strncmp SDL_strncmp

 /* These are per the Texture2D.FromStream spec */
 #define STBI_ONLY_PNG
+#define STBI_ONLY_QOI

 /* These are per the Texture2D.SaveAs* spec */
 #define STBIW_ONLY_PNG
@ -140,6 +136,7 @@ SDL_SIMDRealloc(void *mem, const size_t len)
 #endif

 #define STB_IMAGE_STATIC
+#define STBI_NO_HDR
 #define STBI_ASSERT SDL_assert
 #define STBI_MALLOC SDL_SIMDAlloc
 #define STBI_REALLOC SDL_SIMDRealloc
@ -190,28 +187,72 @@ static unsigned char* dgibson_stbi_zlib_compress(
 /* Image Read API */

 uint8_t* Refresh_Image_Load(
-    char const *filename,
+	uint8_t *bufferPtr,
+	int32_t bufferLength,
 	int32_t *w,
 	int32_t *h,
-    int32_t *numChannels
+	int32_t *len
 ) {
-    return stbi_load(filename, w, h, numChannels, STBI_rgb_alpha);
+	uint8_t* result;
+	uint8_t* pixels;
+	int32_t format;
+	int32_t i;
+
+	result = stbi_load_from_memory(
+		bufferPtr,
+		bufferLength,
+		w,
+		h,
+		&format,
+		STBI_rgb_alpha
+	);
+
+	if (result == NULL)
+	{
+		SDL_LogWarn(SDL_LOG_CATEGORY_ERROR, "Image loading failed: %s", stbi_failure_reason());
+	}
+
+	/* Ensure that the alpha pixels are... well, actual alpha.
+	 * You think this looks stupid, but be assured: Your paint program is
+	 * almost certainly even stupider.
+	 * -flibit
+	 */
+	pixels = result;
+	*len = (*w) * (*h) *4;
+	for (i = 0; i < *len; i += 4, pixels += 4)
+	{
+		if (pixels[3] == 0)
+		{
+			pixels[0] = 0;
+			pixels[1] = 1;
+			pixels[2] = 2;
+		}
+	}
+
+	return result;
 }

 void Refresh_Image_Free(uint8_t *mem)
 {
-    stbi_image_free(mem);
+	SDL_SIMDFree(mem);
 }

 /* Image Write API */

 void Refresh_Image_SavePNG(
-    const char *filename,
+	const char* filename,
+	uint8_t* data,
 	int32_t w,
-    int32_t h,
-	uint8_t *data
+	int32_t h
 ) {
-    stbi_write_png(filename, w, h, 4, data, w * 4);
+	stbi_write_png(
+		filename,
+		w,
+		h,
+		4,
+		data,
+		w * 4
+	);
 }

 /* vim: set noexpandtab shiftwidth=8 tabstop=8: */
--- a/src/stb_image.h
+++ b/src/stb_image.h