Simplify clang-format configuration and format all code

1 files changed, 879 insertions, 895 deletions

diff --git a/examples/pugl_vulkan_demo.c b/examples/pugl_vulkan_demo.c
index ec96ec3..4a8324e 100644
--- a/examples/pugl_vulkan_demo.c
+++ b/examples/pugl_vulkan_demo.c
@@ -50,55 +50,55 @@
 
 /// Dynamically loaded Vulkan API functions
 typedef struct {
-	PFN_vkCreateDebugReportCallbackEXT  vkCreateDebugReportCallbackEXT;
-	PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT;
+  PFN_vkCreateDebugReportCallbackEXT  vkCreateDebugReportCallbackEXT;
+  PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT;
 } InstanceAPI;
 
 /// Vulkan swapchain and everything that depends on it
 typedef struct {
-	VkSwapchainKHR   rawSwapchain;
-	uint32_t         nImages;
-	VkExtent2D       extent;
-	VkImage*         images;
-	VkImageView*     imageViews;
-	VkFence*         fences;
-	VkCommandBuffer* commandBuffers;
+  VkSwapchainKHR   rawSwapchain;
+  uint32_t         nImages;
+  VkExtent2D       extent;
+  VkImage*         images;
+  VkImageView*     imageViews;
+  VkFence*         fences;
+  VkCommandBuffer* commandBuffers;
 } Swapchain;
 
 /// Synchronization semaphores
 typedef struct {
-	VkSemaphore presentComplete;
-	VkSemaphore renderFinished;
+  VkSemaphore presentComplete;
+  VkSemaphore renderFinished;
 } Sync;
 
 /// Vulkan state, purely Vulkan functions can depend on only this
 typedef struct {
-	InstanceAPI                api;
-	VkInstance                 instance;
-	VkDebugReportCallbackEXT   debugCallback;
-	VkSurfaceKHR               surface;
-	VkSurfaceFormatKHR         surfaceFormat;
-	VkPresentModeKHR           presentMode;
-	VkPhysicalDeviceProperties deviceProperties;
-	VkPhysicalDevice           physicalDevice;
-	uint32_t                   graphicsIndex;
-	VkDevice                   device;
-	VkQueue                    graphicsQueue;
-	VkCommandPool              commandPool;
-	Swapchain*                 swapchain;
-	Sync                       sync;
+  InstanceAPI                api;
+  VkInstance                 instance;
+  VkDebugReportCallbackEXT   debugCallback;
+  VkSurfaceKHR               surface;
+  VkSurfaceFormatKHR         surfaceFormat;
+  VkPresentModeKHR           presentMode;
+  VkPhysicalDeviceProperties deviceProperties;
+  VkPhysicalDevice           physicalDevice;
+  uint32_t                   graphicsIndex;
+  VkDevice                   device;
+  VkQueue                    graphicsQueue;
+  VkCommandPool              commandPool;
+  Swapchain*                 swapchain;
+  Sync                       sync;
 } VulkanState;
 
 /// Complete application
 typedef struct {
-	PuglTestOptions opts;
-	PuglWorld*      world;
-	PuglView*       view;
-	VulkanState     vk;
-	uint32_t        framesDrawn;
-	uint32_t        width;
-	uint32_t        height;
-	bool            quit;
+  PuglTestOptions opts;
+  PuglWorld*      world;
+  PuglView*       view;
+  VulkanState     vk;
+  uint32_t        framesDrawn;
+  uint32_t        width;
+  uint32_t        height;
+  bool            quit;
 } VulkanApp;
 
 static VKAPI_ATTR VkBool32 VKAPI_CALL
@@ -111,27 +111,27 @@ debugCallback(VkDebugReportFlagsEXT      flags,
               const char*                msg,
               void*                      userData)
 {
-	(void)userData;
-	(void)objType;
-	(void)obj;
-	(void)location;
-	(void)code;
-
-	if (flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT) {
-		fprintf(stderr, "note: ");
-	} else if (flags & VK_DEBUG_REPORT_WARNING_BIT_EXT) {
-		fprintf(stderr, "warning: ");
-	} else if (flags & VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT) {
-		fprintf(stderr, "performance warning: ");
-	} else if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT) {
-		fprintf(stderr, "error: ");
-	} else if (flags & VK_DEBUG_REPORT_DEBUG_BIT_EXT) {
-		fprintf(stderr, "debug: ");
-	}
-
-	fprintf(stderr, "%s: ", layerPrefix);
-	fprintf(stderr, "%s\n", msg);
-	return VK_FALSE;
+  (void)userData;
+  (void)objType;
+  (void)obj;
+  (void)location;
+  (void)code;
+
+  if (flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT) {
+    fprintf(stderr, "note: ");
+  } else if (flags & VK_DEBUG_REPORT_WARNING_BIT_EXT) {
+    fprintf(stderr, "warning: ");
+  } else if (flags & VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT) {
+    fprintf(stderr, "performance warning: ");
+  } else if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT) {
+    fprintf(stderr, "error: ");
+  } else if (flags & VK_DEBUG_REPORT_DEBUG_BIT_EXT) {
+    fprintf(stderr, "debug: ");
+  }
+
+  fprintf(stderr, "%s: ", layerPrefix);
+  fprintf(stderr, "%s\n", msg);
+  return VK_FALSE;
 }
 
 static bool
@@ -139,13 +139,13 @@ hasExtension(const char* const                  name,
              const VkExtensionProperties* const properties,
              const uint32_t                     count)
 {
-	for (uint32_t i = 0; i < count; ++i) {
-		if (!strcmp(properties[i].extensionName, name)) {
-			return true;
-		}
-	}
+  for (uint32_t i = 0; i < count; ++i) {
+    if (!strcmp(properties[i].extensionName, name)) {
+      return true;
+    }
+  }
 
-	return false;
+  return false;
 }
 
 static bool
@@ -153,13 +153,13 @@ hasLayer(const char* const              name,
          const VkLayerProperties* const properties,
          const uint32_t                 count)
 {
-	for (uint32_t i = 0; i < count; ++i) {
-		if (!strcmp(properties[i].layerName, name)) {
-			return true;
-		}
-	}
+  for (uint32_t i = 0; i < count; ++i) {
+    if (!strcmp(properties[i].layerName, name)) {
+      return true;
+    }
+  }
 
-	return false;
+  return false;
 }
 
 static void
@@ -167,129 +167,129 @@ pushString(const char*** const array,
            uint32_t* const     count,
            const char* const   string)
 {
-	*array = (const char**)realloc(*array, (*count + 1) * sizeof(const char*));
-	(*array)[*count] = string;
-	++*count;
+  *array = (const char**)realloc(*array, (*count + 1) * sizeof(const char*));
+  (*array)[*count] = string;
+  ++*count;
 }
 
 static VkResult
 createInstance(VulkanApp* const app)
 {
-	const VkApplicationInfo appInfo = {
-	    VK_STRUCTURE_TYPE_APPLICATION_INFO,
-	    NULL,
-	    "Pugl Vulkan Test",
-	    VK_MAKE_VERSION(0, 1, 0),
-	    "Pugl Vulkan Test Engine",
-	    VK_MAKE_VERSION(0, 1, 0),
-	    VK_MAKE_VERSION(1, 0, 0),
-	};
-
-	// Get the number of supported extensions and layers
-	VkResult vr          = VK_SUCCESS;
-	uint32_t nExtProps   = 0;
-	uint32_t nLayerProps = 0;
-	if ((vr = vkEnumerateInstanceLayerProperties(&nLayerProps, NULL)) ||
-	    (vr = vkEnumerateInstanceExtensionProperties(NULL, &nExtProps, NULL))) {
-		return vr;
-	}
-
-	// Get properties of supported extensions
-	VkExtensionProperties* extProps = AALLOC(nExtProps, VkExtensionProperties);
-	vkEnumerateInstanceExtensionProperties(NULL, &nExtProps, extProps);
-
-	uint32_t     nExtensions = 0;
-	const char** extensions  = NULL;
-
-	// Add extensions required by pugl
-	uint32_t           nPuglExts = 0;
-	const char* const* puglExts  = puglGetInstanceExtensions(&nPuglExts);
-	for (uint32_t i = 0; i < nPuglExts; ++i) {
-		pushString(&extensions, &nExtensions, puglExts[i]);
-	}
-
-	// Add extra extensions we want to use if they are supported
-	if (hasExtension("VK_EXT_debug_report", extProps, nExtProps)) {
-		pushString(&extensions, &nExtensions, "VK_EXT_debug_report");
-	}
-
-	// Get properties of supported layers
-	VkLayerProperties* layerProps = AALLOC(nLayerProps, VkLayerProperties);
-	vkEnumerateInstanceLayerProperties(&nLayerProps, layerProps);
-
-	// Add validation layers if error checking is enabled
-	uint32_t     nLayers = 0;
-	const char** layers  = NULL;
-	if (app->opts.errorChecking) {
-		const char* debugLayers[] = {"VK_LAYER_KHRONOS_validation",
-		                             "VK_LAYER_LUNARG_standard_validation",
-		                             NULL};
-
-		for (const char** l = debugLayers; *l; ++l) {
-			if (hasLayer(*l, layerProps, nLayerProps)) {
-				pushString(&layers, &nLayers, *l);
-			}
-		}
-	}
-
-	for (uint32_t i = 0; i < nExtensions; ++i) {
-		printf("Using instance extension:    %s\n", extensions[i]);
-	}
-
-	for (uint32_t i = 0; i < nLayers; ++i) {
-		printf("Using instance layer:        %s\n", layers[i]);
-	}
-
-	const VkInstanceCreateInfo createInfo = {
-	    VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
-	    NULL,
-	    0,
-	    &appInfo,
-	    COUNTED(nLayers, layers),
-	    COUNTED(nExtensions, extensions),
-	};
-
-	if ((vr = vkCreateInstance(&createInfo, ALLOC_VK, &app->vk.instance))) {
-		logError("Could not create Vulkan Instance: %d\n", vr);
-	}
-
-	free(layers);
-	free(extensions);
-	free(layerProps);
-	free(extProps);
-
-	return vr;
+  const VkApplicationInfo appInfo = {
+    VK_STRUCTURE_TYPE_APPLICATION_INFO,
+    NULL,
+    "Pugl Vulkan Test",
+    VK_MAKE_VERSION(0, 1, 0),
+    "Pugl Vulkan Test Engine",
+    VK_MAKE_VERSION(0, 1, 0),
+    VK_MAKE_VERSION(1, 0, 0),
+  };
+
+  // Get the number of supported extensions and layers
+  VkResult vr          = VK_SUCCESS;
+  uint32_t nExtProps   = 0;
+  uint32_t nLayerProps = 0;
+  if ((vr = vkEnumerateInstanceLayerProperties(&nLayerProps, NULL)) ||
+      (vr = vkEnumerateInstanceExtensionProperties(NULL, &nExtProps, NULL))) {
+    return vr;
+  }
+
+  // Get properties of supported extensions
+  VkExtensionProperties* extProps = AALLOC(nExtProps, VkExtensionProperties);
+  vkEnumerateInstanceExtensionProperties(NULL, &nExtProps, extProps);
+
+  uint32_t     nExtensions = 0;
+  const char** extensions  = NULL;
+
+  // Add extensions required by pugl
+  uint32_t           nPuglExts = 0;
+  const char* const* puglExts  = puglGetInstanceExtensions(&nPuglExts);
+  for (uint32_t i = 0; i < nPuglExts; ++i) {
+    pushString(&extensions, &nExtensions, puglExts[i]);
+  }
+
+  // Add extra extensions we want to use if they are supported
+  if (hasExtension("VK_EXT_debug_report", extProps, nExtProps)) {
+    pushString(&extensions, &nExtensions, "VK_EXT_debug_report");
+  }
+
+  // Get properties of supported layers
+  VkLayerProperties* layerProps = AALLOC(nLayerProps, VkLayerProperties);
+  vkEnumerateInstanceLayerProperties(&nLayerProps, layerProps);
+
+  // Add validation layers if error checking is enabled
+  uint32_t     nLayers = 0;
+  const char** layers  = NULL;
+  if (app->opts.errorChecking) {
+    const char* debugLayers[] = {"VK_LAYER_KHRONOS_validation",
+                                 "VK_LAYER_LUNARG_standard_validation",
+                                 NULL};
+
+    for (const char** l = debugLayers; *l; ++l) {
+      if (hasLayer(*l, layerProps, nLayerProps)) {
+        pushString(&layers, &nLayers, *l);
+      }
+    }
+  }
+
+  for (uint32_t i = 0; i < nExtensions; ++i) {
+    printf("Using instance extension:    %s\n", extensions[i]);
+  }
+
+  for (uint32_t i = 0; i < nLayers; ++i) {
+    printf("Using instance layer:        %s\n", layers[i]);
+  }
+
+  const VkInstanceCreateInfo createInfo = {
+    VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
+    NULL,
+    0,
+    &appInfo,
+    COUNTED(nLayers, layers),
+    COUNTED(nExtensions, extensions),
+  };
+
+  if ((vr = vkCreateInstance(&createInfo, ALLOC_VK, &app->vk.instance))) {
+    logError("Could not create Vulkan Instance: %d\n", vr);
+  }
+
+  free(layers);
+  free(extensions);
+  free(layerProps);
+  free(extProps);
+
+  return vr;
 }
 
 static VkResult
 enableDebugging(VulkanState* const vk)
 {
-	vk->api.vkCreateDebugReportCallbackEXT =
-	    (PFN_vkCreateDebugReportCallbackEXT)vkGetInstanceProcAddr(
-	        vk->instance, "vkCreateDebugReportCallbackEXT");
-
-	vk->api.vkDestroyDebugReportCallbackEXT =
-	    (PFN_vkDestroyDebugReportCallbackEXT)vkGetInstanceProcAddr(
-	        vk->instance, "vkDestroyDebugReportCallbackEXT");
-
-	if (vk->api.vkCreateDebugReportCallbackEXT) {
-		const VkDebugReportCallbackCreateInfoEXT info = {
-		    VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
-		    NULL,
-		    VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT,
-		    debugCallback,
-		    NULL,
-		};
-
-		VkResult vr = VK_SUCCESS;
-		if ((vr = vk->api.vkCreateDebugReportCallbackEXT(
-		         vk->instance, &info, ALLOC_VK, &vk->debugCallback))) {
-			logError("Could not create debug reporter: %d\n", vr);
-			return vr;
-		}
-	}
-
-	return VK_SUCCESS;
+  vk->api.vkCreateDebugReportCallbackEXT =
+    (PFN_vkCreateDebugReportCallbackEXT)vkGetInstanceProcAddr(
+      vk->instance, "vkCreateDebugReportCallbackEXT");
+
+  vk->api.vkDestroyDebugReportCallbackEXT =
+    (PFN_vkDestroyDebugReportCallbackEXT)vkGetInstanceProcAddr(
+      vk->instance, "vkDestroyDebugReportCallbackEXT");
+
+  if (vk->api.vkCreateDebugReportCallbackEXT) {
+    const VkDebugReportCallbackCreateInfoEXT info = {
+      VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
+      NULL,
+      VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT,
+      debugCallback,
+      NULL,
+    };
+
+    VkResult vr = VK_SUCCESS;
+    if ((vr = vk->api.vkCreateDebugReportCallbackEXT(
+           vk->instance, &info, ALLOC_VK, &vk->debugCallback))) {
+      logError("Could not create debug reporter: %d\n", vr);
+      return vr;
+    }
+  }
+
+  return VK_SUCCESS;
 }
 
 static VkResult
@@ -297,52 +297,51 @@ getGraphicsQueueIndex(VkSurfaceKHR     surface,
                       VkPhysicalDevice device,
                       uint32_t*        graphicsIndex)
 {
-	VkResult r = VK_SUCCESS;
-
-	uint32_t nProps = 0;
-	vkGetPhysicalDeviceQueueFamilyProperties(device, &nProps, NULL);
-
-	VkQueueFamilyProperties* props = AALLOC(nProps, VkQueueFamilyProperties);
-	vkGetPhysicalDeviceQueueFamilyProperties(device, &nProps, props);
-
-	for (uint32_t q = 0; q < nProps; ++q) {
-		if (props[q].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
-			VkBool32 supported = false;
-			if ((r = vkGetPhysicalDeviceSurfaceSupportKHR(
-			         device, q, surface, &supported))) {
-				free(props);
-				return r;
-			} else if (supported) {
-				*graphicsIndex = q;
-				free(props);
-				return VK_SUCCESS;
-			}
-		}
-	}
-
-	free(props);
-	return VK_ERROR_FEATURE_NOT_PRESENT;
+  VkResult r = VK_SUCCESS;
+
+  uint32_t nProps = 0;
+  vkGetPhysicalDeviceQueueFamilyProperties(device, &nProps, NULL);
+
+  VkQueueFamilyProperties* props = AALLOC(nProps, VkQueueFamilyProperties);
+  vkGetPhysicalDeviceQueueFamilyProperties(device, &nProps, props);
+
+  for (uint32_t q = 0; q < nProps; ++q) {
+    if (props[q].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
+      VkBool32 supported = false;
+      if ((r = vkGetPhysicalDeviceSurfaceSupportKHR(
+             device, q, surface, &supported))) {
+        free(props);
+        return r;
+      } else if (supported) {
+        *graphicsIndex = q;
+        free(props);
+        return VK_SUCCESS;
+      }
+    }
+  }
+
+  free(props);
+  return VK_ERROR_FEATURE_NOT_PRESENT;
 }
 
 static bool
 supportsRequiredExtensions(const VkPhysicalDevice device)
 {
-	uint32_t nExtProps = 0;
-	vkEnumerateDeviceExtensionProperties(device, NULL, &nExtProps, NULL);
-
-	VkExtensionProperties* extProps = AALLOC(nExtProps, VkExtensionProperties);
-	vkEnumerateDeviceExtensionProperties(device, NULL, &nExtProps, extProps);
-
-	for (uint32_t i = 0; i < nExtProps; ++i) {
-		if (!strcmp(extProps[i].extensionName,
-		            VK_KHR_SWAPCHAIN_EXTENSION_NAME)) {
-			free(extProps);
-			return true;
-		}
-	}
-
-	free(extProps);
-	return false;
+  uint32_t nExtProps = 0;
+  vkEnumerateDeviceExtensionProperties(device, NULL, &nExtProps, NULL);
+
+  VkExtensionProperties* extProps = AALLOC(nExtProps, VkExtensionProperties);
+  vkEnumerateDeviceExtensionProperties(device, NULL, &nExtProps, extProps);
+
+  for (uint32_t i = 0; i < nExtProps; ++i) {
+    if (!strcmp(extProps[i].extensionName, VK_KHR_SWAPCHAIN_EXTENSION_NAME)) {
+      free(extProps);
+      return true;
+    }
+  }
+
+  free(extProps);
+  return false;
 }
 
 static bool
@@ -350,12 +349,12 @@ isDeviceSuitable(const VulkanState* const vk,
                  const VkPhysicalDevice   device,
                  uint32_t* const          graphicsIndex)
 {
-	if (!supportsRequiredExtensions(device) ||
-	    getGraphicsQueueIndex(vk->surface, device, graphicsIndex)) {
-		return false;
-	}
+  if (!supportsRequiredExtensions(device) ||
+      getGraphicsQueueIndex(vk->surface, device, graphicsIndex)) {
+    return false;
+  }
 
-	return true;
+  return true;
 }
 
 /**
@@ -366,134 +365,134 @@ isDeviceSuitable(const VulkanState* const vk,
 static VkResult
 selectPhysicalDevice(VulkanState* const vk)
 {
-	VkResult vr = VK_SUCCESS;
-	if (!vk->surface) {
-		logError("Cannot select a physical device without a surface\n");
-		return VK_ERROR_SURFACE_LOST_KHR;
-	}
-
-	uint32_t nDevices = 0;
-	if ((vr = vkEnumeratePhysicalDevices(vk->instance, &nDevices, NULL))) {
-		logError("Failed to get count of physical devices: %d\n", vr);
-		return vr;
-	}
-
-	if (!nDevices) {
-		logError("No physical devices found\n");
-		return VK_ERROR_DEVICE_LOST;
-	}
-
-	VkPhysicalDevice* devices = AALLOC(nDevices, VkPhysicalDevice);
-	if ((vr = vkEnumeratePhysicalDevices(vk->instance, &nDevices, devices))) {
-		logError("Failed to enumerate physical devices: %d\n", vr);
-		free(devices);
-		return vr;
-	}
-
-	uint32_t i = 0;
-	for (i = 0; i < nDevices; ++i) {
-		VkPhysicalDeviceProperties deviceProps = {0};
-		vkGetPhysicalDeviceProperties(devices[i], &deviceProps);
-
-		uint32_t graphicsIndex = 0;
-		if (isDeviceSuitable(vk, devices[i], &graphicsIndex)) {
-			printf("Using device %u/%u:            \"%s\"\n",
-			       i + 1,
-			       nDevices,
-			       deviceProps.deviceName);
-			vk->deviceProperties = deviceProps;
-			vk->physicalDevice   = devices[i];
-			vk->graphicsIndex    = graphicsIndex;
-			printf("Using graphics queue family: %u\n", vk->graphicsIndex);
-			break;
-		}
-
-		printf("Device \"%s\" not suitable\n", deviceProps.deviceName);
-	}
-
-	if (i >= nDevices) {
-		logError("No suitable devices found\n");
-		vr = VK_ERROR_DEVICE_LOST;
-	}
-
-	free(devices);
-	return vr;
+  VkResult vr = VK_SUCCESS;
+  if (!vk->surface) {
+    logError("Cannot select a physical device without a surface\n");
+    return VK_ERROR_SURFACE_LOST_KHR;
+  }
+
+  uint32_t nDevices = 0;
+  if ((vr = vkEnumeratePhysicalDevices(vk->instance, &nDevices, NULL))) {
+    logError("Failed to get count of physical devices: %d\n", vr);
+    return vr;
+  }
+
+  if (!nDevices) {
+    logError("No physical devices found\n");
+    return VK_ERROR_DEVICE_LOST;
+  }
+
+  VkPhysicalDevice* devices = AALLOC(nDevices, VkPhysicalDevice);
+  if ((vr = vkEnumeratePhysicalDevices(vk->instance, &nDevices, devices))) {
+    logError("Failed to enumerate physical devices: %d\n", vr);
+    free(devices);
+    return vr;
+  }
+
+  uint32_t i = 0;
+  for (i = 0; i < nDevices; ++i) {
+    VkPhysicalDeviceProperties deviceProps = {0};
+    vkGetPhysicalDeviceProperties(devices[i], &deviceProps);
+
+    uint32_t graphicsIndex = 0;
+    if (isDeviceSuitable(vk, devices[i], &graphicsIndex)) {
+      printf("Using device %u/%u:            \"%s\"\n",
+             i + 1,
+             nDevices,
+             deviceProps.deviceName);
+      vk->deviceProperties = deviceProps;
+      vk->physicalDevice   = devices[i];
+      vk->graphicsIndex    = graphicsIndex;
+      printf("Using graphics queue family: %u\n", vk->graphicsIndex);
+      break;
+    }
+
+    printf("Device \"%s\" not suitable\n", deviceProps.deviceName);
+  }
+
+  if (i >= nDevices) {
+    logError("No suitable devices found\n");
+    vr = VK_ERROR_DEVICE_LOST;
+  }
+
+  free(devices);
+  return vr;
 }
 
 /// Opens the logical device and sets up the queue and command pool
 static VkResult
 openDevice(VulkanState* const vk)
 {
-	if (vk->device) {
-		logError("Renderer already has an opened device\n");
-		return VK_NOT_READY;
-	}
-
-	const float       graphicsQueuePriority = 1.0f;
-	const char* const swapchainName         = VK_KHR_SWAPCHAIN_EXTENSION_NAME;
-
-	const VkDeviceQueueCreateInfo queueCreateInfo = {
-	    VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
-	    NULL,
-	    0,
-	    vk->graphicsIndex,
-	    COUNTED(1, &graphicsQueuePriority),
-	};
-
-	const VkDeviceCreateInfo createInfo = {
-	    VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
-	    NULL,
-	    0,
-	    COUNTED(1, &queueCreateInfo),
-	    COUNTED(0, NULL),
-	    COUNTED(1, &swapchainName),
-	    NULL,
-	};
-
-	VkDevice device = NULL;
-	VkResult vr     = VK_SUCCESS;
-	if ((vr = vkCreateDevice(
-	         vk->physicalDevice, &createInfo, ALLOC_VK, &device))) {
-		logError("Could not open device \"%s\": %d\n",
-		         vk->deviceProperties.deviceName,
-		         vr);
-		return vr;
-	}
-
-	vk->device = device;
-	vkGetDeviceQueue(vk->device, vk->graphicsIndex, 0, &vk->graphicsQueue);
-
-	const VkCommandPoolCreateInfo commandInfo = {
-	    VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
-	    NULL,
-	    0,
-	    vk->graphicsIndex,
-	};
-
-	if ((vr = vkCreateCommandPool(
-	         vk->device, &commandInfo, ALLOC_VK, &vk->commandPool))) {
-		logError("Could not create command pool: %d\n", vr);
-		return vr;
-	}
-
-	return VK_SUCCESS;
+  if (vk->device) {
+    logError("Renderer already has an opened device\n");
+    return VK_NOT_READY;
+  }
+
+  const float       graphicsQueuePriority = 1.0f;
+  const char* const swapchainName         = VK_KHR_SWAPCHAIN_EXTENSION_NAME;
+
+  const VkDeviceQueueCreateInfo queueCreateInfo = {
+    VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
+    NULL,
+    0,
+    vk->graphicsIndex,
+    COUNTED(1, &graphicsQueuePriority),
+  };
+
+  const VkDeviceCreateInfo createInfo = {
+    VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
+    NULL,
+    0,
+    COUNTED(1, &queueCreateInfo),
+    COUNTED(0, NULL),
+    COUNTED(1, &swapchainName),
+    NULL,
+  };
+
+  VkDevice device = NULL;
+  VkResult vr     = VK_SUCCESS;
+  if ((vr =
+         vkCreateDevice(vk->physicalDevice, &createInfo, ALLOC_VK, &device))) {
+    logError("Could not open device \"%s\": %d\n",
+             vk->deviceProperties.deviceName,
+             vr);
+    return vr;
+  }
+
+  vk->device = device;
+  vkGetDeviceQueue(vk->device, vk->graphicsIndex, 0, &vk->graphicsQueue);
+
+  const VkCommandPoolCreateInfo commandInfo = {
+    VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
+    NULL,
+    0,
+    vk->graphicsIndex,
+  };
+
+  if ((vr = vkCreateCommandPool(
+         vk->device, &commandInfo, ALLOC_VK, &vk->commandPool))) {
+    logError("Could not create command pool: %d\n", vr);
+    return vr;
+  }
+
+  return VK_SUCCESS;
 }
 
 static const char*
 presentModeString(const VkPresentModeKHR presentMode)
 {
-	switch (presentMode) {
-	case VK_PRESENT_MODE_IMMEDIATE_KHR:
-		return "Immediate";
-	case VK_PRESENT_MODE_MAILBOX_KHR:
-		return "Mailbox";
-	case VK_PRESENT_MODE_FIFO_KHR:
-		return "FIFO";
-	case VK_PRESENT_MODE_FIFO_RELAXED_KHR:
-		return "FIFO relaxed";
-	default:
-		return "Other";
-	}
+  switch (presentMode) {
+  case VK_PRESENT_MODE_IMMEDIATE_KHR:
+    return "Immediate";
+  case VK_PRESENT_MODE_MAILBOX_KHR:
+    return "Mailbox";
+  case VK_PRESENT_MODE_FIFO_KHR:
+    return "FIFO";
+  case VK_PRESENT_MODE_FIFO_RELAXED_KHR:
+    return "FIFO relaxed";
+  default:
+    return "Other";
+  }
 }
 
 static bool
@@ -501,90 +500,82 @@ hasPresentMode(const VkPresentModeKHR        mode,
                const VkPresentModeKHR* const presentModes,
                const uint32_t                nPresentModes)
 {
-	for (uint32_t i = 0; i < nPresentModes; ++i) {
-		if (presentModes[i] == mode) {
-			return true;
-		}
-	}
+  for (uint32_t i = 0; i < nPresentModes; ++i) {
+    if (presentModes[i] == mode) {
+      return true;
+    }
+  }
 
-	return false;
+  return false;
 }
 
 /// Configure the surface for the currently opened device
 static VkResult
 configureSurface(VulkanState* const vk)
 {
-	uint32_t nFormats = 0;
-	vkGetPhysicalDeviceSurfaceFormatsKHR(vk->physicalDevice,
-	                                     vk->surface,
-	                                     &nFormats,
-	                                     NULL);
-	if (!nFormats) {
-		logError("No surface formats available\n");
-		return VK_ERROR_FORMAT_NOT_SUPPORTED;
-	}
-
-	VkSurfaceFormatKHR* surfaceFormats = AALLOC(nFormats, VkSurfaceFormatKHR);
-	vkGetPhysicalDeviceSurfaceFormatsKHR(vk->physicalDevice,
-	                                     vk->surface,
-	                                     &nFormats,
-	                                     surfaceFormats);
-
-	const VkSurfaceFormatKHR want = {VK_FORMAT_B8G8R8A8_UNORM,
-	                                 VK_COLOR_SPACE_SRGB_NONLINEAR_KHR};
-
-	uint32_t formatIndex = 0;
-	for (formatIndex = 0; formatIndex < nFormats; ++formatIndex) {
-		if (surfaceFormats[formatIndex].format == want.format &&
-		    surfaceFormats[formatIndex].colorSpace == want.colorSpace) {
-			vk->surfaceFormat = want;
-			break;
-		}
-	}
-	free(surfaceFormats);
-	if (formatIndex >= nFormats) {
-		logError("Could not find a suitable surface format\n");
-		return VK_ERROR_FORMAT_NOT_SUPPORTED;
-	}
-
-	uint32_t nPresentModes = 0;
-	vkGetPhysicalDeviceSurfacePresentModesKHR(vk->physicalDevice,
-	                                          vk->surface,
-	                                          &nPresentModes,
-	                                          NULL);
-	if (!nPresentModes) {
-		logError("No present modes available\n");
-		return VK_ERROR_FORMAT_NOT_SUPPORTED;
-	}
-
-	VkPresentModeKHR* presentModes = AALLOC(nPresentModes, VkPresentModeKHR);
-	vkGetPhysicalDeviceSurfacePresentModesKHR(vk->physicalDevice,
-	                                          vk->surface,
-	                                          &nPresentModes,
-	                                          presentModes);
-
-	const VkPresentModeKHR tryModes[] = {
-	    VK_PRESENT_MODE_MAILBOX_KHR,
-	    VK_PRESENT_MODE_FIFO_RELAXED_KHR,
-	    VK_PRESENT_MODE_FIFO_KHR,
-	    VK_PRESENT_MODE_IMMEDIATE_KHR,
-	};
-
-	VkPresentModeKHR presentMode = VK_PRESENT_MODE_FIFO_KHR;
-	for (uint32_t i = 0; i < sizeof(tryModes) / sizeof(VkPresentModeKHR); ++i) {
-		if (hasPresentMode(tryModes[i], presentModes, nPresentModes)) {
-			presentMode = tryModes[i];
-			break;
-		}
-	}
-
-	free(presentModes);
-	vk->presentMode = presentMode;
-	printf("Using present mode:          \"%s\" (%u)\n",
-	       presentModeString(presentMode),
-	       presentMode);
-
-	return VK_SUCCESS;
+  uint32_t nFormats = 0;
+  vkGetPhysicalDeviceSurfaceFormatsKHR(
+    vk->physicalDevice, vk->surface, &nFormats, NULL);
+  if (!nFormats) {
+    logError("No surface formats available\n");
+    return VK_ERROR_FORMAT_NOT_SUPPORTED;
+  }
+
+  VkSurfaceFormatKHR* surfaceFormats = AALLOC(nFormats, VkSurfaceFormatKHR);
+  vkGetPhysicalDeviceSurfaceFormatsKHR(
+    vk->physicalDevice, vk->surface, &nFormats, surfaceFormats);
+
+  const VkSurfaceFormatKHR want = {VK_FORMAT_B8G8R8A8_UNORM,
+                                   VK_COLOR_SPACE_SRGB_NONLINEAR_KHR};
+
+  uint32_t formatIndex = 0;
+  for (formatIndex = 0; formatIndex < nFormats; ++formatIndex) {
+    if (surfaceFormats[formatIndex].format == want.format &&
+        surfaceFormats[formatIndex].colorSpace == want.colorSpace) {
+      vk->surfaceFormat = want;
+      break;
+    }
+  }
+  free(surfaceFormats);
+  if (formatIndex >= nFormats) {
+    logError("Could not find a suitable surface format\n");
+    return VK_ERROR_FORMAT_NOT_SUPPORTED;
+  }
+
+  uint32_t nPresentModes = 0;
+  vkGetPhysicalDeviceSurfacePresentModesKHR(
+    vk->physicalDevice, vk->surface, &nPresentModes, NULL);
+  if (!nPresentModes) {
+    logError("No present modes available\n");
+    return VK_ERROR_FORMAT_NOT_SUPPORTED;
+  }
+
+  VkPresentModeKHR* presentModes = AALLOC(nPresentModes, VkPresentModeKHR);
+  vkGetPhysicalDeviceSurfacePresentModesKHR(
+    vk->physicalDevice, vk->surface, &nPresentModes, presentModes);
+
+  const VkPresentModeKHR tryModes[] = {
+    VK_PRESENT_MODE_MAILBOX_KHR,
+    VK_PRESENT_MODE_FIFO_RELAXED_KHR,
+    VK_PRESENT_MODE_FIFO_KHR,
+    VK_PRESENT_MODE_IMMEDIATE_KHR,
+  };
+
+  VkPresentModeKHR presentMode = VK_PRESENT_MODE_FIFO_KHR;
+  for (uint32_t i = 0; i < sizeof(tryModes) / sizeof(VkPresentModeKHR); ++i) {
+    if (hasPresentMode(tryModes[i], presentModes, nPresentModes)) {
+      presentMode = tryModes[i];
+      break;
+    }
+  }
+
+  free(presentModes);
+  vk->presentMode = presentMode;
+  printf("Using present mode:          \"%s\" (%u)\n",
+         presentModeString(presentMode),
+         presentMode);
+
+  return VK_SUCCESS;
 }
 
 static VkResult
@@ -592,140 +583,137 @@ createRawSwapchain(VulkanState* const vk,
                    const uint32_t     width,
                    const uint32_t     height)
 {
-	VkSurfaceCapabilitiesKHR surfaceCapabilities;
-	VkResult                 vr = VK_SUCCESS;
-	if ((vr = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
-	         vk->physicalDevice, vk->surface, &surfaceCapabilities))) {
-		logError("Could not get surface capabilities: %d\n", vr);
-		return vr;
-	}
-
-	/* There is a known race condition with window/surface sizes, so we clamp
-	   to what Vulkan reports and hope for the best. */
-
-	vk->swapchain->extent.width =
-	    CLAMP(width,
-	          surfaceCapabilities.minImageExtent.width,
-	          surfaceCapabilities.maxImageExtent.width);
-
-	vk->swapchain->extent.height =
-	    CLAMP(height,
-	          surfaceCapabilities.minImageExtent.height,
-	          surfaceCapabilities.maxImageExtent.height);
-
-	vk->swapchain->nImages = surfaceCapabilities.minImageCount;
-
-	const VkSwapchainCreateInfoKHR createInfo = {
-	    VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
-	    NULL,
-	    0,
-	    vk->surface,
-	    vk->swapchain->nImages,
-	    vk->surfaceFormat.format,
-	    VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
-	    vk->swapchain->extent,
-	    1,
-	    (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT),
-	    VK_SHARING_MODE_EXCLUSIVE,
-	    COUNTED(0, NULL),
-	    surfaceCapabilities.currentTransform,
-	    VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
-	    vk->presentMode,
-	    VK_TRUE,
-	    0,
-	};
-
-	if ((vr = vkCreateSwapchainKHR(vk->device,
-	                               &createInfo,
-	                               ALLOC_VK,
-	                               &vk->swapchain->rawSwapchain))) {
-		logError("Could not create swapchain: %d\n", vr);
-		return vr;
-	}
-
-	return VK_SUCCESS;
+  VkSurfaceCapabilitiesKHR surfaceCapabilities;
+  VkResult                 vr = VK_SUCCESS;
+  if ((vr = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+         vk->physicalDevice, vk->surface, &surfaceCapabilities))) {
+    logError("Could not get surface capabilities: %d\n", vr);
+    return vr;
+  }
+
+  /* There is a known race condition with window/surface sizes, so we clamp
+     to what Vulkan reports and hope for the best. */
+
+  vk->swapchain->extent.width = CLAMP(width,
+                                      surfaceCapabilities.minImageExtent.width,
+                                      surfaceCapabilities.maxImageExtent.width);
+
+  vk->swapchain->extent.height =
+    CLAMP(height,
+          surfaceCapabilities.minImageExtent.height,
+          surfaceCapabilities.maxImageExtent.height);
+
+  vk->swapchain->nImages = surfaceCapabilities.minImageCount;
+
+  const VkSwapchainCreateInfoKHR createInfo = {
+    VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
+    NULL,
+    0,
+    vk->surface,
+    vk->swapchain->nImages,
+    vk->surfaceFormat.format,
+    VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
+    vk->swapchain->extent,
+    1,
+    (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT),
+    VK_SHARING_MODE_EXCLUSIVE,
+    COUNTED(0, NULL),
+    surfaceCapabilities.currentTransform,
+    VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
+    vk->presentMode,
+    VK_TRUE,
+    0,
+  };
+
+  if ((vr = vkCreateSwapchainKHR(
+         vk->device, &createInfo, ALLOC_VK, &vk->swapchain->rawSwapchain))) {
+    logError("Could not create swapchain: %d\n", vr);
+    return vr;
+  }
+
+  return VK_SUCCESS;
 }
 
 static VkResult
 recordCommandBuffers(VulkanState* const vk)
 {
-	const VkClearColorValue clearValue = {{
-	    0xA4 / (float)0x100, // R
-	    0x1E / (float)0x100, // G
-	    0x22 / (float)0x100, // B
-	    0xFF / (float)0x100, // A
-	}};
-
-	const VkImageSubresourceRange range = {
-	    VK_IMAGE_ASPECT_COLOR_BIT,
-	    0,
-	    1,
-	    0,
-	    1,
-	};
-
-	const VkCommandBufferBeginInfo beginInfo = {
-	    VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
-	    NULL,
-	    VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
-	    NULL,
-	};
-
-	for (uint32_t i = 0; i < vk->swapchain->nImages; ++i) {
-		const VkImageMemoryBarrier toClearBarrier = {
-		    VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-		    NULL,
-		    VK_ACCESS_MEMORY_READ_BIT,
-		    VK_ACCESS_TRANSFER_WRITE_BIT,
-		    VK_IMAGE_LAYOUT_UNDEFINED,
-		    VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-		    vk->graphicsIndex,
-		    vk->graphicsIndex,
-		    vk->swapchain->images[i],
-		    range,
-		};
-
-		const VkImageMemoryBarrier toPresentBarrier = {
-		    VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-		    NULL,
-		    VK_ACCESS_TRANSFER_WRITE_BIT,
-		    VK_ACCESS_MEMORY_READ_BIT,
-		    VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-		    VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
-		    vk->graphicsIndex,
-		    vk->graphicsIndex,
-		    vk->swapchain->images[i],
-		    range,
-		};
-
-		vkBeginCommandBuffer(vk->swapchain->commandBuffers[i], &beginInfo);
-
-		vkCmdPipelineBarrier(vk->swapchain->commandBuffers[i],
-		                     VK_PIPELINE_STAGE_TRANSFER_BIT,
-		                     VK_PIPELINE_STAGE_TRANSFER_BIT,
-		                     0,
-		                     COUNTED(0, NULL),
-		                     COUNTED(0, NULL),
-		                     COUNTED(1, &toClearBarrier));
-
-		vkCmdClearColorImage(vk->swapchain->commandBuffers[i],
-		                     vk->swapchain->images[i],
-		                     VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-		                     &clearValue,
-		                     COUNTED(1, &range));
-
-		vkCmdPipelineBarrier(vk->swapchain->commandBuffers[i],
-		                     VK_PIPELINE_STAGE_TRANSFER_BIT,
-		                     VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
-		                     0,
-		                     COUNTED(0, NULL),
-		                     COUNTED(0, NULL),
-		                     COUNTED(1, &toPresentBarrier));
-
-		vkEndCommandBuffer(vk->swapchain->commandBuffers[i]);
-	}
-
-	return VK_SUCCESS;
+  const VkClearColorValue clearValue = {{
+    0xA4 / (float)0x100, // R
+    0x1E / (float)0x100, // G
+    0x22 / (float)0x100, // B
+    0xFF / (float)0x100, // A
+  }};
+
+  const VkImageSubresourceRange range = {
+    VK_IMAGE_ASPECT_COLOR_BIT,
+    0,
+    1,
+    0,
+    1,
+  };
+
+  const VkCommandBufferBeginInfo beginInfo = {
+    VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
+    NULL,
+    VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
+    NULL,
+  };
+
+  for (uint32_t i = 0; i < vk->swapchain->nImages; ++i) {
+    const VkImageMemoryBarrier toClearBarrier = {
+      VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+      NULL,
+      VK_ACCESS_MEMORY_READ_BIT,
+      VK_ACCESS_TRANSFER_WRITE_BIT,
+      VK_IMAGE_LAYOUT_UNDEFINED,
+      VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+      vk->graphicsIndex,
+      vk->graphicsIndex,
+      vk->swapchain->images[i],
+      range,
+    };
+
+    const VkImageMemoryBarrier toPresentBarrier = {
+      VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+      NULL,
+      VK_ACCESS_TRANSFER_WRITE_BIT,
+      VK_ACCESS_MEMORY_READ_BIT,
+      VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+      VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
+      vk->graphicsIndex,
+      vk->graphicsIndex,
+      vk->swapchain->images[i],
+      range,
+    };
+
+    vkBeginCommandBuffer(vk->swapchain->commandBuffers[i], &beginInfo);
+
+    vkCmdPipelineBarrier(vk->swapchain->commandBuffers[i],
+                         VK_PIPELINE_STAGE_TRANSFER_BIT,
+                         VK_PIPELINE_STAGE_TRANSFER_BIT,
+                         0,
+                         COUNTED(0, NULL),
+                         COUNTED(0, NULL),
+                         COUNTED(1, &toClearBarrier));
+
+    vkCmdClearColorImage(vk->swapchain->commandBuffers[i],
+                         vk->swapchain->images[i],
+                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+                         &clearValue,
+                         COUNTED(1, &range));
+
+    vkCmdPipelineBarrier(vk->swapchain->commandBuffers[i],
+                         VK_PIPELINE_STAGE_TRANSFER_BIT,
+                         VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
+                         0,
+                         COUNTED(0, NULL),
+                         COUNTED(0, NULL),
+                         COUNTED(1, &toPresentBarrier));
+
+    vkEndCommandBuffer(vk->swapchain->commandBuffers[i]);
+  }
+
+  return VK_SUCCESS;
 }
 
 static VkResult
@@ -733,204 +721,200 @@ createSwapchain(VulkanState* const vk,
                 const uint32_t     width,
                 const uint32_t     height)
 {
-	VkResult vr = VK_SUCCESS;
-
-	vk->swapchain = AALLOC(1, Swapchain);
-	if ((vr = createRawSwapchain(vk, width, height))) {
-		return vr;
-	}
-
-	if ((vr = vkGetSwapchainImagesKHR(vk->device,
-	                                  vk->swapchain->rawSwapchain,
-	                                  &vk->swapchain->nImages,
-	                                  NULL))) {
-		logError("Failed to query swapchain images: %d\n", vr);
-		return vr;
-	}
-
-	vk->swapchain->images = AALLOC(vk->swapchain->nImages, VkImage);
-	if ((vr = vkGetSwapchainImagesKHR(vk->device,
-	                                  vk->swapchain->rawSwapchain,
-	                                  &vk->swapchain->nImages,
-	                                  vk->swapchain->images))) {
-		logError("Failed to get swapchain images: %d\n", vr);
-		return vr;
-	}
-
-	const VkCommandBufferAllocateInfo allocInfo = {
-	    VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
-	    NULL,
-	    vk->commandPool,
-	    VK_COMMAND_BUFFER_LEVEL_PRIMARY,
-	    vk->swapchain->nImages,
-	};
-
-	vk->swapchain->commandBuffers = AALLOC(vk->swapchain->nImages,
-	                                       VkCommandBuffer);
-
-	if ((vr = vkAllocateCommandBuffers(vk->device,
-	                                   &allocInfo,
-	                                   vk->swapchain->commandBuffers))) {
-		logError("Could not allocate command buffers: %d\n", vr);
-		return vr;
-	}
-
-	const VkFenceCreateInfo fenceInfo = {
-	    VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
-	    NULL,
-	    VK_FENCE_CREATE_SIGNALED_BIT,
-	};
-	vk->swapchain->fences = AALLOC(vk->swapchain->nImages, VkFence);
-
-	for (uint32_t i = 0; i < vk->swapchain->nImages; ++i) {
-		if ((vr = vkCreateFence(vk->device,
-		                        &fenceInfo,
-		                        ALLOC_VK,
-		                        &vk->swapchain->fences[i]))) {
-			logError("Could not create render finished fence: %d\n", vr);
-			return vr;
-		}
-	}
-
-	if ((vr = recordCommandBuffers(vk))) {
-		logError("Failed to record command buffers\n");
-		return vr;
-	}
-
-	return VK_SUCCESS;
+  VkResult vr = VK_SUCCESS;
+
+  vk->swapchain = AALLOC(1, Swapchain);
+  if ((vr = createRawSwapchain(vk, width, height))) {
+    return vr;
+  }
+
+  if ((vr = vkGetSwapchainImagesKHR(vk->device,
+                                    vk->swapchain->rawSwapchain,
+                                    &vk->swapchain->nImages,
+                                    NULL))) {
+    logError("Failed to query swapchain images: %d\n", vr);
+    return vr;
+  }
+
+  vk->swapchain->images = AALLOC(vk->swapchain->nImages, VkImage);
+  if ((vr = vkGetSwapchainImagesKHR(vk->device,
+                                    vk->swapchain->rawSwapchain,
+                                    &vk->swapchain->nImages,
+                                    vk->swapchain->images))) {
+    logError("Failed to get swapchain images: %d\n", vr);
+    return vr;
+  }
+
+  const VkCommandBufferAllocateInfo allocInfo = {
+    VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
+    NULL,
+    vk->commandPool,
+    VK_COMMAND_BUFFER_LEVEL_PRIMARY,
+    vk->swapchain->nImages,
+  };
+
+  vk->swapchain->commandBuffers =
+    AALLOC(vk->swapchain->nImages, VkCommandBuffer);
+
+  if ((vr = vkAllocateCommandBuffers(
+         vk->device, &allocInfo, vk->swapchain->commandBuffers))) {
+    logError("Could not allocate command buffers: %d\n", vr);
+    return vr;
+  }
+
+  const VkFenceCreateInfo fenceInfo = {
+    VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
+    NULL,
+    VK_FENCE_CREATE_SIGNALED_BIT,
+  };
+  vk->swapchain->fences = AALLOC(vk->swapchain->nImages, VkFence);
+
+  for (uint32_t i = 0; i < vk->swapchain->nImages; ++i) {
+    if ((vr = vkCreateFence(
+           vk->device, &fenceInfo, ALLOC_VK, &vk->swapchain->fences[i]))) {
+      logError("Could not create render finished fence: %d\n", vr);
+      return vr;
+    }
+  }
+
+  if ((vr = recordCommandBuffers(vk))) {
+    logError("Failed to record command buffers\n");
+    return vr;
+  }
+
+  return VK_SUCCESS;
 }
 
 static void
 destroySwapchain(VulkanState* const vk, Swapchain* const swapchain)
 {
-	if (!swapchain) {
-		return;
-	}
-
-	for (uint32_t i = 0; i < swapchain->nImages; ++i) {
-		if (swapchain->fences[i]) {
-			vkDestroyFence(vk->device, swapchain->fences[i], ALLOC_VK);
-		}
-
-		if (swapchain->imageViews && swapchain->imageViews[i]) {
-			vkDestroyImageView(vk->device, swapchain->imageViews[i], ALLOC_VK);
-		}
-	}
-
-	free(swapchain->fences);
-	swapchain->fences = NULL;
-	free(swapchain->imageViews);
-	swapchain->imageViews = NULL;
-
-	if (swapchain->images) {
-		free(swapchain->images);
-		swapchain->images = NULL;
-	}
-
-	if (swapchain->commandBuffers) {
-		vkFreeCommandBuffers(vk->device,
-		                     vk->commandPool,
-		                     swapchain->nImages,
-		                     swapchain->commandBuffers);
-		free(swapchain->commandBuffers);
-	}
-
-	if (swapchain->rawSwapchain) {
-		vkDestroySwapchainKHR(vk->device, swapchain->rawSwapchain, ALLOC_VK);
-	}
-
-	free(swapchain);
+  if (!swapchain) {
+    return;
+  }
+
+  for (uint32_t i = 0; i < swapchain->nImages; ++i) {
+    if (swapchain->fences[i]) {
+      vkDestroyFence(vk->device, swapchain->fences[i], ALLOC_VK);
+    }
+
+    if (swapchain->imageViews && swapchain->imageViews[i]) {
+      vkDestroyImageView(vk->device, swapchain->imageViews[i], ALLOC_VK);
+    }
+  }
+
+  free(swapchain->fences);
+  swapchain->fences = NULL;
+  free(swapchain->imageViews);
+  swapchain->imageViews = NULL;
+
+  if (swapchain->images) {
+    free(swapchain->images);
+    swapchain->images = NULL;
+  }
+
+  if (swapchain->commandBuffers) {
+    vkFreeCommandBuffers(vk->device,
+                         vk->commandPool,
+                         swapchain->nImages,
+                         swapchain->commandBuffers);
+    free(swapchain->commandBuffers);
+  }
+
+  if (swapchain->rawSwapchain) {
+    vkDestroySwapchainKHR(vk->device, swapchain->rawSwapchain, ALLOC_VK);
+  }
+
+  free(swapchain);
 }
 
 static VkResult
 createSyncObjects(VulkanState* const vk)
 {
-	const VkSemaphoreCreateInfo info = {
-	    VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
-	    NULL,
-	    0,
-	};
-
-	vkCreateSemaphore(vk->device, &info, ALLOC_VK, &vk->sync.presentComplete);
-	vkCreateSemaphore(vk->device, &info, ALLOC_VK, &vk->sync.renderFinished);
-	return VK_SUCCESS;
+  const VkSemaphoreCreateInfo info = {
+    VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
+    NULL,
+    0,
+  };
+
+  vkCreateSemaphore(vk->device, &info, ALLOC_VK, &vk->sync.presentComplete);
+  vkCreateSemaphore(vk->device, &info, ALLOC_VK, &vk->sync.renderFinished);
+  return VK_SUCCESS;
 }
 
 static void
 destroySyncObjects(VulkanState* const vk)
 {
-	if (vk->sync.renderFinished) {
-		vkDestroySemaphore(vk->device, vk->sync.renderFinished, ALLOC_VK);
-		vk->sync.renderFinished = VK_NULL_HANDLE;
-	}
-	if (vk->sync.presentComplete) {
-		vkDestroySemaphore(vk->device, vk->sync.presentComplete, ALLOC_VK);
-		vk->sync.presentComplete = VK_NULL_HANDLE;
-	}
+  if (vk->sync.renderFinished) {
+    vkDestroySemaphore(vk->device, vk->sync.renderFinished, ALLOC_VK);
+    vk->sync.renderFinished = VK_NULL_HANDLE;
+  }
+  if (vk->sync.presentComplete) {
+    vkDestroySemaphore(vk->device, vk->sync.presentComplete, ALLOC_VK);
+    vk->sync.presentComplete = VK_NULL_HANDLE;
+  }
 }
 
 static void
 closeDevice(VulkanState* const vk)
 {
-	if (vk->device) {
-		vkDeviceWaitIdle(vk->device);
-		destroySyncObjects(vk);
-		destroySwapchain(vk, vk->swapchain);
-		if (vk->commandPool) {
-			vkDestroyCommandPool(vk->device, vk->commandPool, ALLOC_VK);
-			vk->commandPool = VK_NULL_HANDLE;
-		}
-		vk->graphicsQueue = VK_NULL_HANDLE;
-		vkDestroyDevice(vk->device, ALLOC_VK);
-		vk->device = VK_NULL_HANDLE;
-	}
+  if (vk->device) {
+    vkDeviceWaitIdle(vk->device);
+    destroySyncObjects(vk);
+    destroySwapchain(vk, vk->swapchain);
+    if (vk->commandPool) {
+      vkDestroyCommandPool(vk->device, vk->commandPool, ALLOC_VK);
+      vk->commandPool = VK_NULL_HANDLE;
+    }
+    vk->graphicsQueue = VK_NULL_HANDLE;
+    vkDestroyDevice(vk->device, ALLOC_VK);
+    vk->device = VK_NULL_HANDLE;
+  }
 }
 
 static void
 destroyWorld(VulkanApp* const app)
 {
-	VulkanState* vk = &app->vk;
-
-	if (vk) {
-		closeDevice(vk);
-
-		if (app->view) {
-			puglHide(app->view);
-			puglFreeView(app->view);
-			app->view = NULL;
-		}
-		if (vk->debugCallback && vk->api.vkDestroyDebugReportCallbackEXT) {
-			vk->api.vkDestroyDebugReportCallbackEXT(vk->instance,
-			                                        vk->debugCallback,
-			                                        ALLOC_VK);
-			vk->debugCallback = VK_NULL_HANDLE;
-		}
-		if (vk->surface) {
-			vkDestroySurfaceKHR(vk->instance, vk->surface, ALLOC_VK);
-			vk->surface = VK_NULL_HANDLE;
-		}
-		if (vk->instance) {
-			fflush(stderr);
-			vkDestroyInstance(vk->instance, ALLOC_VK);
-			vk->instance = VK_NULL_HANDLE;
-		}
-		if (app->world) {
-			puglFreeWorld(app->world);
-			app->world = NULL;
-		}
-	}
+  VulkanState* vk = &app->vk;
+
+  if (vk) {
+    closeDevice(vk);
+
+    if (app->view) {
+      puglHide(app->view);
+      puglFreeView(app->view);
+      app->view = NULL;
+    }
+    if (vk->debugCallback && vk->api.vkDestroyDebugReportCallbackEXT) {
+      vk->api.vkDestroyDebugReportCallbackEXT(
+        vk->instance, vk->debugCallback, ALLOC_VK);
+      vk->debugCallback = VK_NULL_HANDLE;
+    }
+    if (vk->surface) {
+      vkDestroySurfaceKHR(vk->instance, vk->surface, ALLOC_VK);
+      vk->surface = VK_NULL_HANDLE;
+    }
+    if (vk->instance) {
+      fflush(stderr);
+      vkDestroyInstance(vk->instance, ALLOC_VK);
+      vk->instance = VK_NULL_HANDLE;
+    }
+    if (app->world) {
+      puglFreeWorld(app->world);
+      app->world = NULL;
+    }
+  }
 }
 
 static PuglStatus
 onConfigure(PuglView* const view, const double width, const double height)
 {
-	VulkanApp* const app = (VulkanApp*)puglGetHandle(view);
+  VulkanApp* const app = (VulkanApp*)puglGetHandle(view);
 
-	// We just record the size here and lazily resize the surface when exposed
-	app->width  = (uint32_t)width;
-	app->height = (uint32_t)height;
+  // We just record the size here and lazily resize the surface when exposed
+  app->width  = (uint32_t)width;
+  app->height = (uint32_t)height;
 
-	return PUGL_SUCCESS;
+  return PUGL_SUCCESS;
 }
 
 static PuglStatus
@@ -938,202 +922,202 @@ recreateSwapchain(VulkanState* const vk,
                   const uint32_t     width,
                   const uint32_t     height)
 {
-	vkDeviceWaitIdle(vk->device);
-	destroySwapchain(vk, vk->swapchain);
+  vkDeviceWaitIdle(vk->device);
+  destroySwapchain(vk, vk->swapchain);
 
-	if (createSwapchain(vk, width, height)) {
-		logError("Failed to recreate swapchain\n");
-		return PUGL_UNKNOWN_ERROR;
-	}
+  if (createSwapchain(vk, width, height)) {
+    logError("Failed to recreate swapchain\n");
+    return PUGL_UNKNOWN_ERROR;
+  }
 
-	return PUGL_SUCCESS;
+  return PUGL_SUCCESS;
 }
 
 static PuglStatus
 onExpose(PuglView* const view)
 {
-	VulkanApp*   app        = (VulkanApp*)puglGetHandle(view);
-	VulkanState* vk         = &app->vk;
-	uint32_t     imageIndex = 0;
-	VkResult     result     = VK_SUCCESS;
-
-	// Recreate swapchain if the window size has changed
-	const Swapchain* swapchain = vk->swapchain;
-	if (swapchain->extent.width != app->width ||
-	    swapchain->extent.height != app->height) {
-		recreateSwapchain(vk, app->width, app->height);
-	}
-
-	// Acquire the next image to render, rebuilding if necessary
-	while ((result = vkAcquireNextImageKHR(vk->device,
-	                                       vk->swapchain->rawSwapchain,
-	                                       UINT64_MAX,
-	                                       vk->sync.presentComplete,
-	                                       VK_NULL_HANDLE,
-	                                       &imageIndex))) {
-		switch (result) {
-		case VK_SUCCESS:
-			break;
-		case VK_SUBOPTIMAL_KHR:
-		case VK_ERROR_OUT_OF_DATE_KHR:
-			recreateSwapchain(vk, app->width, app->height);
-			continue;
-		default:
-			logError("Could not acquire swapchain image: %d\n", result);
-			return PUGL_UNKNOWN_ERROR;
-		}
-	}
-
-	// Wait until we can start rendering this frame
-	vkWaitForFences(vk->device,
-	                COUNTED(1, &vk->swapchain->fences[imageIndex]),
-	                VK_TRUE,
-	                UINT64_MAX);
-	vkResetFences(vk->device, 1, &vk->swapchain->fences[imageIndex]);
-
-	const VkPipelineStageFlags waitStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
-
-	// Submit command buffer to render this frame
-	const VkSubmitInfo submitInfo = {
-	    VK_STRUCTURE_TYPE_SUBMIT_INFO,
-	    NULL,
-	    COUNTED(1, &vk->sync.presentComplete),
-	    &waitStage,
-	    COUNTED(1, &vk->swapchain->commandBuffers[imageIndex]),
-	    COUNTED(1, &vk->sync.renderFinished)};
-	if ((result = vkQueueSubmit(vk->graphicsQueue,
-	                            1,
-	                            &submitInfo,
-	                            vk->swapchain->fences[imageIndex]))) {
-		logError("Could not submit to queue: %d\n", result);
-		return PUGL_FAILURE;
-	}
-
-	// Present this frame
-	const VkPresentInfoKHR presentInfo = {
-	    VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
-	    NULL,
-	    COUNTED(1, &vk->sync.renderFinished),
-	    COUNTED(1, &vk->swapchain->rawSwapchain, &imageIndex, NULL),
-	};
-	if ((result = vkQueuePresentKHR(vk->graphicsQueue, &presentInfo))) {
-		logError("Could not present image: %d\n", result);
-	}
-
-	if (app->opts.continuous) {
-		++app->framesDrawn;
-	}
-
-	return PUGL_SUCCESS;
+  VulkanApp*   app        = (VulkanApp*)puglGetHandle(view);
+  VulkanState* vk         = &app->vk;
+  uint32_t     imageIndex = 0;
+  VkResult     result     = VK_SUCCESS;
+
+  // Recreate swapchain if the window size has changed
+  const Swapchain* swapchain = vk->swapchain;
+  if (swapchain->extent.width != app->width ||
+      swapchain->extent.height != app->height) {
+    recreateSwapchain(vk, app->width, app->height);
+  }
+
+  // Acquire the next image to render, rebuilding if necessary
+  while ((result = vkAcquireNextImageKHR(vk->device,
+                                         vk->swapchain->rawSwapchain,
+                                         UINT64_MAX,
+                                         vk->sync.presentComplete,
+                                         VK_NULL_HANDLE,
+                                         &imageIndex))) {
+    switch (result) {
+    case VK_SUCCESS:
+      break;
+    case VK_SUBOPTIMAL_KHR:
+    case VK_ERROR_OUT_OF_DATE_KHR:
+      recreateSwapchain(vk, app->width, app->height);
+      continue;
+    default:
+      logError("Could not acquire swapchain image: %d\n", result);
+      return PUGL_UNKNOWN_ERROR;
+    }
+  }
+
+  // Wait until we can start rendering this frame
+  vkWaitForFences(vk->device,
+                  COUNTED(1, &vk->swapchain->fences[imageIndex]),
+                  VK_TRUE,
+                  UINT64_MAX);
+  vkResetFences(vk->device, 1, &vk->swapchain->fences[imageIndex]);
+
+  const VkPipelineStageFlags waitStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
+
+  // Submit command buffer to render this frame
+  const VkSubmitInfo submitInfo = {
+    VK_STRUCTURE_TYPE_SUBMIT_INFO,
+    NULL,
+    COUNTED(1, &vk->sync.presentComplete),
+    &waitStage,
+    COUNTED(1, &vk->swapchain->commandBuffers[imageIndex]),
+    COUNTED(1, &vk->sync.renderFinished)};
+  if ((result = vkQueueSubmit(vk->graphicsQueue,
+                              1,
+                              &submitInfo,
+                              vk->swapchain->fences[imageIndex]))) {
+    logError("Could not submit to queue: %d\n", result);
+    return PUGL_FAILURE;
+  }
+
+  // Present this frame
+  const VkPresentInfoKHR presentInfo = {
+    VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
+    NULL,
+    COUNTED(1, &vk->sync.renderFinished),
+    COUNTED(1, &vk->swapchain->rawSwapchain, &imageIndex, NULL),
+  };
+  if ((result = vkQueuePresentKHR(vk->graphicsQueue, &presentInfo))) {
+    logError("Could not present image: %d\n", result);
+  }
+
+  if (app->opts.continuous) {
+    ++app->framesDrawn;
+  }
+
+  return PUGL_SUCCESS;
 }
 
 static PuglStatus
 onEvent(PuglView* const view, const PuglEvent* const e)
 {
-	VulkanApp* const app = (VulkanApp*)puglGetHandle(view);
-
-	printEvent(e, "Event: ", app->opts.verbose);
-
-	switch (e->type) {
-	case PUGL_EXPOSE:
-		return onExpose(view);
-	case PUGL_CONFIGURE:
-		return onConfigure(view, e->configure.width, e->configure.height);
-	case PUGL_CLOSE:
-		app->quit = 1;
-		break;
-	case PUGL_KEY_PRESS:
-		switch (e->key.key) {
-		case PUGL_KEY_ESCAPE:
-		case 'q':
-			app->quit = 1;
-			break;
-		}
-		break;
-	default:
-		break;
-	}
-	return PUGL_SUCCESS;
+  VulkanApp* const app = (VulkanApp*)puglGetHandle(view);
+
+  printEvent(e, "Event: ", app->opts.verbose);
+
+  switch (e->type) {
+  case PUGL_EXPOSE:
+    return onExpose(view);
+  case PUGL_CONFIGURE:
+    return onConfigure(view, e->configure.width, e->configure.height);
+  case PUGL_CLOSE:
+    app->quit = 1;
+    break;
+  case PUGL_KEY_PRESS:
+    switch (e->key.key) {
+    case PUGL_KEY_ESCAPE:
+    case 'q':
+      app->quit = 1;
+      break;
+    }
+    break;
+  default:
+    break;
+  }
+  return PUGL_SUCCESS;
 }
 
 int
 main(int argc, char** argv)
 {
-	VulkanApp      app           = {0};
-	VulkanState*   vk            = &app.vk;
-	const uint32_t defaultWidth  = 640;
-	const uint32_t defaultHeight = 360;
-	const PuglRect frame         = {0, 0, defaultWidth, defaultHeight};
-
-	// Parse command line options
-	app.opts = puglParseTestOptions(&argc, &argv);
-	if (app.opts.help) {
-		puglPrintTestUsage(argv[0], "");
-		return 0;
-	}
-
-	// Create world and view
-	if (!(app.world = puglNewWorld(PUGL_PROGRAM, PUGL_WORLD_THREADS))) {
-		return logError("Failed to create world\n");
-	} else if (!(app.view = puglNewView(app.world))) {
-		puglFreeWorld(app.world);
-		return logError("Failed to create Pugl World and View\n");
-	}
-
-	// Create Vulkan instance
-	if (createInstance(&app)) {
-		puglFreeWorld(app.world);
-		return logError("Failed to create instance\n");
-	}
-
-	// Create window
-	puglSetWindowTitle(app.view, "Pugl Vulkan");
-	puglSetFrame(app.view, frame);
-	puglSetHandle(app.view, &app);
-	puglSetBackend(app.view, puglVulkanBackend());
-	puglSetViewHint(app.view, PUGL_RESIZABLE, app.opts.resizable);
-	puglSetEventFunc(app.view, onEvent);
-	const PuglStatus st = puglRealize(app.view);
-	if (st) {
-		puglFreeWorld(app.world);
-		puglFreeView(app.view);
-		return logError("Failed to create window (%s)\n", puglStrerror(st));
-	}
-
-	// Create Vulkan surface for Window
-	PuglVulkanLoader* loader = puglNewVulkanLoader(app.world);
-	if (puglCreateSurface(puglGetInstanceProcAddrFunc(loader),
-	                      app.view,
-	                      vk->instance,
-	                      ALLOC_VK,
-	                      &vk->surface)) {
-		return logError("Failed to create surface\n");
-	}
-
-	// Set up Vulkan
-	VkResult vr = VK_SUCCESS;
-	if ((vr = enableDebugging(vk)) ||                              //
-	    (vr = selectPhysicalDevice(vk)) ||                         //
-	    (vr = openDevice(vk)) ||                                   //
-	    (vr = configureSurface(vk)) ||                             //
-	    (vr = createSwapchain(vk, defaultWidth, defaultHeight)) || //
-	    (vr = createSyncObjects(vk))) {
-		destroyWorld(&app);
-		return logError("Failed to set up graphics (%d)\n", vr);
-	}
-
-	printf("Swapchain images:            %u\n", app.vk.swapchain->nImages);
-
-	PuglFpsPrinter fpsPrinter = {puglGetTime(app.world)};
-	puglShow(app.view);
-	while (!app.quit) {
-		puglUpdate(app.world, -1.0);
-
-		if (app.opts.continuous) {
-			puglPrintFps(app.world, &fpsPrinter, &app.framesDrawn);
-		}
-	}
-
-	destroyWorld(&app);
-	return 0;
+  VulkanApp      app           = {0};
+  VulkanState*   vk            = &app.vk;
+  const uint32_t defaultWidth  = 640;
+  const uint32_t defaultHeight = 360;
+  const PuglRect frame         = {0, 0, defaultWidth, defaultHeight};
+
+  // Parse command line options
+  app.opts = puglParseTestOptions(&argc, &argv);
+  if (app.opts.help) {
+    puglPrintTestUsage(argv[0], "");
+    return 0;
+  }
+
+  // Create world and view
+  if (!(app.world = puglNewWorld(PUGL_PROGRAM, PUGL_WORLD_THREADS))) {
+    return logError("Failed to create world\n");
+  } else if (!(app.view = puglNewView(app.world))) {
+    puglFreeWorld(app.world);
+    return logError("Failed to create Pugl World and View\n");
+  }
+
+  // Create Vulkan instance
+  if (createInstance(&app)) {
+    puglFreeWorld(app.world);
+    return logError("Failed to create instance\n");
+  }
+
+  // Create window
+  puglSetWindowTitle(app.view, "Pugl Vulkan");
+  puglSetFrame(app.view, frame);
+  puglSetHandle(app.view, &app);
+  puglSetBackend(app.view, puglVulkanBackend());
+  puglSetViewHint(app.view, PUGL_RESIZABLE, app.opts.resizable);
+  puglSetEventFunc(app.view, onEvent);
+  const PuglStatus st = puglRealize(app.view);
+  if (st) {
+    puglFreeWorld(app.world);
+    puglFreeView(app.view);
+    return logError("Failed to create window (%s)\n", puglStrerror(st));
+  }
+
+  // Create Vulkan surface for Window
+  PuglVulkanLoader* loader = puglNewVulkanLoader(app.world);
+  if (puglCreateSurface(puglGetInstanceProcAddrFunc(loader),
+                        app.view,
+                        vk->instance,
+                        ALLOC_VK,
+                        &vk->surface)) {
+    return logError("Failed to create surface\n");
+  }
+
+  // Set up Vulkan
+  VkResult vr = VK_SUCCESS;
+  if ((vr = enableDebugging(vk)) ||                              //
+      (vr = selectPhysicalDevice(vk)) ||                         //
+      (vr = openDevice(vk)) ||                                   //
+      (vr = configureSurface(vk)) ||                             //
+      (vr = createSwapchain(vk, defaultWidth, defaultHeight)) || //
+      (vr = createSyncObjects(vk))) {
+    destroyWorld(&app);
+    return logError("Failed to set up graphics (%d)\n", vr);
+  }
+
+  printf("Swapchain images:            %u\n", app.vk.swapchain->nImages);
+
+  PuglFpsPrinter fpsPrinter = {puglGetTime(app.world)};
+  puglShow(app.view);
+  while (!app.quit) {
+    puglUpdate(app.world, -1.0);
+
+    if (app.opts.continuous) {
+      puglPrintFps(app.world, &fpsPrinter, &app.framesDrawn);
+    }
+  }
+
+  destroyWorld(&app);
+  return 0;
 }