Merge commit 'fb1fd1d63eb20cc6f922228f04d8b96cec452b46' into merge-vulkan-1.1.114

Change-Id: I00628e99ea2ea7186af6d0f0657ce7282e2a63f8

9 files changed, 465 insertions, 62 deletions

diff --git a/.appveyor.yml b/.appveyor.yml
index 0b82eff0..c7976b37 100644
--- a/.appveyor.yml
+++ b/.appveyor.yml
@@ -17,15 +17,22 @@ os:
 environment:
   PYTHON_PATH: "C:/Python35"
   PYTHON_PACKAGE_PATH: "C:/Python35/Scripts"
+  CMAKE_URL: "http://cmake.org/files/v3.10/cmake-3.10.2-win64-x64.zip"
 
 branches:
   only:
     - master
 
+# Install desired CMake version 3.10.2 before any other building
+install:
+  - appveyor DownloadFile %CMAKE_URL% -FileName cmake.zip
+  - 7z x cmake.zip -oC:\cmake > nul
+  - set path=C:\cmake\bin;%path%
+  - cmake --version
+
 before_build:
   - "SET PATH=C:\\Python35;C:\\Python35\\Scripts;%PATH%"
   - echo Starting build for %APPVEYOR_REPO_NAME% in %APPVEYOR_BUILD_FOLDER%
-  - cmake --version
   # Generate build files using CMake for the build step.
   - echo Generating Vulkan-Tools CMake files for %PLATFORM% %CONFIGURATION%
   - cd %APPVEYOR_BUILD_FOLDER%
diff --git a/.travis.yml b/.travis.yml
index 6e09f66b..60c57865 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -45,6 +45,17 @@ cache: ccache
 
 before_install:
   - set -e
+  - CMAKE_VERSION=3.10.2
+  - |
+    if [[ "${TRAVIS_OS_NAME}" == "linux" ]]; then
+      CMAKE_URL="https://cmake.org/files/v${CMAKE_VERSION%.*}/cmake-${CMAKE_VERSION}-Linux-x86_64.tar.gz"
+      echo CMAKE_URL=${CMAKE_URL}
+      mkdir cmake-${CMAKE_VERSION} && travis_retry wget --no-check-certificate -O - ${CMAKE_URL} | tar --strip-components=1 -xz -C cmake-${CMAKE_VERSION}
+      export PATH=${PWD}/cmake-${CMAKE_VERSION}/bin:${PATH}
+    else
+      brew install cmake || brew upgrade cmake
+    fi
+    cmake --version
   - |
     if [[ "$VULKAN_BUILD_TARGET" == "LINUX" ]] || [[ "$VULKAN_BUILD_TARGET" == "GN" ]]; then
       # Install the appropriate Linux packages.
@@ -73,7 +84,6 @@ before_install:
 
 script:
   - set -e
-  - cmake --version
   - |
     if [[ "$VULKAN_BUILD_TARGET" == "LINUX" ]]; then
       # Build Vulkan-Tools
@@ -134,7 +144,6 @@ script:
 notifications:
   email:
     recipients:
-      - karl@lunarg.com
       - cnorthrop@google.com
       - tobine@google.com
       - chrisforbes@google.com
diff --git a/BUILD.md b/BUILD.md
index 9b6aaba9..7bc0253e 100644
--- a/BUILD.md
+++ b/BUILD.md
@@ -112,22 +112,41 @@ directories and place them in any location.
 
 ### Building Dependent Repositories with Known-Good Revisions
 
-There is a Python utility script, `scripts/update_deps.py`, that you can use
-to gather and build the dependent repositories mentioned above. This program
-also uses information stored in the `scripts/known-good.json` file to checkout
-dependent repository revisions that are known to be compatible with the
-revision of this repository that you currently have checked out.
+There is a Python utility script, `scripts/update_deps.py`, that you can use to
+gather and build the dependent repositories mentioned above. This script uses
+information stored in the `scripts/known_good.json` file to check out dependent
+repository revisions that are known to be compatible with the revision of this
+repository that you currently have checked out. As such, this script is useful
+as a quick-start tool for common use cases and default configurations.
 
-Here is a usage example for this repository:
+For all platforms, start with:
 
     git clone git@github.com:KhronosGroup/Vulkan-Tools.git
     cd Vulkan-Tools
     mkdir build
     cd build
+
+For 64-bit Linux and MacOS, continue with:
+
     ../scripts/update_deps.py
     cmake -C helper.cmake ..
     cmake --build .
 
+For 64-bit Windows, continue with:
+
+    ..\scripts\update_deps.py --arch x64
+    cmake -A x64 -C helper.cmake ..
+    cmake --build .
+
+For 32-bit Windows, continue with:
+
+    ..\scripts\update_deps.py --arch Win32
+    cmake -A Win32 -C helper.cmake ..
+    cmake --build .
+
+Please see the more detailed build information later in this file if you have
+specific requirements for configuring and building these components.
+
 #### Notes
 
 - You may need to adjust some of the CMake options based on your platform. See
@@ -197,7 +216,7 @@ generate the native platform files.
     - [2017](https://www.visualstudio.com/vs/downloads/)
   - The Community Edition of each of the above versions is sufficient, as
     well as any more capable edition.
-- CMake: Continuous integration tools use [CMake 3.12.2](https://github.com/Kitware/CMake/releases/tag/v3.12.2) for Windows
+- [CMake 3.10.2](https://cmake.org/files/v3.10/cmake-3.10.2-win64-x64.zip) is recommended.
   - Use the installer option to add CMake to the system PATH
 - Git Client Support
   - [Git for Windows](http://git-scm.com/download/win) is a popular solution
@@ -344,7 +363,7 @@ that the minimum supported compiler versions are GCC 4.8.2 and Clang 3.4,
 although earlier versions may work. It should be straightforward to adapt this
 repository to other Linux distributions.
 
-The continuous integration tools use [CMake 3.12.4](https://github.com/Kitware/CMake/releases/tag/v3.12.4) for Linux
+[CMake 3.10.2](https://cmake.org/files/v3.10/cmake-3.10.2-Linux-x86_64.tar.gz) is recommended.
 
 #### Required Package List
 
@@ -592,7 +611,7 @@ Setup Homebrew and components
 
 - Add packages with the following:
 
-      brew install cmake python
+      brew install python
 
 ### Android Build
 
@@ -688,7 +707,7 @@ first build layers using steps above, then run:
 
 Tested on OSX version 10.12.6
 
-The continuous integration tools use [CMake 3.11.3](https://github.com/Kitware/CMake/releases/tag/v3.11.3) for MacOS
+- [CMake 3.10.2](https://cmake.org/files/v3.10/cmake-3.10.2-Darwin-x86_64.tar.gz) is recommended.
 
 Setup Homebrew and components
 
@@ -703,7 +722,7 @@ Setup Homebrew and components
 
 - Add packages with the following (may need refinement)
 
-      brew install cmake python python3 git
+      brew install python python3 git
 
 ### Clone the Repository
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index c163b180..e6ba640b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -18,7 +18,7 @@
 # CMake project initialization ---------------------------------------------------------------------------------------------------
 # This section contains pre-project() initialization, and ends with the project() command.
 
-cmake_minimum_required(VERSION 3.4)
+cmake_minimum_required(VERSION 3.10.2)
 
 # Apple: Must be set before enable_language() or project() as it may influence configuration of the toolchain and flags.
 set(CMAKE_OSX_DEPLOYMENT_TARGET "10.12" CACHE STRING "Minimum OS X deployment version")
diff --git a/build-android/vulkan-headers_revision_android b/build-android/vulkan-headers_revision_android
index 54f9e778..09d7f29e 100644
--- a/build-android/vulkan-headers_revision_android
+++ b/build-android/vulkan-headers_revision_android
@@ -1 +1 @@
-v1.1.108
+v1.1.114
diff --git a/cube/cube.c b/cube/cube.c
index ff4d5a6f..18344e46 100644
--- a/cube/cube.c
+++ b/cube/cube.c
@@ -1,7 +1,7 @@
 /*
- * Copyright (c) 2015-2016 The Khronos Group Inc.
- * Copyright (c) 2015-2016 Valve Corporation
- * Copyright (c) 2015-2016 LunarG, Inc.
+ * Copyright (c) 2015-2019 The Khronos Group Inc.
+ * Copyright (c) 2015-2019 Valve Corporation
+ * Copyright (c) 2015-2019 LunarG, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -90,9 +90,9 @@ bool in_callback = false;
 void DbgMsg(char *fmt, ...) {
     va_list va;
     va_start(va, fmt);
-    printf(fmt, va);
-    fflush(stdout);
+    vprintf(fmt, va);
     va_end(va);
+    fflush(stdout);
 }
 
 #elif defined __ANDROID__
@@ -125,9 +125,9 @@ void DbgMsg(const char *fmt, ...) {
 void DbgMsg(char *fmt, ...) {
     va_list va;
     va_start(va, fmt);
-    printf(fmt, va);
-    fflush(stdout);
+    vprintf(fmt, va);
     va_end(va);
+    fflush(stdout);
 }
 #endif
 
@@ -1892,6 +1892,32 @@ static void demo_prepare_render_pass(struct demo *demo) {
         .preserveAttachmentCount = 0,
         .pPreserveAttachments = NULL,
     };
+
+    VkSubpassDependency attachmentDependencies[2] = {
+        [0] =
+            {
+                // Depth buffer is shared between swapchain images
+                .srcSubpass = VK_SUBPASS_EXTERNAL,
+                .dstSubpass = 0,
+                .srcStageMask = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
+                .dstStageMask = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
+                .srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
+                .dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
+                .dependencyFlags = 0,
+            },
+        [1] =
+            {
+                // Image Layout Transition
+                .srcSubpass = VK_SUBPASS_EXTERNAL,
+                .dstSubpass = 0,
+                .srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+                .dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+                .srcAccessMask = 0,
+                .dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT,
+                .dependencyFlags = 0,
+            },
+    };
+
     const VkRenderPassCreateInfo rp_info = {
         .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
         .pNext = NULL,
@@ -1900,8 +1926,8 @@ static void demo_prepare_render_pass(struct demo *demo) {
         .pAttachments = attachments,
         .subpassCount = 1,
         .pSubpasses = &subpass,
-        .dependencyCount = 0,
-        .pDependencies = NULL,
+        .dependencyCount = 2,
+        .pDependencies = attachmentDependencies,
     };
     VkResult U_ASSERT_ONLY err;
 
@@ -3711,17 +3737,31 @@ static void demo_init(struct demo *demo, int argc, char **argv) {
 #if defined(ANDROID)
         ERR_EXIT("Usage: vkcube [--validate]\n", "Usage");
 #else
-        fprintf(stderr,
-                "Usage:\n  %s\t[--use_staging] [--validate] [--validate-checks-disabled] [--break]\n"
-                "\t[--c <framecount>] [--suppress_popups] [--incremental_present] [--display_timing]\n"
-                "\t[--present_mode <present mode enum>]\n"
-                "\t <present_mode_enum>\tVK_PRESENT_MODE_IMMEDIATE_KHR = %d\n"
-                "\t\t\t\tVK_PRESENT_MODE_MAILBOX_KHR = %d\n"
-                "\t\t\t\tVK_PRESENT_MODE_FIFO_KHR = %d\n"
-                "\t\t\t\tVK_PRESENT_MODE_FIFO_RELAXED_KHR = %d\n",
-                APP_SHORT_NAME, VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_FIFO_KHR,
-                VK_PRESENT_MODE_FIFO_RELAXED_KHR);
+        char *message =
+            "Usage:\n  %s\t[--use_staging] [--validate] [--validate-checks-disabled]\n"
+            "\t[--break] [--c <framecount>] [--suppress_popups]\n"
+            "\t[--incremental_present] [--display_timing]\n"
+            "\t[--present_mode <present mode enum>]\n"
+            "\t<present_mode_enum>\n"
+            "\t\tVK_PRESENT_MODE_IMMEDIATE_KHR = %d\n"
+            "\t\tVK_PRESENT_MODE_MAILBOX_KHR = %d\n"
+            "\t\tVK_PRESENT_MODE_FIFO_KHR = %d\n"
+            "\t\tVK_PRESENT_MODE_FIFO_RELAXED_KHR = %d\n";
+        int length = snprintf(NULL, 0, message, APP_SHORT_NAME, VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_MAILBOX_KHR,
+                              VK_PRESENT_MODE_FIFO_KHR, VK_PRESENT_MODE_FIFO_RELAXED_KHR);
+        char *usage = (char *)malloc(length + 1);
+        if (!usage) {
+            exit(1);
+        }
+        snprintf(usage, length + 1, message, APP_SHORT_NAME, VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_MAILBOX_KHR,
+                 VK_PRESENT_MODE_FIFO_KHR, VK_PRESENT_MODE_FIFO_RELAXED_KHR);
+#if defined(_WIN32)
+        if (!demo->suppress_popups) MessageBox(NULL, usage, "Usage Error", MB_OK);
+#else
+        fprintf(stderr, "%s", usage);
         fflush(stderr);
+#endif
+        free(usage);
         exit(1);
 #endif
     }
diff --git a/cube/cube.cpp b/cube/cube.cpp
index 965f6faf..04447fcd 100644
--- a/cube/cube.cpp
+++ b/cube/cube.cpp
@@ -1,7 +1,7 @@
 /*
- * Copyright (c) 2015-2016 The Khronos Group Inc.
- * Copyright (c) 2015-2016 Valve Corporation
- * Copyright (c) 2015-2016 LunarG, Inc.
+ * Copyright (c) 2015-2019 The Khronos Group Inc.
+ * Copyright (c) 2015-2019 Valve Corporation
+ * Copyright (c) 2015-2019 LunarG, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -30,6 +30,8 @@
 #include <cstdlib>
 #include <cstring>
 #include <csignal>
+#include <iostream>
+#include <sstream>
 #include <memory>
 
 #define VULKAN_HPP_NO_SMART_HANDLE
@@ -930,18 +932,22 @@ void Demo::init(int argc, char **argv) {
             continue;
         }
 
-        fprintf(stderr,
-                "Usage:\n  %s [--use_staging] [--validate] [--break] [--c <framecount>] \n"
-                "       [--suppress_popups] [--present_mode {0,1,2,3}]\n"
-                "\n"
-                "Options for --present_mode:\n"
-                "  %d: VK_PRESENT_MODE_IMMEDIATE_KHR\n"
-                "  %d: VK_PRESENT_MODE_MAILBOX_KHR\n"
-                "  %d: VK_PRESENT_MODE_FIFO_KHR (default)\n"
-                "  %d: VK_PRESENT_MODE_FIFO_RELAXED_KHR\n",
-                APP_SHORT_NAME, VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_FIFO_KHR,
-                VK_PRESENT_MODE_FIFO_RELAXED_KHR);
-        fflush(stderr);
+        std::stringstream usage;
+        usage << "Usage:\n  " << APP_SHORT_NAME << "\t[--use_staging] [--validate]\n"
+              << "\t[--break] [--c <framecount>] [--suppress_popups]\n"
+              << "\t[--present_mode <present mode enum>]\n"
+              << "\t<present_mode_enum>\n"
+              << "\t\tVK_PRESENT_MODE_IMMEDIATE_KHR = " << VK_PRESENT_MODE_IMMEDIATE_KHR << "\n"
+              << "\t\tVK_PRESENT_MODE_MAILBOX_KHR = " << VK_PRESENT_MODE_MAILBOX_KHR << "\n"
+              << "\t\tVK_PRESENT_MODE_FIFO_KHR = " << VK_PRESENT_MODE_FIFO_KHR << "\n"
+              << "\t\tVK_PRESENT_MODE_FIFO_RELAXED_KHR = " << VK_PRESENT_MODE_FIFO_RELAXED_KHR;
+
+#if defined(_WIN32)
+        if (!suppress_popups) MessageBox(NULL, usage.str().c_str(), "Usage Error", MB_OK);
+#else
+        std::cerr << usage.str();
+        std::cerr.flush();
+#endif
         exit(1);
     }
 
@@ -1969,13 +1975,33 @@ void Demo::prepare_render_pass() {
                              .setPreserveAttachmentCount(0)
                              .setPPreserveAttachments(nullptr);
 
+    vk::PipelineStageFlags stages = vk::PipelineStageFlagBits::eEarlyFragmentTests | vk::PipelineStageFlagBits::eLateFragmentTests;
+    vk::SubpassDependency const dependencies[2] = {
+        vk::SubpassDependency()  // Depth buffer is shared between swapchain images
+            .setSrcSubpass(VK_SUBPASS_EXTERNAL)
+            .setDstSubpass(0)
+            .setSrcStageMask(stages)
+            .setDstStageMask(stages)
+            .setSrcAccessMask(vk::AccessFlagBits::eDepthStencilAttachmentWrite)
+            .setDstAccessMask(vk::AccessFlagBits::eDepthStencilAttachmentRead | vk::AccessFlagBits::eDepthStencilAttachmentWrite)
+            .setDependencyFlags(vk::DependencyFlags()),
+        vk::SubpassDependency()  // Image layout transition
+            .setSrcSubpass(VK_SUBPASS_EXTERNAL)
+            .setDstSubpass(0)
+            .setSrcStageMask(vk::PipelineStageFlagBits::eColorAttachmentOutput)
+            .setDstStageMask(vk::PipelineStageFlagBits::eColorAttachmentOutput)
+            .setSrcAccessMask(vk::AccessFlagBits())
+            .setDstAccessMask(vk::AccessFlagBits::eColorAttachmentWrite | vk::AccessFlagBits::eColorAttachmentRead)
+            .setDependencyFlags(vk::DependencyFlags()),
+    };
+
     auto const rp_info = vk::RenderPassCreateInfo()
                              .setAttachmentCount(2)
                              .setPAttachments(attachments)
                              .setSubpassCount(1)
                              .setPSubpasses(&subpass)
-                             .setDependencyCount(0)
-                             .setPDependencies(nullptr);
+                             .setDependencyCount(2)
+                             .setPDependencies(dependencies);
 
     auto result = device.createRenderPass(&rp_info, nullptr, &render_pass);
     VERIFY(result == vk::Result::eSuccess);
@@ -3008,7 +3034,6 @@ int main(int argc, char **argv) {
 
 // Global function invoked from NS or UI views and controllers to create demo
 static void demo_main(struct Demo &demo, void *view, int argc, const char *argv[]) {
-
     demo.init(argc, (char **)argv);
     demo.window = view;
     demo.init_vk_swapchain();
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 705c06e4..46a6c3ea 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -6,7 +6,7 @@
       "sub_dir" : "glslang",
       "build_dir" : "glslang/build",
       "install_dir" : "glslang/build/install",
-      "commit" : "e06c7e9a515b716c731bda13f507546f107775d1",
+      "commit" : "21eebe74214488264bbf0d19323a03c13a9e53a7",
       "prebuild" : [
         "python update_glslang_sources.py"
       ]
@@ -17,7 +17,7 @@
       "sub_dir" : "Vulkan-Headers",
       "build_dir" : "Vulkan-Headers/build",
       "install_dir" : "Vulkan-Headers/build/install",
-      "commit" : "v1.1.108"
+      "commit" : "v1.1.114"
     },
     {
       "name" : "MoltenVK",
@@ -25,10 +25,10 @@
       "sub_dir" : "MoltenVK",
       "build_dir" : "MoltenVK",
       "install_dir" : "MoltenVK",
-      "commit" : "v1.0.34",
+      "commit" : "v1.0.35",
       "custom_build" : [
         "./fetchDependencies --v-headers-root {0[Vulkan-Headers][repo_dir]} --glslang-root {0[glslang][repo_dir]}",
-        "xcodebuild -project MoltenVKPackaging.xcodeproj GCC_PREPROCESSOR_DEFINITIONS='$GCC_PREPROCESSOR_DEFINITIONS MVK_LOGGING_ENABLED=0' -scheme \"MoltenVK Package\" build"
+        "xcodebuild -project MoltenVKPackaging.xcodeproj GCC_PREPROCESSOR_DEFINITIONS='$GCC_PREPROCESSOR_DEFINITIONS MVK_CONFIG_LOG_LEVEL=1' -scheme \"MoltenVK Package\" build"
       ],
       "build_step" : "custom",
       "build_platforms" : [
@@ -41,7 +41,7 @@
       "sub_dir" : "Vulkan-Loader",
       "build_dir" : "Vulkan-Loader/build",
       "install_dir" : "Vulkan-Loader/build/install",
-      "commit" : "v1.1.108",
+      "commit" : "v1.1.114",
       "deps" : [
         {
           "var_name" : "VULKAN_HEADERS_INSTALL_DIR",
diff --git a/vulkaninfo/vulkaninfo.c b/vulkaninfo/vulkaninfo.c
index 8570ed8e..bb099194 100644
--- a/vulkaninfo/vulkaninfo.c
+++ b/vulkaninfo/vulkaninfo.c
@@ -58,7 +58,6 @@
 
 #ifdef _WIN32
 
-#define snprintf _snprintf
 #define strdup _strdup
 
 // Returns nonzero if the console is used only for this process. Will return
@@ -918,6 +917,9 @@ static void AppCreateInstance(struct AppInstance *inst) {
     VkResult err = vkCreateInstance(&inst_info, NULL, &inst->instance);
     if (err == VK_ERROR_INCOMPATIBLE_DRIVER) {
         fprintf(stderr, "Cannot create Vulkan instance.\n");
+        fprintf(stderr,
+                "This problem is often caused by a faulty installation of the Vulkan driver or attempting to use a GPU that does "
+                "not support Vulkan.\n");
         ERR_EXIT(err);
     } else if (err) {
         ERR_EXIT(err);
@@ -975,6 +977,8 @@ static void AppGpuInit(struct AppGpu *gpu, struct AppInstance *inst, uint32_t id
              .mem_size = sizeof(VkPhysicalDeviceTransformFeedbackPropertiesEXT)},
             {.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT,
              .mem_size = sizeof(VkPhysicalDeviceFragmentDensityMapPropertiesEXT)},
+            {.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT,
+             .mem_size = sizeof(VkPhysicalDeviceDescriptorIndexingPropertiesEXT)},
             {.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR,
              .mem_size = sizeof(VkPhysicalDeviceDepthStencilResolvePropertiesKHR)}};
 
@@ -1095,6 +1099,8 @@ static void AppGpuInit(struct AppGpu *gpu, struct AppInstance *inst, uint32_t id
              .mem_size = sizeof(VkPhysicalDeviceMemoryPriorityFeaturesEXT)},
             {.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT,
              .mem_size = sizeof(VkPhysicalDeviceBufferAddressFeaturesEXT)},
+            {.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT,
+             .mem_size = sizeof(VkPhysicalDeviceDescriptorIndexingFeaturesEXT)},
             {.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT,
              .mem_size = sizeof(VkPhysicalDeviceYcbcrImageArraysFeaturesEXT)},
             {.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT,
@@ -3252,6 +3258,137 @@ static void AppGpuDumpFeatures(const struct AppGpu *gpu, FILE *out) {
                     printf("=======================================\n");
                     printf("\thostQueryReset = %" PRIuLEAST32 "\n", host_query_reset_features->hostQueryReset);
                 }
+            } else if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT &&
+                       CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME, gpu->device_extensions,
+                                                            gpu->device_extension_count)) {
+                VkPhysicalDeviceDescriptorIndexingFeaturesEXT *indexing_features =
+                    (VkPhysicalDeviceDescriptorIndexingFeaturesEXT *)structure;
+                if (html_output) {
+                    fprintf(out, "\t\t\t\t\t<details><summary>VkPhysicalDeviceDescriptorIndexingFeatures</summary>\n");
+                    fprintf(out,
+                            "\t\t\t\t\t\t<details><summary>shaderInputAttachmentArrayDynamicIndexing    = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_features->shaderInputAttachmentArrayDynamicIndexing);
+                    fprintf(out,
+                            "\t\t\t\t\t\t<details><summary>shaderUniformTexelBufferArrayDynamicIndexing    = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_features->shaderUniformTexelBufferArrayDynamicIndexing);
+                    fprintf(out,
+                            "\t\t\t\t\t\t<details><summary>shaderStorageTexelBufferArrayDynamicIndexing    = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_features->shaderStorageTexelBufferArrayDynamicIndexing);
+                    fprintf(out,
+                            "\t\t\t\t\t\t<details><summary>shaderUniformBufferArrayNonUniformIndexing    = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_features->shaderUniformBufferArrayNonUniformIndexing);
+                    fprintf(out,
+                            "\t\t\t\t\t\t<details><summary>shaderSampledImageArrayNonUniformIndexing    = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_features->shaderSampledImageArrayNonUniformIndexing);
+                    fprintf(out,
+                            "\t\t\t\t\t\t<details><summary>shaderStorageBufferArrayNonUniformIndexing    = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_features->shaderStorageBufferArrayNonUniformIndexing);
+                    fprintf(out,
+                            "\t\t\t\t\t\t<details><summary>shaderStorageImageArrayNonUniformIndexing    = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_features->shaderStorageImageArrayNonUniformIndexing);
+                    fprintf(out,
+                            "\t\t\t\t\t\t<details><summary>shaderInputAttachmentArrayNonUniformIndexing    = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_features->shaderInputAttachmentArrayNonUniformIndexing);
+                    fprintf(out,
+                            "\t\t\t\t\t\t<details><summary>shaderUniformTexelBufferArrayNonUniformIndexing    = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_features->shaderUniformTexelBufferArrayNonUniformIndexing);
+                    fprintf(out,
+                            "\t\t\t\t\t\t<details><summary>shaderStorageTexelBufferArrayNonUniformIndexing    = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_features->shaderStorageTexelBufferArrayNonUniformIndexing);
+                    fprintf(out,
+                            "\t\t\t\t\t\t<details><summary>descriptorBindingUniformBufferUpdateAfterBind    = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_features->descriptorBindingUniformBufferUpdateAfterBind);
+                    fprintf(out,
+                            "\t\t\t\t\t\t<details><summary>descriptorBindingSampledImageUpdateAfterBind    = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_features->descriptorBindingSampledImageUpdateAfterBind);
+                    fprintf(out,
+                            "\t\t\t\t\t\t<details><summary>descriptorBindingStorageImageUpdateAfterBind    = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_features->descriptorBindingStorageImageUpdateAfterBind);
+                    fprintf(out,
+                            "\t\t\t\t\t\t<details><summary>descriptorBindingStorageBufferUpdateAfterBind    = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_features->descriptorBindingStorageBufferUpdateAfterBind);
+                    fprintf(out,
+                            "\t\t\t\t\t\t<details><summary>descriptorBindingUniformTexelBufferUpdateAfterBind    = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_features->descriptorBindingUniformTexelBufferUpdateAfterBind);
+                    fprintf(out,
+                            "\t\t\t\t\t\t<details><summary>descriptorBindingStorageTexelBufferUpdateAfterBind    = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_features->descriptorBindingStorageTexelBufferUpdateAfterBind);
+                    fprintf(out,
+                            "\t\t\t\t\t\t<details><summary>descriptorBindingUpdateUnusedWhilePending    = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_features->descriptorBindingUpdateUnusedWhilePending);
+                    fprintf(out,
+                            "\t\t\t\t\t\t<details><summary>descriptorBindingPartiallyBound    = <span class='val'>%" PRIuLEAST32
+                            "</span></summary></details>\n",
+                            indexing_features->descriptorBindingPartiallyBound);
+                    fprintf(out,
+                            "\t\t\t\t\t\t<details><summary>descriptorBindingVariableDescriptorCount    = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_features->descriptorBindingVariableDescriptorCount);
+                    fprintf(out,
+                            "\t\t\t\t\t\t<details><summary>runtimeDescriptorArray    = <span class='val'>%" PRIuLEAST32
+                            "</span></summary></details>\n",
+                            indexing_features->runtimeDescriptorArray);
+                    fprintf(out, "\t\t\t\t\t</details>\n");
+                } else if (human_readable_output) {
+                    printf("\nVkPhysicalDeviceDescriptorIndexingFeatures:\n");
+                    printf("=======================================\n");
+                    printf("\tshaderInputAttachmentArrayDynamicIndexing = %" PRIuLEAST32 "\n",
+                           indexing_features->shaderInputAttachmentArrayDynamicIndexing);
+                    printf("\tshaderUniformTexelBufferArrayDynamicIndexing = %" PRIuLEAST32 "\n",
+                           indexing_features->shaderUniformTexelBufferArrayDynamicIndexing);
+                    printf("\tshaderStorageTexelBufferArrayDynamicIndexing = %" PRIuLEAST32 "\n",
+                           indexing_features->shaderStorageTexelBufferArrayDynamicIndexing);
+                    printf("\tshaderUniformBufferArrayNonUniformIndexing = %" PRIuLEAST32 "\n",
+                           indexing_features->shaderUniformBufferArrayNonUniformIndexing);
+                    printf("\tshaderSampledImageArrayNonUniformIndexing = %" PRIuLEAST32 "\n",
+                           indexing_features->shaderSampledImageArrayNonUniformIndexing);
+                    printf("\tshaderStorageBufferArrayNonUniformIndexing = %" PRIuLEAST32 "\n",
+                           indexing_features->shaderStorageBufferArrayNonUniformIndexing);
+                    printf("\tshaderStorageImageArrayNonUniformIndexing = %" PRIuLEAST32 "\n",
+                           indexing_features->shaderStorageImageArrayNonUniformIndexing);
+                    printf("\tshaderInputAttachmentArrayNonUniformIndexing = %" PRIuLEAST32 "\n",
+                           indexing_features->shaderInputAttachmentArrayNonUniformIndexing);
+                    printf("\tshaderUniformTexelBufferArrayNonUniformIndexing = %" PRIuLEAST32 "\n",
+                           indexing_features->shaderUniformTexelBufferArrayNonUniformIndexing);
+                    printf("\tshaderStorageTexelBufferArrayNonUniformIndexing = %" PRIuLEAST32 "\n",
+                           indexing_features->shaderStorageTexelBufferArrayNonUniformIndexing);
+                    printf("\tdescriptorBindingUniformBufferUpdateAfterBind = %" PRIuLEAST32 "\n",
+                           indexing_features->descriptorBindingUniformBufferUpdateAfterBind);
+                    printf("\tdescriptorBindingSampledImageUpdateAfterBind = %" PRIuLEAST32 "\n",
+                           indexing_features->descriptorBindingSampledImageUpdateAfterBind);
+                    printf("\tdescriptorBindingStorageImageUpdateAfterBind = %" PRIuLEAST32 "\n",
+                           indexing_features->descriptorBindingStorageImageUpdateAfterBind);
+                    printf("\tdescriptorBindingStorageBufferUpdateAfterBind = %" PRIuLEAST32 "\n",
+                           indexing_features->descriptorBindingStorageBufferUpdateAfterBind);
+                    printf("\tdescriptorBindingUniformTexelBufferUpdateAfterBind = %" PRIuLEAST32 "\n",
+                           indexing_features->descriptorBindingUniformTexelBufferUpdateAfterBind);
+                    printf("\tdescriptorBindingStorageTexelBufferUpdateAfterBind = %" PRIuLEAST32 "\n",
+                           indexing_features->descriptorBindingStorageTexelBufferUpdateAfterBind);
+                    printf("\tdescriptorBindingUpdateUnusedWhilePending = %" PRIuLEAST32 "\n",
+                           indexing_features->descriptorBindingUpdateUnusedWhilePending);
+                    printf("\tdescriptorBindingPartiallyBound = %" PRIuLEAST32 "\n",
+                           indexing_features->descriptorBindingPartiallyBound);
+                    printf("\tdescriptorBindingVariableDescriptorCount = %" PRIuLEAST32 "\n",
+                           indexing_features->descriptorBindingVariableDescriptorCount);
+                    printf("\truntimeDescriptorArray = %" PRIuLEAST32 "\n", indexing_features->runtimeDescriptorArray);
+                }
             }
             place = structure->pNext;
         }
@@ -3511,7 +3648,7 @@ static void AppDumpLimits(const VkPhysicalDeviceLimits *limits, FILE *out) {
                 "class='val'>%u</span></summary></details>\n",
                 limits->maxFragmentCombinedOutputResources);
         fprintf(out,
-                "\t\t\t\t\t\t<details><summary>maxComputeSharedMemorySize              = <span class='val'>0x%" PRIxLEAST32
+                "\t\t\t\t\t\t<details><summary>maxComputeSharedMemorySize              = <span class='val'>%" PRIuLEAST32
                 "</span></summary></details>\n",
                 limits->maxComputeSharedMemorySize);
         fprintf(out,
@@ -3820,7 +3957,7 @@ static void AppDumpLimits(const VkPhysicalDeviceLimits *limits, FILE *out) {
         printf("\t\tmaxFragmentOutputAttachments            = %u\n", limits->maxFragmentOutputAttachments);
         printf("\t\tmaxFragmentDualSrcAttachments           = %u\n", limits->maxFragmentDualSrcAttachments);
         printf("\t\tmaxFragmentCombinedOutputResources      = %u\n", limits->maxFragmentCombinedOutputResources);
-        printf("\t\tmaxComputeSharedMemorySize              = 0x%" PRIxLEAST32 "\n", limits->maxComputeSharedMemorySize);
+        printf("\t\tmaxComputeSharedMemorySize              = %" PRIuLEAST32 "\n", limits->maxComputeSharedMemorySize);
         printf("\t\tmaxComputeWorkGroupCount[0]             = %u\n", limits->maxComputeWorkGroupCount[0]);
         printf("\t\tmaxComputeWorkGroupCount[1]             = %u\n", limits->maxComputeWorkGroupCount[1]);
         printf("\t\tmaxComputeWorkGroupCount[2]             = %u\n", limits->maxComputeWorkGroupCount[2]);
@@ -4565,6 +4702,7 @@ static void AppGpuDumpProps(const struct AppGpu *gpu, FILE *out) {
                         "\t\t\t\t\t\t<details><summary>transformFeedbackDraw                      = <span class='val'>%" PRIuLEAST32
                         "</span></summary></details>\n",
                         transform_feedback_properties->transformFeedbackDraw);
+                    fprintf(out, "\t\t\t\t\t</details>\n");
                 } else if (human_readable_output) {
                     printf("\nVkPhysicalDeviceTransformFeedbackProperties\n");
                     printf("===========================================\n");
@@ -4618,6 +4756,7 @@ static void AppGpuDumpProps(const struct AppGpu *gpu, FILE *out) {
                             "\t\t\t\t\t\t<details><summary>fragmentDensityInvocations = <span class='val'>%" PRIuLEAST32
                             "</span></summary></details>\n",
                             fragment_density_map_properties->fragmentDensityInvocations);
+                    fprintf(out, "\t\t\t\t\t</details>\n");
                 } else if (human_readable_output) {
                     printf("\nVkPhysicalDeviceFragmentDensityMapProperties\n");
                     printf("============================================\n");
@@ -4691,6 +4830,7 @@ static void AppGpuDumpProps(const struct AppGpu *gpu, FILE *out) {
                             "\t\t\t\t\t\t<details><summary>independentResolve = <span class='val'>%" PRIuLEAST32
                             "</span></summary></details>\n",
                             depth_stencil_resolve_properties->independentResolve);
+                    fprintf(out, "\t\t\t\t\t</details>\n");
                 } else if (human_readable_output) {
                     printf("\nVkPhysicalDeviceDepthStencilResolveProperties\n");
                     printf("============================================\n");
@@ -4724,8 +4864,158 @@ static void AppGpuDumpProps(const struct AppGpu *gpu, FILE *out) {
                            depth_stencil_resolve_properties->independentResolveNone);
                     printf("\t\tindependentResolve     = %" PRIuLEAST32 "\n", depth_stencil_resolve_properties->independentResolve);
                 }
+            } else if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT &&
+                       CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME, gpu->device_extensions,
+                                                            gpu->device_extension_count)) {
+                VkPhysicalDeviceDescriptorIndexingPropertiesEXT *indexing_properties =
+                    (VkPhysicalDeviceDescriptorIndexingPropertiesEXT *)structure;
+                if (html_output) {
+                    fprintf(out, "\n\t\t\t\t\t<details><summary>VkPhysicalDeviceDescriptorIndexingProperties</summary>\n");
+                    fprintf(
+                        out,
+                        "\t\t\t\t\t\t\t<details><summary>maxUpdateAfterBindDescriptorsInAllPools = <span class='val'>%" PRIuLEAST32
+                        "</span></summary></details>\n",
+                        indexing_properties->maxUpdateAfterBindDescriptorsInAllPools);
+                    fprintf(out,
+                            "\t\t\t\t\t\t\t<details><summary>shaderUniformBufferArrayNonUniformIndexingNative = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_properties->shaderUniformBufferArrayNonUniformIndexingNative);
+                    fprintf(out,
+                            "\t\t\t\t\t\t\t<details><summary>shaderSampledImageArrayNonUniformIndexingNative = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_properties->shaderSampledImageArrayNonUniformIndexingNative);
+                    fprintf(out,
+                            "\t\t\t\t\t\t\t<details><summary>shaderStorageBufferArrayNonUniformIndexingNative = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_properties->shaderStorageBufferArrayNonUniformIndexingNative);
+                    fprintf(out,
+                            "\t\t\t\t\t\t\t<details><summary>shaderStorageImageArrayNonUniformIndexingNative = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_properties->shaderStorageImageArrayNonUniformIndexingNative);
+                    fprintf(out,
+                            "\t\t\t\t\t\t\t<details><summary>shaderInputAttachmentArrayNonUniformIndexingNative = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_properties->shaderInputAttachmentArrayNonUniformIndexingNative);
+                    fprintf(out,
+                            "\t\t\t\t\t\t\t<details><summary>robustBufferAccessUpdateAfterBind = <span class='val'>%" PRIuLEAST32
+                            "</span></summary></details>\n",
+                            indexing_properties->robustBufferAccessUpdateAfterBind);
+                    fprintf(out,
+                            "\t\t\t\t\t\t\t<details><summary>quadDivergentImplicitLod = <span class='val'>%" PRIuLEAST32
+                            "</span></summary></details>\n",
+                            indexing_properties->quadDivergentImplicitLod);
+                    fprintf(out,
+                            "\t\t\t\t\t\t\t<details><summary>maxPerStageDescriptorUpdateAfterBindSamplers = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_properties->maxPerStageDescriptorUpdateAfterBindSamplers);
+                    fprintf(out,
+                            "\t\t\t\t\t\t\t<details><summary>maxPerStageDescriptorUpdateAfterBindUniformBuffers = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_properties->maxPerStageDescriptorUpdateAfterBindUniformBuffers);
+                    fprintf(out,
+                            "\t\t\t\t\t\t\t<details><summary>maxPerStageDescriptorUpdateAfterBindStorageBuffers = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_properties->maxPerStageDescriptorUpdateAfterBindStorageBuffers);
+                    fprintf(out,
+                            "\t\t\t\t\t\t\t<details><summary>maxPerStageDescriptorUpdateAfterBindSampledImages = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_properties->maxPerStageDescriptorUpdateAfterBindSampledImages);
+                    fprintf(out,
+                            "\t\t\t\t\t\t\t<details><summary>maxPerStageDescriptorUpdateAfterBindStorageImages = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_properties->maxPerStageDescriptorUpdateAfterBindStorageImages);
+                    fprintf(out,
+                            "\t\t\t\t\t\t\t<details><summary>maxPerStageDescriptorUpdateAfterBindInputAttachments = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_properties->maxPerStageDescriptorUpdateAfterBindInputAttachments);
+                    fprintf(out,
+                            "\t\t\t\t\t\t\t<details><summary>maxPerStageUpdateAfterBindResources = <span class='val'>%" PRIuLEAST32
+                            "</span></summary></details>\n",
+                            indexing_properties->maxPerStageUpdateAfterBindResources);
+                    fprintf(
+                        out,
+                        "\t\t\t\t\t\t\t<details><summary>maxDescriptorSetUpdateAfterBindSamplers = <span class='val'>%" PRIuLEAST32
+                        "</span></summary></details>\n",
+                        indexing_properties->maxDescriptorSetUpdateAfterBindSamplers);
+                    fprintf(out,
+                            "\t\t\t\t\t\t\t<details><summary>maxDescriptorSetUpdateAfterBindUniformBuffers = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_properties->maxDescriptorSetUpdateAfterBindUniformBuffers);
+                    fprintf(out,
+                            "\t\t\t\t\t\t\t<details><summary>maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_properties->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
+                    fprintf(out,
+                            "\t\t\t\t\t\t\t<details><summary>maxDescriptorSetUpdateAfterBindStorageBuffers = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_properties->maxDescriptorSetUpdateAfterBindStorageBuffers);
+                    fprintf(out,
+                            "\t\t\t\t\t\t\t<details><summary>maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_properties->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
+                    fprintf(out,
+                            "\t\t\t\t\t\t\t<details><summary>maxDescriptorSetUpdateAfterBindSampledImages = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_properties->maxDescriptorSetUpdateAfterBindSampledImages);
+                    fprintf(out,
+                            "\t\t\t\t\t\t\t<details><summary>maxDescriptorSetUpdateAfterBindStorageImages = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_properties->maxDescriptorSetUpdateAfterBindStorageImages);
+                    fprintf(out,
+                            "\t\t\t\t\t\t\t<details><summary>maxDescriptorSetUpdateAfterBindInputAttachments = <span "
+                            "class='val'>%" PRIuLEAST32 "</span></summary></details>\n",
+                            indexing_properties->maxDescriptorSetUpdateAfterBindInputAttachments);
+                    fprintf(out, "\t\t\t\t\t</details>\n");
+                } else if (human_readable_output) {
+                    printf("\nVkPhysicalDeviceDescriptorIndexingProperties\n");
+                    printf("============================================\n");
+                    printf("\tmaxUpdateAfterBindDescriptorsInAllPools = %" PRIuLEAST32 "\n",
+                           indexing_properties->maxUpdateAfterBindDescriptorsInAllPools);
+                    printf("\tshaderUniformBufferArrayNonUniformIndexingNative = %" PRIuLEAST32 "\n",
+                           indexing_properties->shaderUniformBufferArrayNonUniformIndexingNative);
+                    printf("\tshaderSampledImageArrayNonUniformIndexingNative = %" PRIuLEAST32 "\n",
+                           indexing_properties->shaderSampledImageArrayNonUniformIndexingNative);
+                    printf("\tshaderStorageBufferArrayNonUniformIndexingNative = %" PRIuLEAST32 "\n",
+                           indexing_properties->shaderStorageBufferArrayNonUniformIndexingNative);
+                    printf("\tshaderStorageImageArrayNonUniformIndexingNative = %" PRIuLEAST32 "\n",
+                           indexing_properties->shaderStorageImageArrayNonUniformIndexingNative);
+                    printf("\tshaderInputAttachmentArrayNonUniformIndexingNative = %" PRIuLEAST32 "\n",
+                           indexing_properties->shaderInputAttachmentArrayNonUniformIndexingNative);
+                    printf("\trobustBufferAccessUpdateAfterBind = %" PRIuLEAST32 "\n",
+                           indexing_properties->robustBufferAccessUpdateAfterBind);
+                    printf("\tquadDivergentImplicitLod = %" PRIuLEAST32 "\n", indexing_properties->quadDivergentImplicitLod);
+                    printf("\tmaxPerStageDescriptorUpdateAfterBindSamplers = %" PRIuLEAST32 "\n",
+                           indexing_properties->maxPerStageDescriptorUpdateAfterBindSamplers);
+                    printf("\tmaxPerStageDescriptorUpdateAfterBindUniformBuffers = %" PRIuLEAST32 "\n",
+                           indexing_properties->maxPerStageDescriptorUpdateAfterBindUniformBuffers);
+                    printf("\tmaxPerStageDescriptorUpdateAfterBindStorageBuffers = %" PRIuLEAST32 "\n",
+                           indexing_properties->maxPerStageDescriptorUpdateAfterBindStorageBuffers);
+                    printf("\tmaxPerStageDescriptorUpdateAfterBindSampledImages = %" PRIuLEAST32 "\n",
+                           indexing_properties->maxPerStageDescriptorUpdateAfterBindSampledImages);
+                    printf("\tmaxPerStageDescriptorUpdateAfterBindStorageImages = %" PRIuLEAST32 "\n",
+                           indexing_properties->maxPerStageDescriptorUpdateAfterBindStorageImages);
+                    printf("\tmaxPerStageDescriptorUpdateAfterBindInputAttachments = %" PRIuLEAST32 "\n",
+                           indexing_properties->maxPerStageDescriptorUpdateAfterBindInputAttachments);
+                    printf("\tmaxPerStageUpdateAfterBindResources = %" PRIuLEAST32 "\n",
+                           indexing_properties->maxPerStageUpdateAfterBindResources);
+                    printf("\tmaxDescriptorSetUpdateAfterBindSamplers = %" PRIuLEAST32 "\n",
+                           indexing_properties->maxDescriptorSetUpdateAfterBindSamplers);
+                    printf("\tmaxDescriptorSetUpdateAfterBindUniformBuffers = %" PRIuLEAST32 "\n",
+                           indexing_properties->maxDescriptorSetUpdateAfterBindUniformBuffers);
+                    printf("\tmaxDescriptorSetUpdateAfterBindUniformBuffersDynamic = %" PRIuLEAST32 "\n",
+                           indexing_properties->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
+                    printf("\tmaxDescriptorSetUpdateAfterBindStorageBuffer = %" PRIuLEAST32 "\n",
+                           indexing_properties->maxDescriptorSetUpdateAfterBindStorageBuffers);
+                    printf("\tmaxDescriptorSetUpdateAfterBindStorageBuffersDynamic = %" PRIuLEAST32 "\n",
+                           indexing_properties->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
+                    printf("\tmaxDescriptorSetUpdateAfterBindSampledImages = %" PRIuLEAST32 "\n",
+                           indexing_properties->maxDescriptorSetUpdateAfterBindSampledImages);
+                    printf("\tmaxDescriptorSetUpdateAfterBindStorageImages = %" PRIuLEAST32 "\n",
+                           indexing_properties->maxDescriptorSetUpdateAfterBindStorageImages);
+                    printf("\tmaxDescriptorSetUpdateAfterBindInputAttachments = %" PRIuLEAST32 "\n",
+                           indexing_properties->maxDescriptorSetUpdateAfterBindInputAttachments);
+                }
             }
-
             place = structure->pNext;
         }
     }
@@ -4947,7 +5237,11 @@ static char *HumanReadable(const size_t sz) {
     if (which >= 0) {
         unit[0] = prefixes[which];
     }
+#ifdef _WIN32
+    _snprintf_s(buf, kBufferSize * sizeof(char), kBufferSize, "%.2f %sB", result, unit);
+#else
     snprintf(buf, kBufferSize, "%.2f %sB", result, unit);
+#endif
     return strndup(buf, kBufferSize);
 }
 
@@ -5558,7 +5852,11 @@ int main(int argc, char **argv) {
     AppCreateInstance(&inst);
 
     if (html_output) {
+#ifdef _WIN32
+        if (fopen_s(&out, "vulkaninfo.html", "w") != 0) out = NULL;
+#else
         out = fopen("vulkaninfo.html", "w");
+#endif
         if (!out) {
             printf("Unable to open vulkaninfo.html for writing\n");
             return 1;
@@ -5645,8 +5943,13 @@ int main(int argc, char **argv) {
         VkLayerProperties const *layer_prop = &inst.global_layers[i].layer_properties;
 
         ExtractVersion(layer_prop->specVersion, &layer_major, &layer_minor, &layer_patch);
+#ifdef _WIN32
+        _snprintf_s(spec_version, sizeof(spec_version), 64, "%d.%d.%d", layer_major, layer_minor, layer_patch);
+        _snprintf_s(layer_version, sizeof(layer_version), 64, "%d", layer_prop->implementationVersion);
+#else
         snprintf(spec_version, sizeof(spec_version), "%d.%d.%d", layer_major, layer_minor, layer_patch);
         snprintf(layer_version, sizeof(layer_version), "%d", layer_prop->implementationVersion);
+#endif
 
         if (html_output) {
             fprintf(out, "\t\t\t\t<details><summary>");