Rebased ref, commits from common ancestor:
commit ebf46deb849a2d4cab3382c606a9fe36699dfa78
Author: Lenny Komow <le...@lunarg.com>
Date:   Fri Sep 9 09:43:17 2016 -0600

    winsdk: Fix ConfigureRT.exe not being deleted

diff --git a/windowsRuntimeInstaller/InstallerRT.nsi 
b/windowsRuntimeInstaller/InstallerRT.nsi
index 7023447..7d5e684 100644
--- a/windowsRuntimeInstaller/InstallerRT.nsi
+++ b/windowsRuntimeInstaller/InstallerRT.nsi
@@ -636,6 +636,9 @@ Section "uninstall"
         StrCpy $1 85
     ${Endif}
     Call un.CheckForError
+    
+    # Remove ConfigureRT regardless of the ref count
+    Delete /REBOOTOK "$IDir\ConfigureRT.exe"
 
     # If Ref Count is zero, remove install dir
     ${If} $IC <= 0
@@ -645,7 +648,6 @@ Section "uninstall"
         Delete /REBOOTOK "$IDir\LICENSE.txt"
         Delete /REBOOTOK "$IDir\Uninstall${PRODUCTNAME}.exe"
         Delete /REBOOTOK "$IDir\V.ico"
-        Delete /REBOOTOK "$IDir\ConfigureRT.exe"
         Delete /REBOOTOK "$IDir\vulkaninfo.exe"
 
         # If running on a 64-bit OS machine

commit 73b0ff342b45e665dd007503da0342abb5f81117
Author: Mark Young <ma...@lunarg.com>
Date:   Fri Sep 9 07:26:48 2016 -0600

    loader: Add back func calls
    
    Previously removed function calls in extension_create_instance
    because I believed they were no longer needed.  I was incorrect.
    
    Change-Id: Ibc63009f0038a413b7e1bc03225818b046a62352

diff --git a/loader/extensions.c b/loader/extensions.c
index fd7e0ec..5a0608a 100644
--- a/loader/extensions.c
+++ b/loader/extensions.c
@@ -130,6 +130,29 @@ bool extension_instance_gpa(struct loader_instance 
*ptr_instance,
         return true;
     }
 
+    // Functions for the VK_AMD_draw_indirect_count extension
+
+    if (!strcmp("vkCmdDrawIndirectCountAMD", name)) {
+        *addr = (void *)vkCmdDrawIndirectCountAMD;
+        return true;
+    }
+
+    if (!strcmp("vkCmdDrawIndexedIndirectCountAMD", name)) {
+        *addr = (void *)vkCmdDrawIndexedIndirectCountAMD;
+        return true;
+    }
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+    // Functions for the VK_NV_external_memory_win32 extension
+
+    if (!strcmp("vkGetMemoryWin32HandleNV", name)) {
+        *addr = (void *)vkGetMemoryWin32HandleNV;
+        return true;
+    }
+
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
     return false;
 }
 

commit 91b1f8d66cb86b022bd67a62c33a507ae9dec626
Author: Mark Young <ma...@lunarg.com>
Date:   Thu Sep 8 18:36:32 2016 -0600

    loader: Remove extension enable checks
    
    Apparently, the intent of Vulkan is to have the loader do no
    run-time checking in each of the functions as to whether or not
    the extension is enabled.  This should only be done in the
    validation layers.
    
    This resolves the crash Jeff was seeing in the Nvidia driver when
    using the new extension.
    
    Change-Id: Ic90db0bde062d6b2511954abb8677f9f20bb4285

diff --git a/loader/extensions.c b/loader/extensions.c
index 4749e20..fd7e0ec 100644
--- a/loader/extensions.c
+++ b/loader/extensions.c
@@ -27,61 +27,6 @@
 #include "extensions.h"
 #include <vulkan/vk_icd.h>
 
-// Definitions for EXT_debug_marker extension
-
-VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT(
-    VkDevice device, VkDebugMarkerObjectTagInfoEXT *pTagInfo) {
-    struct loader_dev_dispatch_table *disp = loader_get_dev_dispatch(device);
-    if (0 == disp->enabled_known_extensions.ext_debug_marker ||
-        NULL == disp->core_dispatch.DebugMarkerSetObjectTagEXT) {
-        return VK_ERROR_EXTENSION_NOT_PRESENT;
-    } else {
-        return disp->core_dispatch.DebugMarkerSetObjectTagEXT(device, 
pTagInfo);
-    }
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT(
-    VkDevice device, VkDebugMarkerObjectNameInfoEXT *pNameInfo) {
-    struct loader_dev_dispatch_table *disp = loader_get_dev_dispatch(device);
-    if (0 == disp->enabled_known_extensions.ext_debug_marker ||
-        NULL == disp->core_dispatch.DebugMarkerSetObjectNameEXT) {
-        return VK_ERROR_EXTENSION_NOT_PRESENT;
-    } else {
-        return disp->core_dispatch.DebugMarkerSetObjectNameEXT(device,
-                                                               pNameInfo);
-    }
-}
-
-VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT(
-    VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT *pMarkerInfo) {
-    struct loader_dev_dispatch_table *disp =
-        loader_get_dev_dispatch(commandBuffer);
-    if (1 == disp->enabled_known_extensions.ext_debug_marker &&
-        NULL != disp->core_dispatch.CmdDebugMarkerBeginEXT) {
-        disp->core_dispatch.CmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo);
-    }
-}
-
-VKAPI_ATTR void VKAPI_CALL
-vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) {
-    struct loader_dev_dispatch_table *disp =
-        loader_get_dev_dispatch(commandBuffer);
-    if (1 == disp->enabled_known_extensions.ext_debug_marker &&
-        NULL != disp->core_dispatch.CmdDebugMarkerEndEXT) {
-        disp->core_dispatch.CmdDebugMarkerEndEXT(commandBuffer);
-    }
-}
-
-VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT(
-    VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT *pMarkerInfo) {
-    struct loader_dev_dispatch_table *disp =
-        loader_get_dev_dispatch(commandBuffer);
-    if (1 == disp->enabled_known_extensions.ext_debug_marker &&
-        NULL != disp->core_dispatch.CmdDebugMarkerInsertEXT) {
-        disp->core_dispatch.CmdDebugMarkerInsertEXT(commandBuffer, 
pMarkerInfo);
-    }
-}
-
 // Definitions for the VK_NV_external_memory_capabilities extension
 
 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
@@ -90,27 +35,16 @@ vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
     VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags,
     VkExternalMemoryHandleTypeFlagsNV externalHandleType,
     VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties) {
-
     const VkLayerInstanceDispatchTable *disp;
     struct loader_physical_device_tramp *phys_dev =
         (struct loader_physical_device_tramp *)physicalDevice;
-    struct loader_instance *inst = phys_dev->this_instance;
     VkPhysicalDevice unwrapped_phys_dev =
         loader_unwrap_physical_device(physicalDevice);
     disp = loader_get_instance_dispatch(physicalDevice);
 
-    if (0 == inst->enabled_known_extensions.nv_external_memory_capabilities ||
-        NULL == disp->GetPhysicalDeviceExternalImageFormatPropertiesNV) {
-        loader_log(
-            inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-            "vkGetPhysicalDeviceExternalImageFormatPropertiesNV called without"
-            " NV_external_memory_capabilities extension being enabled");
-        return VK_ERROR_EXTENSION_NOT_PRESENT;
-    } else {
-        return disp->GetPhysicalDeviceExternalImageFormatPropertiesNV(
-            unwrapped_phys_dev, format, type, tiling, usage, flags,
-            externalHandleType, pExternalImageFormatProperties);
-    }
+    return disp->GetPhysicalDeviceExternalImageFormatPropertiesNV(
+        unwrapped_phys_dev, format, type, tiling, usage, flags,
+        externalHandleType, pExternalImageFormatProperties);
 }
 
 VKAPI_ATTR VkResult VKAPI_CALL
@@ -152,28 +86,19 @@ VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD(
     VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
     VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t 
maxDrawCount,
     uint32_t stride) {
-    struct loader_dev_dispatch_table *disp =
-        loader_get_dev_dispatch(commandBuffer);
-    if (1 == disp->enabled_known_extensions.amd_draw_indirect_count &&
-        NULL != disp->core_dispatch.CmdDrawIndirectCountAMD) {
-        disp->core_dispatch.CmdDrawIndirectCountAMD(
-            commandBuffer, buffer, offset, countBuffer, countBufferOffset,
-            maxDrawCount, stride);
-    }
+    const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
+    disp->CmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer,
+                                  countBufferOffset, maxDrawCount, stride);
 }
 
 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD(
     VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
     VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t 
maxDrawCount,
     uint32_t stride) {
-    struct loader_dev_dispatch_table *disp =
-        loader_get_dev_dispatch(commandBuffer);
-    if (1 == disp->enabled_known_extensions.amd_draw_indirect_count &&
-        NULL != disp->core_dispatch.CmdDrawIndexedIndirectCountAMD) {
-        disp->core_dispatch.CmdDrawIndexedIndirectCountAMD(
-            commandBuffer, buffer, offset, countBuffer, countBufferOffset,
-            maxDrawCount, stride);
-    }
+    const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
+    disp->CmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset,
+                                         countBuffer, countBufferOffset,
+                                         maxDrawCount, stride);
 }
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
@@ -183,14 +108,8 @@ VKAPI_ATTR void VKAPI_CALL 
vkCmdDrawIndexedIndirectCountAMD(
 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
     VkDevice device, VkDeviceMemory memory,
     VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE *pHandle) {
-    struct loader_dev_dispatch_table *disp = loader_get_dev_dispatch(device);
-    if (0 == disp->enabled_known_extensions.nv_external_memory_win32 ||
-        NULL == disp->core_dispatch.GetMemoryWin32HandleNV) {
-        return VK_ERROR_EXTENSION_NOT_PRESENT;
-    } else {
-        return disp->core_dispatch.GetMemoryWin32HandleNV(device, memory,
-                                                          handleType, pHandle);
-    }
+    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+    return disp->GetMemoryWin32HandleNV(device, memory, handleType, pHandle);
 }
 
 #endif // VK_USE_PLATFORM_WIN32_KHR
@@ -201,29 +120,6 @@ bool extension_instance_gpa(struct loader_instance 
*ptr_instance,
                             const char *name, void **addr) {
     *addr = NULL;
 
-    // Functions for the EXT_debug_marker extension
-
-    if (!strcmp("vkDebugMarkerSetObjectTagEXT", name)) {
-        *addr = (void *)vkDebugMarkerSetObjectTagEXT;
-        return true;
-    }
-    if (!strcmp("vkDebugMarkerSetObjectNameEXT", name)) {
-        *addr = (void *)vkDebugMarkerSetObjectNameEXT;
-        return true;
-    }
-    if (!strcmp("vkCmdDebugMarkerBeginEXT", name)) {
-        *addr = (void *)vkCmdDebugMarkerBeginEXT;
-        return true;
-    }
-    if (!strcmp("vkCmdDebugMarkerEndEXT", name)) {
-        *addr = (void *)vkCmdDebugMarkerEndEXT;
-        return true;
-    }
-    if (!strcmp("vkCmdDebugMarkerInsertEXT", name)) {
-        *addr = (void *)vkCmdDebugMarkerInsertEXT;
-        return true;
-    }
-
     // Functions for the VK_NV_external_memory_capabilities extension
 
     if (!strcmp("vkGetPhysicalDeviceExternalImageFormatPropertiesNV", name)) {
@@ -234,29 +130,6 @@ bool extension_instance_gpa(struct loader_instance 
*ptr_instance,
         return true;
     }
 
-    // Functions for the VK_AMD_draw_indirect_count extension
-
-    if (!strcmp("vkCmdDrawIndirectCountAMD", name)) {
-        *addr = (void *)vkCmdDrawIndirectCountAMD;
-        return true;
-    }
-
-    if (!strcmp("vkCmdDrawIndexedIndirectCountAMD", name)) {
-        *addr = (void *)vkCmdDrawIndexedIndirectCountAMD;
-        return true;
-    }
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-
-    // Functions for the VK_NV_external_memory_win32 extension
-
-    if (!strcmp("vkGetMemoryWin32HandleNV", name)) {
-        *addr = (void *)vkGetMemoryWin32HandleNV;
-        return true;
-    }
-
-#endif // VK_USE_PLATFORM_WIN32_KHR
-
     return false;
 }
 
@@ -273,34 +146,3 @@ void extensions_create_instance(struct loader_instance 
*ptr_instance,
         }
     }
 }
-
-void extensions_create_device(struct loader_device *dev,
-                              const VkDeviceCreateInfo *pCreateInfo) {
-    dev->loader_dispatch.enabled_known_extensions.ext_debug_marker = 0;
-    dev->loader_dispatch.enabled_known_extensions.amd_draw_indirect_count = 0;
-    dev->loader_dispatch.enabled_known_extensions.nv_external_memory_win32 = 0;
-
-    for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i],
-                   VK_EXT_DEBUG_MARKER_EXTENSION_NAME) == 0) {
-            dev->loader_dispatch.enabled_known_extensions.ext_debug_marker = 1;
-            return;
-        }
-
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i],
-                   VK_AMD_EXTENSION_DRAW_INDIRECT_COUNT_EXTENSION_NAME) == 0) {
-            dev->loader_dispatch.enabled_known_extensions
-                .amd_draw_indirect_count = 1;
-            return;
-        }
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i],
-                   VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME) == 0) {
-            dev->loader_dispatch.enabled_known_extensions
-                .nv_external_memory_win32 = 1;
-            return;
-        }
-#endif // VK_USE_PLATFORM_WIN32_KHR
-    }
-}
diff --git a/loader/extensions.h b/loader/extensions.h
index c84fd86..651d5f5 100644
--- a/loader/extensions.h
+++ b/loader/extensions.h
@@ -28,9 +28,6 @@ bool extension_instance_gpa(struct loader_instance 
*ptr_instance,
 void extensions_create_instance(struct loader_instance *ptr_instance,
                                 const VkInstanceCreateInfo *pCreateInfo);
 
-void extensions_create_device(struct loader_device *dev,
-                              const VkDeviceCreateInfo *pCreateInfo);
-
 // Definitions for the VK_NV_external_memory_capabilities extension
 
 VKAPI_ATTR VkResult VKAPI_CALL
diff --git a/loader/loader.c b/loader/loader.c
index 5a347db..92afbe1 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -4324,9 +4324,6 @@ VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDevice(
         }
     }
 
-    wsi_create_device(dev, pCreateInfo);
-    extensions_create_device(dev, pCreateInfo);
-
     // TODO: Why does fpCreateDevice behave differently than
     // this_icd->CreateDevice?
     //    VkResult res = fpCreateDevice(phys_dev->phys_dev, &localCreateInfo,
diff --git a/loader/loader.h b/loader/loader.h
index 651d507..19d28e1 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -158,20 +158,9 @@ struct loader_dev_ext_dispatch_table {
     PFN_vkDevExt dev_ext[MAX_NUM_DEV_EXTS];
 };
 
-union loader_device_extension_enables {
-    struct {
-        uint8_t khr_display_swapchain       : 1;
-        uint8_t ext_debug_marker            : 1;
-        uint8_t amd_draw_indirect_count     : 1;
-        uint8_t nv_external_memory_win32    : 1;
-    };
-    uint64_t padding[4];
-};
-
 struct loader_dev_dispatch_table {
     VkLayerDispatchTable core_dispatch;
     struct loader_dev_ext_dispatch_table ext_dispatch;
-    union loader_device_extension_enables enabled_known_extensions;
 };
 
 // per CreateDevice structure
diff --git a/loader/wsi.c b/loader/wsi.c
index 13d3004..a74cdb4 100644
--- a/loader/wsi.c
+++ b/loader/wsi.c
@@ -158,20 +158,6 @@ void wsi_create_instance(struct loader_instance 
*ptr_instance,
     }
 }
 
-void wsi_create_device(struct loader_device *dev,
-    const VkDeviceCreateInfo *pCreateInfo) {
-    dev->loader_dispatch.enabled_known_extensions.khr_display_swapchain = 0;
-
-    for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i],
-                   VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME) == 0) {
-            dev->loader_dispatch.enabled_known_extensions
-                .khr_display_swapchain = 1;
-            return;
-        }
-    }
-}
-
 // Linux WSI surface extensions are not always compiled into the loader. 
(Assume
 // for Windows the KHR_win32_surface is always compiled into loader). A given
 // Linux build environment might not have the headers required for building one
@@ -1278,14 +1264,9 @@ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 
vkCreateSharedSwapchainsKHR(
     VkDevice device, uint32_t swapchainCount,
     const VkSwapchainCreateInfoKHR *pCreateInfos,
     const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchains) {
-    struct loader_dev_dispatch_table *disp = loader_get_dev_dispatch(device);
-    if (0 == disp->enabled_known_extensions.khr_display_swapchain ||
-        NULL == disp->core_dispatch.CreateSharedSwapchainsKHR) {
-        return VK_ERROR_EXTENSION_NOT_PRESENT;
-    } else {
-        return disp->core_dispatch.CreateSharedSwapchainsKHR(
-            device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
-    }
+    const VkLayerDispatchTable *disp;
+    disp = loader_get_dispatch(device);
+    return disp->CreateSharedSwapchainsKHR(device, swapchainCount, 
pCreateInfos, pAllocator, pSwapchains);
 }
 
 bool wsi_swapchain_instance_gpa(struct loader_instance *ptr_instance,
diff --git a/loader/wsi.h b/loader/wsi.h
index 7409e7d..fa60088 100644
--- a/loader/wsi.h
+++ b/loader/wsi.h
@@ -27,8 +27,6 @@ bool wsi_swapchain_instance_gpa(struct loader_instance 
*ptr_instance,
 
 void wsi_create_instance(struct loader_instance *ptr_instance,
                          const VkInstanceCreateInfo *pCreateInfo);
-void wsi_create_device(struct loader_device *dev,
-                       const VkDeviceCreateInfo *pCreateInfo);
 bool wsi_unsupported_instance_extension(const VkExtensionProperties *ext_prop);
 
 VKAPI_ATTR void VKAPI_CALL

commit 19ab93c7fb4fb9ae62679852783a97f599d1b367
Author: Mark Young <ma...@lunarg.com>
Date:   Thu Sep 8 12:28:38 2016 -0600

    loader: Add checks for usage of wsi extensions
    
    The loader really should validate that the WSI extensions are
    enabled before being called.  Additionally, I needed to add
    more checks for the KHR_display_swapchain extension in the
    parameter_validation and object_tracker layers.
    
    Change-Id: I3d07d46baf551be6f5f07e5374d6c683e3f52e7e

diff --git a/layers/object_tracker.cpp b/layers/object_tracker.cpp
index e3d49b5..3c906ac 100644
--- a/layers/object_tracker.cpp
+++ b/layers/object_tracker.cpp
@@ -2940,6 +2940,40 @@ VKAPI_ATTR VkResult VKAPI_CALL 
CreateAndroidSurfaceKHR(VkInstance instance, cons
 }
 #endif // VK_USE_PLATFORM_ANDROID_KHR
 
+VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR(VkDevice device, 
uint32_t swapchainCount,
+                                                         const 
VkSwapchainCreateInfoKHR *pCreateInfos,
+                                                         const 
VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchains) {
+    bool skip_call = false;
+    uint32_t i = 0;
+    {
+        std::lock_guard<std::mutex> lock(global_lock);
+        skip_call |= ValidateDispatchableObject(device, device, 
VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false);
+        if (NULL != pCreateInfos) {
+            for (i = 0; i < swapchainCount; i++) {
+                skip_call |= ValidateNonDispatchableObject(device, 
pCreateInfos[i].oldSwapchain,
+                                                           
VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, true);
+                layer_data *device_data = 
get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+                skip_call |= 
ValidateNonDispatchableObject(device_data->physical_device, 
pCreateInfos[i].surface,
+                                                           
VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, false);
+            }
+        }
+    }
+    if (skip_call) {
+        return VK_ERROR_VALIDATION_FAILED_EXT;
+    }
+    VkResult result =
+        get_dispatch_table(ot_device_table_map, 
device)->CreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, 
pAllocator, pSwapchains);
+    {
+        std::lock_guard<std::mutex> lock(global_lock);
+        if (result == VK_SUCCESS) {
+            for (i = 0; i < swapchainCount; i++) {
+                CreateNonDispatchableObject(device, pSwapchains[i], 
VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT);
+            }
+        }
+    }
+    return result;
+}
+
 VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(VkInstance 
instance,
                                                             const 
VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
                                                             const 
VkAllocationCallbacks *pAllocator,
@@ -3066,11 +3100,16 @@ static inline PFN_vkVoidFunction 
InterceptWsiEnabledCommand(const char *name, Vk
 static void CheckDeviceRegisterExtensions(const VkDeviceCreateInfo 
*pCreateInfo, VkDevice device) {
     layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), 
layer_data_map);
     device_data->wsi_enabled = false;
+    device_data->wsi_display_swapchain_enabled = false;
+    device_data->objtrack_extensions_enabled = false;
 
     for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
         if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], 
VK_KHR_SWAPCHAIN_EXTENSION_NAME) == 0) {
             device_data->wsi_enabled = true;
         }
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], 
VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME) == 0) {
+            device_data->wsi_display_swapchain_enabled = true;
+        }
         if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], 
"OBJTRACK_EXTENSIONS") == 0) {
             device_data->objtrack_extensions_enabled = true;
         }
@@ -3885,19 +3924,26 @@ static inline PFN_vkVoidFunction 
InterceptCoreInstanceCommand(const char *name)
 static inline PFN_vkVoidFunction InterceptWsiEnabledCommand(const char *name, 
VkDevice device) {
     if (device) {
         layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), 
layer_data_map);
-        if (!device_data->wsi_enabled)
-            return nullptr;
-    }
-    if (!strcmp("vkCreateSwapchainKHR", name))
-        return reinterpret_cast<PFN_vkVoidFunction>(CreateSwapchainKHR);
-    if (!strcmp("vkDestroySwapchainKHR", name))
-        return reinterpret_cast<PFN_vkVoidFunction>(DestroySwapchainKHR);
-    if (!strcmp("vkGetSwapchainImagesKHR", name))
-        return reinterpret_cast<PFN_vkVoidFunction>(GetSwapchainImagesKHR);
-    if (!strcmp("vkAcquireNextImageKHR", name))
-        return reinterpret_cast<PFN_vkVoidFunction>(AcquireNextImageKHR);
-    if (!strcmp("vkQueuePresentKHR", name))
-        return reinterpret_cast<PFN_vkVoidFunction>(QueuePresentKHR);
+
+        if (device_data->wsi_enabled) {
+            if (!strcmp("vkCreateSwapchainKHR", name))
+                return 
reinterpret_cast<PFN_vkVoidFunction>(CreateSwapchainKHR);
+            if (!strcmp("vkDestroySwapchainKHR", name))
+                return 
reinterpret_cast<PFN_vkVoidFunction>(DestroySwapchainKHR);
+            if (!strcmp("vkGetSwapchainImagesKHR", name))
+                return 
reinterpret_cast<PFN_vkVoidFunction>(GetSwapchainImagesKHR);
+            if (!strcmp("vkAcquireNextImageKHR", name))
+                return 
reinterpret_cast<PFN_vkVoidFunction>(AcquireNextImageKHR);
+            if (!strcmp("vkQueuePresentKHR", name))
+                return reinterpret_cast<PFN_vkVoidFunction>(QueuePresentKHR);
+        }
+
+        if (device_data->wsi_display_swapchain_enabled) {
+            if (!strcmp("vkCreateSharedSwapchainsKHR", name)) {
+                return 
reinterpret_cast<PFN_vkVoidFunction>(CreateSharedSwapchainsKHR);
+            }
+        }
+    }
 
     return nullptr;
 }
diff --git a/layers/object_tracker.h b/layers/object_tracker.h
index 8f514a6..c4088a9 100644
--- a/layers/object_tracker.h
+++ b/layers/object_tracker.h
@@ -92,6 +92,7 @@ struct layer_data {
     debug_report_data *report_data;
     std::vector<VkDebugReportCallbackEXT> logging_callback;
     bool wsi_enabled;
+    bool wsi_display_swapchain_enabled;
     bool objtrack_extensions_enabled;
 
     // The following are for keeping track of the temporary callbacks that can
@@ -112,8 +113,8 @@ struct layer_data {
     // Default constructor
     layer_data()
         : instance(nullptr), physical_device(nullptr), num_objects{}, 
num_total_objects(0), report_data(nullptr),
-          wsi_enabled(false), objtrack_extensions_enabled(false), 
num_tmp_callbacks(0), tmp_dbg_create_infos(nullptr),
-                 tmp_callbacks(nullptr), object_map{} {
+          wsi_enabled(false), wsi_display_swapchain_enabled(false), 
objtrack_extensions_enabled(false), num_tmp_callbacks(0),
+          tmp_dbg_create_infos(nullptr), tmp_callbacks(nullptr), object_map{} {
         object_map.resize(VK_DEBUG_REPORT_OBJECT_TYPE_RANGE_SIZE_EXT + 1);
     }
 };
diff --git a/layers/parameter_validation.cpp b/layers/parameter_validation.cpp
index bf45285..2bc8d38 100644
--- a/layers/parameter_validation.cpp
+++ b/layers/parameter_validation.cpp
@@ -73,10 +73,11 @@ struct layer_data {
     VkPhysicalDevice physical_device;
 
     bool wsi_enabled;
+    bool wsi_display_swapchain_enabled;
 
     layer_data()
         : report_data(nullptr), num_tmp_callbacks(0), 
tmp_dbg_create_infos(nullptr), tmp_callbacks(nullptr), device_limits{},
-          physical_device_features{}, physical_device{}, wsi_enabled(false){};
+          physical_device_features{}, physical_device{}, wsi_enabled(false), 
wsi_display_swapchain_enabled(false) {};
 };
 
 static std::unordered_map<void *, struct instance_extension_enables> 
instance_extension_map;
@@ -1633,11 +1634,15 @@ static void CheckInstanceRegisterExtensions(const 
VkInstanceCreateInfo *pCreateI
 static void CheckDeviceRegisterExtensions(const VkDeviceCreateInfo 
*pCreateInfo, VkDevice device) {
     layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), 
layer_data_map);
     device_data->wsi_enabled = false;
+    device_data->wsi_display_swapchain_enabled = false;
 
     for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
         if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], 
VK_KHR_SWAPCHAIN_EXTENSION_NAME) == 0) {
             device_data->wsi_enabled = true;
         }
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], 
VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME) == 0) {
+            device_data->wsi_display_swapchain_enabled = true;
+        }
     }
 }
 
@@ -5051,6 +5056,27 @@ VKAPI_ATTR VkResult VKAPI_CALL 
CreateAndroidSurfaceKHR(VkInstance instance, cons
 }
 #endif // VK_USE_PLATFORM_ANDROID_KHR
 
+VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR(VkDevice device, 
uint32_t swapchainCount,
+                                                         const 
VkSwapchainCreateInfoKHR *pCreateInfos,
+                                                         const 
VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchains) {
+    VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
+    bool skip_call = false;
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), 
layer_data_map);
+    assert(my_data != NULL);
+
+    skip_call |= 
parameter_validation_vkCreateSharedSwapchainsKHR(my_data->report_data, 
swapchainCount, pCreateInfos, pAllocator,
+                                                                  pSwapchains);
+
+    if (!skip_call) {
+        result = get_dispatch_table(pc_device_table_map, device)
+                     ->CreateSharedSwapchainsKHR(device, swapchainCount, 
pCreateInfos, pAllocator, pSwapchains);
+
+        validate_result(my_data->report_data, "vkCreateSharedSwapchainsKHR", 
result);
+    }
+
+    return result;
+}
+
 static PFN_vkVoidFunction intercept_core_instance_command(const char *name);
 
 static PFN_vkVoidFunction intercept_core_device_command(const char *name);
@@ -5285,13 +5311,19 @@ static PFN_vkVoidFunction 
InterceptWsiEnabledCommand(const char *name, VkDevice
 
     if (device) {
         layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), 
layer_data_map);
-        if (!device_data->wsi_enabled)
-            return nullptr;
-    }
 
-    for (size_t i = 0; i < ARRAY_SIZE(wsi_device_commands); i++) {
-        if (!strcmp(wsi_device_commands[i].name, name))
-            return wsi_device_commands[i].proc;
+        if (device_data->wsi_enabled) {
+            for (size_t i = 0; i < ARRAY_SIZE(wsi_device_commands); i++) {
+                if (!strcmp(wsi_device_commands[i].name, name))
+                    return wsi_device_commands[i].proc;
+            }
+        }
+
+        if (device_data->wsi_display_swapchain_enabled) {
+            if (!strcmp("vkCreateSharedSwapchainsKHR", name)) {
+                return 
reinterpret_cast<PFN_vkVoidFunction>(CreateSharedSwapchainsKHR);
+            }
+        }
     }
 
     return nullptr;
diff --git a/loader/loader.c b/loader/loader.c
index ac8f4fc..5a347db 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -4324,6 +4324,7 @@ VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDevice(
         }
     }
 
+    wsi_create_device(dev, pCreateInfo);
     extensions_create_device(dev, pCreateInfo);
 
     // TODO: Why does fpCreateDevice behave differently than
diff --git a/loader/loader.h b/loader/loader.h
index 9b57372..651d507 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -160,6 +160,7 @@ struct loader_dev_ext_dispatch_table {
 
 union loader_device_extension_enables {
     struct {
+        uint8_t khr_display_swapchain       : 1;
         uint8_t ext_debug_marker            : 1;
         uint8_t amd_draw_indirect_count     : 1;
         uint8_t nv_external_memory_win32    : 1;
diff --git a/loader/wsi.c b/loader/wsi.c
index 10c5260..13d3004 100644
--- a/loader/wsi.c
+++ b/loader/wsi.c
@@ -158,6 +158,20 @@ void wsi_create_instance(struct loader_instance 
*ptr_instance,
     }
 }
 
+void wsi_create_device(struct loader_device *dev,
+    const VkDeviceCreateInfo *pCreateInfo) {
+    dev->loader_dispatch.enabled_known_extensions.khr_display_swapchain = 0;
+
+    for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i],
+                   VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME) == 0) {
+            dev->loader_dispatch.enabled_known_extensions
+                .khr_display_swapchain = 1;
+            return;
+        }
+    }
+}
+
 // Linux WSI surface extensions are not always compiled into the loader. 
(Assume
 // for Windows the KHR_win32_surface is always compiled into loader). A given
 // Linux build environment might not have the headers required for building one
@@ -403,9 +417,8 @@ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 
vkCreateSwapchainKHR(
     const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) {
     const VkLayerDispatchTable *disp;
     disp = loader_get_dispatch(device);
-    VkResult res =
-        disp->CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
-    return res;
+    return disp->CreateSwapchainKHR(device, pCreateInfo, pAllocator,
+                                    pSwapchain);
 }
 
 // This is the trampoline entrypoint for DestroySwapchainKHR
@@ -424,9 +437,8 @@ vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR 
swapchain,
                         VkImage *pSwapchainImages) {
     const VkLayerDispatchTable *disp;
     disp = loader_get_dispatch(device);
-    VkResult res = disp->GetSwapchainImagesKHR(
+    return disp->GetSwapchainImagesKHR(
         device, swapchain, pSwapchainImageCount, pSwapchainImages);
-    return res;
 }
 
 // This is the trampoline entrypoint for AcquireNextImageKHR
@@ -436,9 +448,8 @@ vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR 
swapchain,
                       uint32_t *pImageIndex) {
     const VkLayerDispatchTable *disp;
     disp = loader_get_dispatch(device);
-    VkResult res = disp->AcquireNextImageKHR(device, swapchain, timeout,
-                                             semaphore, fence, pImageIndex);
-    return res;
+    return disp->AcquireNextImageKHR(device, swapchain, timeout,
+        semaphore, fence, pImageIndex);
 }
 
 // This is the trampoline entrypoint for QueuePresentKHR
@@ -446,8 +457,7 @@ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
 vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) {
     const VkLayerDispatchTable *disp;
     disp = loader_get_dispatch(queue);
-    VkResult res = disp->QueuePresentKHR(queue, pPresentInfo);
-    return res;
+    return disp->QueuePresentKHR(queue, pPresentInfo);
 }
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
@@ -1268,10 +1278,14 @@ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 
vkCreateSharedSwapchainsKHR(
     VkDevice device, uint32_t swapchainCount,
     const VkSwapchainCreateInfoKHR *pCreateInfos,
     const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchains) {
-    const VkLayerDispatchTable *disp;
-    disp = loader_get_dispatch(device);
-    return disp->CreateSharedSwapchainsKHR(
-        device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
+    struct loader_dev_dispatch_table *disp = loader_get_dev_dispatch(device);
+    if (0 == disp->enabled_known_extensions.khr_display_swapchain ||
+        NULL == disp->core_dispatch.CreateSharedSwapchainsKHR) {
+        return VK_ERROR_EXTENSION_NOT_PRESENT;
+    } else {
+        return disp->core_dispatch.CreateSharedSwapchainsKHR(
+            device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
+    }
 }
 
 bool wsi_swapchain_instance_gpa(struct loader_instance *ptr_instance,
diff --git a/loader/wsi.h b/loader/wsi.h
index fa60088..7409e7d 100644
--- a/loader/wsi.h
+++ b/loader/wsi.h
@@ -27,6 +27,8 @@ bool wsi_swapchain_instance_gpa(struct loader_instance 
*ptr_instance,
 
 void wsi_create_instance(struct loader_instance *ptr_instance,
                          const VkInstanceCreateInfo *pCreateInfo);
+void wsi_create_device(struct loader_device *dev,
+                       const VkDeviceCreateInfo *pCreateInfo);
 bool wsi_unsupported_instance_extension(const VkExtensionProperties *ext_prop);
 
 VKAPI_ATTR void VKAPI_CALL

commit 5e2a8443e9d4c2dcfac3c388fd9d53f86a0ea002
Author: Mark Mueller <ma...@lunarg.com>
Date:   Thu Sep 8 11:11:25 2016 -0600

    tests: GH428 removal of offending line
    
    The ill constructed draw is not needed and causes issues on some platforms.
    
    Change-Id: I695a386e3a70a2d004b047044ee534e204a6499a

diff --git a/tests/layer_validation_tests.cpp b/tests/layer_validation_tests.cpp
index b630e6b..579f8ed 100644
--- a/tests/layer_validation_tests.cpp
+++ b/tests/layer_validation_tests.cpp
@@ -12644,7 +12644,6 @@ TEST_F(VkLayerTest, InUseDestroyedSignaled) {
     vkCmdBindPipeline(m_commandBuffer->GetBufferHandle(), 
VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle());
     vkCmdBindDescriptorSets(m_commandBuffer->GetBufferHandle(), 
VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout, 0, 1,
                             &descriptorset, 0, NULL);
-    vkCmdDraw(m_commandBuffer->handle(), 3, 1, 0, 0);
 
     EndCommandBuffer();
 

commit fb2ef429c4951f7e23522286a438047346fe9f83
Author: Ian Elliott <ianelli...@google.com>
Date:   Thu Sep 8 11:34:52 2016 -0600

    layers: Remove old/unnecessary FIXME from swapchain layer
    
    This FIXME comment does not apply.  It may have applied, if the line being
    referred to once copied a pointer to user data, but at this point, the 
actual
    data is being copied into a struct owned by the swapchain layer, which is 
what
    the comment was about.

diff --git a/layers/swapchain.cpp b/layers/swapchain.cpp
index 792b063..5aca7f6 100644
--- a/layers/swapchain.cpp
+++ b/layers/swapchain.cpp
@@ -1389,7 +1389,6 @@ VKAPI_ATTR VkResult VKAPI_CALL 
GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysica
         if ((result == VK_SUCCESS) && pPhysicalDevice) {
             // Record the result of this query:
             pPhysicalDevice->gotSurfaceCapabilities = true;
-            // FIXME: NEED TO COPY THIS DATA, BECAUSE pSurfaceCapabilities 
POINTS TO APP-ALLOCATED DATA
             pPhysicalDevice->surfaceCapabilities = *pSurfaceCapabilities;
         }
         lock.unlock();

commit 44d6a5576388f2ad138a00e6ed97fc0ace12ea15
Author: Mark Lobodzinski <m...@lunarg.com>
Date:   Thu Sep 8 10:45:35 2016 -0600

    tests: Clang-format layer_validation_tests.cpp
    
    Change-Id: I9f790550be5e727f8f4e10c42ddfba6fad3d581a

diff --git a/tests/layer_validation_tests.cpp b/tests/layer_validation_tests.cpp
index 3497e14..b630e6b 100644
--- a/tests/layer_validation_tests.cpp
+++ b/tests/layer_validation_tests.cpp
@@ -31,10 +31,10 @@
 #include <android_native_app_glue.h>
 #endif
 
+#include "icd-spv.h"
 #include "test_common.h"
-#include "vkrenderframework.h"
 #include "vk_layer_config.h"
-#include "icd-spv.h"
+#include "vkrenderframework.h"
 
 #define GLM_FORCE_RADIANS
 #include "glm/glm.hpp"
@@ -81,32 +81,28 @@ struct vktriangle_vs_uniform {
     float color[3][4];
 };
 
-static const char bindStateVertShaderText[] =
-    "#version 450\n"
-    "vec2 vertices[3];\n"
-    "out gl_PerVertex {\n"
-    "    vec4 gl_Position;\n"
-    "};\n"
-    "void main() {\n"
-    "      vertices[0] = vec2(-1.0, -1.0);\n"
-    "      vertices[1] = vec2( 1.0, -1.0);\n"
-    "      vertices[2] = vec2( 0.0,  1.0);\n"
-    "   gl_Position = vec4(vertices[gl_VertexIndex % 3], 0.0, 1.0);\n"
-    "}\n";
-
-static const char bindStateFragShaderText[] =
-    "#version 450\n"
-    "\n"
-    "layout(location = 0) out vec4 uFragColor;\n"
-    "void main(){\n"
-    "   uFragColor = vec4(0,1,0,1);\n"
-    "}\n";
-
-static VKAPI_ATTR VkBool32 VKAPI_CALL
-myDbgFunc(VkFlags msgFlags, VkDebugReportObjectTypeEXT objType,
-          uint64_t srcObject, size_t location, int32_t msgCode,
-          const char *pLayerPrefix, const char *pMsg, void *pUserData);
-
+static const char bindStateVertShaderText[] = "#version 450\n"
+                                              "vec2 vertices[3];\n"
+                                              "out gl_PerVertex {\n"
+                                              "    vec4 gl_Position;\n"
+                                              "};\n"
+                                              "void main() {\n"
+                                              "      vertices[0] = vec2(-1.0, 
-1.0);\n"
+                                              "      vertices[1] = vec2( 1.0, 
-1.0);\n"
+                                              "      vertices[2] = vec2( 0.0,  
1.0);\n"
+                                              "   gl_Position = 
vec4(vertices[gl_VertexIndex % 3], 0.0, 1.0);\n"
+                                              "}\n";
+
+static const char bindStateFragShaderText[] = "#version 450\n"
+                                              "\n"
+                                              "layout(location = 0) out vec4 
uFragColor;\n"
+                                              "void main(){\n"
+                                              "   uFragColor = 
vec4(0,1,0,1);\n"
+                                              "}\n";
+
+static VKAPI_ATTR VkBool32 VKAPI_CALL myDbgFunc(VkFlags msgFlags, 
VkDebugReportObjectTypeEXT objType, uint64_t srcObject,
+                                                size_t location, int32_t 
msgCode, const char *pLayerPrefix, const char *pMsg,
+                                                void *pUserData);
 
 // ********************************************************
 // ErrorMonitor Usage:
@@ -217,10 +213,9 @@ class ErrorMonitor {
     VkBool32 m_msgFound;
 };
 
-static VKAPI_ATTR VkBool32 VKAPI_CALL
-myDbgFunc(VkFlags msgFlags, VkDebugReportObjectTypeEXT objType,
-          uint64_t srcObject, size_t location, int32_t msgCode,
-          const char *pLayerPrefix, const char *pMsg, void *pUserData) {
+static VKAPI_ATTR VkBool32 VKAPI_CALL myDbgFunc(VkFlags msgFlags, 
VkDebugReportObjectTypeEXT objType, uint64_t srcObject,
+                                                size_t location, int32_t 
msgCode, const char *pLayerPrefix, const char *pMsg,
+                                                void *pUserData) {
     ErrorMonitor *errMonitor = (ErrorMonitor *)pUserData;
     if (msgFlags & errMonitor->GetMessageFlags()) {
         return errMonitor->CheckForDesiredMsg(pMsg);
@@ -232,42 +227,26 @@ class VkLayerTest : public VkRenderFramework {
   public:
     VkResult BeginCommandBuffer(VkCommandBufferObj &commandBuffer);
     VkResult EndCommandBuffer(VkCommandBufferObj &commandBuffer);
-    void VKTriangleTest(const char *vertShaderText, const char *fragShaderText,
-                        BsoFailSelect failMask);
-    void GenericDrawPreparation(VkCommandBufferObj *commandBuffer,
-                                VkPipelineObj &pipelineobj,
-                                VkDescriptorSetObj &descriptorSet,
+    void VKTriangleTest(const char *vertShaderText, const char 
*fragShaderText, BsoFailSelect failMask);
+    void GenericDrawPreparation(VkCommandBufferObj *commandBuffer, 
VkPipelineObj &pipelineobj, VkDescriptorSetObj &descriptorSet,
                                 BsoFailSelect failMask);
-    void GenericDrawPreparation(VkPipelineObj &pipelineobj,
-                                VkDescriptorSetObj &descriptorSet,
-                                BsoFailSelect failMask) {
-        GenericDrawPreparation(m_commandBuffer, pipelineobj, descriptorSet,
-                               failMask);
+    void GenericDrawPreparation(VkPipelineObj &pipelineobj, VkDescriptorSetObj 
&descriptorSet, BsoFailSelect failMask) {
+        GenericDrawPreparation(m_commandBuffer, pipelineobj, descriptorSet, 
failMask);
     }
 
     /* Convenience functions that use built-in command buffer */
-    VkResult BeginCommandBuffer() {
-        return BeginCommandBuffer(*m_commandBuffer);
-    }
+    VkResult BeginCommandBuffer() { return 
BeginCommandBuffer(*m_commandBuffer); }
     VkResult EndCommandBuffer() { return EndCommandBuffer(*m_commandBuffer); }
-    void Draw(uint32_t vertexCount, uint32_t instanceCount,
-              uint32_t firstVertex, uint32_t firstInstance) {
-        m_commandBuffer->Draw(vertexCount, instanceCount, firstVertex,
-                              firstInstance);
+    void Draw(uint32_t vertexCount, uint32_t instanceCount, uint32_t 
firstVertex, uint32_t firstInstance) {
+        m_commandBuffer->Draw(vertexCount, instanceCount, firstVertex, 
firstInstance);
     }
-    void DrawIndexed(uint32_t indexCount, uint32_t instanceCount,
-                     uint32_t firstIndex, int32_t vertexOffset,
+    void DrawIndexed(uint32_t indexCount, uint32_t instanceCount, uint32_t 
firstIndex, int32_t vertexOffset,
                      uint32_t firstInstance) {
-        m_commandBuffer->DrawIndexed(indexCount, instanceCount, firstIndex,
-                                     vertexOffset, firstInstance);
+        m_commandBuffer->DrawIndexed(indexCount, instanceCount, firstIndex, 
vertexOffset, firstInstance);
     }
-    void QueueCommandBuffer(bool checkSuccess = true) {
-        m_commandBuffer->QueueCommandBuffer(checkSuccess); }
-    void QueueCommandBuffer(const VkFence &fence) {
-        m_commandBuffer->QueueCommandBuffer(fence);
-    }
-    void BindVertexBuffer(VkConstantBufferObj *vertexBuffer,
-                          VkDeviceSize offset, uint32_t binding) {
+    void QueueCommandBuffer(bool checkSuccess = true) { 
m_commandBuffer->QueueCommandBuffer(checkSuccess); }
+    void QueueCommandBuffer(const VkFence &fence) { 
m_commandBuffer->QueueCommandBuffer(fence); }
+    void BindVertexBuffer(VkConstantBufferObj *vertexBuffer, VkDeviceSize 
offset, uint32_t binding) {
         m_commandBuffer->BindVertexBuffer(vertexBuffer, offset, binding);
     }
     void BindIndexBuffer(VkIndexBufferObj *indexBuffer, VkDeviceSize offset) {
@@ -332,8 +311,7 @@ class VkLayerTest : public VkRenderFramework {
         this->app_info.apiVersion = VK_API_VERSION_1_0;
 
         m_errorMonitor = new ErrorMonitor;
-        InitFramework(instance_layer_names, instance_extension_names,

Reply via email to