Stage 1 of rename

TODO: re-enable glave build, advance API for glave

v2: get rid of outdated code in tri introduced by rebase
    rename wsi_null.c (olv)

10 files changed, 580 insertions, 580 deletions

diff --git a/icd/common/icd-enumerate-drm.c b/icd/common/icd-enumerate-drm.c
index d09f3b8c..65e30655 100644
--- a/icd/common/icd-enumerate-drm.c
+++ b/icd/common/icd-enumerate-drm.c
@@ -1,5 +1,5 @@
 /*
- * XGL
+ * Vulkan
  *
  * Copyright (C) 2014 LunarG, Inc.
  *
@@ -125,7 +125,7 @@ static struct icd_drm_device *probe_syspath(const struct icd_instance *instance,
         return devices;
     } else {
         dev = icd_instance_alloc(instance, sizeof(*dev), 0,
-                XGL_SYSTEM_ALLOC_INTERNAL_TEMP);
+                VK_SYSTEM_ALLOC_INTERNAL_TEMP);
         if (!dev)
             return devices;
 
@@ -151,16 +151,16 @@ struct icd_drm_device *icd_drm_enumerate(const struct icd_instance *instance,
 
     udev = udev_new();
     if (udev == NULL) {
-        icd_instance_log(instance, XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0,
-                XGL_NULL_HANDLE, 0, 0, "failed to initialize udev context");
+        icd_instance_log(instance, VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0,
+                VK_NULL_HANDLE, 0, 0, "failed to initialize udev context");
 
         return NULL;
     }
 
     e = udev_enumerate_new(udev);
     if (e == NULL) {
-        icd_instance_log(instance, XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0,
-                XGL_NULL_HANDLE, 0, 0,
+        icd_instance_log(instance, VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0,
+                VK_NULL_HANDLE, 0, 0,
                 "failed to initialize udev enumerate context");
         udev_unref(udev);
 
diff --git a/icd/common/icd-enumerate-drm.h b/icd/common/icd-enumerate-drm.h
index 71b20e8f..6b318f01 100644
--- a/icd/common/icd-enumerate-drm.h
+++ b/icd/common/icd-enumerate-drm.h
@@ -1,5 +1,5 @@
 /*
- * XGL
+ * Vulkan
  *
  * Copyright (C) 2014 LunarG, Inc.
  *
diff --git a/icd/common/icd-format.c b/icd/common/icd-format.c
index 49093490..dff3638c 100644
--- a/icd/common/icd-format.c
+++ b/icd/common/icd-format.c
@@ -1,5 +1,5 @@
 /*
- * XGL
+ * Vulkan
  *
  * Copyright (C) 2014 LunarG, Inc.
  *
@@ -32,191 +32,191 @@
 static const struct icd_format_info {
     size_t size;
     uint32_t channel_count;
-} icd_format_table[XGL_NUM_FMT] = {
-    [XGL_FMT_UNDEFINED]            = { 0,  0 },
-    [XGL_FMT_R4G4_UNORM]           = { 1,  2 },
-    [XGL_FMT_R4G4_USCALED]         = { 1,  2 },
-    [XGL_FMT_R4G4B4A4_UNORM]       = { 2,  4 },
-    [XGL_FMT_R4G4B4A4_USCALED]     = { 2,  4 },
-    [XGL_FMT_R5G6B5_UNORM]         = { 2,  3 },
-    [XGL_FMT_R5G6B5_USCALED]       = { 2,  3 },
-    [XGL_FMT_R5G5B5A1_UNORM]       = { 2,  4 },
-    [XGL_FMT_R5G5B5A1_USCALED]     = { 2,  4 },
-    [XGL_FMT_R8_UNORM]             = { 1,  1 },
-    [XGL_FMT_R8_SNORM]             = { 1,  1 },
-    [XGL_FMT_R8_USCALED]           = { 1,  1 },
-    [XGL_FMT_R8_SSCALED]           = { 1,  1 },
-    [XGL_FMT_R8_UINT]              = { 1,  1 },
-    [XGL_FMT_R8_SINT]              = { 1,  1 },
-    [XGL_FMT_R8_SRGB]              = { 1,  1 },
-    [XGL_FMT_R8G8_UNORM]           = { 2,  2 },
-    [XGL_FMT_R8G8_SNORM]           = { 2,  2 },
-    [XGL_FMT_R8G8_USCALED]         = { 2,  2 },
-    [XGL_FMT_R8G8_SSCALED]         = { 2,  2 },
-    [XGL_FMT_R8G8_UINT]            = { 2,  2 },
-    [XGL_FMT_R8G8_SINT]            = { 2,  2 },
-    [XGL_FMT_R8G8_SRGB]            = { 2,  2 },
-    [XGL_FMT_R8G8B8_UNORM]         = { 3,  3 },
-    [XGL_FMT_R8G8B8_SNORM]         = { 3,  3 },
-    [XGL_FMT_R8G8B8_USCALED]       = { 3,  3 },
-    [XGL_FMT_R8G8B8_SSCALED]       = { 3,  3 },
-    [XGL_FMT_R8G8B8_UINT]          = { 3,  3 },
-    [XGL_FMT_R8G8B8_SINT]          = { 3,  3 },
-    [XGL_FMT_R8G8B8_SRGB]          = { 3,  3 },
-    [XGL_FMT_R8G8B8A8_UNORM]       = { 4,  4 },
-    [XGL_FMT_R8G8B8A8_SNORM]       = { 4,  4 },
-    [XGL_FMT_R8G8B8A8_USCALED]     = { 4,  4 },
-    [XGL_FMT_R8G8B8A8_SSCALED]     = { 4,  4 },
-    [XGL_FMT_R8G8B8A8_UINT]        = { 4,  4 },
-    [XGL_FMT_R8G8B8A8_SINT]        = { 4,  4 },
-    [XGL_FMT_R8G8B8A8_SRGB]        = { 4,  4 },
-    [XGL_FMT_R10G10B10A2_UNORM]    = { 4,  4 },
-    [XGL_FMT_R10G10B10A2_SNORM]    = { 4,  4 },
-    [XGL_FMT_R10G10B10A2_USCALED]  = { 4,  4 },
-    [XGL_FMT_R10G10B10A2_SSCALED]  = { 4,  4 },
-    [XGL_FMT_R10G10B10A2_UINT]     = { 4,  4 },
-    [XGL_FMT_R10G10B10A2_SINT]     = { 4,  4 },
-    [XGL_FMT_R16_UNORM]            = { 2,  1 },
-    [XGL_FMT_R16_SNORM]            = { 2,  1 },
-    [XGL_FMT_R16_USCALED]          = { 2,  1 },
-    [XGL_FMT_R16_SSCALED]          = { 2,  1 },
-    [XGL_FMT_R16_UINT]             = { 2,  1 },
-    [XGL_FMT_R16_SINT]             = { 2,  1 },
-    [XGL_FMT_R16_SFLOAT]           = { 2,  1 },
-    [XGL_FMT_R16G16_UNORM]         = { 4,  2 },
-    [XGL_FMT_R16G16_SNORM]         = { 4,  2 },
-    [XGL_FMT_R16G16_USCALED]       = { 4,  2 },
-    [XGL_FMT_R16G16_SSCALED]       = { 4,  2 },
-    [XGL_FMT_R16G16_UINT]          = { 4,  2 },
-    [XGL_FMT_R16G16_SINT]          = { 4,  2 },
-    [XGL_FMT_R16G16_SFLOAT]        = { 4,  2 },
-    [XGL_FMT_R16G16B16_UNORM]      = { 6,  3 },
-    [XGL_FMT_R16G16B16_SNORM]      = { 6,  3 },
-    [XGL_FMT_R16G16B16_USCALED]    = { 6,  3 },
-    [XGL_FMT_R16G16B16_SSCALED]    = { 6,  3 },
-    [XGL_FMT_R16G16B16_UINT]       = { 6,  3 },
-    [XGL_FMT_R16G16B16_SINT]       = { 6,  3 },
-    [XGL_FMT_R16G16B16_SFLOAT]     = { 6,  3 },
-    [XGL_FMT_R16G16B16A16_UNORM]   = { 8,  4 },
-    [XGL_FMT_R16G16B16A16_SNORM]   = { 8,  4 },
-    [XGL_FMT_R16G16B16A16_USCALED] = { 8,  4 },
-    [XGL_FMT_R16G16B16A16_SSCALED] = { 8,  4 },
-    [XGL_FMT_R16G16B16A16_UINT]    = { 8,  4 },
-    [XGL_FMT_R16G16B16A16_SINT]    = { 8,  4 },
-    [XGL_FMT_R16G16B16A16_SFLOAT]  = { 8,  4 },
-    [XGL_FMT_R32_UINT]             = { 4,  1 },
-    [XGL_FMT_R32_SINT]             = { 4,  1 },
-    [XGL_FMT_R32_SFLOAT]           = { 4,  1 },
-    [XGL_FMT_R32G32_UINT]          = { 8,  2 },
-    [XGL_FMT_R32G32_SINT]          = { 8,  2 },
-    [XGL_FMT_R32G32_SFLOAT]        = { 8,  2 },
-    [XGL_FMT_R32G32B32_UINT]       = { 12, 3 },
-    [XGL_FMT_R32G32B32_SINT]       = { 12, 3 },
-    [XGL_FMT_R32G32B32_SFLOAT]     = { 12, 3 },
-    [XGL_FMT_R32G32B32A32_UINT]    = { 16, 4 },
-    [XGL_FMT_R32G32B32A32_SINT]    = { 16, 4 },
-    [XGL_FMT_R32G32B32A32_SFLOAT]  = { 16, 4 },
-    [XGL_FMT_R64_SFLOAT]           = { 8,  1 },
-    [XGL_FMT_R64G64_SFLOAT]        = { 16, 2 },
-    [XGL_FMT_R64G64B64_SFLOAT]     = { 24, 3 },
-    [XGL_FMT_R64G64B64A64_SFLOAT]  = { 32, 4 },
-    [XGL_FMT_R11G11B10_UFLOAT]     = { 4,  3 },
-    [XGL_FMT_R9G9B9E5_UFLOAT]      = { 4,  3 },
-    [XGL_FMT_D16_UNORM]            = { 2,  1 },
-    [XGL_FMT_D24_UNORM]            = { 3,  1 },
-    [XGL_FMT_D32_SFLOAT]           = { 4,  1 },
-    [XGL_FMT_S8_UINT]              = { 1,  1 },
-    [XGL_FMT_D16_UNORM_S8_UINT]    = { 3,  2 },
-    [XGL_FMT_D24_UNORM_S8_UINT]    = { 4,  2 },
-    [XGL_FMT_D32_SFLOAT_S8_UINT]   = { 4,  2 },
-    [XGL_FMT_BC1_RGB_UNORM]        = { 8,  4 },
-    [XGL_FMT_BC1_RGB_SRGB]         = { 8,  4 },
-    [XGL_FMT_BC1_RGBA_UNORM]       = { 8,  4 },
-    [XGL_FMT_BC1_RGBA_SRGB]        = { 8,  4 },
-    [XGL_FMT_BC2_UNORM]            = { 16, 4 },
-    [XGL_FMT_BC2_SRGB]             = { 16, 4 },
-    [XGL_FMT_BC3_UNORM]            = { 16, 4 },
-    [XGL_FMT_BC3_SRGB]             = { 16, 4 },
-    [XGL_FMT_BC4_UNORM]            = { 8,  4 },
-    [XGL_FMT_BC4_SNORM]            = { 8,  4 },
-    [XGL_FMT_BC5_UNORM]            = { 16, 4 },
-    [XGL_FMT_BC5_SNORM]            = { 16, 4 },
-    [XGL_FMT_BC6H_UFLOAT]          = { 16, 4 },
-    [XGL_FMT_BC6H_SFLOAT]          = { 16, 4 },
-    [XGL_FMT_BC7_UNORM]            = { 16, 4 },
-    [XGL_FMT_BC7_SRGB]             = { 16, 4 },
+} icd_format_table[VK_NUM_FMT] = {
+    [VK_FMT_UNDEFINED]            = { 0,  0 },
+    [VK_FMT_R4G4_UNORM]           = { 1,  2 },
+    [VK_FMT_R4G4_USCALED]         = { 1,  2 },
+    [VK_FMT_R4G4B4A4_UNORM]       = { 2,  4 },
+    [VK_FMT_R4G4B4A4_USCALED]     = { 2,  4 },
+    [VK_FMT_R5G6B5_UNORM]         = { 2,  3 },
+    [VK_FMT_R5G6B5_USCALED]       = { 2,  3 },
+    [VK_FMT_R5G5B5A1_UNORM]       = { 2,  4 },
+    [VK_FMT_R5G5B5A1_USCALED]     = { 2,  4 },
+    [VK_FMT_R8_UNORM]             = { 1,  1 },
+    [VK_FMT_R8_SNORM]             = { 1,  1 },
+    [VK_FMT_R8_USCALED]           = { 1,  1 },
+    [VK_FMT_R8_SSCALED]           = { 1,  1 },
+    [VK_FMT_R8_UINT]              = { 1,  1 },
+    [VK_FMT_R8_SINT]              = { 1,  1 },
+    [VK_FMT_R8_SRGB]              = { 1,  1 },
+    [VK_FMT_R8G8_UNORM]           = { 2,  2 },
+    [VK_FMT_R8G8_SNORM]           = { 2,  2 },
+    [VK_FMT_R8G8_USCALED]         = { 2,  2 },
+    [VK_FMT_R8G8_SSCALED]         = { 2,  2 },
+    [VK_FMT_R8G8_UINT]            = { 2,  2 },
+    [VK_FMT_R8G8_SINT]            = { 2,  2 },
+    [VK_FMT_R8G8_SRGB]            = { 2,  2 },
+    [VK_FMT_R8G8B8_UNORM]         = { 3,  3 },
+    [VK_FMT_R8G8B8_SNORM]         = { 3,  3 },
+    [VK_FMT_R8G8B8_USCALED]       = { 3,  3 },
+    [VK_FMT_R8G8B8_SSCALED]       = { 3,  3 },
+    [VK_FMT_R8G8B8_UINT]          = { 3,  3 },
+    [VK_FMT_R8G8B8_SINT]          = { 3,  3 },
+    [VK_FMT_R8G8B8_SRGB]          = { 3,  3 },
+    [VK_FMT_R8G8B8A8_UNORM]       = { 4,  4 },
+    [VK_FMT_R8G8B8A8_SNORM]       = { 4,  4 },
+    [VK_FMT_R8G8B8A8_USCALED]     = { 4,  4 },
+    [VK_FMT_R8G8B8A8_SSCALED]     = { 4,  4 },
+    [VK_FMT_R8G8B8A8_UINT]        = { 4,  4 },
+    [VK_FMT_R8G8B8A8_SINT]        = { 4,  4 },
+    [VK_FMT_R8G8B8A8_SRGB]        = { 4,  4 },
+    [VK_FMT_R10G10B10A2_UNORM]    = { 4,  4 },
+    [VK_FMT_R10G10B10A2_SNORM]    = { 4,  4 },
+    [VK_FMT_R10G10B10A2_USCALED]  = { 4,  4 },
+    [VK_FMT_R10G10B10A2_SSCALED]  = { 4,  4 },
+    [VK_FMT_R10G10B10A2_UINT]     = { 4,  4 },
+    [VK_FMT_R10G10B10A2_SINT]     = { 4,  4 },
+    [VK_FMT_R16_UNORM]            = { 2,  1 },
+    [VK_FMT_R16_SNORM]            = { 2,  1 },
+    [VK_FMT_R16_USCALED]          = { 2,  1 },
+    [VK_FMT_R16_SSCALED]          = { 2,  1 },
+    [VK_FMT_R16_UINT]             = { 2,  1 },
+    [VK_FMT_R16_SINT]             = { 2,  1 },
+    [VK_FMT_R16_SFLOAT]           = { 2,  1 },
+    [VK_FMT_R16G16_UNORM]         = { 4,  2 },
+    [VK_FMT_R16G16_SNORM]         = { 4,  2 },
+    [VK_FMT_R16G16_USCALED]       = { 4,  2 },
+    [VK_FMT_R16G16_SSCALED]       = { 4,  2 },
+    [VK_FMT_R16G16_UINT]          = { 4,  2 },
+    [VK_FMT_R16G16_SINT]          = { 4,  2 },
+    [VK_FMT_R16G16_SFLOAT]        = { 4,  2 },
+    [VK_FMT_R16G16B16_UNORM]      = { 6,  3 },
+    [VK_FMT_R16G16B16_SNORM]      = { 6,  3 },
+    [VK_FMT_R16G16B16_USCALED]    = { 6,  3 },
+    [VK_FMT_R16G16B16_SSCALED]    = { 6,  3 },
+    [VK_FMT_R16G16B16_UINT]       = { 6,  3 },
+    [VK_FMT_R16G16B16_SINT]       = { 6,  3 },
+    [VK_FMT_R16G16B16_SFLOAT]     = { 6,  3 },
+    [VK_FMT_R16G16B16A16_UNORM]   = { 8,  4 },
+    [VK_FMT_R16G16B16A16_SNORM]   = { 8,  4 },
+    [VK_FMT_R16G16B16A16_USCALED] = { 8,  4 },
+    [VK_FMT_R16G16B16A16_SSCALED] = { 8,  4 },
+    [VK_FMT_R16G16B16A16_UINT]    = { 8,  4 },
+    [VK_FMT_R16G16B16A16_SINT]    = { 8,  4 },
+    [VK_FMT_R16G16B16A16_SFLOAT]  = { 8,  4 },
+    [VK_FMT_R32_UINT]             = { 4,  1 },
+    [VK_FMT_R32_SINT]             = { 4,  1 },
+    [VK_FMT_R32_SFLOAT]           = { 4,  1 },
+    [VK_FMT_R32G32_UINT]          = { 8,  2 },
+    [VK_FMT_R32G32_SINT]          = { 8,  2 },
+    [VK_FMT_R32G32_SFLOAT]        = { 8,  2 },
+    [VK_FMT_R32G32B32_UINT]       = { 12, 3 },
+    [VK_FMT_R32G32B32_SINT]       = { 12, 3 },
+    [VK_FMT_R32G32B32_SFLOAT]     = { 12, 3 },
+    [VK_FMT_R32G32B32A32_UINT]    = { 16, 4 },
+    [VK_FMT_R32G32B32A32_SINT]    = { 16, 4 },
+    [VK_FMT_R32G32B32A32_SFLOAT]  = { 16, 4 },
+    [VK_FMT_R64_SFLOAT]           = { 8,  1 },
+    [VK_FMT_R64G64_SFLOAT]        = { 16, 2 },
+    [VK_FMT_R64G64B64_SFLOAT]     = { 24, 3 },
+    [VK_FMT_R64G64B64A64_SFLOAT]  = { 32, 4 },
+    [VK_FMT_R11G11B10_UFLOAT]     = { 4,  3 },
+    [VK_FMT_R9G9B9E5_UFLOAT]      = { 4,  3 },
+    [VK_FMT_D16_UNORM]            = { 2,  1 },
+    [VK_FMT_D24_UNORM]            = { 3,  1 },
+    [VK_FMT_D32_SFLOAT]           = { 4,  1 },
+    [VK_FMT_S8_UINT]              = { 1,  1 },
+    [VK_FMT_D16_UNORM_S8_UINT]    = { 3,  2 },
+    [VK_FMT_D24_UNORM_S8_UINT]    = { 4,  2 },
+    [VK_FMT_D32_SFLOAT_S8_UINT]   = { 4,  2 },
+    [VK_FMT_BC1_RGB_UNORM]        = { 8,  4 },
+    [VK_FMT_BC1_RGB_SRGB]         = { 8,  4 },
+    [VK_FMT_BC1_RGBA_UNORM]       = { 8,  4 },
+    [VK_FMT_BC1_RGBA_SRGB]        = { 8,  4 },
+    [VK_FMT_BC2_UNORM]            = { 16, 4 },
+    [VK_FMT_BC2_SRGB]             = { 16, 4 },
+    [VK_FMT_BC3_UNORM]            = { 16, 4 },
+    [VK_FMT_BC3_SRGB]             = { 16, 4 },
+    [VK_FMT_BC4_UNORM]            = { 8,  4 },
+    [VK_FMT_BC4_SNORM]            = { 8,  4 },
+    [VK_FMT_BC5_UNORM]            = { 16, 4 },
+    [VK_FMT_BC5_SNORM]            = { 16, 4 },
+    [VK_FMT_BC6H_UFLOAT]          = { 16, 4 },
+    [VK_FMT_BC6H_SFLOAT]          = { 16, 4 },
+    [VK_FMT_BC7_UNORM]            = { 16, 4 },
+    [VK_FMT_BC7_SRGB]             = { 16, 4 },
     /* TODO: Initialize remaining compressed formats. */
-    [XGL_FMT_ETC2_R8G8B8_UNORM]    = { 0, 0 },
-    [XGL_FMT_ETC2_R8G8B8A1_UNORM]  = { 0, 0 },
-    [XGL_FMT_ETC2_R8G8B8A8_UNORM]  = { 0, 0 },
-    [XGL_FMT_EAC_R11_UNORM]        = { 0, 0 },
-    [XGL_FMT_EAC_R11_SNORM]        = { 0, 0 },
-    [XGL_FMT_EAC_R11G11_UNORM]     = { 0, 0 },
-    [XGL_FMT_EAC_R11G11_SNORM]     = { 0, 0 },
-    [XGL_FMT_ASTC_4x4_UNORM]       = { 0, 0 },
-    [XGL_FMT_ASTC_4x4_SRGB]        = { 0, 0 },
-    [XGL_FMT_ASTC_5x4_UNORM]       = { 0, 0 },
-    [XGL_FMT_ASTC_5x4_SRGB]        = { 0, 0 },
-    [XGL_FMT_ASTC_5x5_UNORM]       = { 0, 0 },
-    [XGL_FMT_ASTC_5x5_SRGB]        = { 0, 0 },
-    [XGL_FMT_ASTC_6x5_UNORM]       = { 0, 0 },
-    [XGL_FMT_ASTC_6x5_SRGB]        = { 0, 0 },
-    [XGL_FMT_ASTC_6x6_UNORM]       = { 0, 0 },
-    [XGL_FMT_ASTC_6x6_SRGB]        = { 0, 0 },
-    [XGL_FMT_ASTC_8x5_UNORM]       = { 0, 0 },
-    [XGL_FMT_ASTC_8x5_SRGB]        = { 0, 0 },
-    [XGL_FMT_ASTC_8x6_UNORM]       = { 0, 0 },
-    [XGL_FMT_ASTC_8x6_SRGB]        = { 0, 0 },
-    [XGL_FMT_ASTC_8x8_UNORM]       = { 0, 0 },
-    [XGL_FMT_ASTC_8x8_SRGB]        = { 0, 0 },
-    [XGL_FMT_ASTC_10x5_UNORM]      = { 0, 0 },
-    [XGL_FMT_ASTC_10x5_SRGB]       = { 0, 0 },
-    [XGL_FMT_ASTC_10x6_UNORM]      = { 0, 0 },
-    [XGL_FMT_ASTC_10x6_SRGB]       = { 0, 0 },
-    [XGL_FMT_ASTC_10x8_UNORM]      = { 0, 0 },
-    [XGL_FMT_ASTC_10x8_SRGB]       = { 0, 0 },
-    [XGL_FMT_ASTC_10x10_UNORM]     = { 0, 0 },
-    [XGL_FMT_ASTC_10x10_SRGB]      = { 0, 0 },
-    [XGL_FMT_ASTC_12x10_UNORM]     = { 0, 0 },
-    [XGL_FMT_ASTC_12x10_SRGB]      = { 0, 0 },
-    [XGL_FMT_ASTC_12x12_UNORM]     = { 0, 0 },
-    [XGL_FMT_ASTC_12x12_SRGB]      = { 0, 0 },
-    [XGL_FMT_B5G6R5_UNORM]         = { 2, 3 },
-    [XGL_FMT_B5G6R5_USCALED]       = { 2, 3 },
-    [XGL_FMT_B8G8R8_UNORM]         = { 3, 3 },
-    [XGL_FMT_B8G8R8_SNORM]         = { 3, 3 },
-    [XGL_FMT_B8G8R8_USCALED]       = { 3, 3 },
-    [XGL_FMT_B8G8R8_SSCALED]       = { 3, 3 },
-    [XGL_FMT_B8G8R8_UINT]          = { 3, 3 },
-    [XGL_FMT_B8G8R8_SINT]          = { 3, 3 },
-    [XGL_FMT_B8G8R8_SRGB]          = { 3, 3 },
-    [XGL_FMT_B8G8R8A8_UNORM]       = { 4, 4 },
-    [XGL_FMT_B8G8R8A8_SNORM]       = { 4, 4 },
-    [XGL_FMT_B8G8R8A8_USCALED]     = { 4, 4 },
-    [XGL_FMT_B8G8R8A8_SSCALED]     = { 4, 4 },
-    [XGL_FMT_B8G8R8A8_UINT]        = { 4, 4 },
-    [XGL_FMT_B8G8R8A8_SINT]        = { 4, 4 },
-    [XGL_FMT_B8G8R8A8_SRGB]        = { 4, 4 },
-    [XGL_FMT_B10G10R10A2_UNORM]    = { 4, 4 },
-    [XGL_FMT_B10G10R10A2_SNORM]    = { 4, 4 },
-    [XGL_FMT_B10G10R10A2_USCALED]  = { 4, 4 },
-    [XGL_FMT_B10G10R10A2_SSCALED]  = { 4, 4 },
-    [XGL_FMT_B10G10R10A2_UINT]     = { 4, 4 },
-    [XGL_FMT_B10G10R10A2_SINT]     = { 4, 4 },
+    [VK_FMT_ETC2_R8G8B8_UNORM]    = { 0, 0 },
+    [VK_FMT_ETC2_R8G8B8A1_UNORM]  = { 0, 0 },
+    [VK_FMT_ETC2_R8G8B8A8_UNORM]  = { 0, 0 },
+    [VK_FMT_EAC_R11_UNORM]        = { 0, 0 },
+    [VK_FMT_EAC_R11_SNORM]        = { 0, 0 },
+    [VK_FMT_EAC_R11G11_UNORM]     = { 0, 0 },
+    [VK_FMT_EAC_R11G11_SNORM]     = { 0, 0 },
+    [VK_FMT_ASTC_4x4_UNORM]       = { 0, 0 },
+    [VK_FMT_ASTC_4x4_SRGB]        = { 0, 0 },
+    [VK_FMT_ASTC_5x4_UNORM]       = { 0, 0 },
+    [VK_FMT_ASTC_5x4_SRGB]        = { 0, 0 },
+    [VK_FMT_ASTC_5x5_UNORM]       = { 0, 0 },
+    [VK_FMT_ASTC_5x5_SRGB]        = { 0, 0 },
+    [VK_FMT_ASTC_6x5_UNORM]       = { 0, 0 },
+    [VK_FMT_ASTC_6x5_SRGB]        = { 0, 0 },
+    [VK_FMT_ASTC_6x6_UNORM]       = { 0, 0 },
+    [VK_FMT_ASTC_6x6_SRGB]        = { 0, 0 },
+    [VK_FMT_ASTC_8x5_UNORM]       = { 0, 0 },
+    [VK_FMT_ASTC_8x5_SRGB]        = { 0, 0 },
+    [VK_FMT_ASTC_8x6_UNORM]       = { 0, 0 },
+    [VK_FMT_ASTC_8x6_SRGB]        = { 0, 0 },
+    [VK_FMT_ASTC_8x8_UNORM]       = { 0, 0 },
+    [VK_FMT_ASTC_8x8_SRGB]        = { 0, 0 },
+    [VK_FMT_ASTC_10x5_UNORM]      = { 0, 0 },
+    [VK_FMT_ASTC_10x5_SRGB]       = { 0, 0 },
+    [VK_FMT_ASTC_10x6_UNORM]      = { 0, 0 },
+    [VK_FMT_ASTC_10x6_SRGB]       = { 0, 0 },
+    [VK_FMT_ASTC_10x8_UNORM]      = { 0, 0 },
+    [VK_FMT_ASTC_10x8_SRGB]       = { 0, 0 },
+    [VK_FMT_ASTC_10x10_UNORM]     = { 0, 0 },
+    [VK_FMT_ASTC_10x10_SRGB]      = { 0, 0 },
+    [VK_FMT_ASTC_12x10_UNORM]     = { 0, 0 },
+    [VK_FMT_ASTC_12x10_SRGB]      = { 0, 0 },
+    [VK_FMT_ASTC_12x12_UNORM]     = { 0, 0 },
+    [VK_FMT_ASTC_12x12_SRGB]      = { 0, 0 },
+    [VK_FMT_B5G6R5_UNORM]         = { 2, 3 },
+    [VK_FMT_B5G6R5_USCALED]       = { 2, 3 },
+    [VK_FMT_B8G8R8_UNORM]         = { 3, 3 },
+    [VK_FMT_B8G8R8_SNORM]         = { 3, 3 },
+    [VK_FMT_B8G8R8_USCALED]       = { 3, 3 },
+    [VK_FMT_B8G8R8_SSCALED]       = { 3, 3 },
+    [VK_FMT_B8G8R8_UINT]          = { 3, 3 },
+    [VK_FMT_B8G8R8_SINT]          = { 3, 3 },
+    [VK_FMT_B8G8R8_SRGB]          = { 3, 3 },
+    [VK_FMT_B8G8R8A8_UNORM]       = { 4, 4 },
+    [VK_FMT_B8G8R8A8_SNORM]       = { 4, 4 },
+    [VK_FMT_B8G8R8A8_USCALED]     = { 4, 4 },
+    [VK_FMT_B8G8R8A8_SSCALED]     = { 4, 4 },
+    [VK_FMT_B8G8R8A8_UINT]        = { 4, 4 },
+    [VK_FMT_B8G8R8A8_SINT]        = { 4, 4 },
+    [VK_FMT_B8G8R8A8_SRGB]        = { 4, 4 },
+    [VK_FMT_B10G10R10A2_UNORM]    = { 4, 4 },
+    [VK_FMT_B10G10R10A2_SNORM]    = { 4, 4 },
+    [VK_FMT_B10G10R10A2_USCALED]  = { 4, 4 },
+    [VK_FMT_B10G10R10A2_SSCALED]  = { 4, 4 },
+    [VK_FMT_B10G10R10A2_UINT]     = { 4, 4 },
+    [VK_FMT_B10G10R10A2_SINT]     = { 4, 4 },
 };
 
-bool icd_format_is_ds(XGL_FORMAT format)
+bool icd_format_is_ds(VK_FORMAT format)
 {
     bool is_ds = false;
 
     switch (format) {
-    case XGL_FMT_D16_UNORM:
-    case XGL_FMT_D24_UNORM:
-    case XGL_FMT_D32_SFLOAT:
-    case XGL_FMT_S8_UINT:
-    case XGL_FMT_D16_UNORM_S8_UINT:
-    case XGL_FMT_D24_UNORM_S8_UINT:
-    case XGL_FMT_D32_SFLOAT_S8_UINT:
+    case VK_FMT_D16_UNORM:
+    case VK_FMT_D24_UNORM:
+    case VK_FMT_D32_SFLOAT:
+    case VK_FMT_S8_UINT:
+    case VK_FMT_D16_UNORM_S8_UINT:
+    case VK_FMT_D24_UNORM_S8_UINT:
+    case VK_FMT_D32_SFLOAT_S8_UINT:
         is_ds = true;
         break;
     default:
@@ -226,69 +226,69 @@ bool icd_format_is_ds(XGL_FORMAT format)
     return is_ds;
 }
 
-bool icd_format_is_norm(XGL_FORMAT format)
+bool icd_format_is_norm(VK_FORMAT format)
 {
     bool is_norm = false;
 
     switch (format) {
-    case XGL_FMT_R4G4_UNORM:
-    case XGL_FMT_R4G4B4A4_UNORM:
-    case XGL_FMT_R5G6B5_UNORM:
-    case XGL_FMT_R5G5B5A1_UNORM:
-    case XGL_FMT_R8_UNORM:
-    case XGL_FMT_R8_SNORM:
-    case XGL_FMT_R8G8_UNORM:
-    case XGL_FMT_R8G8_SNORM:
-    case XGL_FMT_R8G8B8_UNORM:
-    case XGL_FMT_R8G8B8_SNORM:
-    case XGL_FMT_R8G8B8A8_UNORM:
-    case XGL_FMT_R8G8B8A8_SNORM:
-    case XGL_FMT_R10G10B10A2_UNORM:
-    case XGL_FMT_R10G10B10A2_SNORM:
-    case XGL_FMT_R16_UNORM:
-    case XGL_FMT_R16_SNORM:
-    case XGL_FMT_R16G16_UNORM:
-    case XGL_FMT_R16G16_SNORM:
-    case XGL_FMT_R16G16B16_UNORM:
-    case XGL_FMT_R16G16B16_SNORM:
-    case XGL_FMT_R16G16B16A16_UNORM:
-    case XGL_FMT_R16G16B16A16_SNORM:
-    case XGL_FMT_BC1_RGB_UNORM:
-    case XGL_FMT_BC2_UNORM:
-    case XGL_FMT_BC3_UNORM:
-    case XGL_FMT_BC4_UNORM:
-    case XGL_FMT_BC4_SNORM:
-    case XGL_FMT_BC5_UNORM:
-    case XGL_FMT_BC5_SNORM:
-    case XGL_FMT_BC7_UNORM:
-    case XGL_FMT_ETC2_R8G8B8_UNORM:
-    case XGL_FMT_ETC2_R8G8B8A1_UNORM:
-    case XGL_FMT_ETC2_R8G8B8A8_UNORM:
-    case XGL_FMT_EAC_R11_UNORM:
-    case XGL_FMT_EAC_R11_SNORM:
-    case XGL_FMT_EAC_R11G11_UNORM:
-    case XGL_FMT_EAC_R11G11_SNORM:
-    case XGL_FMT_ASTC_4x4_UNORM:
-    case XGL_FMT_ASTC_5x4_UNORM:
-    case XGL_FMT_ASTC_5x5_UNORM:
-    case XGL_FMT_ASTC_6x5_UNORM:
-    case XGL_FMT_ASTC_6x6_UNORM:
-    case XGL_FMT_ASTC_8x5_UNORM:
-    case XGL_FMT_ASTC_8x6_UNORM:
-    case XGL_FMT_ASTC_8x8_UNORM:
-    case XGL_FMT_ASTC_10x5_UNORM:
-    case XGL_FMT_ASTC_10x6_UNORM:
-    case XGL_FMT_ASTC_10x8_UNORM:
-    case XGL_FMT_ASTC_10x10_UNORM:
-    case XGL_FMT_ASTC_12x10_UNORM:
-    case XGL_FMT_ASTC_12x12_UNORM:
-    case XGL_FMT_B5G6R5_UNORM:
-    case XGL_FMT_B8G8R8_UNORM:
-    case XGL_FMT_B8G8R8_SNORM:
-    case XGL_FMT_B8G8R8A8_UNORM:
-    case XGL_FMT_B8G8R8A8_SNORM:
-    case XGL_FMT_B10G10R10A2_UNORM:
-    case XGL_FMT_B10G10R10A2_SNORM:
+    case VK_FMT_R4G4_UNORM:
+    case VK_FMT_R4G4B4A4_UNORM:
+    case VK_FMT_R5G6B5_UNORM:
+    case VK_FMT_R5G5B5A1_UNORM:
+    case VK_FMT_R8_UNORM:
+    case VK_FMT_R8_SNORM:
+    case VK_FMT_R8G8_UNORM:
+    case VK_FMT_R8G8_SNORM:
+    case VK_FMT_R8G8B8_UNORM:
+    case VK_FMT_R8G8B8_SNORM:
+    case VK_FMT_R8G8B8A8_UNORM:
+    case VK_FMT_R8G8B8A8_SNORM:
+    case VK_FMT_R10G10B10A2_UNORM:
+    case VK_FMT_R10G10B10A2_SNORM:
+    case VK_FMT_R16_UNORM:
+    case VK_FMT_R16_SNORM:
+    case VK_FMT_R16G16_UNORM:
+    case VK_FMT_R16G16_SNORM:
+    case VK_FMT_R16G16B16_UNORM:
+    case VK_FMT_R16G16B16_SNORM:
+    case VK_FMT_R16G16B16A16_UNORM:
+    case VK_FMT_R16G16B16A16_SNORM:
+    case VK_FMT_BC1_RGB_UNORM:
+    case VK_FMT_BC2_UNORM:
+    case VK_FMT_BC3_UNORM:
+    case VK_FMT_BC4_UNORM:
+    case VK_FMT_BC4_SNORM:
+    case VK_FMT_BC5_UNORM:
+    case VK_FMT_BC5_SNORM:
+    case VK_FMT_BC7_UNORM:
+    case VK_FMT_ETC2_R8G8B8_UNORM:
+    case VK_FMT_ETC2_R8G8B8A1_UNORM:
+    case VK_FMT_ETC2_R8G8B8A8_UNORM:
+    case VK_FMT_EAC_R11_UNORM:
+    case VK_FMT_EAC_R11_SNORM:
+    case VK_FMT_EAC_R11G11_UNORM:
+    case VK_FMT_EAC_R11G11_SNORM:
+    case VK_FMT_ASTC_4x4_UNORM:
+    case VK_FMT_ASTC_5x4_UNORM:
+    case VK_FMT_ASTC_5x5_UNORM:
+    case VK_FMT_ASTC_6x5_UNORM:
+    case VK_FMT_ASTC_6x6_UNORM:
+    case VK_FMT_ASTC_8x5_UNORM:
+    case VK_FMT_ASTC_8x6_UNORM:
+    case VK_FMT_ASTC_8x8_UNORM:
+    case VK_FMT_ASTC_10x5_UNORM:
+    case VK_FMT_ASTC_10x6_UNORM:
+    case VK_FMT_ASTC_10x8_UNORM:
+    case VK_FMT_ASTC_10x10_UNORM:
+    case VK_FMT_ASTC_12x10_UNORM:
+    case VK_FMT_ASTC_12x12_UNORM:
+    case VK_FMT_B5G6R5_UNORM:
+    case VK_FMT_B8G8R8_UNORM:
+    case VK_FMT_B8G8R8_SNORM:
+    case VK_FMT_B8G8R8A8_UNORM:
+    case VK_FMT_B8G8R8A8_SNORM:
+    case VK_FMT_B10G10R10A2_UNORM:
+    case VK_FMT_B10G10R10A2_SNORM:
         is_norm = true;
         break;
     default:
@@ -298,43 +298,43 @@ bool icd_format_is_norm(XGL_FORMAT format)
     return is_norm;
 };
 
-bool icd_format_is_int(XGL_FORMAT format)
+bool icd_format_is_int(VK_FORMAT format)
 {
     bool is_int = false;
 
     switch (format) {
-    case XGL_FMT_R8_UINT:
-    case XGL_FMT_R8_SINT:
-    case XGL_FMT_R8G8_UINT:
-    case XGL_FMT_R8G8_SINT:
-    case XGL_FMT_R8G8B8_UINT:
-    case XGL_FMT_R8G8B8_SINT:
-    case XGL_FMT_R8G8B8A8_UINT:
-    case XGL_FMT_R8G8B8A8_SINT:
-    case XGL_FMT_R10G10B10A2_UINT:
-    case XGL_FMT_R10G10B10A2_SINT:
-    case XGL_FMT_R16_UINT:
-    case XGL_FMT_R16_SINT:
-    case XGL_FMT_R16G16_UINT:
-    case XGL_FMT_R16G16_SINT:
-    case XGL_FMT_R16G16B16_UINT:
-    case XGL_FMT_R16G16B16_SINT:
-    case XGL_FMT_R16G16B16A16_UINT:
-    case XGL_FMT_R16G16B16A16_SINT:
-    case XGL_FMT_R32_UINT:
-    case XGL_FMT_R32_SINT:
-    case XGL_FMT_R32G32_UINT:
-    case XGL_FMT_R32G32_SINT:
-    case XGL_FMT_R32G32B32_UINT:
-    case XGL_FMT_R32G32B32_SINT:
-    case XGL_FMT_R32G32B32A32_UINT:
-    case XGL_FMT_R32G32B32A32_SINT:
-    case XGL_FMT_B8G8R8_UINT:
-    case XGL_FMT_B8G8R8_SINT:
-    case XGL_FMT_B8G8R8A8_UINT:
-    case XGL_FMT_B8G8R8A8_SINT:
-    case XGL_FMT_B10G10R10A2_UINT:
-    case XGL_FMT_B10G10R10A2_SINT:
+    case VK_FMT_R8_UINT:
+    case VK_FMT_R8_SINT:
+    case VK_FMT_R8G8_UINT:
+    case VK_FMT_R8G8_SINT:
+    case VK_FMT_R8G8B8_UINT:
+    case VK_FMT_R8G8B8_SINT:
+    case VK_FMT_R8G8B8A8_UINT:
+    case VK_FMT_R8G8B8A8_SINT:
+    case VK_FMT_R10G10B10A2_UINT:
+    case VK_FMT_R10G10B10A2_SINT:
+    case VK_FMT_R16_UINT:
+    case VK_FMT_R16_SINT:
+    case VK_FMT_R16G16_UINT:
+    case VK_FMT_R16G16_SINT:
+    case VK_FMT_R16G16B16_UINT:
+    case VK_FMT_R16G16B16_SINT:
+    case VK_FMT_R16G16B16A16_UINT:
+    case VK_FMT_R16G16B16A16_SINT:
+    case VK_FMT_R32_UINT:
+    case VK_FMT_R32_SINT:
+    case VK_FMT_R32G32_UINT:
+    case VK_FMT_R32G32_SINT:
+    case VK_FMT_R32G32B32_UINT:
+    case VK_FMT_R32G32B32_SINT:
+    case VK_FMT_R32G32B32A32_UINT:
+    case VK_FMT_R32G32B32A32_SINT:
+    case VK_FMT_B8G8R8_UINT:
+    case VK_FMT_B8G8R8_SINT:
+    case VK_FMT_B8G8R8A8_UINT:
+    case VK_FMT_B8G8R8A8_SINT:
+    case VK_FMT_B10G10R10A2_UINT:
+    case VK_FMT_B10G10R10A2_SINT:
         is_int = true;
         break;
     default:
@@ -344,27 +344,27 @@ bool icd_format_is_int(XGL_FORMAT format)
     return is_int;
 }
 
-bool icd_format_is_float(XGL_FORMAT format)
+bool icd_format_is_float(VK_FORMAT format)
 {
     bool is_float = false;
 
     switch (format) {
-    case XGL_FMT_R16_SFLOAT:
-    case XGL_FMT_R16G16_SFLOAT:
-    case XGL_FMT_R16G16B16_SFLOAT:
-    case XGL_FMT_R16G16B16A16_SFLOAT:
-    case XGL_FMT_R32_SFLOAT:
-    case XGL_FMT_R32G32_SFLOAT:
-    case XGL_FMT_R32G32B32_SFLOAT:
-    case XGL_FMT_R32G32B32A32_SFLOAT:
-    case XGL_FMT_R64_SFLOAT:
-    case XGL_FMT_R64G64_SFLOAT:
-    case XGL_FMT_R64G64B64_SFLOAT:
-    case XGL_FMT_R64G64B64A64_SFLOAT:
-    case XGL_FMT_R11G11B10_UFLOAT:
-    case XGL_FMT_R9G9B9E5_UFLOAT:
-    case XGL_FMT_BC6H_UFLOAT:
-    case XGL_FMT_BC6H_SFLOAT:
+    case VK_FMT_R16_SFLOAT:
+    case VK_FMT_R16G16_SFLOAT:
+    case VK_FMT_R16G16B16_SFLOAT:
+    case VK_FMT_R16G16B16A16_SFLOAT:
+    case VK_FMT_R32_SFLOAT:
+    case VK_FMT_R32G32_SFLOAT:
+    case VK_FMT_R32G32B32_SFLOAT:
+    case VK_FMT_R32G32B32A32_SFLOAT:
+    case VK_FMT_R64_SFLOAT:
+    case VK_FMT_R64G64_SFLOAT:
+    case VK_FMT_R64G64B64_SFLOAT:
+    case VK_FMT_R64G64B64A64_SFLOAT:
+    case VK_FMT_R11G11B10_UFLOAT:
+    case VK_FMT_R9G9B9E5_UFLOAT:
+    case VK_FMT_BC6H_UFLOAT:
+    case VK_FMT_BC6H_SFLOAT:
         is_float = true;
         break;
     default:
@@ -374,35 +374,35 @@ bool icd_format_is_float(XGL_FORMAT format)
     return is_float;
 }
 
-bool icd_format_is_srgb(XGL_FORMAT format)
+bool icd_format_is_srgb(VK_FORMAT format)
 {
     bool is_srgb = false;
 
     switch (format) {
-    case XGL_FMT_R8_SRGB:
-    case XGL_FMT_R8G8_SRGB:
-    case XGL_FMT_R8G8B8_SRGB:
-    case XGL_FMT_R8G8B8A8_SRGB:
-    case XGL_FMT_BC1_RGB_SRGB:
-    case XGL_FMT_BC2_SRGB:
-    case XGL_FMT_BC3_SRGB:
-    case XGL_FMT_BC7_SRGB:
-    case XGL_FMT_ASTC_4x4_SRGB:
-    case XGL_FMT_ASTC_5x4_SRGB:
-    case XGL_FMT_ASTC_5x5_SRGB:
-    case XGL_FMT_ASTC_6x5_SRGB:
-    case XGL_FMT_ASTC_6x6_SRGB:
-    case XGL_FMT_ASTC_8x5_SRGB:
-    case XGL_FMT_ASTC_8x6_SRGB:
-    case XGL_FMT_ASTC_8x8_SRGB:
-    case XGL_FMT_ASTC_10x5_SRGB:
-    case XGL_FMT_ASTC_10x6_SRGB:
-    case XGL_FMT_ASTC_10x8_SRGB:
-    case XGL_FMT_ASTC_10x10_SRGB:
-    case XGL_FMT_ASTC_12x10_SRGB:
-    case XGL_FMT_ASTC_12x12_SRGB:
-    case XGL_FMT_B8G8R8_SRGB:
-    case XGL_FMT_B8G8R8A8_SRGB:
+    case VK_FMT_R8_SRGB:
+    case VK_FMT_R8G8_SRGB:
+    case VK_FMT_R8G8B8_SRGB:
+    case VK_FMT_R8G8B8A8_SRGB:
+    case VK_FMT_BC1_RGB_SRGB:
+    case VK_FMT_BC2_SRGB:
+    case VK_FMT_BC3_SRGB:
+    case VK_FMT_BC7_SRGB:
+    case VK_FMT_ASTC_4x4_SRGB:
+    case VK_FMT_ASTC_5x4_SRGB:
+    case VK_FMT_ASTC_5x5_SRGB:
+    case VK_FMT_ASTC_6x5_SRGB:
+    case VK_FMT_ASTC_6x6_SRGB:
+    case VK_FMT_ASTC_8x5_SRGB:
+    case VK_FMT_ASTC_8x6_SRGB:
+    case VK_FMT_ASTC_8x8_SRGB:
+    case VK_FMT_ASTC_10x5_SRGB:
+    case VK_FMT_ASTC_10x6_SRGB:
+    case VK_FMT_ASTC_10x8_SRGB:
+    case VK_FMT_ASTC_10x10_SRGB:
+    case VK_FMT_ASTC_12x10_SRGB:
+    case VK_FMT_ASTC_12x12_SRGB:
+    case VK_FMT_B8G8R8_SRGB:
+    case VK_FMT_B8G8R8A8_SRGB:
         is_srgb = true;
         break;
     default:
@@ -412,136 +412,136 @@ bool icd_format_is_srgb(XGL_FORMAT format)
     return is_srgb;
 }
 
-bool icd_format_is_compressed(XGL_FORMAT format)
+bool icd_format_is_compressed(VK_FORMAT format)
 {
     switch (format) {
-    case XGL_FMT_BC1_RGB_UNORM:
-    case XGL_FMT_BC1_RGB_SRGB:
-    case XGL_FMT_BC2_UNORM:
-    case XGL_FMT_BC2_SRGB:
-    case XGL_FMT_BC3_UNORM:
-    case XGL_FMT_BC3_SRGB:
-    case XGL_FMT_BC4_UNORM:
-    case XGL_FMT_BC4_SNORM:
-    case XGL_FMT_BC5_UNORM:
-    case XGL_FMT_BC5_SNORM:
-    case XGL_FMT_BC6H_UFLOAT:
-    case XGL_FMT_BC6H_SFLOAT:
-    case XGL_FMT_BC7_UNORM:
-    case XGL_FMT_BC7_SRGB:
-    case XGL_FMT_ETC2_R8G8B8_UNORM:
-    case XGL_FMT_ETC2_R8G8B8A1_UNORM:
-    case XGL_FMT_ETC2_R8G8B8A8_UNORM:
-    case XGL_FMT_EAC_R11_UNORM:
-    case XGL_FMT_EAC_R11_SNORM:
-    case XGL_FMT_EAC_R11G11_UNORM:
-    case XGL_FMT_EAC_R11G11_SNORM:
-    case XGL_FMT_ASTC_4x4_UNORM:
-    case XGL_FMT_ASTC_4x4_SRGB:
-    case XGL_FMT_ASTC_5x4_UNORM:
-    case XGL_FMT_ASTC_5x4_SRGB:
-    case XGL_FMT_ASTC_5x5_UNORM:
-    case XGL_FMT_ASTC_5x5_SRGB:
-    case XGL_FMT_ASTC_6x5_UNORM:
-    case XGL_FMT_ASTC_6x5_SRGB:
-    case XGL_FMT_ASTC_6x6_UNORM:
-    case XGL_FMT_ASTC_6x6_SRGB:
-    case XGL_FMT_ASTC_8x5_UNORM:
-    case XGL_FMT_ASTC_8x5_SRGB:
-    case XGL_FMT_ASTC_8x6_UNORM:
-    case XGL_FMT_ASTC_8x6_SRGB:
-    case XGL_FMT_ASTC_8x8_UNORM:
-    case XGL_FMT_ASTC_8x8_SRGB:
-    case XGL_FMT_ASTC_10x5_UNORM:
-    case XGL_FMT_ASTC_10x5_SRGB:
-    case XGL_FMT_ASTC_10x6_UNORM:
-    case XGL_FMT_ASTC_10x6_SRGB:
-    case XGL_FMT_ASTC_10x8_UNORM:
-    case XGL_FMT_ASTC_10x8_SRGB:
-    case XGL_FMT_ASTC_10x10_UNORM:
-    case XGL_FMT_ASTC_10x10_SRGB:
-    case XGL_FMT_ASTC_12x10_UNORM:
-    case XGL_FMT_ASTC_12x10_SRGB:
-    case XGL_FMT_ASTC_12x12_UNORM:
-    case XGL_FMT_ASTC_12x12_SRGB:
+    case VK_FMT_BC1_RGB_UNORM:
+    case VK_FMT_BC1_RGB_SRGB:
+    case VK_FMT_BC2_UNORM:
+    case VK_FMT_BC2_SRGB:
+    case VK_FMT_BC3_UNORM:
+    case VK_FMT_BC3_SRGB:
+    case VK_FMT_BC4_UNORM:
+    case VK_FMT_BC4_SNORM:
+    case VK_FMT_BC5_UNORM:
+    case VK_FMT_BC5_SNORM:
+    case VK_FMT_BC6H_UFLOAT:
+    case VK_FMT_BC6H_SFLOAT:
+    case VK_FMT_BC7_UNORM:
+    case VK_FMT_BC7_SRGB:
+    case VK_FMT_ETC2_R8G8B8_UNORM:
+    case VK_FMT_ETC2_R8G8B8A1_UNORM:
+    case VK_FMT_ETC2_R8G8B8A8_UNORM:
+    case VK_FMT_EAC_R11_UNORM:
+    case VK_FMT_EAC_R11_SNORM:
+    case VK_FMT_EAC_R11G11_UNORM:
+    case VK_FMT_EAC_R11G11_SNORM:
+    case VK_FMT_ASTC_4x4_UNORM:
+    case VK_FMT_ASTC_4x4_SRGB:
+    case VK_FMT_ASTC_5x4_UNORM:
+    case VK_FMT_ASTC_5x4_SRGB:
+    case VK_FMT_ASTC_5x5_UNORM:
+    case VK_FMT_ASTC_5x5_SRGB:
+    case VK_FMT_ASTC_6x5_UNORM:
+    case VK_FMT_ASTC_6x5_SRGB:
+    case VK_FMT_ASTC_6x6_UNORM:
+    case VK_FMT_ASTC_6x6_SRGB:
+    case VK_FMT_ASTC_8x5_UNORM:
+    case VK_FMT_ASTC_8x5_SRGB:
+    case VK_FMT_ASTC_8x6_UNORM:
+    case VK_FMT_ASTC_8x6_SRGB:
+    case VK_FMT_ASTC_8x8_UNORM:
+    case VK_FMT_ASTC_8x8_SRGB:
+    case VK_FMT_ASTC_10x5_UNORM:
+    case VK_FMT_ASTC_10x5_SRGB:
+    case VK_FMT_ASTC_10x6_UNORM:
+    case VK_FMT_ASTC_10x6_SRGB:
+    case VK_FMT_ASTC_10x8_UNORM:
+    case VK_FMT_ASTC_10x8_SRGB:
+    case VK_FMT_ASTC_10x10_UNORM:
+    case VK_FMT_ASTC_10x10_SRGB:
+    case VK_FMT_ASTC_12x10_UNORM:
+    case VK_FMT_ASTC_12x10_SRGB:
+    case VK_FMT_ASTC_12x12_UNORM:
+    case VK_FMT_ASTC_12x12_SRGB:
         return true;
     default:
         return false;
     }
 }
 
-size_t icd_format_get_size(XGL_FORMAT format)
+size_t icd_format_get_size(VK_FORMAT format)
 {
     return icd_format_table[format].size;
 }
 
-XGL_IMAGE_FORMAT_CLASS icd_format_get_class(XGL_FORMAT format)
+VK_IMAGE_FORMAT_CLASS icd_format_get_class(VK_FORMAT format)
 {
     if (icd_format_is_undef(format))
         assert(!"undefined format");
     if (icd_format_is_compressed(format)) {
         switch (icd_format_get_size(format)) {
         case 8:
-            return XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK;
+            return VK_IMAGE_FORMAT_CLASS_64_BIT_BLOCK;
         case 16:
-            return XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK;
+            return VK_IMAGE_FORMAT_CLASS_128_BIT_BLOCK;
         default:
             assert(!"illegal compressed format");
         }
     } else if (icd_format_is_ds(format)) {
         switch (icd_format_get_size(format)) {
         case 1:
-            return XGL_IMAGE_FORMAT_CLASS_S8;
+            return VK_IMAGE_FORMAT_CLASS_S8;
         case 2:
-            return XGL_IMAGE_FORMAT_CLASS_D16;
+            return VK_IMAGE_FORMAT_CLASS_D16;
         case 3:
             switch (icd_format_get_channel_count(format)) {
             case 1:
-                return XGL_IMAGE_FORMAT_CLASS_D24;
+                return VK_IMAGE_FORMAT_CLASS_D24;
             case 2:
-                return XGL_IMAGE_FORMAT_CLASS_D16S8;
+                return VK_IMAGE_FORMAT_CLASS_D16S8;
             default:
                 assert(!"illegal depth stencil format channels");
             }
         case 4:
             switch (icd_format_get_channel_count(format)) {
             case 1:
-                return XGL_IMAGE_FORMAT_CLASS_D32;
+                return VK_IMAGE_FORMAT_CLASS_D32;
             case 2:
-                return XGL_IMAGE_FORMAT_CLASS_D24S8;
+                return VK_IMAGE_FORMAT_CLASS_D24S8;
             default:
                 assert(!"illegal depth stencil format channels");
             }
         case 5:
-            return XGL_IMAGE_FORMAT_CLASS_D32S8;
+            return VK_IMAGE_FORMAT_CLASS_D32S8;
         default:
             assert(!"illegal depth stencil format");
         }
     } else { /* uncompressed color format */
         switch (icd_format_get_size(format)) {
         case 1:
-            return XGL_IMAGE_FORMAT_CLASS_8_BITS;
+            return VK_IMAGE_FORMAT_CLASS_8_BITS;
         case 2:
-            return XGL_IMAGE_FORMAT_CLASS_16_BITS;
+            return VK_IMAGE_FORMAT_CLASS_16_BITS;
         case 3:
-            return XGL_IMAGE_FORMAT_CLASS_24_BITS;
+            return VK_IMAGE_FORMAT_CLASS_24_BITS;
         case 4:
-            return XGL_IMAGE_FORMAT_CLASS_32_BITS;
+            return VK_IMAGE_FORMAT_CLASS_32_BITS;
         case 6:
-            return XGL_IMAGE_FORMAT_CLASS_48_BITS;
+            return VK_IMAGE_FORMAT_CLASS_48_BITS;
         case 8:
-            return XGL_IMAGE_FORMAT_CLASS_64_BITS;
+            return VK_IMAGE_FORMAT_CLASS_64_BITS;
         case 12:
-            return XGL_IMAGE_FORMAT_CLASS_96_BITS;
+            return VK_IMAGE_FORMAT_CLASS_96_BITS;
         case 16:
-            return XGL_IMAGE_FORMAT_CLASS_128_BITS;
+            return VK_IMAGE_FORMAT_CLASS_128_BITS;
         default:
             assert(!"illegal uncompressed color format");
         }
     }
 }
 
-unsigned int icd_format_get_channel_count(XGL_FORMAT format)
+unsigned int icd_format_get_channel_count(VK_FORMAT format)
 {
     return icd_format_table[format].channel_count;
 }
@@ -550,234 +550,234 @@ unsigned int icd_format_get_channel_count(XGL_FORMAT format)
  * Convert a raw RGBA color to a raw value.  \p value must have at least
  * icd_format_get_size(format) bytes.
  */
-void icd_format_get_raw_value(XGL_FORMAT format,
+void icd_format_get_raw_value(VK_FORMAT format,
                               const uint32_t color[4],
                               void *value)
 {
     /* assume little-endian */
     switch (format) {
-    case XGL_FMT_UNDEFINED:
+    case VK_FMT_UNDEFINED:
         break;
-    case XGL_FMT_R4G4_UNORM:
-    case XGL_FMT_R4G4_USCALED:
+    case VK_FMT_R4G4_UNORM:
+    case VK_FMT_R4G4_USCALED:
         ((uint8_t *) value)[0]  = (color[0] & 0xf) << 0   |
                                   (color[1] & 0xf) << 4;
         break;
-    case XGL_FMT_R4G4B4A4_UNORM:
-    case XGL_FMT_R4G4B4A4_USCALED:
+    case VK_FMT_R4G4B4A4_UNORM:
+    case VK_FMT_R4G4B4A4_USCALED:
         ((uint16_t *) value)[0] = (color[0] & 0xf) << 0   |
                                   (color[1] & 0xf) << 4   |
                                   (color[2] & 0xf) << 8   |
                                   (color[3] & 0xf) << 12;
         break;
-    case XGL_FMT_R5G6B5_UNORM:
-    case XGL_FMT_R5G6B5_USCALED:
+    case VK_FMT_R5G6B5_UNORM:
+    case VK_FMT_R5G6B5_USCALED:
         ((uint16_t *) value)[0] = (color[0] & 0x1f) << 0  |
                                   (color[1] & 0x3f) << 5  |
                                   (color[2] & 0x1f) << 11;
         break;
-    case XGL_FMT_B5G6R5_UNORM:
+    case VK_FMT_B5G6R5_UNORM:
         ((uint16_t *) value)[0] = (color[2] & 0x1f) << 0  |
                                   (color[1] & 0x3f) << 5  |
                                   (color[0] & 0x1f) << 11;
         break;
-    case XGL_FMT_R5G5B5A1_UNORM:
-    case XGL_FMT_R5G5B5A1_USCALED:
+    case VK_FMT_R5G5B5A1_UNORM:
+    case VK_FMT_R5G5B5A1_USCALED:
         ((uint16_t *) value)[0] = (color[0] & 0x1f) << 0  |
                                   (color[1] & 0x1f) << 5  |
                                   (color[2] & 0x1f) << 10 |
                                   (color[3] & 0x1)  << 15;
         break;
-    case XGL_FMT_R8_UNORM:
-    case XGL_FMT_R8_SNORM:
-    case XGL_FMT_R8_USCALED:
-    case XGL_FMT_R8_SSCALED:
-    case XGL_FMT_R8_UINT:
-    case XGL_FMT_R8_SINT:
-    case XGL_FMT_R8_SRGB:
+    case VK_FMT_R8_UNORM:
+    case VK_FMT_R8_SNORM:
+    case VK_FMT_R8_USCALED:
+    case VK_FMT_R8_SSCALED:
+    case VK_FMT_R8_UINT:
+    case VK_FMT_R8_SINT:
+    case VK_FMT_R8_SRGB:
         ((uint8_t *) value)[0]  = (uint8_t) color[0];
         break;
-    case XGL_FMT_R8G8_UNORM:
-    case XGL_FMT_R8G8_SNORM:
-    case XGL_FMT_R8G8_USCALED:
-    case XGL_FMT_R8G8_SSCALED:
-    case XGL_FMT_R8G8_UINT:
-    case XGL_FMT_R8G8_SINT:
-    case XGL_FMT_R8G8_SRGB:
+    case VK_FMT_R8G8_UNORM:
+    case VK_FMT_R8G8_SNORM:
+    case VK_FMT_R8G8_USCALED:
+    case VK_FMT_R8G8_SSCALED:
+    case VK_FMT_R8G8_UINT:
+    case VK_FMT_R8G8_SINT:
+    case VK_FMT_R8G8_SRGB:
         ((uint8_t *) value)[0]  = (uint8_t) color[0];
         ((uint8_t *) value)[1]  = (uint8_t) color[1];
         break;
-    case XGL_FMT_R8G8B8A8_UNORM:
-    case XGL_FMT_R8G8B8A8_SNORM:
-    case XGL_FMT_R8G8B8A8_USCALED:
-    case XGL_FMT_R8G8B8A8_SSCALED:
-    case XGL_FMT_R8G8B8A8_UINT:
-    case XGL_FMT_R8G8B8A8_SINT:
-    case XGL_FMT_R8G8B8A8_SRGB:
+    case VK_FMT_R8G8B8A8_UNORM:
+    case VK_FMT_R8G8B8A8_SNORM:
+    case VK_FMT_R8G8B8A8_USCALED:
+    case VK_FMT_R8G8B8A8_SSCALED:
+    case VK_FMT_R8G8B8A8_UINT:
+    case VK_FMT_R8G8B8A8_SINT:
+    case VK_FMT_R8G8B8A8_SRGB:
         ((uint8_t *) value)[0]  = (uint8_t) color[0];
         ((uint8_t *) value)[1]  = (uint8_t) color[1];
         ((uint8_t *) value)[2]  = (uint8_t) color[2];
         ((uint8_t *) value)[3]  = (uint8_t) color[3];
         break;
-    case XGL_FMT_B8G8R8A8_UNORM:
-    case XGL_FMT_B8G8R8A8_SRGB:
+    case VK_FMT_B8G8R8A8_UNORM:
+    case VK_FMT_B8G8R8A8_SRGB:
         ((uint8_t *) value)[0]  = (uint8_t) color[2];
         ((uint8_t *) value)[1]  = (uint8_t) color[1];
         ((uint8_t *) value)[2]  = (uint8_t) color[0];
         ((uint8_t *) value)[3]  = (uint8_t) color[3];
         break;
-    case XGL_FMT_R11G11B10_UFLOAT:
+    case VK_FMT_R11G11B10_UFLOAT:
         ((uint32_t *) value)[0] = (color[0] & 0x7ff) << 0  |
                                   (color[1] & 0x7ff) << 11 |
                                   (color[2] & 0x3ff) << 22;
         break;
-    case XGL_FMT_R10G10B10A2_UNORM:
-    case XGL_FMT_R10G10B10A2_SNORM:
-    case XGL_FMT_R10G10B10A2_USCALED:
-    case XGL_FMT_R10G10B10A2_SSCALED:
-    case XGL_FMT_R10G10B10A2_UINT:
-    case XGL_FMT_R10G10B10A2_SINT:
+    case VK_FMT_R10G10B10A2_UNORM:
+    case VK_FMT_R10G10B10A2_SNORM:
+    case VK_FMT_R10G10B10A2_USCALED:
+    case VK_FMT_R10G10B10A2_SSCALED:
+    case VK_FMT_R10G10B10A2_UINT:
+    case VK_FMT_R10G10B10A2_SINT:
         ((uint32_t *) value)[0] = (color[0] & 0x3ff) << 0  |
                                   (color[1] & 0x3ff) << 10 |
                                   (color[2] & 0x3ff) << 20 |
                                   (color[3] & 0x3)   << 30;
         break;
-    case XGL_FMT_R16_UNORM:
-    case XGL_FMT_R16_SNORM:
-    case XGL_FMT_R16_USCALED:
-    case XGL_FMT_R16_SSCALED:
-    case XGL_FMT_R16_UINT:
-    case XGL_FMT_R16_SINT:
-    case XGL_FMT_R16_SFLOAT:
+    case VK_FMT_R16_UNORM:
+    case VK_FMT_R16_SNORM:
+    case VK_FMT_R16_USCALED:
+    case VK_FMT_R16_SSCALED:
+    case VK_FMT_R16_UINT:
+    case VK_FMT_R16_SINT:
+    case VK_FMT_R16_SFLOAT:
         ((uint16_t *) value)[0] = (uint16_t) color[0];
         break;
-    case XGL_FMT_R16G16_UNORM:
-    case XGL_FMT_R16G16_SNORM:
-    case XGL_FMT_R16G16_USCALED:
-    case XGL_FMT_R16G16_SSCALED:
-    case XGL_FMT_R16G16_UINT:
-    case XGL_FMT_R16G16_SINT:
-    case XGL_FMT_R16G16_SFLOAT:
+    case VK_FMT_R16G16_UNORM:
+    case VK_FMT_R16G16_SNORM:
+    case VK_FMT_R16G16_USCALED:
+    case VK_FMT_R16G16_SSCALED:
+    case VK_FMT_R16G16_UINT:
+    case VK_FMT_R16G16_SINT:
+    case VK_FMT_R16G16_SFLOAT:
         ((uint16_t *) value)[0] = (uint16_t) color[0];
         ((uint16_t *) value)[1] = (uint16_t) color[1];
         break;
-    case XGL_FMT_R16G16B16A16_UNORM:
-    case XGL_FMT_R16G16B16A16_SNORM:
-    case XGL_FMT_R16G16B16A16_USCALED:
-    case XGL_FMT_R16G16B16A16_SSCALED:
-    case XGL_FMT_R16G16B16A16_UINT:
-    case XGL_FMT_R16G16B16A16_SINT:
-    case XGL_FMT_R16G16B16A16_SFLOAT:
+    case VK_FMT_R16G16B16A16_UNORM:
+    case VK_FMT_R16G16B16A16_SNORM:
+    case VK_FMT_R16G16B16A16_USCALED:
+    case VK_FMT_R16G16B16A16_SSCALED:
+    case VK_FMT_R16G16B16A16_UINT:
+    case VK_FMT_R16G16B16A16_SINT:
+    case VK_FMT_R16G16B16A16_SFLOAT:
         ((uint16_t *) value)[0] = (uint16_t) color[0];
         ((uint16_t *) value)[1] = (uint16_t) color[1];
         ((uint16_t *) value)[2] = (uint16_t) color[2];
         ((uint16_t *) value)[3] = (uint16_t) color[3];
         break;
-    case XGL_FMT_R32_UINT:
-    case XGL_FMT_R32_SINT:
-    case XGL_FMT_R32_SFLOAT:
+    case VK_FMT_R32_UINT:
+    case VK_FMT_R32_SINT:
+    case VK_FMT_R32_SFLOAT:
         ((uint32_t *) value)[0] = color[0];
         break;
-    case XGL_FMT_R32G32_UINT:
-    case XGL_FMT_R32G32_SINT:
-    case XGL_FMT_R32G32_SFLOAT:
+    case VK_FMT_R32G32_UINT:
+    case VK_FMT_R32G32_SINT:
+    case VK_FMT_R32G32_SFLOAT:
         ((uint32_t *) value)[0] = color[0];
         ((uint32_t *) value)[1] = color[1];
         break;
-    case XGL_FMT_R32G32B32_UINT:
-    case XGL_FMT_R32G32B32_SINT:
-    case XGL_FMT_R32G32B32_SFLOAT:
+    case VK_FMT_R32G32B32_UINT:
+    case VK_FMT_R32G32B32_SINT:
+    case VK_FMT_R32G32B32_SFLOAT:
         ((uint32_t *) value)[0] = color[0];
         ((uint32_t *) value)[1] = color[1];
         ((uint32_t *) value)[2] = color[2];
         break;
-    case XGL_FMT_R32G32B32A32_UINT:
-    case XGL_FMT_R32G32B32A32_SINT:
-    case XGL_FMT_R32G32B32A32_SFLOAT:
+    case VK_FMT_R32G32B32A32_UINT:
+    case VK_FMT_R32G32B32A32_SINT:
+    case VK_FMT_R32G32B32A32_SFLOAT:
         ((uint32_t *) value)[0] = color[0];
         ((uint32_t *) value)[1] = color[1];
         ((uint32_t *) value)[2] = color[2];
         ((uint32_t *) value)[3] = color[3];
         break;
-    case XGL_FMT_D16_UNORM_S8_UINT:
+    case VK_FMT_D16_UNORM_S8_UINT:
         ((uint16_t *) value)[0] = (uint16_t) color[0];
         ((char *) value)[2] = (uint8_t) color[1];
         break;
-    case XGL_FMT_D32_SFLOAT_S8_UINT:
+    case VK_FMT_D32_SFLOAT_S8_UINT:
         ((uint32_t *) value)[0] = (uint32_t) color[0];
         ((char *) value)[4] = (uint8_t) color[1];
         break;
-    case XGL_FMT_R9G9B9E5_UFLOAT:
+    case VK_FMT_R9G9B9E5_UFLOAT:
         ((uint32_t *) value)[0] = (color[0] & 0x1ff) << 0  |
                                   (color[1] & 0x1ff) << 9  |
                                   (color[2] & 0x1ff) << 18 |
                                   (color[3] & 0x1f)  << 27;
         break;
-    case XGL_FMT_BC1_RGB_UNORM:
-    case XGL_FMT_BC1_RGB_SRGB:
-    case XGL_FMT_BC4_UNORM:
-    case XGL_FMT_BC4_SNORM:
+    case VK_FMT_BC1_RGB_UNORM:
+    case VK_FMT_BC1_RGB_SRGB:
+    case VK_FMT_BC4_UNORM:
+    case VK_FMT_BC4_SNORM:
         memcpy(value, color, 8);
         break;
-    case XGL_FMT_BC2_UNORM:
-    case XGL_FMT_BC2_SRGB:
-    case XGL_FMT_BC3_UNORM:
-    case XGL_FMT_BC3_SRGB:
-    case XGL_FMT_BC5_UNORM:
-    case XGL_FMT_BC5_SNORM:
-    case XGL_FMT_BC6H_UFLOAT:
-    case XGL_FMT_BC6H_SFLOAT:
-    case XGL_FMT_BC7_UNORM:
-    case XGL_FMT_BC7_SRGB:
+    case VK_FMT_BC2_UNORM:
+    case VK_FMT_BC2_SRGB:
+    case VK_FMT_BC3_UNORM:
+    case VK_FMT_BC3_SRGB:
+    case VK_FMT_BC5_UNORM:
+    case VK_FMT_BC5_SNORM:
+    case VK_FMT_BC6H_UFLOAT:
+    case VK_FMT_BC6H_SFLOAT:
+    case VK_FMT_BC7_UNORM:
+    case VK_FMT_BC7_SRGB:
         memcpy(value, color, 16);
         break;
-    case XGL_FMT_R8G8B8_UNORM:
-    case XGL_FMT_R8G8B8_SNORM:
-    case XGL_FMT_R8G8B8_USCALED:
-    case XGL_FMT_R8G8B8_SSCALED:
-    case XGL_FMT_R8G8B8_UINT:
-    case XGL_FMT_R8G8B8_SINT:
-    case XGL_FMT_R8G8B8_SRGB:
+    case VK_FMT_R8G8B8_UNORM:
+    case VK_FMT_R8G8B8_SNORM:
+    case VK_FMT_R8G8B8_USCALED:
+    case VK_FMT_R8G8B8_SSCALED:
+    case VK_FMT_R8G8B8_UINT:
+    case VK_FMT_R8G8B8_SINT:
+    case VK_FMT_R8G8B8_SRGB:
         ((uint8_t *) value)[0]  = (uint8_t) color[0];
         ((uint8_t *) value)[1]  = (uint8_t) color[1];
         ((uint8_t *) value)[2]  = (uint8_t) color[2];
         break;
-    case XGL_FMT_R16G16B16_UNORM:
-    case XGL_FMT_R16G16B16_SNORM:
-    case XGL_FMT_R16G16B16_USCALED:
-    case XGL_FMT_R16G16B16_SSCALED:
-    case XGL_FMT_R16G16B16_UINT:
-    case XGL_FMT_R16G16B16_SINT:
-    case XGL_FMT_R16G16B16_SFLOAT:
+    case VK_FMT_R16G16B16_UNORM:
+    case VK_FMT_R16G16B16_SNORM:
+    case VK_FMT_R16G16B16_USCALED:
+    case VK_FMT_R16G16B16_SSCALED:
+    case VK_FMT_R16G16B16_UINT:
+    case VK_FMT_R16G16B16_SINT:
+    case VK_FMT_R16G16B16_SFLOAT:
         ((uint16_t *) value)[0] = (uint16_t) color[0];
         ((uint16_t *) value)[1] = (uint16_t) color[1];
         ((uint16_t *) value)[2] = (uint16_t) color[2];
         break;
-    case XGL_FMT_B10G10R10A2_UNORM:
-    case XGL_FMT_B10G10R10A2_SNORM:
-    case XGL_FMT_B10G10R10A2_USCALED:
-    case XGL_FMT_B10G10R10A2_SSCALED:
-    case XGL_FMT_B10G10R10A2_UINT:
-    case XGL_FMT_B10G10R10A2_SINT:
+    case VK_FMT_B10G10R10A2_UNORM:
+    case VK_FMT_B10G10R10A2_SNORM:
+    case VK_FMT_B10G10R10A2_USCALED:
+    case VK_FMT_B10G10R10A2_SSCALED:
+    case VK_FMT_B10G10R10A2_UINT:
+    case VK_FMT_B10G10R10A2_SINT:
         ((uint32_t *) value)[0] = (color[2] & 0x3ff) << 0  |
                                   (color[1] & 0x3ff) << 10 |
                                   (color[0] & 0x3ff) << 20 |
                                   (color[3] & 0x3)   << 30;
         break;
-    case XGL_FMT_R64_SFLOAT:
+    case VK_FMT_R64_SFLOAT:
         /* higher 32 bits always 0 */
         ((uint64_t *) value)[0] = color[0];
         break;
-    case XGL_FMT_R64G64_SFLOAT:
+    case VK_FMT_R64G64_SFLOAT:
         ((uint64_t *) value)[0] = color[0];
         ((uint64_t *) value)[1] = color[1];
         break;
-    case XGL_FMT_R64G64B64_SFLOAT:
+    case VK_FMT_R64G64B64_SFLOAT:
         ((uint64_t *) value)[0] = color[0];
         ((uint64_t *) value)[1] = color[1];
         ((uint64_t *) value)[2] = color[2];
         break;
-    case XGL_FMT_R64G64B64A64_SFLOAT:
+    case VK_FMT_R64G64B64A64_SFLOAT:
         ((uint64_t *) value)[0] = color[0];
         ((uint64_t *) value)[1] = color[1];
         ((uint64_t *) value)[2] = color[2];
diff --git a/icd/common/icd-format.h b/icd/common/icd-format.h
index 28c2dcae..ea227c13 100644
--- a/icd/common/icd-format.h
+++ b/icd/common/icd-format.h
@@ -1,5 +1,5 @@
 /*
- * XGL
+ * Vulkan
  *
  * Copyright (C) 2014 LunarG, Inc.
  *
@@ -31,43 +31,43 @@
 #include <stdbool.h>
 #include "icd.h"
 
-static inline bool icd_format_is_undef(XGL_FORMAT format)
+static inline bool icd_format_is_undef(VK_FORMAT format)
 {
-    return (format == XGL_FMT_UNDEFINED);
+    return (format == VK_FMT_UNDEFINED);
 }
 
-bool icd_format_is_ds(XGL_FORMAT format);
+bool icd_format_is_ds(VK_FORMAT format);
 
-static inline bool icd_format_is_color(XGL_FORMAT format)
+static inline bool icd_format_is_color(VK_FORMAT format)
 {
     return !(icd_format_is_undef(format) || icd_format_is_ds(format));
 }
 
-bool icd_format_is_norm(XGL_FORMAT format);
+bool icd_format_is_norm(VK_FORMAT format);
 
-bool icd_format_is_int(XGL_FORMAT format);
+bool icd_format_is_int(VK_FORMAT format);
 
-bool icd_format_is_float(XGL_FORMAT format);
+bool icd_format_is_float(VK_FORMAT format);
 
-bool icd_format_is_srgb(XGL_FORMAT format);
+bool icd_format_is_srgb(VK_FORMAT format);
 
-bool icd_format_is_compressed(XGL_FORMAT format);
+bool icd_format_is_compressed(VK_FORMAT format);
 
-static inline int icd_format_get_block_width(XGL_FORMAT format)
+static inline int icd_format_get_block_width(VK_FORMAT format)
 {
     /* all compressed formats use 4x4 blocks */
     return (icd_format_is_compressed(format)) ? 4 : 1;
 }
 
-static inline bool icd_blend_mode_is_dual_src(XGL_BLEND mode)
+static inline bool icd_blend_mode_is_dual_src(VK_BLEND mode)
 {
-    return (mode == XGL_BLEND_SRC1_COLOR) ||
-           (mode == XGL_BLEND_SRC1_ALPHA) ||
-           (mode == XGL_BLEND_ONE_MINUS_SRC1_COLOR) ||
-           (mode == XGL_BLEND_ONE_MINUS_SRC1_ALPHA);
+    return (mode == VK_BLEND_SRC1_COLOR) ||
+           (mode == VK_BLEND_SRC1_ALPHA) ||
+           (mode == VK_BLEND_ONE_MINUS_SRC1_COLOR) ||
+           (mode == VK_BLEND_ONE_MINUS_SRC1_ALPHA);
 }
 
-static inline bool icd_pipeline_cb_att_needs_dual_source_blending(const XGL_PIPELINE_CB_ATTACHMENT_STATE *att)
+static inline bool icd_pipeline_cb_att_needs_dual_source_blending(const VK_PIPELINE_CB_ATTACHMENT_STATE *att)
 {
     if (icd_blend_mode_is_dual_src(att->srcBlendColor) ||
         icd_blend_mode_is_dual_src(att->srcBlendAlpha) ||
@@ -78,13 +78,13 @@ static inline bool icd_pipeline_cb_att_needs_dual_source_blending(const XGL_PIPE
     return false;
 }
 
-size_t icd_format_get_size(XGL_FORMAT format);
+size_t icd_format_get_size(VK_FORMAT format);
 
-XGL_IMAGE_FORMAT_CLASS icd_format_get_class(XGL_FORMAT format);
+VK_IMAGE_FORMAT_CLASS icd_format_get_class(VK_FORMAT format);
 
-unsigned int icd_format_get_channel_count(XGL_FORMAT format);
+unsigned int icd_format_get_channel_count(VK_FORMAT format);
 
-void icd_format_get_raw_value(XGL_FORMAT format,
+void icd_format_get_raw_value(VK_FORMAT format,
                               const uint32_t color[4],
                               void *value);
 
diff --git a/icd/common/icd-instance.c b/icd/common/icd-instance.c
index d54e5720..fed138e7 100644
--- a/icd/common/icd-instance.c
+++ b/icd/common/icd-instance.c
@@ -1,5 +1,5 @@
 /*
- * XGL
+ * Vulkan
  *
  * Copyright (C) 2014-2015 LunarG, Inc.
  *
@@ -31,9 +31,9 @@
 #include <string.h>
 #include "icd-instance.h"
 
-static void * XGLAPI default_alloc(void *user_data, size_t size,
+static void * VKAPI default_alloc(void *user_data, size_t size,
                                    size_t alignment,
-                                   XGL_SYSTEM_ALLOC_TYPE allocType)
+                                   VK_SYSTEM_ALLOC_TYPE allocType)
 {
     if (alignment <= 1) {
         return malloc(size);
@@ -56,15 +56,15 @@ static void * XGLAPI default_alloc(void *user_data, size_t size,
     }
 }
 
-static void XGLAPI default_free(void *user_data, void *ptr)
+static void VKAPI default_free(void *user_data, void *ptr)
 {
     free(ptr);
 }
 
-struct icd_instance *icd_instance_create(const XGL_APPLICATION_INFO *app_info,
-                                         const XGL_ALLOC_CALLBACKS *alloc_cb)
+struct icd_instance *icd_instance_create(const VK_APPLICATION_INFO *app_info,
+                                         const VK_ALLOC_CALLBACKS *alloc_cb)
 {
-    static const XGL_ALLOC_CALLBACKS default_alloc_cb = {
+    static const VK_ALLOC_CALLBACKS default_alloc_cb = {
         .pfnAlloc = default_alloc,
         .pfnFree = default_free,
     };
@@ -76,7 +76,7 @@ struct icd_instance *icd_instance_create(const XGL_APPLICATION_INFO *app_info,
         alloc_cb = &default_alloc_cb;
 
     instance = alloc_cb->pfnAlloc(alloc_cb->pUserData, sizeof(*instance), 0,
-            XGL_SYSTEM_ALLOC_API_OBJECT);
+            VK_SYSTEM_ALLOC_API_OBJECT);
     if (!instance)
         return NULL;
 
@@ -85,7 +85,7 @@ struct icd_instance *icd_instance_create(const XGL_APPLICATION_INFO *app_info,
     name = (app_info->pAppName) ? app_info->pAppName : "unnamed";
     len = strlen(name);
     instance->name = alloc_cb->pfnAlloc(alloc_cb->pUserData, len + 1, 0,
-            XGL_SYSTEM_ALLOC_INTERNAL);
+            VK_SYSTEM_ALLOC_INTERNAL);
     if (!instance->name) {
         alloc_cb->pfnFree(alloc_cb->pUserData, instance);
         return NULL;
@@ -114,31 +114,31 @@ void icd_instance_destroy(struct icd_instance *instance)
     icd_instance_free(instance, instance);
 }
 
-XGL_RESULT icd_instance_set_bool(struct icd_instance *instance,
-                                 XGL_DBG_GLOBAL_OPTION option, bool yes)
+VK_RESULT icd_instance_set_bool(struct icd_instance *instance,
+                                 VK_DBG_GLOBAL_OPTION option, bool yes)
 {
-    XGL_RESULT res = XGL_SUCCESS;
+    VK_RESULT res = VK_SUCCESS;
 
     switch (option) {
-    case XGL_DBG_OPTION_DEBUG_ECHO_ENABLE:
+    case VK_DBG_OPTION_DEBUG_ECHO_ENABLE:
         instance->debug_echo_enable = yes;
         break;
-    case XGL_DBG_OPTION_BREAK_ON_ERROR:
+    case VK_DBG_OPTION_BREAK_ON_ERROR:
         instance->break_on_error = yes;
         break;
-    case XGL_DBG_OPTION_BREAK_ON_WARNING:
+    case VK_DBG_OPTION_BREAK_ON_WARNING:
         instance->break_on_warning = yes;
         break;
     default:
-        res = XGL_ERROR_INVALID_VALUE;
+        res = VK_ERROR_INVALID_VALUE;
         break;
     }
 
     return res;
 }
 
-XGL_RESULT icd_instance_add_logger(struct icd_instance *instance,
-                                   XGL_DBG_MSG_CALLBACK_FUNCTION func,
+VK_RESULT icd_instance_add_logger(struct icd_instance *instance,
+                                   VK_DBG_MSG_CALLBACK_FUNCTION func,
                                    void *user_data)
 {
     struct icd_instance_logger *logger;
@@ -150,9 +150,9 @@ XGL_RESULT icd_instance_add_logger(struct icd_instance *instance,
 
     if (!logger) {
         logger = icd_instance_alloc(instance, sizeof(*logger), 0,
-                XGL_SYSTEM_ALLOC_DEBUG);
+                VK_SYSTEM_ALLOC_DEBUG);
         if (!logger)
-            return XGL_ERROR_OUT_OF_MEMORY;
+            return VK_ERROR_OUT_OF_MEMORY;
 
         logger->func = func;
         logger->next = instance->loggers;
@@ -161,11 +161,11 @@ XGL_RESULT icd_instance_add_logger(struct icd_instance *instance,
 
     logger->user_data = user_data;
 
-    return XGL_SUCCESS;
+    return VK_SUCCESS;
 }
 
-XGL_RESULT icd_instance_remove_logger(struct icd_instance *instance,
-                                      XGL_DBG_MSG_CALLBACK_FUNCTION func)
+VK_RESULT icd_instance_remove_logger(struct icd_instance *instance,
+                                      VK_DBG_MSG_CALLBACK_FUNCTION func)
 {
     struct icd_instance_logger *logger, *prev;
 
@@ -176,7 +176,7 @@ XGL_RESULT icd_instance_remove_logger(struct icd_instance *instance,
     }
 
     if (!logger)
-        return XGL_ERROR_INVALID_POINTER;
+        return VK_ERROR_INVALID_POINTER;
 
     if (prev)
         prev->next = logger->next;
@@ -185,13 +185,13 @@ XGL_RESULT icd_instance_remove_logger(struct icd_instance *instance,
 
     icd_instance_free(instance, logger);
 
-    return XGL_SUCCESS;
+    return VK_SUCCESS;
 }
 
 void icd_instance_log(const struct icd_instance *instance,
-                      XGL_DBG_MSG_TYPE msg_type,
-                      XGL_VALIDATION_LEVEL validation_level,
-                      XGL_BASE_OBJECT src_object,
+                      VK_DBG_MSG_TYPE msg_type,
+                      VK_VALIDATION_LEVEL validation_level,
+                      VK_BASE_OBJECT src_object,
                       size_t location, int32_t msg_code,
                       const char *msg)
 {
@@ -208,11 +208,11 @@ void icd_instance_log(const struct icd_instance *instance,
     }
 
     switch (msg_type) {
-    case XGL_DBG_MSG_ERROR:
+    case VK_DBG_MSG_ERROR:
         if (instance->break_on_error)
             abort();
         /* fall through */
-    case XGL_DBG_MSG_WARNING:
+    case VK_DBG_MSG_WARNING:
         if (instance->break_on_warning)
             abort();
         break;
diff --git a/icd/common/icd-instance.h b/icd/common/icd-instance.h
index 43f3179c..9b7093cf 100644
--- a/icd/common/icd-instance.h
+++ b/icd/common/icd-instance.h
@@ -1,5 +1,5 @@
 /*
- * XGL
+ * Vulkan
  *
  * Copyright (C) 2014-2015 LunarG, Inc.
  *
@@ -36,7 +36,7 @@ extern "C" {
 #endif
 
 struct icd_instance_logger {
-    XGL_DBG_MSG_CALLBACK_FUNCTION func;
+    VK_DBG_MSG_CALLBACK_FUNCTION func;
     void *user_data;
 
     struct icd_instance_logger *next;
@@ -49,21 +49,21 @@ struct icd_instance {
     bool break_on_error;
     bool break_on_warning;
 
-    XGL_ALLOC_CALLBACKS alloc_cb;
+    VK_ALLOC_CALLBACKS alloc_cb;
 
     struct icd_instance_logger *loggers;
 };
 
-struct icd_instance *icd_instance_create(const XGL_APPLICATION_INFO *app_info,
-                                         const XGL_ALLOC_CALLBACKS *alloc_cb);
+struct icd_instance *icd_instance_create(const VK_APPLICATION_INFO *app_info,
+                                         const VK_ALLOC_CALLBACKS *alloc_cb);
 void icd_instance_destroy(struct icd_instance *instance);
 
-XGL_RESULT icd_instance_set_bool(struct icd_instance *instance,
-                                 XGL_DBG_GLOBAL_OPTION option, bool yes);
+VK_RESULT icd_instance_set_bool(struct icd_instance *instance,
+                                 VK_DBG_GLOBAL_OPTION option, bool yes);
 
 static inline void *icd_instance_alloc(const struct icd_instance *instance,
                                        size_t size, size_t alignment,
-                                       XGL_SYSTEM_ALLOC_TYPE type)
+                                       VK_SYSTEM_ALLOC_TYPE type)
 {
     return instance->alloc_cb.pfnAlloc(instance->alloc_cb.pUserData,
             size, alignment, type);
@@ -75,16 +75,16 @@ static inline void icd_instance_free(const struct icd_instance *instance,
     instance->alloc_cb.pfnFree(instance->alloc_cb.pUserData, ptr);
 }
 
-XGL_RESULT icd_instance_add_logger(struct icd_instance *instance,
-                                   XGL_DBG_MSG_CALLBACK_FUNCTION func,
+VK_RESULT icd_instance_add_logger(struct icd_instance *instance,
+                                   VK_DBG_MSG_CALLBACK_FUNCTION func,
                                    void *user_data);
-XGL_RESULT icd_instance_remove_logger(struct icd_instance *instance,
-                                      XGL_DBG_MSG_CALLBACK_FUNCTION func);
+VK_RESULT icd_instance_remove_logger(struct icd_instance *instance,
+                                      VK_DBG_MSG_CALLBACK_FUNCTION func);
 
 void icd_instance_log(const struct icd_instance *instance,
-                      XGL_DBG_MSG_TYPE msg_type,
-                      XGL_VALIDATION_LEVEL validation_level,
-                      XGL_BASE_OBJECT src_object,
+                      VK_DBG_MSG_TYPE msg_type,
+                      VK_VALIDATION_LEVEL validation_level,
+                      VK_BASE_OBJECT src_object,
                       size_t location, int32_t msg_code,
                       const char *msg);
 
diff --git a/icd/common/icd-spv.h b/icd/common/icd-spv.h
index cf620a52..d9457c45 100644
--- a/icd/common/icd-spv.h
+++ b/icd/common/icd-spv.h
@@ -1,5 +1,5 @@
 /*
- * XGL
+ * Vulkan
  *
  * Copyright (C) 2014 LunarG, Inc.
  *
diff --git a/icd/common/icd-utils.c b/icd/common/icd-utils.c
index 8e7bb938..9abf4c76 100644
--- a/icd/common/icd-utils.c
+++ b/icd/common/icd-utils.c
@@ -1,5 +1,5 @@
 /*
- * XGL
+ * Vulkan
  *
  * Copyright (C) 2014 LunarG, Inc.
  *
diff --git a/icd/common/icd-utils.h b/icd/common/icd-utils.h
index fa9c3237..6e164439 100644
--- a/icd/common/icd-utils.h
+++ b/icd/common/icd-utils.h
@@ -1,5 +1,5 @@
 /*
- * XGL
+ * Vulkan
  *
  * Copyright (C) 2014 LunarG, Inc.
  *
diff --git a/icd/common/icd.h b/icd/common/icd.h
index 3c799a65..a23b4d07 100644
--- a/icd/common/icd.h
+++ b/icd/common/icd.h
@@ -1,5 +1,5 @@
 /*
- * XGL
+ * Vulkan
  *
  * Copyright (C) 2014 LunarG, Inc.
  *
@@ -28,17 +28,17 @@
 #ifndef ICD_H
 #define ICD_H
 
-#include <xgl.h>
-#include <xglPlatform.h>
-#include <xglDbg.h>
+#include <vulkan.h>
+#include <vkPlatform.h>
+#include <vkDbg.h>
 
 #if defined(PLATFORM_LINUX)
 
-#include <xglWsiX11Ext.h>
+#include <vkWsiX11Ext.h>
 
 #else
 
-#include <xglWsiWinExt.h>
+#include <vkWsiWinExt.h>
 
 #endif