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

This reverts commit e260acfb96ea20945149ede6a250ef622ca7fd03.
The clang-format changes need to be postponed until just prior
to public release to facilitate MRs.

1 files changed, 205 insertions, 479 deletions

diff --git a/layers/unique_objects.h b/layers/unique_objects.h
index 6e073aec..5b3d5d5c 100644
--- a/layers/unique_objects.h
+++ b/layers/unique_objects.h
@@ -50,7 +50,9 @@
 struct layer_data {
     bool wsi_enabled;
 
-    layer_data() : wsi_enabled(false){};
+    layer_data() :
+        wsi_enabled(false)
+    {};
 };
 
 struct instExts {
@@ -63,126 +65,93 @@ 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;
     }
@@ -195,8 +164,7 @@ VkResult explicit_CreateInstance(const VkInstanceCreateInfo *pCreateInfo,
         return result;
     }
 
-    initInstanceTable(*pInstance, fpGetInstanceProcAddr,
-                      unique_objects_instance_table_map);
+    initInstanceTable(*pInstance, fpGetInstanceProcAddr, unique_objects_instance_table_map);
 
     createInstanceRegisterExtensions(pCreateInfo, *pInstance);
 
@@ -204,46 +172,36 @@ VkResult explicit_CreateInstance(const VkInstanceCreateInfo *pCreateInfo,
 }
 
 // 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;
     }
@@ -257,73 +215,54 @@ VkResult explicit_CreateDevice(VkPhysicalDevice gpu,
     }
 
     // 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];
                 }
             }
@@ -332,17 +271,10 @@ VkResult explicit_QueueSubmit(VkQueue queue, uint32_t submitCount,
     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 = {};
@@ -352,203 +284,93 @@ VkResult explicit_QueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
     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];
                             }
                         }
@@ -556,30 +378,15 @@ VkResult explicit_QueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
                 }
             }
             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];
                             }
                         }
@@ -587,28 +394,15 @@ VkResult explicit_QueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
                 }
             }
             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];
                             }
                         }
@@ -616,19 +410,14 @@ VkResult explicit_QueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
                 }
             }
             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];
                 }
             }
@@ -637,79 +426,55 @@ VkResult explicit_QueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
     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;
@@ -718,107 +483,73 @@ VkResult explicit_CreateComputePipelines(
     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;
@@ -827,24 +558,19 @@ VkResult explicit_CreateGraphicsPipelines(
     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];