layers: Clang-format changes for files in layers dir of repo

1 files changed, 479 insertions, 205 deletions

diff --git a/layers/unique_objects.h b/layers/unique_objects.h
index 5b3d5d5c..6e073aec 100644
--- a/layers/unique_objects.h
+++ b/layers/unique_objects.h
@@ -50,9 +50,7 @@
 struct layer_data {
     bool wsi_enabled;
 
-    layer_data() :
-        wsi_enabled(false)
-    {};
+    layer_data() : wsi_enabled(false){};
 };
 
 struct instExts {
@@ -65,93 +63,126 @@ struct instExts {
     bool win32_enabled;
 };
 
-static std::unordered_map<void*, struct instExts> instanceExtMap;
-static std::unordered_map<void*, layer_data *>    layer_data_map;
-static device_table_map                           unique_objects_device_table_map;
-static instance_table_map                         unique_objects_instance_table_map;
-// Structure to wrap returned non-dispatchable objects to guarantee they have unique handles
+static std::unordered_map<void *, struct instExts> instanceExtMap;
+static std::unordered_map<void *, layer_data *> layer_data_map;
+static device_table_map unique_objects_device_table_map;
+static instance_table_map unique_objects_instance_table_map;
+// Structure to wrap returned non-dispatchable objects to guarantee they have
+// unique handles
 //  address of struct will be used as the unique handle
-struct VkUniqueObject
-{
+struct VkUniqueObject {
     uint64_t actualObject;
 };
 
 // Handle CreateInstance
-static void createInstanceRegisterExtensions(const VkInstanceCreateInfo* pCreateInfo, VkInstance instance)
-{
+static void
+createInstanceRegisterExtensions(const VkInstanceCreateInfo *pCreateInfo,
+                                 VkInstance instance) {
     uint32_t i;
-    VkLayerInstanceDispatchTable *pDisp = get_dispatch_table(unique_objects_instance_table_map, instance);
+    VkLayerInstanceDispatchTable *pDisp =
+        get_dispatch_table(unique_objects_instance_table_map, instance);
     PFN_vkGetInstanceProcAddr gpa = pDisp->GetInstanceProcAddr;
-    pDisp->GetPhysicalDeviceSurfaceSupportKHR = (PFN_vkGetPhysicalDeviceSurfaceSupportKHR) gpa(instance, "vkGetPhysicalDeviceSurfaceSupportKHR");
-    pDisp->GetPhysicalDeviceSurfaceCapabilitiesKHR = (PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR) gpa(instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
-    pDisp->GetPhysicalDeviceSurfaceFormatsKHR = (PFN_vkGetPhysicalDeviceSurfaceFormatsKHR) gpa(instance, "vkGetPhysicalDeviceSurfaceFormatsKHR");
-    pDisp->GetPhysicalDeviceSurfacePresentModesKHR = (PFN_vkGetPhysicalDeviceSurfacePresentModesKHR) gpa(instance, "vkGetPhysicalDeviceSurfacePresentModesKHR");
+    pDisp->GetPhysicalDeviceSurfaceSupportKHR =
+        (PFN_vkGetPhysicalDeviceSurfaceSupportKHR)gpa(
+            instance, "vkGetPhysicalDeviceSurfaceSupportKHR");
+    pDisp->GetPhysicalDeviceSurfaceCapabilitiesKHR =
+        (PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)gpa(
+            instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
+    pDisp->GetPhysicalDeviceSurfaceFormatsKHR =
+        (PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)gpa(
+            instance, "vkGetPhysicalDeviceSurfaceFormatsKHR");
+    pDisp->GetPhysicalDeviceSurfacePresentModesKHR =
+        (PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)gpa(
+            instance, "vkGetPhysicalDeviceSurfacePresentModesKHR");
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-    pDisp->CreateWin32SurfaceKHR = (PFN_vkCreateWin32SurfaceKHR) gpa(instance, "vkCreateWin32SurfaceKHR");
-    pDisp->GetPhysicalDeviceWin32PresentationSupportKHR = (PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR) gpa(instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR");
+    pDisp->CreateWin32SurfaceKHR =
+        (PFN_vkCreateWin32SurfaceKHR)gpa(instance, "vkCreateWin32SurfaceKHR");
+    pDisp->GetPhysicalDeviceWin32PresentationSupportKHR =
+        (PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)gpa(
+            instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR");
 #endif // VK_USE_PLATFORM_WIN32_KHR
 #ifdef VK_USE_PLATFORM_XCB_KHR
-    pDisp->CreateXcbSurfaceKHR = (PFN_vkCreateXcbSurfaceKHR) gpa(instance, "vkCreateXcbSurfaceKHR");
-    pDisp->GetPhysicalDeviceXcbPresentationSupportKHR = (PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR) gpa(instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR");
+    pDisp->CreateXcbSurfaceKHR =
+        (PFN_vkCreateXcbSurfaceKHR)gpa(instance, "vkCreateXcbSurfaceKHR");
+    pDisp->GetPhysicalDeviceXcbPresentationSupportKHR =
+        (PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)gpa(
+            instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR");
 #endif // VK_USE_PLATFORM_XCB_KHR
 #ifdef VK_USE_PLATFORM_XLIB_KHR
-    pDisp->CreateXlibSurfaceKHR = (PFN_vkCreateXlibSurfaceKHR) gpa(instance, "vkCreateXlibSurfaceKHR");
-    pDisp->GetPhysicalDeviceXlibPresentationSupportKHR = (PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR) gpa(instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR");
+    pDisp->CreateXlibSurfaceKHR =
+        (PFN_vkCreateXlibSurfaceKHR)gpa(instance, "vkCreateXlibSurfaceKHR");
+    pDisp->GetPhysicalDeviceXlibPresentationSupportKHR =
+        (PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)gpa(
+            instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR");
 #endif // VK_USE_PLATFORM_XLIB_KHR
 #ifdef VK_USE_PLATFORM_MIR_KHR
-    pDisp->CreateMirSurfaceKHR = (PFN_vkCreateMirSurfaceKHR) gpa(instance, "vkCreateMirSurfaceKHR");
-    pDisp->GetPhysicalDeviceMirPresentationSupportKHR = (PFN_vkGetPhysicalDeviceMirPresentationSupportKHR) gpa(instance, "vkGetPhysicalDeviceMirPresentationSupportKHR");
+    pDisp->CreateMirSurfaceKHR =
+        (PFN_vkCreateMirSurfaceKHR)gpa(instance, "vkCreateMirSurfaceKHR");
+    pDisp->GetPhysicalDeviceMirPresentationSupportKHR =
+        (PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)gpa(
+            instance, "vkGetPhysicalDeviceMirPresentationSupportKHR");
 #endif // VK_USE_PLATFORM_MIR_KHR
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
-    pDisp->CreateWaylandSurfaceKHR = (PFN_vkCreateWaylandSurfaceKHR) gpa(instance, "vkCreateWaylandSurfaceKHR");
-    pDisp->GetPhysicalDeviceWaylandPresentationSupportKHR = (PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR) gpa(instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR");
+    pDisp->CreateWaylandSurfaceKHR = (PFN_vkCreateWaylandSurfaceKHR)gpa(
+        instance, "vkCreateWaylandSurfaceKHR");
+    pDisp->GetPhysicalDeviceWaylandPresentationSupportKHR =
+        (PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)gpa(
+            instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR");
 #endif //  VK_USE_PLATFORM_WAYLAND_KHR
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
-    pDisp->CreateAndroidSurfaceKHR = (PFN_vkCreateAndroidSurfaceKHR) gpa(instance, "vkCreateAndroidSurfaceKHR");
+    pDisp->CreateAndroidSurfaceKHR = (PFN_vkCreateAndroidSurfaceKHR)gpa(
+        instance, "vkCreateAndroidSurfaceKHR");
 #endif // VK_USE_PLATFORM_ANDROID_KHR
 
     instanceExtMap[pDisp] = {};
     for (i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_SURFACE_EXTENSION_NAME) == 0)
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i],
+                   VK_KHR_SURFACE_EXTENSION_NAME) == 0)
             instanceExtMap[pDisp].wsi_enabled = true;
 #ifdef VK_USE_PLATFORM_XLIB_KHR
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_XLIB_SURFACE_EXTENSION_NAME) == 0)
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i],
+                   VK_KHR_XLIB_SURFACE_EXTENSION_NAME) == 0)
             instanceExtMap[pDisp].xlib_enabled = true;
 #endif
 #ifdef VK_USE_PLATFORM_XCB_KHR
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_XCB_SURFACE_EXTENSION_NAME) == 0)
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i],
+                   VK_KHR_XCB_SURFACE_EXTENSION_NAME) == 0)
             instanceExtMap[pDisp].xcb_enabled = true;
 #endif
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME) == 0)
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i],
+                   VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME) == 0)
             instanceExtMap[pDisp].wayland_enabled = true;
 #endif
 #ifdef VK_USE_PLATFORM_MIR_KHR
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_MIR_SURFACE_EXTENSION_NAME) == 0)
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i],
+                   VK_KHR_MIR_SURFACE_EXTENSION_NAME) == 0)
             instanceExtMap[pDisp].mir_enabled = true;
 #endif
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_ANDROID_SURFACE_EXTENSION_NAME) == 0)
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i],
+                   VK_KHR_ANDROID_SURFACE_EXTENSION_NAME) == 0)
             instanceExtMap[pDisp].android_enabled = true;
 #endif
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_WIN32_SURFACE_EXTENSION_NAME) == 0)
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i],
+                   VK_KHR_WIN32_SURFACE_EXTENSION_NAME) == 0)
             instanceExtMap[pDisp].win32_enabled = true;
 #endif
     }
 }
 
-VkResult
-explicit_CreateInstance(
-    const VkInstanceCreateInfo  *pCreateInfo,
-    const VkAllocationCallbacks *pAllocator,
-    VkInstance                  *pInstance)
-{
-    VkLayerInstanceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
+VkResult explicit_CreateInstance(const VkInstanceCreateInfo *pCreateInfo,
+                                 const VkAllocationCallbacks *pAllocator,
+                                 VkInstance *pInstance) {
+    VkLayerInstanceCreateInfo *chain_info =
+        get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
 
     assert(chain_info->u.pLayerInfo);
-    PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
-    PFN_vkCreateInstance fpCreateInstance = (PFN_vkCreateInstance) fpGetInstanceProcAddr(NULL, "vkCreateInstance");
+    PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr =
+        chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
+    PFN_vkCreateInstance fpCreateInstance =
+        (PFN_vkCreateInstance)fpGetInstanceProcAddr(NULL, "vkCreateInstance");
     if (fpCreateInstance == NULL) {
         return VK_ERROR_INITIALIZATION_FAILED;
     }
@@ -164,7 +195,8 @@ explicit_CreateInstance(
         return result;
     }
 
-    initInstanceTable(*pInstance, fpGetInstanceProcAddr, unique_objects_instance_table_map);
+    initInstanceTable(*pInstance, fpGetInstanceProcAddr,
+                      unique_objects_instance_table_map);
 
     createInstanceRegisterExtensions(pCreateInfo, *pInstance);
 
@@ -172,36 +204,46 @@ explicit_CreateInstance(
 }
 
 // Handle CreateDevice
-static void createDeviceRegisterExtensions(const VkDeviceCreateInfo* pCreateInfo, VkDevice device)
-{
-    layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkLayerDispatchTable *pDisp = get_dispatch_table(unique_objects_device_table_map, device);
+static void
+createDeviceRegisterExtensions(const VkDeviceCreateInfo *pCreateInfo,
+                               VkDevice device) {
+    layer_data *my_device_data =
+        get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+    VkLayerDispatchTable *pDisp =
+        get_dispatch_table(unique_objects_device_table_map, device);
     PFN_vkGetDeviceProcAddr gpa = pDisp->GetDeviceProcAddr;
-    pDisp->CreateSwapchainKHR = (PFN_vkCreateSwapchainKHR) gpa(device, "vkCreateSwapchainKHR");
-    pDisp->DestroySwapchainKHR = (PFN_vkDestroySwapchainKHR) gpa(device, "vkDestroySwapchainKHR");
-    pDisp->GetSwapchainImagesKHR = (PFN_vkGetSwapchainImagesKHR) gpa(device, "vkGetSwapchainImagesKHR");
-    pDisp->AcquireNextImageKHR = (PFN_vkAcquireNextImageKHR) gpa(device, "vkAcquireNextImageKHR");
-    pDisp->QueuePresentKHR = (PFN_vkQueuePresentKHR) gpa(device, "vkQueuePresentKHR");
+    pDisp->CreateSwapchainKHR =
+        (PFN_vkCreateSwapchainKHR)gpa(device, "vkCreateSwapchainKHR");
+    pDisp->DestroySwapchainKHR =
+        (PFN_vkDestroySwapchainKHR)gpa(device, "vkDestroySwapchainKHR");
+    pDisp->GetSwapchainImagesKHR =
+        (PFN_vkGetSwapchainImagesKHR)gpa(device, "vkGetSwapchainImagesKHR");
+    pDisp->AcquireNextImageKHR =
+        (PFN_vkAcquireNextImageKHR)gpa(device, "vkAcquireNextImageKHR");
+    pDisp->QueuePresentKHR =
+        (PFN_vkQueuePresentKHR)gpa(device, "vkQueuePresentKHR");
     my_device_data->wsi_enabled = false;
     for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_SWAPCHAIN_EXTENSION_NAME) == 0)
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i],
+                   VK_KHR_SWAPCHAIN_EXTENSION_NAME) == 0)
             my_device_data->wsi_enabled = true;
     }
 }
 
-VkResult
-explicit_CreateDevice(
-    VkPhysicalDevice         gpu,
-    const VkDeviceCreateInfo *pCreateInfo,
-    const VkAllocationCallbacks   *pAllocator,
-    VkDevice                 *pDevice)
-{
-    VkLayerDeviceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
+VkResult explicit_CreateDevice(VkPhysicalDevice gpu,
+                               const VkDeviceCreateInfo *pCreateInfo,
+                               const VkAllocationCallbacks *pAllocator,
+                               VkDevice *pDevice) {
+    VkLayerDeviceCreateInfo *chain_info =
+        get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
 
     assert(chain_info->u.pLayerInfo);
-    PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
-    PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr;
-    PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice) fpGetInstanceProcAddr(NULL, "vkCreateDevice");
+    PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr =
+        chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
+    PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr =
+        chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr;
+    PFN_vkCreateDevice fpCreateDevice =
+        (PFN_vkCreateDevice)fpGetInstanceProcAddr(NULL, "vkCreateDevice");
     if (fpCreateDevice == NULL) {
         return VK_ERROR_INITIALIZATION_FAILED;
     }
@@ -215,54 +257,73 @@ explicit_CreateDevice(
     }
 
     // Setup layer's device dispatch table
-    initDeviceTable(*pDevice, fpGetDeviceProcAddr, unique_objects_device_table_map);
+    initDeviceTable(*pDevice, fpGetDeviceProcAddr,
+                    unique_objects_device_table_map);
 
     createDeviceRegisterExtensions(pCreateInfo, *pDevice);
 
     return result;
 }
 
-VkResult explicit_QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
-{
-// UNWRAP USES:
-//  0 : fence,VkFence
+VkResult explicit_QueueSubmit(VkQueue queue, uint32_t submitCount,
+                              const VkSubmitInfo *pSubmits, VkFence fence) {
+    // UNWRAP USES:
+    //  0 : fence,VkFence
     if (VK_NULL_HANDLE != fence) {
-        fence = (VkFence)((VkUniqueObject*)fence)->actualObject;
+        fence = (VkFence)((VkUniqueObject *)fence)->actualObject;
     }
-//  waitSemaphoreCount : pSubmits[submitCount]->pWaitSemaphores,VkSemaphore
+    //  waitSemaphoreCount : pSubmits[submitCount]->pWaitSemaphores,VkSemaphore
     std::vector<VkSemaphore> original_pWaitSemaphores = {};
-//  signalSemaphoreCount : pSubmits[submitCount]->pSignalSemaphores,VkSemaphore
+    //  signalSemaphoreCount :
+    //  pSubmits[submitCount]->pSignalSemaphores,VkSemaphore
     std::vector<VkSemaphore> original_pSignalSemaphores = {};
     if (pSubmits) {
-        for (uint32_t index0=0; index0<submitCount; ++index0) {
+        for (uint32_t index0 = 0; index0 < submitCount; ++index0) {
             if (pSubmits[index0].pWaitSemaphores) {
-                for (uint32_t index1=0; index1<pSubmits[index0].waitSemaphoreCount; ++index1) {
-                    VkSemaphore** ppSemaphore = (VkSemaphore**)&(pSubmits[index0].pWaitSemaphores);
-                    original_pWaitSemaphores.push_back(pSubmits[index0].pWaitSemaphores[index1]);
-                    *(ppSemaphore[index1]) = (VkSemaphore)((VkUniqueObject*)pSubmits[index0].pWaitSemaphores[index1])->actualObject;
+                for (uint32_t index1 = 0;
+                     index1 < pSubmits[index0].waitSemaphoreCount; ++index1) {
+                    VkSemaphore **ppSemaphore =
+                        (VkSemaphore **)&(pSubmits[index0].pWaitSemaphores);
+                    original_pWaitSemaphores.push_back(
+                        pSubmits[index0].pWaitSemaphores[index1]);
+                    *(ppSemaphore[index1]) =
+                        (VkSemaphore)((VkUniqueObject *)
+                                      pSubmits[index0].pWaitSemaphores[index1])
+                            ->actualObject;
                 }
             }
             if (pSubmits[index0].pSignalSemaphores) {
-                for (uint32_t index1=0; index1<pSubmits[index0].signalSemaphoreCount; ++index1) {
-                    VkSemaphore** ppSemaphore = (VkSemaphore**)&(pSubmits[index0].pSignalSemaphores);
-                    original_pSignalSemaphores.push_back(pSubmits[index0].pSignalSemaphores[index1]);
-                    *(ppSemaphore[index1]) = (VkSemaphore)((VkUniqueObject*)pSubmits[index0].pSignalSemaphores[index1])->actualObject;
+                for (uint32_t index1 = 0;
+                     index1 < pSubmits[index0].signalSemaphoreCount; ++index1) {
+                    VkSemaphore **ppSemaphore =
+                        (VkSemaphore **)&(pSubmits[index0].pSignalSemaphores);
+                    original_pSignalSemaphores.push_back(
+                        pSubmits[index0].pSignalSemaphores[index1]);
+                    *(ppSemaphore[index1]) =
+                        (VkSemaphore)((VkUniqueObject *)pSubmits[index0]
+                                          .pSignalSemaphores[index1])
+                            ->actualObject;
                 }
             }
         }
     }
-    VkResult result = get_dispatch_table(unique_objects_device_table_map, queue)->QueueSubmit(queue, submitCount, pSubmits, fence);
+    VkResult result = get_dispatch_table(unique_objects_device_table_map, queue)
+                          ->QueueSubmit(queue, submitCount, pSubmits, fence);
     if (pSubmits) {
-        for (uint32_t index0=0; index0<submitCount; ++index0) {
+        for (uint32_t index0 = 0; index0 < submitCount; ++index0) {
             if (pSubmits[index0].pWaitSemaphores) {
-                for (uint32_t index1=0; index1<pSubmits[index0].waitSemaphoreCount; ++index1) {
-                    VkSemaphore** ppSemaphore = (VkSemaphore**)&(pSubmits[index0].pWaitSemaphores);
+                for (uint32_t index1 = 0;
+                     index1 < pSubmits[index0].waitSemaphoreCount; ++index1) {
+                    VkSemaphore **ppSemaphore =
+                        (VkSemaphore **)&(pSubmits[index0].pWaitSemaphores);
                     *(ppSemaphore[index1]) = original_pWaitSemaphores[index1];
                 }
             }
             if (pSubmits[index0].pSignalSemaphores) {
-                for (uint32_t index1=0; index1<pSubmits[index0].signalSemaphoreCount; ++index1) {
-                    VkSemaphore** ppSemaphore = (VkSemaphore**)&(pSubmits[index0].pSignalSemaphores);
+                for (uint32_t index1 = 0;
+                     index1 < pSubmits[index0].signalSemaphoreCount; ++index1) {
+                    VkSemaphore **ppSemaphore =
+                        (VkSemaphore **)&(pSubmits[index0].pSignalSemaphores);
                     *(ppSemaphore[index1]) = original_pSignalSemaphores[index1];
                 }
             }
@@ -271,10 +332,17 @@ VkResult explicit_QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmi
     return result;
 }
 
-VkResult explicit_QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
-{
-// UNWRAP USES:
-//  0 : pBindInfo[bindInfoCount]->pBufferBinds[bufferBindCount]->buffer,VkBuffer, pBindInfo[bindInfoCount]->pBufferBinds[bufferBindCount]->pBinds[bindCount]->memory,VkDeviceMemory, pBindInfo[bindInfoCount]->pImageOpaqueBinds[imageOpaqueBindCount]->image,VkImage, pBindInfo[bindInfoCount]->pImageOpaqueBinds[imageOpaqueBindCount]->pBinds[bindCount]->memory,VkDeviceMemory, pBindInfo[bindInfoCount]->pImageBinds[imageBindCount]->image,VkImage, pBindInfo[bindInfoCount]->pImageBinds[imageBindCount]->pBinds[bindCount]->memory,VkDeviceMemory
+VkResult explicit_QueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
+                                  const VkBindSparseInfo *pBindInfo,
+                                  VkFence fence) {
+    // UNWRAP USES:
+    //  0 :
+    //  pBindInfo[bindInfoCount]->pBufferBinds[bufferBindCount]->buffer,VkBuffer,
+    //  pBindInfo[bindInfoCount]->pBufferBinds[bufferBindCount]->pBinds[bindCount]->memory,VkDeviceMemory,
+    //  pBindInfo[bindInfoCount]->pImageOpaqueBinds[imageOpaqueBindCount]->image,VkImage,
+    //  pBindInfo[bindInfoCount]->pImageOpaqueBinds[imageOpaqueBindCount]->pBinds[bindCount]->memory,VkDeviceMemory,
+    //  pBindInfo[bindInfoCount]->pImageBinds[imageBindCount]->image,VkImage,
+    //  pBindInfo[bindInfoCount]->pImageBinds[imageBindCount]->pBinds[bindCount]->memory,VkDeviceMemory
     std::vector<VkBuffer> original_buffer = {};
     std::vector<VkDeviceMemory> original_memory1 = {};
     std::vector<VkImage> original_image1 = {};
@@ -284,93 +352,203 @@ VkResult explicit_QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const V
     std::vector<VkSemaphore> original_pWaitSemaphores = {};
     std::vector<VkSemaphore> original_pSignalSemaphores = {};
     if (pBindInfo) {
-        for (uint32_t index0=0; index0<bindInfoCount; ++index0) {
+        for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) {
             if (pBindInfo[index0].pBufferBinds) {
-                for (uint32_t index1=0; index1<pBindInfo[index0].bufferBindCount; ++index1) {
+                for (uint32_t index1 = 0;
+                     index1 < pBindInfo[index0].bufferBindCount; ++index1) {
                     if (pBindInfo[index0].pBufferBinds[index1].buffer) {
-                        VkBuffer* pBuffer = (VkBuffer*)&(pBindInfo[index0].pBufferBinds[index1].buffer);
-                        original_buffer.push_back(pBindInfo[index0].pBufferBinds[index1].buffer);
-                        *(pBuffer) = (VkBuffer)((VkUniqueObject*)pBindInfo[index0].pBufferBinds[index1].buffer)->actualObject;
+                        VkBuffer *pBuffer = (VkBuffer *)&(
+                            pBindInfo[index0].pBufferBinds[index1].buffer);
+                        original_buffer.push_back(
+                            pBindInfo[index0].pBufferBinds[index1].buffer);
+                        *(pBuffer) =
+                            (VkBuffer)((VkUniqueObject *)pBindInfo[index0]
+                                           .pBufferBinds[index1]
+                                           .buffer)->actualObject;
                     }
                     if (pBindInfo[index0].pBufferBinds[index1].pBinds) {
-                        for (uint32_t index2=0; index2<pBindInfo[index0].pBufferBinds[index1].bindCount; ++index2) {
-                            if (pBindInfo[index0].pBufferBinds[index1].pBinds[index2].memory) {
-                                VkDeviceMemory* pDeviceMemory = (VkDeviceMemory*)&(pBindInfo[index0].pBufferBinds[index1].pBinds[index2].memory);
-                                original_memory1.push_back(pBindInfo[index0].pBufferBinds[index1].pBinds[index2].memory);
-                                *(pDeviceMemory) = (VkDeviceMemory)((VkUniqueObject*)pBindInfo[index0].pBufferBinds[index1].pBinds[index2].memory)->actualObject;
+                        for (uint32_t index2 = 0;
+                             index2 < pBindInfo[index0]
+                                          .pBufferBinds[index1]
+                                          .bindCount;
+                             ++index2) {
+                            if (pBindInfo[index0]
+                                    .pBufferBinds[index1]
+                                    .pBinds[index2]
+                                    .memory) {
+                                VkDeviceMemory *pDeviceMemory =
+                                    (VkDeviceMemory *)&(
+                                        pBindInfo[index0]
+                                            .pBufferBinds[index1]
+                                            .pBinds[index2]
+                                            .memory);
+                                original_memory1.push_back(
+                                    pBindInfo[index0]
+                                        .pBufferBinds[index1]
+                                        .pBinds[index2]
+                                        .memory);
+                                *(pDeviceMemory) =
+                                    (VkDeviceMemory)(
+                                        (VkUniqueObject *)pBindInfo[index0]
+                                            .pBufferBinds[index1]
+                                            .pBinds[index2]
+                                            .memory)->actualObject;
                             }
                         }
                     }
                 }
             }
             if (pBindInfo[index0].pImageOpaqueBinds) {
-                for (uint32_t index1=0; index1<pBindInfo[index0].imageOpaqueBindCount; ++index1) {
+                for (uint32_t index1 = 0;
+                     index1 < pBindInfo[index0].imageOpaqueBindCount;
+                     ++index1) {
                     if (pBindInfo[index0].pImageOpaqueBinds[index1].image) {
-                        VkImage* pImage = (VkImage*)&(pBindInfo[index0].pImageOpaqueBinds[index1].image);
-                        original_image1.push_back(pBindInfo[index0].pImageOpaqueBinds[index1].image);
-                        *(pImage) = (VkImage)((VkUniqueObject*)pBindInfo[index0].pImageOpaqueBinds[index1].image)->actualObject;
+                        VkImage *pImage = (VkImage *)&(
+                            pBindInfo[index0].pImageOpaqueBinds[index1].image);
+                        original_image1.push_back(
+                            pBindInfo[index0].pImageOpaqueBinds[index1].image);
+                        *(pImage) =
+                            (VkImage)((VkUniqueObject *)pBindInfo[index0]
+                                          .pImageOpaqueBinds[index1]
+                                          .image)->actualObject;
                     }
                     if (pBindInfo[index0].pImageOpaqueBinds[index1].pBinds) {
-                        for (uint32_t index2=0; index2<pBindInfo[index0].pImageOpaqueBinds[index1].bindCount; ++index2) {
-                            if (pBindInfo[index0].pImageOpaqueBinds[index1].pBinds[index2].memory) {
-                                VkDeviceMemory* pDeviceMemory = (VkDeviceMemory*)&(pBindInfo[index0].pImageOpaqueBinds[index1].pBinds[index2].memory);
-                                original_memory2.push_back(pBindInfo[index0].pImageOpaqueBinds[index1].pBinds[index2].memory);
-                                *(pDeviceMemory) = (VkDeviceMemory)((VkUniqueObject*)pBindInfo[index0].pImageOpaqueBinds[index1].pBinds[index2].memory)->actualObject;
+                        for (uint32_t index2 = 0;
+                             index2 < pBindInfo[index0]
+                                          .pImageOpaqueBinds[index1]
+                                          .bindCount;
+                             ++index2) {
+                            if (pBindInfo[index0]
+                                    .pImageOpaqueBinds[index1]
+                                    .pBinds[index2]
+                                    .memory) {
+                                VkDeviceMemory *pDeviceMemory =
+                                    (VkDeviceMemory *)&(
+                                        pBindInfo[index0]
+                                            .pImageOpaqueBinds[index1]
+                                            .pBinds[index2]
+                                            .memory);
+                                original_memory2.push_back(
+                                    pBindInfo[index0]
+                                        .pImageOpaqueBinds[index1]
+                                        .pBinds[index2]
+                                        .memory);
+                                *(pDeviceMemory) =
+                                    (VkDeviceMemory)(
+                                        (VkUniqueObject *)pBindInfo[index0]
+                                            .pImageOpaqueBinds[index1]
+                                            .pBinds[index2]
+                                            .memory)->actualObject;
                             }
                         }
                     }
                 }
             }
             if (pBindInfo[index0].pImageBinds) {
-                for (uint32_t index1=0; index1<pBindInfo[index0].imageBindCount; ++index1) {
+                for (uint32_t index1 = 0;
+                     index1 < pBindInfo[index0].imageBindCount; ++index1) {
                     if (pBindInfo[index0].pImageBinds[index1].image) {
-                        VkImage* pImage = (VkImage*)&(pBindInfo[index0].pImageBinds[index1].image);
-                        original_image2.push_back(pBindInfo[index0].pImageBinds[index1].image);
-                        *(pImage) = (VkImage)((VkUniqueObject*)pBindInfo[index0].pImageBinds[index1].image)->actualObject;
+                        VkImage *pImage = (VkImage *)&(
+                            pBindInfo[index0].pImageBinds[index1].image);
+                        original_image2.push_back(
+                            pBindInfo[index0].pImageBinds[index1].image);
+                        *(pImage) =
+                            (VkImage)((VkUniqueObject *)pBindInfo[index0]
+                                          .pImageBinds[index1]
+                                          .image)->actualObject;
                     }
                     if (pBindInfo[index0].pImageBinds[index1].pBinds) {
-                        for (uint32_t index2=0; index2<pBindInfo[index0].pImageBinds[index1].bindCount; ++index2) {
-                            if (pBindInfo[index0].pImageBinds[index1].pBinds[index2].memory) {
-                                VkDeviceMemory* pDeviceMemory = (VkDeviceMemory*)&(pBindInfo[index0].pImageBinds[index1].pBinds[index2].memory);
-                                original_memory3.push_back(pBindInfo[index0].pImageBinds[index1].pBinds[index2].memory);
-                                *(pDeviceMemory) = (VkDeviceMemory)((VkUniqueObject*)pBindInfo[index0].pImageBinds[index1].pBinds[index2].memory)->actualObject;
+                        for (
+                            uint32_t index2 = 0;
+                            index2 <
+                                pBindInfo[index0].pImageBinds[index1].bindCount;
+                            ++index2) {
+                            if (pBindInfo[index0]
+                                    .pImageBinds[index1]
+                                    .pBinds[index2]
+                                    .memory) {
+                                VkDeviceMemory *pDeviceMemory =
+                                    (VkDeviceMemory *)&(pBindInfo[index0]
+                                                            .pImageBinds[index1]
+                                                            .pBinds[index2]
+                                                            .memory);
+                                original_memory3.push_back(
+                                    pBindInfo[index0]
+                                        .pImageBinds[index1]
+                                        .pBinds[index2]
+                                        .memory);
+                                *(pDeviceMemory) =
+                                    (VkDeviceMemory)(
+                                        (VkUniqueObject *)pBindInfo[index0]
+                                            .pImageBinds[index1]
+                                            .pBinds[index2]
+                                            .memory)->actualObject;
                             }
                         }
                     }
                 }
             }
             if (pBindInfo[index0].pWaitSemaphores) {
-                for (uint32_t index1=0; index1<pBindInfo[index0].waitSemaphoreCount; ++index1) {
-                    VkSemaphore** ppSemaphore = (VkSemaphore**)&(pBindInfo[index0].pWaitSemaphores);
-                    original_pWaitSemaphores.push_back(pBindInfo[index0].pWaitSemaphores[index1]);
-                    *(ppSemaphore[index1]) = (VkSemaphore)((VkUniqueObject*)pBindInfo[index0].pWaitSemaphores[index1])->actualObject;
+                for (uint32_t index1 = 0;
+                     index1 < pBindInfo[index0].waitSemaphoreCount; ++index1) {
+                    VkSemaphore **ppSemaphore =
+                        (VkSemaphore **)&(pBindInfo[index0].pWaitSemaphores);
+                    original_pWaitSemaphores.push_back(
+                        pBindInfo[index0].pWaitSemaphores[index1]);
+                    *(ppSemaphore[index1]) =
+                        (VkSemaphore)((VkUniqueObject *)
+                                      pBindInfo[index0].pWaitSemaphores[index1])
+                            ->actualObject;
                 }
             }
             if (pBindInfo[index0].pSignalSemaphores) {
-                for (uint32_t index1=0; index1<pBindInfo[index0].signalSemaphoreCount; ++index1) {
-                    VkSemaphore** ppSemaphore = (VkSemaphore**)&(pBindInfo[index0].pSignalSemaphores);
-                    original_pSignalSemaphores.push_back(pBindInfo[index0].pSignalSemaphores[index1]);
-                    *(ppSemaphore[index1]) = (VkSemaphore)((VkUniqueObject*)pBindInfo[index0].pSignalSemaphores[index1])->actualObject;
+                for (uint32_t index1 = 0;
+                     index1 < pBindInfo[index0].signalSemaphoreCount;
+                     ++index1) {
+                    VkSemaphore **ppSemaphore =
+                        (VkSemaphore **)&(pBindInfo[index0].pSignalSemaphores);
+                    original_pSignalSemaphores.push_back(
+                        pBindInfo[index0].pSignalSemaphores[index1]);
+                    *(ppSemaphore[index1]) =
+                        (VkSemaphore)((VkUniqueObject *)pBindInfo[index0]
+                                          .pSignalSemaphores[index1])
+                            ->actualObject;
                 }
             }
         }
     }
     if (VK_NULL_HANDLE != fence) {
-        fence = (VkFence)((VkUniqueObject*)fence)->actualObject;
+        fence = (VkFence)((VkUniqueObject *)fence)->actualObject;
     }
-    VkResult result = get_dispatch_table(unique_objects_device_table_map, queue)->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
+    VkResult result =
+        get_dispatch_table(unique_objects_device_table_map, queue)
+            ->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
     if (pBindInfo) {
-        for (uint32_t index0=0; index0<bindInfoCount; ++index0) {
+        for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) {
             if (pBindInfo[index0].pBufferBinds) {
-                for (uint32_t index1=0; index1<pBindInfo[index0].bufferBindCount; ++index1) {
+                for (uint32_t index1 = 0;
+                     index1 < pBindInfo[index0].bufferBindCount; ++index1) {
                     if (pBindInfo[index0].pBufferBinds[index1].buffer) {
-                        VkBuffer* pBuffer = (VkBuffer*)&(pBindInfo[index0].pBufferBinds[index1].buffer);
+                        VkBuffer *pBuffer = (VkBuffer *)&(
+                            pBindInfo[index0].pBufferBinds[index1].buffer);
                         *(pBuffer) = original_buffer[index1];
                     }
                     if (pBindInfo[index0].pBufferBinds[index1].pBinds) {
-                        for (uint32_t index2=0; index2<pBindInfo[index0].pBufferBinds[index1].bindCount; ++index2) {
-                            if (pBindInfo[index0].pBufferBinds[index1].pBinds[index2].memory) {
-                                VkDeviceMemory* pDeviceMemory = (VkDeviceMemory*)&(pBindInfo[index0].pBufferBinds[index1].pBinds[index2].memory);
+                        for (uint32_t index2 = 0;
+                             index2 < pBindInfo[index0]
+                                          .pBufferBinds[index1]
+                                          .bindCount;
+                             ++index2) {
+                            if (pBindInfo[index0]
+                                    .pBufferBinds[index1]
+                                    .pBinds[index2]
+                                    .memory) {
+                                VkDeviceMemory *pDeviceMemory =
+                                    (VkDeviceMemory *)&(
+                                        pBindInfo[index0]
+                                            .pBufferBinds[index1]
+                                            .pBinds[index2]
+                                            .memory);
                                 *(pDeviceMemory) = original_memory1[index2];
                             }
                         }
@@ -378,15 +556,30 @@ VkResult explicit_QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const V
                 }
             }
             if (pBindInfo[index0].pImageOpaqueBinds) {
-                for (uint32_t index1=0; index1<pBindInfo[index0].imageOpaqueBindCount; ++index1) {
+                for (uint32_t index1 = 0;
+                     index1 < pBindInfo[index0].imageOpaqueBindCount;
+                     ++index1) {
                     if (pBindInfo[index0].pImageOpaqueBinds[index1].image) {
-                        VkImage* pImage = (VkImage*)&(pBindInfo[index0].pImageOpaqueBinds[index1].image);
+                        VkImage *pImage = (VkImage *)&(
+                            pBindInfo[index0].pImageOpaqueBinds[index1].image);
                         *(pImage) = original_image1[index1];
                     }
                     if (pBindInfo[index0].pImageOpaqueBinds[index1].pBinds) {
-                        for (uint32_t index2=0; index2<pBindInfo[index0].pImageOpaqueBinds[index1].bindCount; ++index2) {
-                            if (pBindInfo[index0].pImageOpaqueBinds[index1].pBinds[index2].memory) {
-                                VkDeviceMemory* pDeviceMemory = (VkDeviceMemory*)&(pBindInfo[index0].pImageOpaqueBinds[index1].pBinds[index2].memory);
+                        for (uint32_t index2 = 0;
+                             index2 < pBindInfo[index0]
+                                          .pImageOpaqueBinds[index1]
+                                          .bindCount;
+                             ++index2) {
+                            if (pBindInfo[index0]
+                                    .pImageOpaqueBinds[index1]
+                                    .pBinds[index2]
+                                    .memory) {
+                                VkDeviceMemory *pDeviceMemory =
+                                    (VkDeviceMemory *)&(
+                                        pBindInfo[index0]
+                                            .pImageOpaqueBinds[index1]
+                                            .pBinds[index2]
+                                            .memory);
                                 *(pDeviceMemory) = original_memory2[index2];
                             }
                         }
@@ -394,15 +587,28 @@ VkResult explicit_QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const V
                 }
             }
             if (pBindInfo[index0].pImageBinds) {
-                for (uint32_t index1=0; index1<pBindInfo[index0].imageBindCount; ++index1) {
+                for (uint32_t index1 = 0;
+                     index1 < pBindInfo[index0].imageBindCount; ++index1) {
                     if (pBindInfo[index0].pImageBinds[index1].image) {
-                        VkImage* pImage = (VkImage*)&(pBindInfo[index0].pImageBinds[index1].image);
+                        VkImage *pImage = (VkImage *)&(
+                            pBindInfo[index0].pImageBinds[index1].image);
                         *(pImage) = original_image2[index1];
                     }
                     if (pBindInfo[index0].pImageBinds[index1].pBinds) {
-                        for (uint32_t index2=0; index2<pBindInfo[index0].pImageBinds[index1].bindCount; ++index2) {
-                            if (pBindInfo[index0].pImageBinds[index1].pBinds[index2].memory) {
-                                VkDeviceMemory* pDeviceMemory = (VkDeviceMemory*)&(pBindInfo[index0].pImageBinds[index1].pBinds[index2].memory);
+                        for (
+                            uint32_t index2 = 0;
+                            index2 <
+                                pBindInfo[index0].pImageBinds[index1].bindCount;
+                            ++index2) {
+                            if (pBindInfo[index0]
+                                    .pImageBinds[index1]
+                                    .pBinds[index2]
+                                    .memory) {
+                                VkDeviceMemory *pDeviceMemory =
+                                    (VkDeviceMemory *)&(pBindInfo[index0]
+                                                            .pImageBinds[index1]
+                                                            .pBinds[index2]
+                                                            .memory);
                                 *(pDeviceMemory) = original_memory3[index2];
                             }
                         }
@@ -410,14 +616,19 @@ VkResult explicit_QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const V
                 }
             }
             if (pBindInfo[index0].pWaitSemaphores) {
-                for (uint32_t index1=0; index1<pBindInfo[index0].waitSemaphoreCount; ++index1) {
-                    VkSemaphore** ppSemaphore = (VkSemaphore**)&(pBindInfo[index0].pWaitSemaphores);
+                for (uint32_t index1 = 0;
+                     index1 < pBindInfo[index0].waitSemaphoreCount; ++index1) {
+                    VkSemaphore **ppSemaphore =
+                        (VkSemaphore **)&(pBindInfo[index0].pWaitSemaphores);
                     *(ppSemaphore[index1]) = original_pWaitSemaphores[index1];
                 }
             }
             if (pBindInfo[index0].pSignalSemaphores) {
-                for (uint32_t index1=0; index1<pBindInfo[index0].signalSemaphoreCount; ++index1) {
-                    VkSemaphore** ppSemaphore = (VkSemaphore**)&(pBindInfo[index0].pSignalSemaphores);
+                for (uint32_t index1 = 0;
+                     index1 < pBindInfo[index0].signalSemaphoreCount;
+                     ++index1) {
+                    VkSemaphore **ppSemaphore =
+                        (VkSemaphore **)&(pBindInfo[index0].pSignalSemaphores);
                     *(ppSemaphore[index1]) = original_pSignalSemaphores[index1];
                 }
             }
@@ -426,55 +637,79 @@ VkResult explicit_QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const V
     return result;
 }
 
-VkResult explicit_CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
-{
-// UNWRAP USES:
-//  0 : pipelineCache,VkPipelineCache, pCreateInfos[createInfoCount]->stage[0]->module,VkShaderModule, pCreateInfos[createInfoCount]->layout,VkPipelineLayout, pCreateInfos[createInfoCount]->basePipelineHandle,VkPipeline
+VkResult explicit_CreateComputePipelines(
+    VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount,
+    const VkComputePipelineCreateInfo *pCreateInfos,
+    const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) {
+    // UNWRAP USES:
+    //  0 : pipelineCache,VkPipelineCache,
+    //  pCreateInfos[createInfoCount]->stage[0]->module,VkShaderModule,
+    //  pCreateInfos[createInfoCount]->layout,VkPipelineLayout,
+    //  pCreateInfos[createInfoCount]->basePipelineHandle,VkPipeline
     if (VK_NULL_HANDLE != pipelineCache) {
-        pipelineCache = (VkPipelineCache)((VkUniqueObject*)pipelineCache)->actualObject;
+        pipelineCache =
+            (VkPipelineCache)((VkUniqueObject *)pipelineCache)->actualObject;
     }
     std::vector<VkShaderModule> original_module = {};
     std::vector<VkPipelineLayout> original_layout = {};
     std::vector<VkPipeline> original_basePipelineHandle = {};
     if (pCreateInfos) {
-        for (uint32_t index0=0; index0<createInfoCount; ++index0) {
+        for (uint32_t index0 = 0; index0 < createInfoCount; ++index0) {
             if (pCreateInfos[index0].stage.module) {
-                VkShaderModule* pShaderModule = (VkShaderModule*)&(pCreateInfos[index0].stage.module);
+                VkShaderModule *pShaderModule =
+                    (VkShaderModule *)&(pCreateInfos[index0].stage.module);
                 original_module.push_back(pCreateInfos[index0].stage.module);
-                *(pShaderModule) = (VkShaderModule)((VkUniqueObject*)pCreateInfos[index0].stage.module)->actualObject;
+                *(pShaderModule) =
+                    (VkShaderModule)(
+                        (VkUniqueObject *)pCreateInfos[index0].stage.module)
+                        ->actualObject;
             }
             if (pCreateInfos[index0].layout) {
-                VkPipelineLayout* pPipelineLayout = (VkPipelineLayout*)&(pCreateInfos[index0].layout);
+                VkPipelineLayout *pPipelineLayout =
+                    (VkPipelineLayout *)&(pCreateInfos[index0].layout);
                 original_layout.push_back(pCreateInfos[index0].layout);
-                *(pPipelineLayout) = (VkPipelineLayout)((VkUniqueObject*)pCreateInfos[index0].layout)->actualObject;
+                *(pPipelineLayout) =
+                    (VkPipelineLayout)(
+                        (VkUniqueObject *)pCreateInfos[index0].layout)
+                        ->actualObject;
             }
             if (pCreateInfos[index0].basePipelineHandle) {
-                VkPipeline* pPipeline = (VkPipeline*)&(pCreateInfos[index0].basePipelineHandle);
-                original_basePipelineHandle.push_back(pCreateInfos[index0].basePipelineHandle);
-                *(pPipeline) = (VkPipeline)((VkUniqueObject*)pCreateInfos[index0].basePipelineHandle)->actualObject;
+                VkPipeline *pPipeline =
+                    (VkPipeline *)&(pCreateInfos[index0].basePipelineHandle);
+                original_basePipelineHandle.push_back(
+                    pCreateInfos[index0].basePipelineHandle);
+                *(pPipeline) =
+                    (VkPipeline)((VkUniqueObject *)pCreateInfos[index0]
+                                     .basePipelineHandle)->actualObject;
             }
         }
     }
-    VkResult result = get_dispatch_table(unique_objects_device_table_map, device)->CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+    VkResult result =
+        get_dispatch_table(unique_objects_device_table_map, device)
+            ->CreateComputePipelines(device, pipelineCache, createInfoCount,
+                                     pCreateInfos, pAllocator, pPipelines);
     if (pCreateInfos) {
-        for (uint32_t index0=0; index0<createInfoCount; ++index0) {
+        for (uint32_t index0 = 0; index0 < createInfoCount; ++index0) {
             if (pCreateInfos[index0].stage.module) {
-                VkShaderModule* pShaderModule = (VkShaderModule*)&(pCreateInfos[index0].stage.module);
+                VkShaderModule *pShaderModule =
+                    (VkShaderModule *)&(pCreateInfos[index0].stage.module);
                 *(pShaderModule) = original_module[index0];
             }
             if (pCreateInfos[index0].layout) {
-                VkPipelineLayout* pPipelineLayout = (VkPipelineLayout*)&(pCreateInfos[index0].layout);
+                VkPipelineLayout *pPipelineLayout =
+                    (VkPipelineLayout *)&(pCreateInfos[index0].layout);
                 *(pPipelineLayout) = original_layout[index0];
             }
             if (pCreateInfos[index0].basePipelineHandle) {
-                VkPipeline* pPipeline = (VkPipeline*)&(pCreateInfos[index0].basePipelineHandle);
+                VkPipeline *pPipeline =
+                    (VkPipeline *)&(pCreateInfos[index0].basePipelineHandle);
                 *(pPipeline) = original_basePipelineHandle[index0];
             }
         }
     }
     if (VK_SUCCESS == result) {
-        VkUniqueObject* pUO = NULL;
-        for (uint32_t i=0; i<createInfoCount; ++i) {
+        VkUniqueObject *pUO = NULL;
+        for (uint32_t i = 0; i < createInfoCount; ++i) {
             pUO = new VkUniqueObject();
             pUO->actualObject = (uint64_t)pPipelines[i];
             pPipelines[i] = (VkPipeline)pUO;
@@ -483,73 +718,107 @@ VkResult explicit_CreateComputePipelines(VkDevice device, VkPipelineCache pipeli
     return result;
 }
 
-VkResult explicit_CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
-{
-// UNWRAP USES:
-//  0 : pipelineCache,VkPipelineCache, pCreateInfos[createInfoCount]->pStages[stageCount]->module,VkShaderModule, pCreateInfos[createInfoCount]->layout,VkPipelineLayout, pCreateInfos[createInfoCount]->renderPass,VkRenderPass, pCreateInfos[createInfoCount]->basePipelineHandle,VkPipeline
+VkResult explicit_CreateGraphicsPipelines(
+    VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount,
+    const VkGraphicsPipelineCreateInfo *pCreateInfos,
+    const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) {
+    // UNWRAP USES:
+    //  0 : pipelineCache,VkPipelineCache,
+    //  pCreateInfos[createInfoCount]->pStages[stageCount]->module,VkShaderModule,
+    //  pCreateInfos[createInfoCount]->layout,VkPipelineLayout,
+    //  pCreateInfos[createInfoCount]->renderPass,VkRenderPass,
+    //  pCreateInfos[createInfoCount]->basePipelineHandle,VkPipeline
     if (VK_NULL_HANDLE != pipelineCache) {
-        pipelineCache = (VkPipelineCache)((VkUniqueObject*)pipelineCache)->actualObject;
+        pipelineCache =
+            (VkPipelineCache)((VkUniqueObject *)pipelineCache)->actualObject;
     }
     std::vector<VkShaderModule> original_module = {};
     std::vector<VkPipelineLayout> original_layout = {};
     std::vector<VkRenderPass> original_renderPass = {};
     std::vector<VkPipeline> original_basePipelineHandle = {};
     if (pCreateInfos) {
-        for (uint32_t index0=0; index0<createInfoCount; ++index0) {
+        for (uint32_t index0 = 0; index0 < createInfoCount; ++index0) {
             if (pCreateInfos[index0].pStages) {
-                for (uint32_t index1=0; index1<pCreateInfos[index0].stageCount; ++index1) {
+                for (uint32_t index1 = 0;
+                     index1 < pCreateInfos[index0].stageCount; ++index1) {
                     if (pCreateInfos[index0].pStages[index1].module) {
-                        VkShaderModule* pShaderModule = (VkShaderModule*)&(pCreateInfos[index0].pStages[index1].module);
-                        original_module.push_back(pCreateInfos[index0].pStages[index1].module);
-                        *(pShaderModule) = (VkShaderModule)((VkUniqueObject*)pCreateInfos[index0].pStages[index1].module)->actualObject;
+                        VkShaderModule *pShaderModule = (VkShaderModule *)&(
+                            pCreateInfos[index0].pStages[index1].module);
+                        original_module.push_back(
+                            pCreateInfos[index0].pStages[index1].module);
+                        *(pShaderModule) =
+                            (VkShaderModule)(
+                                (VkUniqueObject *)pCreateInfos[index0]
+                                    .pStages[index1]
+                                    .module)->actualObject;
                     }
                 }
             }
             if (pCreateInfos[index0].layout) {
-                VkPipelineLayout* pPipelineLayout = (VkPipelineLayout*)&(pCreateInfos[index0].layout);
+                VkPipelineLayout *pPipelineLayout =
+                    (VkPipelineLayout *)&(pCreateInfos[index0].layout);
                 original_layout.push_back(pCreateInfos[index0].layout);
-                *(pPipelineLayout) = (VkPipelineLayout)((VkUniqueObject*)pCreateInfos[index0].layout)->actualObject;
+                *(pPipelineLayout) =
+                    (VkPipelineLayout)(
+                        (VkUniqueObject *)pCreateInfos[index0].layout)
+                        ->actualObject;
             }
             if (pCreateInfos[index0].renderPass) {
-                VkRenderPass* pRenderPass = (VkRenderPass*)&(pCreateInfos[index0].renderPass);
+                VkRenderPass *pRenderPass =
+                    (VkRenderPass *)&(pCreateInfos[index0].renderPass);
                 original_renderPass.push_back(pCreateInfos[index0].renderPass);
-                *(pRenderPass) = (VkRenderPass)((VkUniqueObject*)pCreateInfos[index0].renderPass)->actualObject;
+                *(pRenderPass) =
+                    (VkRenderPass)(
+                        (VkUniqueObject *)pCreateInfos[index0].renderPass)
+                        ->actualObject;
             }
             if (pCreateInfos[index0].basePipelineHandle) {
-                VkPipeline* pPipeline = (VkPipeline*)&(pCreateInfos[index0].basePipelineHandle);
-                original_basePipelineHandle.push_back(pCreateInfos[index0].basePipelineHandle);
-                *(pPipeline) = (VkPipeline)((VkUniqueObject*)pCreateInfos[index0].basePipelineHandle)->actualObject;
+                VkPipeline *pPipeline =
+                    (VkPipeline *)&(pCreateInfos[index0].basePipelineHandle);
+                original_basePipelineHandle.push_back(
+                    pCreateInfos[index0].basePipelineHandle);
+                *(pPipeline) =
+                    (VkPipeline)((VkUniqueObject *)pCreateInfos[index0]
+                                     .basePipelineHandle)->actualObject;
             }
         }
     }
-    VkResult result = get_dispatch_table(unique_objects_device_table_map, device)->CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+    VkResult result =
+        get_dispatch_table(unique_objects_device_table_map, device)
+            ->CreateGraphicsPipelines(device, pipelineCache, createInfoCount,
+                                      pCreateInfos, pAllocator, pPipelines);
     if (pCreateInfos) {
-        for (uint32_t index0=0; index0<createInfoCount; ++index0) {
+        for (uint32_t index0 = 0; index0 < createInfoCount; ++index0) {
             if (pCreateInfos[index0].pStages) {
-                for (uint32_t index1=0; index1<pCreateInfos[index0].stageCount; ++index1) {
+                for (uint32_t index1 = 0;
+                     index1 < pCreateInfos[index0].stageCount; ++index1) {
                     if (pCreateInfos[index0].pStages[index1].module) {
-                        VkShaderModule* pShaderModule = (VkShaderModule*)&(pCreateInfos[index0].pStages[index1].module);
+                        VkShaderModule *pShaderModule = (VkShaderModule *)&(
+                            pCreateInfos[index0].pStages[index1].module);
                         *(pShaderModule) = original_module[index1];
                     }
                 }
             }
             if (pCreateInfos[index0].layout) {
-                VkPipelineLayout* pPipelineLayout = (VkPipelineLayout*)&(pCreateInfos[index0].layout);
+                VkPipelineLayout *pPipelineLayout =
+                    (VkPipelineLayout *)&(pCreateInfos[index0].layout);
                 *(pPipelineLayout) = original_layout[index0];
             }
             if (pCreateInfos[index0].renderPass) {
-                VkRenderPass* pRenderPass = (VkRenderPass*)&(pCreateInfos[index0].renderPass);
+                VkRenderPass *pRenderPass =
+                    (VkRenderPass *)&(pCreateInfos[index0].renderPass);
                 *(pRenderPass) = original_renderPass[index0];
             }
             if (pCreateInfos[index0].basePipelineHandle) {
-                VkPipeline* pPipeline = (VkPipeline*)&(pCreateInfos[index0].basePipelineHandle);
+                VkPipeline *pPipeline =
+                    (VkPipeline *)&(pCreateInfos[index0].basePipelineHandle);
                 *(pPipeline) = original_basePipelineHandle[index0];
             }
         }
     }
     if (VK_SUCCESS == result) {
-        VkUniqueObject* pUO = NULL;
-        for (uint32_t i=0; i<createInfoCount; ++i) {
+        VkUniqueObject *pUO = NULL;
+        for (uint32_t i = 0; i < createInfoCount; ++i) {
             pUO = new VkUniqueObject();
             pUO->actualObject = (uint64_t)pPipelines[i];
             pPipelines[i] = (VkPipeline)pUO;
@@ -558,19 +827,24 @@ VkResult explicit_CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipel
     return result;
 }
 
-VkResult explicit_GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages)
-{
-// UNWRAP USES:
-//  0 : swapchain,VkSwapchainKHR, pSwapchainImages,VkImage
+VkResult explicit_GetSwapchainImagesKHR(VkDevice device,
+                                        VkSwapchainKHR swapchain,
+                                        uint32_t *pSwapchainImageCount,
+                                        VkImage *pSwapchainImages) {
+    // UNWRAP USES:
+    //  0 : swapchain,VkSwapchainKHR, pSwapchainImages,VkImage
     if (VK_NULL_HANDLE != swapchain) {
-        swapchain = (VkSwapchainKHR)((VkUniqueObject*)swapchain)->actualObject;
+        swapchain = (VkSwapchainKHR)((VkUniqueObject *)swapchain)->actualObject;
     }
-    VkResult result = get_dispatch_table(unique_objects_device_table_map, device)->GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
+    VkResult result =
+        get_dispatch_table(unique_objects_device_table_map, device)
+            ->GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount,
+                                    pSwapchainImages);
     // TODO : Need to add corresponding code to delete these images
     if (VK_SUCCESS == result) {
         if ((*pSwapchainImageCount > 0) && pSwapchainImages) {
-            std::vector<VkUniqueObject*> uniqueImages = {};
-            for (uint32_t i=0; i<*pSwapchainImageCount; ++i) {
+            std::vector<VkUniqueObject *> uniqueImages = {};
+            for (uint32_t i = 0; i < *pSwapchainImageCount; ++i) {
                 uniqueImages.push_back(new VkUniqueObject());
                 uniqueImages[i]->actualObject = (uint64_t)pSwapchainImages[i];
                 pSwapchainImages[i] = (VkImage)uniqueImages[i];