aboutsummaryrefslogtreecommitdiff
path: root/icd
diff options
context:
space:
mode:
authorCourtney Goeltzenleuchter <courtney@LunarG.com>2015-04-08 15:36:08 -0600
committerChia-I Wu <olv@lunarg.com>2015-04-16 17:48:17 +0800
commita4131c4e8a3027dbda941e43992fa2435801247e (patch)
tree9b2d3b1526d31d16e3a57c5ff096794cd835b44f /icd
parent63b889ec0ae38e1ba1db8e1970f934caef51ce9e (diff)
downloadusermoji-a4131c4e8a3027dbda941e43992fa2435801247e.tar.xz
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)
Diffstat (limited to 'icd')
-rw-r--r--icd/README.md18
-rw-r--r--icd/common/icd-enumerate-drm.c12
-rw-r--r--icd/common/icd-enumerate-drm.h2
-rw-r--r--icd/common/icd-format.c996
-rw-r--r--icd/common/icd-format.h42
-rw-r--r--icd/common/icd-instance.c60
-rw-r--r--icd/common/icd-instance.h30
-rw-r--r--icd/common/icd-spv.h2
-rw-r--r--icd/common/icd-utils.c2
-rw-r--r--icd/common/icd-utils.h2
-rw-r--r--icd/common/icd.h12
-rw-r--r--icd/nulldrv/CMakeLists.txt2
-rw-r--r--icd/nulldrv/README.md4
-rw-r--r--icd/nulldrv/XGL_nulldrv.def12
-rw-r--r--icd/nulldrv/nulldrv.c1388
-rw-r--r--icd/nulldrv/nulldrv.h26
16 files changed, 1305 insertions, 1305 deletions
diff --git a/icd/README.md b/icd/README.md
index 2c0b009a..bec64cda 100644
--- a/icd/README.md
+++ b/icd/README.md
@@ -3,12 +3,12 @@ This sample driver implementation provide multiple subcomponents required to bui
- [Implementation for Intel GPUs](intel)
- [Null driver](nulldrv)
- [*Sample Driver Tests*](../tests)
- - Now includes Golden images to verify xgl_render_tests rendering.
+ - Now includes Golden images to verify vk_render_tests rendering.
-common/ provides helper and utility functions, as well as all XGL entry points
-except xglInitAndEnumerateGpus. Hardware drivers are required to provide that
-function, and to embed a "XGL_LAYER_DISPATCH_TABLE *" as the first member of
-XGL_PHYSICAL_GPU and all XGL_BASE_OBJECT.
+common/ provides helper and utility functions, as well as all VK entry points
+except vkInitAndEnumerateGpus. Hardware drivers are required to provide that
+function, and to embed a "VK_LAYER_DISPATCH_TABLE *" as the first member of
+VK_PHYSICAL_GPU and all VK_BASE_OBJECT.
Thread safety
@@ -20,7 +20,7 @@ Thread safety
They require that there is no other thread calling the ICD when these
functions are called
- - xglInitAndEnumerateGpus
- - xglDbgRegisterMsgCallback
- - xglDbgUnregisterMsgCallback
- - xglDbgSetGlobalOption
+ - vkInitAndEnumerateGpus
+ - vkDbgRegisterMsgCallback
+ - vkDbgUnregisterMsgCallback
+ - vkDbgSetGlobalOption
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
diff --git a/icd/nulldrv/CMakeLists.txt b/icd/nulldrv/CMakeLists.txt
index a0686d35..45a82b65 100644
--- a/icd/nulldrv/CMakeLists.txt
+++ b/icd/nulldrv/CMakeLists.txt
@@ -1,6 +1,6 @@
# Create the nulldrv XGL DRI library
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DXGL_PROTOTYPES")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DVK_PROTOTYPES")
add_custom_command(OUTPUT nulldrv_gpa.c
COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/xgl-generate.py icd-get-proc-addr > nulldrv_gpa.c
diff --git a/icd/nulldrv/README.md b/icd/nulldrv/README.md
index 0772b7bd..448d517b 100644
--- a/icd/nulldrv/README.md
+++ b/icd/nulldrv/README.md
@@ -1,3 +1,3 @@
-# Null XGL Driver
+# Null VK Driver
-This directory provides a null XGL driver
+This directory provides a null VK driver
diff --git a/icd/nulldrv/XGL_nulldrv.def b/icd/nulldrv/XGL_nulldrv.def
index 1f5d7157..792fe6dd 100644
--- a/icd/nulldrv/XGL_nulldrv.def
+++ b/icd/nulldrv/XGL_nulldrv.def
@@ -1,5 +1,5 @@
;;;; Begin Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-; XGL
+; VK
;
; Copyright (C) 2015 LunarG, Inc.
;
@@ -24,12 +24,12 @@
; The following is required on Windows, for exporting symbols from the DLL
-LIBRARY XGL_nulldrv
+LIBRARY VK_nulldrv
EXPORTS
- xglGetProcAddr
- xglCreateInstance
- xglEnumerateGpus
- xglDestroyInstance
+ vkGetProcAddr
+ vkCreateInstance
+ vkEnumerateGpus
+ vkDestroyInstance
xcbCreateWindow
xcbDestroyWindow
xcbGetMessage
diff --git a/icd/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c
index 0769fc83..55b5f2d4 100644
--- a/icd/nulldrv/nulldrv.c
+++ b/icd/nulldrv/nulldrv.c
@@ -1,5 +1,5 @@
/*
- * XGL null driver
+ * Vulkan null driver
*
* Copyright (C) 2015 LunarG, Inc.
*
@@ -40,57 +40,57 @@
// The null driver supports all WSI extenstions ... for now ...
static const char * const nulldrv_gpu_exts[NULLDRV_EXT_COUNT] = {
- [NULLDRV_EXT_WSI_X11] = "XGL_WSI_X11",
- [NULLDRV_EXT_WSI_WINDOWS] = "XGL_WSI_WINDOWS"
+ [NULLDRV_EXT_WSI_X11] = "VK_WSI_X11",
+ [NULLDRV_EXT_WSI_WINDOWS] = "VK_WSI_WINDOWS"
};
-static struct nulldrv_base *nulldrv_base(XGL_BASE_OBJECT base)
+static struct nulldrv_base *nulldrv_base(VK_BASE_OBJECT base)
{
return (struct nulldrv_base *) base;
}
-static XGL_RESULT nulldrv_base_get_info(struct nulldrv_base *base, int type,
+static VK_RESULT nulldrv_base_get_info(struct nulldrv_base *base, int type,
size_t *size, void *data)
{
- XGL_RESULT ret = XGL_SUCCESS;
+ VK_RESULT ret = VK_SUCCESS;
size_t s;
uint32_t *count;
switch (type) {
- case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+ case VK_INFO_TYPE_MEMORY_REQUIREMENTS:
{
- XGL_MEMORY_REQUIREMENTS *mem_req = data;
- s = sizeof(XGL_MEMORY_REQUIREMENTS);
+ VK_MEMORY_REQUIREMENTS *mem_req = data;
+ s = sizeof(VK_MEMORY_REQUIREMENTS);
*size = s;
if (data == NULL)
return ret;
memset(data, 0, s);
- mem_req->memType = XGL_MEMORY_TYPE_OTHER;
+ mem_req->memType = VK_MEMORY_TYPE_OTHER;
break;
}
- case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
+ case VK_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
*size = sizeof(uint32_t);
if (data == NULL)
return ret;
count = (uint32_t *) data;
*count = 1;
break;
- case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
- s = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
+ case VK_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
+ s = sizeof(VK_IMAGE_MEMORY_REQUIREMENTS);
*size = s;
if (data == NULL)
return ret;
memset(data, 0, s);
break;
- case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
- s = sizeof(XGL_BUFFER_MEMORY_REQUIREMENTS);
+ case VK_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
+ s = sizeof(VK_BUFFER_MEMORY_REQUIREMENTS);
*size = s;
if (data == NULL)
return ret;
memset(data, 0, s);
break;
default:
- ret = XGL_ERROR_INVALID_VALUE;
+ ret = VK_ERROR_INVALID_VALUE;
break;
}
@@ -99,7 +99,7 @@ static XGL_RESULT nulldrv_base_get_info(struct nulldrv_base *base, int type,
static struct nulldrv_base *nulldrv_base_create(struct nulldrv_dev *dev,
size_t obj_size,
- XGL_DBG_OBJECT_TYPE type)
+ VK_DBG_OBJECT_TYPE type)
{
struct nulldrv_base *base;
@@ -131,14 +131,14 @@ static struct nulldrv_base *nulldrv_base_create(struct nulldrv_dev *dev,
return base;
}
-static XGL_RESULT nulldrv_gpu_add(int devid, const char *primary_node,
+static VK_RESULT nulldrv_gpu_add(int devid, const char *primary_node,
const char *render_node, struct nulldrv_gpu **gpu_ret)
{
struct nulldrv_gpu *gpu;
gpu = malloc(sizeof(*gpu));
if (!gpu)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
memset(gpu, 0, sizeof(*gpu));
// Initialize pointer to loader's dispatch table with ICD_LOADER_MAGIC
@@ -146,54 +146,54 @@ static XGL_RESULT nulldrv_gpu_add(int devid, const char *primary_node,
*gpu_ret = gpu;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-static XGL_RESULT nulldrv_queue_create(struct nulldrv_dev *dev,
+static VK_RESULT nulldrv_queue_create(struct nulldrv_dev *dev,
uint32_t node_index,
struct nulldrv_queue **queue_ret)
{
struct nulldrv_queue *queue;
queue = (struct nulldrv_queue *) nulldrv_base_create(dev, sizeof(*queue),
- XGL_DBG_OBJECT_QUEUE);
+ VK_DBG_OBJECT_QUEUE);
if (!queue)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
queue->dev = dev;
*queue_ret = queue;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-static XGL_RESULT dev_create_queues(struct nulldrv_dev *dev,
- const XGL_DEVICE_QUEUE_CREATE_INFO *queues,
+static VK_RESULT dev_create_queues(struct nulldrv_dev *dev,
+ const VK_DEVICE_QUEUE_CREATE_INFO *queues,
uint32_t count)
{
uint32_t i;
if (!count)
- return XGL_ERROR_INVALID_POINTER;
+ return VK_ERROR_INVALID_POINTER;
for (i = 0; i < count; i++) {
- const XGL_DEVICE_QUEUE_CREATE_INFO *q = &queues[i];
- XGL_RESULT ret = XGL_SUCCESS;
+ const VK_DEVICE_QUEUE_CREATE_INFO *q = &queues[i];
+ VK_RESULT ret = VK_SUCCESS;
if (q->queueCount == 1 && !dev->queues[q->queueNodeIndex]) {
ret = nulldrv_queue_create(dev, q->queueNodeIndex,
&dev->queues[q->queueNodeIndex]);
}
else {
- ret = XGL_ERROR_INVALID_POINTER;
+ ret = VK_ERROR_INVALID_POINTER;
}
- if (ret != XGL_SUCCESS) {
+ if (ret != VK_SUCCESS) {
return ret;
}
}
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
static enum nulldrv_ext_type nulldrv_gpu_lookup_extension(const struct nulldrv_gpu *gpu,
@@ -211,14 +211,14 @@ static enum nulldrv_ext_type nulldrv_gpu_lookup_extension(const struct nulldrv_g
return type;
}
-static XGL_RESULT nulldrv_desc_ooxx_create(struct nulldrv_dev *dev,
+static VK_RESULT nulldrv_desc_ooxx_create(struct nulldrv_dev *dev,
struct nulldrv_desc_ooxx **ooxx_ret)
{
struct nulldrv_desc_ooxx *ooxx;
ooxx = malloc(sizeof(*ooxx));
if (!ooxx)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
memset(ooxx, 0, sizeof(*ooxx));
@@ -227,86 +227,86 @@ static XGL_RESULT nulldrv_desc_ooxx_create(struct nulldrv_dev *dev,
*ooxx_ret = ooxx;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-static XGL_RESULT nulldrv_dev_create(struct nulldrv_gpu *gpu,
- const XGL_DEVICE_CREATE_INFO *info,
+static VK_RESULT nulldrv_dev_create(struct nulldrv_gpu *gpu,
+ const VK_DEVICE_CREATE_INFO *info,
struct nulldrv_dev **dev_ret)
{
struct nulldrv_dev *dev;
uint32_t i;
- XGL_RESULT ret;
+ VK_RESULT ret;
dev = (struct nulldrv_dev *) nulldrv_base_create(NULL, sizeof(*dev),
- XGL_DBG_OBJECT_DEVICE);
+ VK_DBG_OBJECT_DEVICE);
if (!dev)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
for (i = 0; i < info->extensionCount; i++) {
const enum nulldrv_ext_type ext = nulldrv_gpu_lookup_extension(gpu,
info->ppEnabledExtensionNames[i]);
if (ext == NULLDRV_EXT_INVALID)
- return XGL_ERROR_INVALID_EXTENSION;
+ return VK_ERROR_INVALID_EXTENSION;
dev->exts[ext] = true;
}
ret = nulldrv_desc_ooxx_create(dev, &dev->desc_ooxx);
- if (ret != XGL_SUCCESS) {
+ if (ret != VK_SUCCESS) {
return ret;
}
ret = dev_create_queues(dev, info->pRequestedQueues,
info->queueRecordCount);
- if (ret != XGL_SUCCESS) {
+ if (ret != VK_SUCCESS) {
return ret;
}
*dev_ret = dev;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-static struct nulldrv_gpu *nulldrv_gpu(XGL_PHYSICAL_GPU gpu)
+static struct nulldrv_gpu *nulldrv_gpu(VK_PHYSICAL_GPU gpu)
{
return (struct nulldrv_gpu *) gpu;
}
-static XGL_RESULT nulldrv_rt_view_create(struct nulldrv_dev *dev,
- const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO *info,
+static VK_RESULT nulldrv_rt_view_create(struct nulldrv_dev *dev,
+ const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO *info,
struct nulldrv_rt_view **view_ret)
{
struct nulldrv_rt_view *view;
view = (struct nulldrv_rt_view *) nulldrv_base_create(dev, sizeof(*view),
- XGL_DBG_OBJECT_COLOR_TARGET_VIEW);
+ VK_DBG_OBJECT_COLOR_TARGET_VIEW);
if (!view)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
*view_ret = view;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-static XGL_RESULT nulldrv_fence_create(struct nulldrv_dev *dev,
- const XGL_FENCE_CREATE_INFO *info,
+static VK_RESULT nulldrv_fence_create(struct nulldrv_dev *dev,
+ const VK_FENCE_CREATE_INFO *info,
struct nulldrv_fence **fence_ret)
{
struct nulldrv_fence *fence;
fence = (struct nulldrv_fence *) nulldrv_base_create(dev, sizeof(*fence),
- XGL_DBG_OBJECT_FENCE);
+ VK_DBG_OBJECT_FENCE);
if (!fence)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
*fence_ret = fence;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-static struct nulldrv_dev *nulldrv_dev(XGL_DEVICE dev)
+static struct nulldrv_dev *nulldrv_dev(VK_DEVICE dev)
{
return (struct nulldrv_dev *) dev;
}
@@ -317,30 +317,30 @@ static struct nulldrv_img *nulldrv_img_from_base(struct nulldrv_base *base)
}
-static XGL_RESULT img_get_info(struct nulldrv_base *base, int type,
+static VK_RESULT img_get_info(struct nulldrv_base *base, int type,
size_t *size, void *data)
{
struct nulldrv_img *img = nulldrv_img_from_base(base);
- XGL_RESULT ret = XGL_SUCCESS;
+ VK_RESULT ret = VK_SUCCESS;
switch (type) {
- case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+ case VK_INFO_TYPE_MEMORY_REQUIREMENTS:
{
- XGL_MEMORY_REQUIREMENTS *mem_req = data;
+ VK_MEMORY_REQUIREMENTS *mem_req = data;
- *size = sizeof(XGL_MEMORY_REQUIREMENTS);
+ *size = sizeof(VK_MEMORY_REQUIREMENTS);
if (data == NULL)
return ret;
mem_req->size = img->total_size;
mem_req->alignment = 4096;
- mem_req->memType = XGL_MEMORY_TYPE_IMAGE;
+ mem_req->memType = VK_MEMORY_TYPE_IMAGE;
}
break;
- case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
+ case VK_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
{
- XGL_IMAGE_MEMORY_REQUIREMENTS *img_req = data;
+ VK_IMAGE_MEMORY_REQUIREMENTS *img_req = data;
- *size = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
+ *size = sizeof(VK_IMAGE_MEMORY_REQUIREMENTS);
if (data == NULL)
return ret;
img_req->usage = img->usage;
@@ -348,11 +348,11 @@ static XGL_RESULT img_get_info(struct nulldrv_base *base, int type,
img_req->samples = img->samples;
}
break;
- case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
+ case VK_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
{
- XGL_BUFFER_MEMORY_REQUIREMENTS *buf_req = data;
+ VK_BUFFER_MEMORY_REQUIREMENTS *buf_req = data;
- *size = sizeof(XGL_BUFFER_MEMORY_REQUIREMENTS);
+ *size = sizeof(VK_BUFFER_MEMORY_REQUIREMENTS);
if (data == NULL)
return ret;
buf_req->usage = img->usage;
@@ -366,25 +366,25 @@ static XGL_RESULT img_get_info(struct nulldrv_base *base, int type,
return ret;
}
-static XGL_RESULT nulldrv_img_create(struct nulldrv_dev *dev,
- const XGL_IMAGE_CREATE_INFO *info,
+static VK_RESULT nulldrv_img_create(struct nulldrv_dev *dev,
+ const VK_IMAGE_CREATE_INFO *info,
bool scanout,
struct nulldrv_img **img_ret)
{
struct nulldrv_img *img;
img = (struct nulldrv_img *) nulldrv_base_create(dev, sizeof(*img),
- XGL_DBG_OBJECT_IMAGE);
+ VK_DBG_OBJECT_IMAGE);
if (!img)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
img->type = info->imageType;
img->depth = info->extent.depth;
img->mip_levels = info->mipLevels;
img->array_size = info->arraySize;
img->usage = info->usage;
- if (info->tiling == XGL_LINEAR_TILING)
- img->format_class = XGL_IMAGE_FORMAT_CLASS_LINEAR;
+ if (info->tiling == VK_LINEAR_TILING)
+ img->format_class = VK_IMAGE_FORMAT_CLASS_LINEAR;
else
img->format_class = icd_format_get_class(info->format);
img->samples = info->samples;
@@ -393,48 +393,48 @@ static XGL_RESULT nulldrv_img_create(struct nulldrv_dev *dev,
*img_ret = img;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-static struct nulldrv_img *nulldrv_img(XGL_IMAGE image)
+static struct nulldrv_img *nulldrv_img(VK_IMAGE image)
{
return (struct nulldrv_img *) image;
}
-static XGL_RESULT nulldrv_mem_alloc(struct nulldrv_dev *dev,
- const XGL_MEMORY_ALLOC_INFO *info,
+static VK_RESULT nulldrv_mem_alloc(struct nulldrv_dev *dev,
+ const VK_MEMORY_ALLOC_INFO *info,
struct nulldrv_mem **mem_ret)
{
struct nulldrv_mem *mem;
mem = (struct nulldrv_mem *) nulldrv_base_create(dev, sizeof(*mem),
- XGL_DBG_OBJECT_GPU_MEMORY);
+ VK_DBG_OBJECT_GPU_MEMORY);
if (!mem)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
mem->bo = malloc(info->allocationSize);
if (!mem->bo) {
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
}
mem->size = info->allocationSize;
*mem_ret = mem;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-static XGL_RESULT nulldrv_ds_view_create(struct nulldrv_dev *dev,
- const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO *info,
+static VK_RESULT nulldrv_ds_view_create(struct nulldrv_dev *dev,
+ const VK_DEPTH_STENCIL_VIEW_CREATE_INFO *info,
struct nulldrv_ds_view **view_ret)
{
struct nulldrv_img *img = nulldrv_img(info->image);
struct nulldrv_ds_view *view;
view = (struct nulldrv_ds_view *) nulldrv_base_create(dev, sizeof(*view),
- XGL_DBG_OBJECT_DEPTH_STENCIL_VIEW);
+ VK_DBG_OBJECT_DEPTH_STENCIL_VIEW);
if (!view)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
view->img = img;
@@ -442,36 +442,36 @@ static XGL_RESULT nulldrv_ds_view_create(struct nulldrv_dev *dev,
*view_ret = view;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-static XGL_RESULT nulldrv_sampler_create(struct nulldrv_dev *dev,
- const XGL_SAMPLER_CREATE_INFO *info,
+static VK_RESULT nulldrv_sampler_create(struct nulldrv_dev *dev,
+ const VK_SAMPLER_CREATE_INFO *info,
struct nulldrv_sampler **sampler_ret)
{
struct nulldrv_sampler *sampler;
sampler = (struct nulldrv_sampler *) nulldrv_base_create(dev,
- sizeof(*sampler), XGL_DBG_OBJECT_SAMPLER);
+ sizeof(*sampler), VK_DBG_OBJECT_SAMPLER);
if (!sampler)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
*sampler_ret = sampler;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-static XGL_RESULT nulldrv_img_view_create(struct nulldrv_dev *dev,
- const XGL_IMAGE_VIEW_CREATE_INFO *info,
+static VK_RESULT nulldrv_img_view_create(struct nulldrv_dev *dev,
+ const VK_IMAGE_VIEW_CREATE_INFO *info,
struct nulldrv_img_view **view_ret)
{
struct nulldrv_img *img = nulldrv_img(info->image);
struct nulldrv_img_view *view;
view = (struct nulldrv_img_view *) nulldrv_base_create(dev, sizeof(*view),
- XGL_DBG_OBJECT_IMAGE_VIEW);
+ VK_DBG_OBJECT_IMAGE_VIEW);
if (!view)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
view->img = img;
view->min_lod = info->minLod;
@@ -480,15 +480,15 @@ static XGL_RESULT nulldrv_img_view_create(struct nulldrv_dev *dev,
*view_ret = view;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-static void *nulldrv_mem_map(struct nulldrv_mem *mem, XGL_FLAGS flags)
+static void *nulldrv_mem_map(struct nulldrv_mem *mem, VK_FLAGS flags)
{
return mem->bo;
}
-static struct nulldrv_mem *nulldrv_mem(XGL_GPU_MEMORY mem)
+static struct nulldrv_mem *nulldrv_mem(VK_GPU_MEMORY mem)
{
return (struct nulldrv_mem *) mem;
}
@@ -498,32 +498,32 @@ static struct nulldrv_buf *nulldrv_buf_from_base(struct nulldrv_base *base)
return (struct nulldrv_buf *) base;
}
-static XGL_RESULT buf_get_info(struct nulldrv_base *base, int type,
+static VK_RESULT buf_get_info(struct nulldrv_base *base, int type,
size_t *size, void *data)
{
struct nulldrv_buf *buf = nulldrv_buf_from_base(base);
- XGL_RESULT ret = XGL_SUCCESS;
+ VK_RESULT ret = VK_SUCCESS;
switch (type) {
- case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+ case VK_INFO_TYPE_MEMORY_REQUIREMENTS:
{
- XGL_MEMORY_REQUIREMENTS *mem_req = data;
+ VK_MEMORY_REQUIREMENTS *mem_req = data;
- *size = sizeof(XGL_MEMORY_REQUIREMENTS);
+ *size = sizeof(VK_MEMORY_REQUIREMENTS);
if (data == NULL)
return ret;
mem_req->size = buf->size;
mem_req->alignment = 4096;
- mem_req->memType = XGL_MEMORY_TYPE_BUFFER;
+ mem_req->memType = VK_MEMORY_TYPE_BUFFER;
}
break;
- case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
+ case VK_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
{
- XGL_BUFFER_MEMORY_REQUIREMENTS *buf_req = data;
+ VK_BUFFER_MEMORY_REQUIREMENTS *buf_req = data;
- *size = sizeof(XGL_BUFFER_MEMORY_REQUIREMENTS);
+ *size = sizeof(VK_BUFFER_MEMORY_REQUIREMENTS);
if (data == NULL)
return ret;
buf_req->usage = buf->usage;
@@ -537,16 +537,16 @@ static XGL_RESULT buf_get_info(struct nulldrv_base *base, int type,
return ret;
}
-static XGL_RESULT nulldrv_buf_create(struct nulldrv_dev *dev,
- const XGL_BUFFER_CREATE_INFO *info,
+static VK_RESULT nulldrv_buf_create(struct nulldrv_dev *dev,
+ const VK_BUFFER_CREATE_INFO *info,
struct nulldrv_buf **buf_ret)
{
struct nulldrv_buf *buf;
buf = (struct nulldrv_buf *) nulldrv_base_create(dev, sizeof(*buf),
- XGL_DBG_OBJECT_BUFFER);
+ VK_DBG_OBJECT_BUFFER);
if (!buf)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
buf->size = info->size;
buf->usage = info->usage;
@@ -555,187 +555,187 @@ static XGL_RESULT nulldrv_buf_create(struct nulldrv_dev *dev,
*buf_ret = buf;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-static XGL_RESULT nulldrv_desc_layout_create(struct nulldrv_dev *dev,
- const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO *info,
+static VK_RESULT nulldrv_desc_layout_create(struct nulldrv_dev *dev,
+ const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO *info,
struct nulldrv_desc_layout **layout_ret)
{
struct nulldrv_desc_layout *layout;
layout = (struct nulldrv_desc_layout *)
nulldrv_base_create(dev, sizeof(*layout),
- XGL_DBG_OBJECT_DESCRIPTOR_SET_LAYOUT);
+ VK_DBG_OBJECT_DESCRIPTOR_SET_LAYOUT);
if (!layout)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
*layout_ret = layout;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-static XGL_RESULT nulldrv_desc_layout_chain_create(struct nulldrv_dev *dev,
+static VK_RESULT nulldrv_desc_layout_chain_create(struct nulldrv_dev *dev,
uint32_t setLayoutArrayCount,
- const XGL_DESCRIPTOR_SET_LAYOUT *pSetLayoutArray,
+ const VK_DESCRIPTOR_SET_LAYOUT *pSetLayoutArray,
struct nulldrv_desc_layout_chain **chain_ret)
{
struct nulldrv_desc_layout_chain *chain;
chain = (struct nulldrv_desc_layout_chain *)
nulldrv_base_create(dev, sizeof(*chain),
- XGL_DBG_OBJECT_DESCRIPTOR_SET_LAYOUT_CHAIN);
+ VK_DBG_OBJECT_DESCRIPTOR_SET_LAYOUT_CHAIN);
if (!chain)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
*chain_ret = chain;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-static struct nulldrv_desc_layout *nulldrv_desc_layout(XGL_DESCRIPTOR_SET_LAYOUT layout)
+static struct nulldrv_desc_layout *nulldrv_desc_layout(VK_DESCRIPTOR_SET_LAYOUT layout)
{
return (struct nulldrv_desc_layout *) layout;
}
-static XGL_RESULT shader_create(struct nulldrv_dev *dev,
- const XGL_SHADER_CREATE_INFO *info,
+static VK_RESULT shader_create(struct nulldrv_dev *dev,
+ const VK_SHADER_CREATE_INFO *info,
struct nulldrv_shader **sh_ret)
{
struct nulldrv_shader *sh;
sh = (struct nulldrv_shader *) nulldrv_base_create(dev, sizeof(*sh),
- XGL_DBG_OBJECT_SHADER);
+ VK_DBG_OBJECT_SHADER);
if (!sh)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
*sh_ret = sh;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-static XGL_RESULT graphics_pipeline_create(struct nulldrv_dev *dev,
- const XGL_GRAPHICS_PIPELINE_CREATE_INFO *info_,
+static VK_RESULT graphics_pipeline_create(struct nulldrv_dev *dev,
+ const VK_GRAPHICS_PIPELINE_CREATE_INFO *info_,
struct nulldrv_pipeline **pipeline_ret)
{
struct nulldrv_pipeline *pipeline;
pipeline = (struct nulldrv_pipeline *)
nulldrv_base_create(dev, sizeof(*pipeline),
- XGL_DBG_OBJECT_GRAPHICS_PIPELINE);
+ VK_DBG_OBJECT_GRAPHICS_PIPELINE);
if (!pipeline)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
*pipeline_ret = pipeline;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-static XGL_RESULT nulldrv_viewport_state_create(struct nulldrv_dev *dev,
- const XGL_DYNAMIC_VP_STATE_CREATE_INFO *info,
+static VK_RESULT nulldrv_viewport_state_create(struct nulldrv_dev *dev,
+ const VK_DYNAMIC_VP_STATE_CREATE_INFO *info,
struct nulldrv_dynamic_vp **state_ret)
{
struct nulldrv_dynamic_vp *state;
state = (struct nulldrv_dynamic_vp *) nulldrv_base_create(dev,
- sizeof(*state), XGL_DBG_OBJECT_VIEWPORT_STATE);
+ sizeof(*state), VK_DBG_OBJECT_VIEWPORT_STATE);
if (!state)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
*state_ret = state;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-static XGL_RESULT nulldrv_raster_state_create(struct nulldrv_dev *dev,
- const XGL_DYNAMIC_RS_STATE_CREATE_INFO *info,
+static VK_RESULT nulldrv_raster_state_create(struct nulldrv_dev *dev,
+ const VK_DYNAMIC_RS_STATE_CREATE_INFO *info,
struct nulldrv_dynamic_rs **state_ret)
{
struct nulldrv_dynamic_rs *state;
state = (struct nulldrv_dynamic_rs *) nulldrv_base_create(dev,
- sizeof(*state), XGL_DBG_OBJECT_RASTER_STATE);
+ sizeof(*state), VK_DBG_OBJECT_RASTER_STATE);
if (!state)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
*state_ret = state;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-static XGL_RESULT nulldrv_blend_state_create(struct nulldrv_dev *dev,
- const XGL_DYNAMIC_CB_STATE_CREATE_INFO *info,
+static VK_RESULT nulldrv_blend_state_create(struct nulldrv_dev *dev,
+ const VK_DYNAMIC_CB_STATE_CREATE_INFO *info,
struct nulldrv_dynamic_cb **state_ret)
{
struct nulldrv_dynamic_cb *state;
state = (struct nulldrv_dynamic_cb *) nulldrv_base_create(dev,
- sizeof(*state), XGL_DBG_OBJECT_COLOR_BLEND_STATE);
+ sizeof(*state), VK_DBG_OBJECT_COLOR_BLEND_STATE);
if (!state)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
*state_ret = state;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-static XGL_RESULT nulldrv_ds_state_create(struct nulldrv_dev *dev,
- const XGL_DYNAMIC_DS_STATE_CREATE_INFO *info,
+static VK_RESULT nulldrv_ds_state_create(struct nulldrv_dev *dev,
+ const VK_DYNAMIC_DS_STATE_CREATE_INFO *info,
struct nulldrv_dynamic_ds **state_ret)
{
struct nulldrv_dynamic_ds *state;
state = (struct nulldrv_dynamic_ds *) nulldrv_base_create(dev,
- sizeof(*state), XGL_DBG_OBJECT_DEPTH_STENCIL_STATE);
+ sizeof(*state), VK_DBG_OBJECT_DEPTH_STENCIL_STATE);
if (!state)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
*state_ret = state;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-static XGL_RESULT nulldrv_cmd_create(struct nulldrv_dev *dev,
- const XGL_CMD_BUFFER_CREATE_INFO *info,
+static VK_RESULT nulldrv_cmd_create(struct nulldrv_dev *dev,
+ const VK_CMD_BUFFER_CREATE_INFO *info,
struct nulldrv_cmd **cmd_ret)
{
struct nulldrv_cmd *cmd;
cmd = (struct nulldrv_cmd *) nulldrv_base_create(dev, sizeof(*cmd),
- XGL_DBG_OBJECT_CMD_BUFFER);
+ VK_DBG_OBJECT_CMD_BUFFER);
if (!cmd)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
*cmd_ret = cmd;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-static XGL_RESULT nulldrv_desc_pool_create(struct nulldrv_dev *dev,
- XGL_DESCRIPTOR_POOL_USAGE usage,
+static VK_RESULT nulldrv_desc_pool_create(struct nulldrv_dev *dev,
+ VK_DESCRIPTOR_POOL_USAGE usage,
uint32_t max_sets,
- const XGL_DESCRIPTOR_POOL_CREATE_INFO *info,
+ const VK_DESCRIPTOR_POOL_CREATE_INFO *info,
struct nulldrv_desc_pool **pool_ret)
{
struct nulldrv_desc_pool *pool;
pool = (struct nulldrv_desc_pool *)
nulldrv_base_create(dev, sizeof(*pool),
- XGL_DBG_OBJECT_DESCRIPTOR_POOL);
+ VK_DBG_OBJECT_DESCRIPTOR_POOL);
if (!pool)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
pool->dev = dev;
*pool_ret = pool;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-static XGL_RESULT nulldrv_desc_set_create(struct nulldrv_dev *dev,
+static VK_RESULT nulldrv_desc_set_create(struct nulldrv_dev *dev,
struct nulldrv_desc_pool *pool,
- XGL_DESCRIPTOR_SET_USAGE usage,
+ VK_DESCRIPTOR_SET_USAGE usage,
const struct nulldrv_desc_layout *layout,
struct nulldrv_desc_set **set_ret)
{
@@ -743,76 +743,76 @@ static XGL_RESULT nulldrv_desc_set_create(struct nulldrv_dev *dev,
set = (struct nulldrv_desc_set *)
nulldrv_base_create(dev, sizeof(*set),
- XGL_DBG_OBJECT_DESCRIPTOR_SET);
+ VK_DBG_OBJECT_DESCRIPTOR_SET);
if (!set)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
set->ooxx = dev->desc_ooxx;
set->layout = layout;
*set_ret = set;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-static struct nulldrv_desc_pool *nulldrv_desc_pool(XGL_DESCRIPTOR_POOL pool)
+static struct nulldrv_desc_pool *nulldrv_desc_pool(VK_DESCRIPTOR_POOL pool)
{
return (struct nulldrv_desc_pool *) pool;
}
-static XGL_RESULT nulldrv_fb_create(struct nulldrv_dev *dev,
- const XGL_FRAMEBUFFER_CREATE_INFO* info,
+static VK_RESULT nulldrv_fb_create(struct nulldrv_dev *dev,
+ const VK_FRAMEBUFFER_CREATE_INFO* info,
struct nulldrv_framebuffer ** fb_ret)
{
struct nulldrv_framebuffer *fb;
fb = (struct nulldrv_framebuffer *) nulldrv_base_create(dev, sizeof(*fb),
- XGL_DBG_OBJECT_FRAMEBUFFER);
+ VK_DBG_OBJECT_FRAMEBUFFER);
if (!fb)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
*fb_ret = fb;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-static XGL_RESULT nulldrv_render_pass_create(struct nulldrv_dev *dev,
- const XGL_RENDER_PASS_CREATE_INFO* info,
+static VK_RESULT nulldrv_render_pass_create(struct nulldrv_dev *dev,
+ const VK_RENDER_PASS_CREATE_INFO* info,
struct nulldrv_render_pass** rp_ret)
{
struct nulldrv_render_pass *rp;
rp = (struct nulldrv_render_pass *) nulldrv_base_create(dev, sizeof(*rp),
- XGL_DBG_OBJECT_RENDER_PASS);
+ VK_DBG_OBJECT_RENDER_PASS);
if (!rp)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
*rp_ret = rp;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-static struct nulldrv_buf *nulldrv_buf(XGL_BUFFER buf)
+static struct nulldrv_buf *nulldrv_buf(VK_BUFFER buf)
{
return (struct nulldrv_buf *) buf;
}
-static XGL_RESULT nulldrv_buf_view_create(struct nulldrv_dev *dev,
- const XGL_BUFFER_VIEW_CREATE_INFO *info,
+static VK_RESULT nulldrv_buf_view_create(struct nulldrv_dev *dev,
+ const VK_BUFFER_VIEW_CREATE_INFO *info,
struct nulldrv_buf_view **view_ret)
{
struct nulldrv_buf *buf = nulldrv_buf(info->buffer);
struct nulldrv_buf_view *view;
view = (struct nulldrv_buf_view *) nulldrv_base_create(dev, sizeof(*view),
- XGL_DBG_OBJECT_BUFFER_VIEW);
+ VK_DBG_OBJECT_BUFFER_VIEW);
if (!view)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
view->buf = buf;
*view_ret = view;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
@@ -820,10 +820,10 @@ static XGL_RESULT nulldrv_buf_view_create(struct nulldrv_dev *dev,
// Driver entry points
//*********************************************
-ICD_EXPORT XGL_RESULT XGLAPI xglCreateBuffer(
- XGL_DEVICE device,
- const XGL_BUFFER_CREATE_INFO* pCreateInfo,
- XGL_BUFFER* pBuffer)
+ICD_EXPORT VK_RESULT VKAPI vkCreateBuffer(
+ VK_DEVICE device,
+ const VK_BUFFER_CREATE_INFO* pCreateInfo,
+ VK_BUFFER* pBuffer)
{
NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
@@ -831,10 +831,10 @@ ICD_EXPORT XGL_RESULT XGLAPI xglCreateBuffer(
return nulldrv_buf_create(dev, pCreateInfo, (struct nulldrv_buf **) pBuffer);
}
-ICD_EXPORT XGL_RESULT XGLAPI xglCreateCommandBuffer(
- XGL_DEVICE device,
- const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo,
- XGL_CMD_BUFFER* pCmdBuffer)
+ICD_EXPORT VK_RESULT VKAPI vkCreateCommandBuffer(
+ VK_DEVICE device,
+ const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo,
+ VK_CMD_BUFFER* pCmdBuffer)
{
NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
@@ -843,31 +843,31 @@ ICD_EXPORT XGL_RESULT XGLAPI xglCreateCommandBuffer(
(struct nulldrv_cmd **) pCmdBuffer);
}
-ICD_EXPORT XGL_RESULT XGLAPI xglBeginCommandBuffer(
- XGL_CMD_BUFFER cmdBuffer,
- const XGL_CMD_BUFFER_BEGIN_INFO *info)
+ICD_EXPORT VK_RESULT VKAPI vkBeginCommandBuffer(
+ VK_CMD_BUFFER cmdBuffer,
+ const VK_CMD_BUFFER_BEGIN_INFO *info)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglEndCommandBuffer(
- XGL_CMD_BUFFER cmdBuffer)
+ICD_EXPORT VK_RESULT VKAPI vkEndCommandBuffer(
+ VK_CMD_BUFFER cmdBuffer)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglResetCommandBuffer(
- XGL_CMD_BUFFER cmdBuffer)
+ICD_EXPORT VK_RESULT VKAPI vkResetCommandBuffer(
+ VK_CMD_BUFFER cmdBuffer)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT void XGLAPI xglCmdInitAtomicCounters(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ICD_EXPORT void VKAPI vkCmdInitAtomicCounters(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_PIPELINE_BIND_POINT pipelineBindPoint,
uint32_t startCounter,
uint32_t counterCount,
const uint32_t* pData)
@@ -875,261 +875,261 @@ ICD_EXPORT void XGLAPI xglCmdInitAtomicCounters(
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdLoadAtomicCounters(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ICD_EXPORT void VKAPI vkCmdLoadAtomicCounters(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_PIPELINE_BIND_POINT pipelineBindPoint,
uint32_t startCounter,
uint32_t counterCount,
- XGL_BUFFER srcBuffer,
- XGL_GPU_SIZE srcOffset)
+ VK_BUFFER srcBuffer,
+ VK_GPU_SIZE srcOffset)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdSaveAtomicCounters(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ICD_EXPORT void VKAPI vkCmdSaveAtomicCounters(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_PIPELINE_BIND_POINT pipelineBindPoint,
uint32_t startCounter,
uint32_t counterCount,
- XGL_BUFFER destBuffer,
- XGL_GPU_SIZE destOffset)
+ VK_BUFFER destBuffer,
+ VK_GPU_SIZE destOffset)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdDbgMarkerBegin(
- XGL_CMD_BUFFER cmdBuffer,
+ICD_EXPORT void VKAPI vkCmdDbgMarkerBegin(
+ VK_CMD_BUFFER cmdBuffer,
const char* pMarker)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdDbgMarkerEnd(
- XGL_CMD_BUFFER cmdBuffer)
+ICD_EXPORT void VKAPI vkCmdDbgMarkerEnd(
+ VK_CMD_BUFFER cmdBuffer)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdCopyBuffer(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_BUFFER srcBuffer,
- XGL_BUFFER destBuffer,
+ICD_EXPORT void VKAPI vkCmdCopyBuffer(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_BUFFER srcBuffer,
+ VK_BUFFER destBuffer,
uint32_t regionCount,
- const XGL_BUFFER_COPY* pRegions)
+ const VK_BUFFER_COPY* pRegions)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdCopyImage(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE srcImage,
- XGL_IMAGE_LAYOUT srcImageLayout,
- XGL_IMAGE destImage,
- XGL_IMAGE_LAYOUT destImageLayout,
+ICD_EXPORT void VKAPI vkCmdCopyImage(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_IMAGE srcImage,
+ VK_IMAGE_LAYOUT srcImageLayout,
+ VK_IMAGE destImage,
+ VK_IMAGE_LAYOUT destImageLayout,
uint32_t regionCount,
- const XGL_IMAGE_COPY* pRegions)
+ const VK_IMAGE_COPY* pRegions)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdBlitImage(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE srcImage,
- XGL_IMAGE_LAYOUT srcImageLayout,
- XGL_IMAGE destImage,
- XGL_IMAGE_LAYOUT destImageLayout,
+ICD_EXPORT void VKAPI vkCmdBlitImage(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_IMAGE srcImage,
+ VK_IMAGE_LAYOUT srcImageLayout,
+ VK_IMAGE destImage,
+ VK_IMAGE_LAYOUT destImageLayout,
uint32_t regionCount,
- const XGL_IMAGE_BLIT* pRegions)
+ const VK_IMAGE_BLIT* pRegions)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdCopyBufferToImage(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_BUFFER srcBuffer,
- XGL_IMAGE destImage,
- XGL_IMAGE_LAYOUT destImageLayout,
+ICD_EXPORT void VKAPI vkCmdCopyBufferToImage(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_BUFFER srcBuffer,
+ VK_IMAGE destImage,
+ VK_IMAGE_LAYOUT destImageLayout,
uint32_t regionCount,
- const XGL_BUFFER_IMAGE_COPY* pRegions)
+ const VK_BUFFER_IMAGE_COPY* pRegions)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdCopyImageToBuffer(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE srcImage,
- XGL_IMAGE_LAYOUT srcImageLayout,
- XGL_BUFFER destBuffer,
+ICD_EXPORT void VKAPI vkCmdCopyImageToBuffer(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_IMAGE srcImage,
+ VK_IMAGE_LAYOUT srcImageLayout,
+ VK_BUFFER destBuffer,
uint32_t regionCount,
- const XGL_BUFFER_IMAGE_COPY* pRegions)
+ const VK_BUFFER_IMAGE_COPY* pRegions)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdCloneImageData(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE srcImage,
- XGL_IMAGE_LAYOUT srcImageLayout,
- XGL_IMAGE destImage,
- XGL_IMAGE_LAYOUT destImageLayout)
+ICD_EXPORT void VKAPI vkCmdCloneImageData(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_IMAGE srcImage,
+ VK_IMAGE_LAYOUT srcImageLayout,
+ VK_IMAGE destImage,
+ VK_IMAGE_LAYOUT destImageLayout)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdUpdateBuffer(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_BUFFER destBuffer,
- XGL_GPU_SIZE destOffset,
- XGL_GPU_SIZE dataSize,
+ICD_EXPORT void VKAPI vkCmdUpdateBuffer(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_BUFFER destBuffer,
+ VK_GPU_SIZE destOffset,
+ VK_GPU_SIZE dataSize,
const uint32_t* pData)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdFillBuffer(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_BUFFER destBuffer,
- XGL_GPU_SIZE destOffset,
- XGL_GPU_SIZE fillSize,
+ICD_EXPORT void VKAPI vkCmdFillBuffer(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_BUFFER destBuffer,
+ VK_GPU_SIZE destOffset,
+ VK_GPU_SIZE fillSize,
uint32_t data)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdClearColorImage(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE image,
- XGL_IMAGE_LAYOUT imageLayout,
- XGL_CLEAR_COLOR color,
+ICD_EXPORT void VKAPI vkCmdClearColorImage(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_IMAGE image,
+ VK_IMAGE_LAYOUT imageLayout,
+ VK_CLEAR_COLOR color,
uint32_t rangeCount,
- const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+ const VK_IMAGE_SUBRESOURCE_RANGE* pRanges)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdClearDepthStencil(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE image,
- XGL_IMAGE_LAYOUT imageLayout,
+ICD_EXPORT void VKAPI vkCmdClearDepthStencil(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_IMAGE image,
+ VK_IMAGE_LAYOUT imageLayout,
float depth,
uint32_t stencil,
uint32_t rangeCount,
- const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+ const VK_IMAGE_SUBRESOURCE_RANGE* pRanges)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdResolveImage(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_IMAGE srcImage,
- XGL_IMAGE_LAYOUT srcImageLayout,
- XGL_IMAGE destImage,
- XGL_IMAGE_LAYOUT destImageLayout,
+ICD_EXPORT void VKAPI vkCmdResolveImage(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_IMAGE srcImage,
+ VK_IMAGE_LAYOUT srcImageLayout,
+ VK_IMAGE destImage,
+ VK_IMAGE_LAYOUT destImageLayout,
uint32_t rectCount,
- const XGL_IMAGE_RESOLVE* pRects)
+ const VK_IMAGE_RESOLVE* pRects)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdBeginQuery(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_QUERY_POOL queryPool,
+ICD_EXPORT void VKAPI vkCmdBeginQuery(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_QUERY_POOL queryPool,
uint32_t slot,
- XGL_FLAGS flags)
+ VK_FLAGS flags)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdEndQuery(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_QUERY_POOL queryPool,
+ICD_EXPORT void VKAPI vkCmdEndQuery(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_QUERY_POOL queryPool,
uint32_t slot)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdResetQueryPool(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_QUERY_POOL queryPool,
+ICD_EXPORT void VKAPI vkCmdResetQueryPool(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_QUERY_POOL queryPool,
uint32_t startQuery,
uint32_t queryCount)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdSetEvent(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_EVENT event_,
- XGL_PIPE_EVENT pipeEvent)
+ICD_EXPORT void VKAPI vkCmdSetEvent(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_EVENT event_,
+ VK_PIPE_EVENT pipeEvent)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdResetEvent(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_EVENT event_,
- XGL_PIPE_EVENT pipeEvent)
+ICD_EXPORT void VKAPI vkCmdResetEvent(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_EVENT event_,
+ VK_PIPE_EVENT pipeEvent)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdWriteTimestamp(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_TIMESTAMP_TYPE timestampType,
- XGL_BUFFER destBuffer,
- XGL_GPU_SIZE destOffset)
+ICD_EXPORT void VKAPI vkCmdWriteTimestamp(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_TIMESTAMP_TYPE timestampType,
+ VK_BUFFER destBuffer,
+ VK_GPU_SIZE destOffset)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdBindPipeline(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_PIPELINE_BIND_POINT pipelineBindPoint,
- XGL_PIPELINE pipeline)
+ICD_EXPORT void VKAPI vkCmdBindPipeline(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_PIPELINE_BIND_POINT pipelineBindPoint,
+ VK_PIPELINE pipeline)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdBindDynamicStateObject(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_STATE_BIND_POINT stateBindPoint,
- XGL_DYNAMIC_STATE_OBJECT state)
+ICD_EXPORT void VKAPI vkCmdBindDynamicStateObject(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_STATE_BIND_POINT stateBindPoint,
+ VK_DYNAMIC_STATE_OBJECT state)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdBindDescriptorSets(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_PIPELINE_BIND_POINT pipelineBindPoint,
- XGL_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain,
+ICD_EXPORT void VKAPI vkCmdBindDescriptorSets(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_PIPELINE_BIND_POINT pipelineBindPoint,
+ VK_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain,
uint32_t layoutChainSlot,
uint32_t count,
- const XGL_DESCRIPTOR_SET* pDescriptorSets,
+ const VK_DESCRIPTOR_SET* pDescriptorSets,
const uint32_t* pUserData)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdBindVertexBuffer(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_BUFFER buffer,
- XGL_GPU_SIZE offset,
+ICD_EXPORT void VKAPI vkCmdBindVertexBuffer(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_BUFFER buffer,
+ VK_GPU_SIZE offset,
uint32_t binding)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdBindIndexBuffer(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_BUFFER buffer,
- XGL_GPU_SIZE offset,
- XGL_INDEX_TYPE indexType)
+ICD_EXPORT void VKAPI vkCmdBindIndexBuffer(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_BUFFER buffer,
+ VK_GPU_SIZE offset,
+ VK_INDEX_TYPE indexType)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdDraw(
- XGL_CMD_BUFFER cmdBuffer,
+ICD_EXPORT void VKAPI vkCmdDraw(
+ VK_CMD_BUFFER cmdBuffer,
uint32_t firstVertex,
uint32_t vertexCount,
uint32_t firstInstance,
@@ -1138,8 +1138,8 @@ ICD_EXPORT void XGLAPI xglCmdDraw(
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdDrawIndexed(
- XGL_CMD_BUFFER cmdBuffer,
+ICD_EXPORT void VKAPI vkCmdDrawIndexed(
+ VK_CMD_BUFFER cmdBuffer,
uint32_t firstIndex,
uint32_t indexCount,
int32_t vertexOffset,
@@ -1149,28 +1149,28 @@ ICD_EXPORT void XGLAPI xglCmdDrawIndexed(
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdDrawIndirect(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_BUFFER buffer,
- XGL_GPU_SIZE offset,
+ICD_EXPORT void VKAPI vkCmdDrawIndirect(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_BUFFER buffer,
+ VK_GPU_SIZE offset,
uint32_t count,
uint32_t stride)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdDrawIndexedIndirect(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_BUFFER buffer,
- XGL_GPU_SIZE offset,
+ICD_EXPORT void VKAPI vkCmdDrawIndexedIndirect(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_BUFFER buffer,
+ VK_GPU_SIZE offset,
uint32_t count,
uint32_t stride)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdDispatch(
- XGL_CMD_BUFFER cmdBuffer,
+ICD_EXPORT void VKAPI vkCmdDispatch(
+ VK_CMD_BUFFER cmdBuffer,
uint32_t x,
uint32_t y,
uint32_t z)
@@ -1178,125 +1178,125 @@ ICD_EXPORT void XGLAPI xglCmdDispatch(
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdDispatchIndirect(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_BUFFER buffer,
- XGL_GPU_SIZE offset)
+ICD_EXPORT void VKAPI vkCmdDispatchIndirect(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_BUFFER buffer,
+ VK_GPU_SIZE offset)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdWaitEvents(
- XGL_CMD_BUFFER cmdBuffer,
- const XGL_EVENT_WAIT_INFO* pWaitInfo)
+ICD_EXPORT void VKAPI vkCmdWaitEvents(
+ VK_CMD_BUFFER cmdBuffer,
+ const VK_EVENT_WAIT_INFO* pWaitInfo)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdPipelineBarrier(
- XGL_CMD_BUFFER cmdBuffer,
- const XGL_PIPELINE_BARRIER* pBarrier)
+ICD_EXPORT void VKAPI vkCmdPipelineBarrier(
+ VK_CMD_BUFFER cmdBuffer,
+ const VK_PIPELINE_BARRIER* pBarrier)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglCreateDevice(
- XGL_PHYSICAL_GPU gpu_,
- const XGL_DEVICE_CREATE_INFO* pCreateInfo,
- XGL_DEVICE* pDevice)
+ICD_EXPORT VK_RESULT VKAPI vkCreateDevice(
+ VK_PHYSICAL_GPU gpu_,
+ const VK_DEVICE_CREATE_INFO* pCreateInfo,
+ VK_DEVICE* pDevice)
{
NULLDRV_LOG_FUNC;
struct nulldrv_gpu *gpu = nulldrv_gpu(gpu_);
return nulldrv_dev_create(gpu, pCreateInfo, (struct nulldrv_dev**)pDevice);
}
-ICD_EXPORT XGL_RESULT XGLAPI xglDestroyDevice(
- XGL_DEVICE device)
+ICD_EXPORT VK_RESULT VKAPI vkDestroyDevice(
+ VK_DEVICE device)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglGetDeviceQueue(
- XGL_DEVICE device,
+ICD_EXPORT VK_RESULT VKAPI vkGetDeviceQueue(
+ VK_DEVICE device,
uint32_t queueNodeIndex,
uint32_t queueIndex,
- XGL_QUEUE* pQueue)
+ VK_QUEUE* pQueue)
{
NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
*pQueue = dev->queues[0];
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglDeviceWaitIdle(
- XGL_DEVICE device)
+ICD_EXPORT VK_RESULT VKAPI vkDeviceWaitIdle(
+ VK_DEVICE device)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglDbgSetValidationLevel(
- XGL_DEVICE device,
- XGL_VALIDATION_LEVEL validationLevel)
+ICD_EXPORT VK_RESULT VKAPI vkDbgSetValidationLevel(
+ VK_DEVICE device,
+ VK_VALIDATION_LEVEL validationLevel)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglDbgSetMessageFilter(
- XGL_DEVICE device,
+ICD_EXPORT VK_RESULT VKAPI vkDbgSetMessageFilter(
+ VK_DEVICE device,
int32_t msgCode,
- XGL_DBG_MSG_FILTER filter)
+ VK_DBG_MSG_FILTER filter)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglDbgSetDeviceOption(
- XGL_DEVICE device,
- XGL_DBG_DEVICE_OPTION dbgOption,
+ICD_EXPORT VK_RESULT VKAPI vkDbgSetDeviceOption(
+ VK_DEVICE device,
+ VK_DBG_DEVICE_OPTION dbgOption,
size_t dataSize,
const void* pData)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglCreateEvent(
- XGL_DEVICE device,
- const XGL_EVENT_CREATE_INFO* pCreateInfo,
- XGL_EVENT* pEvent)
+ICD_EXPORT VK_RESULT VKAPI vkCreateEvent(
+ VK_DEVICE device,
+ const VK_EVENT_CREATE_INFO* pCreateInfo,
+ VK_EVENT* pEvent)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglGetEventStatus(
- XGL_EVENT event_)
+ICD_EXPORT VK_RESULT VKAPI vkGetEventStatus(
+ VK_EVENT event_)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglSetEvent(
- XGL_EVENT event_)
+ICD_EXPORT VK_RESULT VKAPI vkSetEvent(
+ VK_EVENT event_)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglResetEvent(
- XGL_EVENT event_)
+ICD_EXPORT VK_RESULT VKAPI vkResetEvent(
+ VK_EVENT event_)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglCreateFence(
- XGL_DEVICE device,
- const XGL_FENCE_CREATE_INFO* pCreateInfo,
- XGL_FENCE* pFence)
+ICD_EXPORT VK_RESULT VKAPI vkCreateFence(
+ VK_DEVICE device,
+ const VK_FENCE_CREATE_INFO* pCreateInfo,
+ VK_FENCE* pFence)
{
NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
@@ -1305,76 +1305,76 @@ ICD_EXPORT XGL_RESULT XGLAPI xglCreateFence(
(struct nulldrv_fence **) pFence);
}
-ICD_EXPORT XGL_RESULT XGLAPI xglGetFenceStatus(
- XGL_FENCE fence_)
+ICD_EXPORT VK_RESULT VKAPI vkGetFenceStatus(
+ VK_FENCE fence_)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglWaitForFences(
- XGL_DEVICE device,
+ICD_EXPORT VK_RESULT VKAPI vkWaitForFences(
+ VK_DEVICE device,
uint32_t fenceCount,
- const XGL_FENCE* pFences,
+ const VK_FENCE* pFences,
bool32_t waitAll,
uint64_t timeout)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglGetFormatInfo(
- XGL_DEVICE device,
- XGL_FORMAT format,
- XGL_FORMAT_INFO_TYPE infoType,
+ICD_EXPORT VK_RESULT VKAPI vkGetFormatInfo(
+ VK_DEVICE device,
+ VK_FORMAT format,
+ VK_FORMAT_INFO_TYPE infoType,
size_t* pDataSize,
void* pData)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglGetGpuInfo(
- XGL_PHYSICAL_GPU gpu_,
- XGL_PHYSICAL_GPU_INFO_TYPE infoType,
+ICD_EXPORT VK_RESULT VKAPI vkGetGpuInfo(
+ VK_PHYSICAL_GPU gpu_,
+ VK_PHYSICAL_GPU_INFO_TYPE infoType,
size_t* pDataSize,
void* pData)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglGetExtensionSupport(
- XGL_PHYSICAL_GPU gpu_,
+ICD_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(
+ VK_PHYSICAL_GPU gpu_,
const char* pExtName)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglGetMultiGpuCompatibility(
- XGL_PHYSICAL_GPU gpu0_,
- XGL_PHYSICAL_GPU gpu1_,
- XGL_GPU_COMPATIBILITY_INFO* pInfo)
+ICD_EXPORT VK_RESULT VKAPI vkGetMultiGpuCompatibility(
+ VK_PHYSICAL_GPU gpu0_,
+ VK_PHYSICAL_GPU gpu1_,
+ VK_GPU_COMPATIBILITY_INFO* pInfo)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglOpenPeerImage(
- XGL_DEVICE device,
- const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo,
- XGL_IMAGE* pImage,
- XGL_GPU_MEMORY* pMem)
+ICD_EXPORT VK_RESULT VKAPI vkOpenPeerImage(
+ VK_DEVICE device,
+ const VK_PEER_IMAGE_OPEN_INFO* pOpenInfo,
+ VK_IMAGE* pImage,
+ VK_GPU_MEMORY* pMem)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglCreateImage(
- XGL_DEVICE device,
- const XGL_IMAGE_CREATE_INFO* pCreateInfo,
- XGL_IMAGE* pImage)
+ICD_EXPORT VK_RESULT VKAPI vkCreateImage(
+ VK_DEVICE device,
+ const VK_IMAGE_CREATE_INFO* pCreateInfo,
+ VK_IMAGE* pImage)
{
NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
@@ -1383,22 +1383,22 @@ ICD_EXPORT XGL_RESULT XGLAPI xglCreateImage(
(struct nulldrv_img **) pImage);
}
-ICD_EXPORT XGL_RESULT XGLAPI xglGetImageSubresourceInfo(
- XGL_IMAGE image,
- const XGL_IMAGE_SUBRESOURCE* pSubresource,
- XGL_SUBRESOURCE_INFO_TYPE infoType,
+ICD_EXPORT VK_RESULT VKAPI vkGetImageSubresourceInfo(
+ VK_IMAGE image,
+ const VK_IMAGE_SUBRESOURCE* pSubresource,
+ VK_SUBRESOURCE_INFO_TYPE infoType,
size_t* pDataSize,
void* pData)
{
NULLDRV_LOG_FUNC;
- XGL_RESULT ret = XGL_SUCCESS;
+ VK_RESULT ret = VK_SUCCESS;
switch (infoType) {
- case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
+ case VK_INFO_TYPE_SUBRESOURCE_LAYOUT:
{
- XGL_SUBRESOURCE_LAYOUT *layout = (XGL_SUBRESOURCE_LAYOUT *) pData;
+ VK_SUBRESOURCE_LAYOUT *layout = (VK_SUBRESOURCE_LAYOUT *) pData;
- *pDataSize = sizeof(XGL_SUBRESOURCE_LAYOUT);
+ *pDataSize = sizeof(VK_SUBRESOURCE_LAYOUT);
if (pData == NULL)
return ret;
@@ -1409,17 +1409,17 @@ ICD_EXPORT XGL_RESULT XGLAPI xglGetImageSubresourceInfo(
}
break;
default:
- ret = XGL_ERROR_INVALID_VALUE;
+ ret = VK_ERROR_INVALID_VALUE;
break;
}
return ret;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglAllocMemory(
- XGL_DEVICE device,
- const XGL_MEMORY_ALLOC_INFO* pAllocInfo,
- XGL_GPU_MEMORY* pMem)
+ICD_EXPORT VK_RESULT VKAPI vkAllocMemory(
+ VK_DEVICE device,
+ const VK_MEMORY_ALLOC_INFO* pAllocInfo,
+ VK_GPU_MEMORY* pMem)
{
NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
@@ -1427,24 +1427,24 @@ ICD_EXPORT XGL_RESULT XGLAPI xglAllocMemory(
return nulldrv_mem_alloc(dev, pAllocInfo, (struct nulldrv_mem **) pMem);
}
-ICD_EXPORT XGL_RESULT XGLAPI xglFreeMemory(
- XGL_GPU_MEMORY mem_)
+ICD_EXPORT VK_RESULT VKAPI vkFreeMemory(
+ VK_GPU_MEMORY mem_)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglSetMemoryPriority(
- XGL_GPU_MEMORY mem_,
- XGL_MEMORY_PRIORITY priority)
+ICD_EXPORT VK_RESULT VKAPI vkSetMemoryPriority(
+ VK_GPU_MEMORY mem_,
+ VK_MEMORY_PRIORITY priority)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglMapMemory(
- XGL_GPU_MEMORY mem_,
- XGL_FLAGS flags,
+ICD_EXPORT VK_RESULT VKAPI vkMapMemory(
+ VK_GPU_MEMORY mem_,
+ VK_FLAGS flags,
void** ppData)
{
NULLDRV_LOG_FUNC;
@@ -1453,88 +1453,88 @@ ICD_EXPORT XGL_RESULT XGLAPI xglMapMemory(
*ppData = ptr;
- return (ptr) ? XGL_SUCCESS : XGL_ERROR_UNKNOWN;
+ return (ptr) ? VK_SUCCESS : VK_ERROR_UNKNOWN;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglUnmapMemory(
- XGL_GPU_MEMORY mem_)
+ICD_EXPORT VK_RESULT VKAPI vkUnmapMemory(
+ VK_GPU_MEMORY mem_)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglPinSystemMemory(
- XGL_DEVICE device,
+ICD_EXPORT VK_RESULT VKAPI vkPinSystemMemory(
+ VK_DEVICE device,
const void* pSysMem,
size_t memSize,
- XGL_GPU_MEMORY* pMem)
+ VK_GPU_MEMORY* pMem)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglOpenSharedMemory(
- XGL_DEVICE device,
- const XGL_MEMORY_OPEN_INFO* pOpenInfo,
- XGL_GPU_MEMORY* pMem)
+ICD_EXPORT VK_RESULT VKAPI vkOpenSharedMemory(
+ VK_DEVICE device,
+ const VK_MEMORY_OPEN_INFO* pOpenInfo,
+ VK_GPU_MEMORY* pMem)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglOpenPeerMemory(
- XGL_DEVICE device,
- const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo,
- XGL_GPU_MEMORY* pMem)
+ICD_EXPORT VK_RESULT VKAPI vkOpenPeerMemory(
+ VK_DEVICE device,
+ const VK_PEER_MEMORY_OPEN_INFO* pOpenInfo,
+ VK_GPU_MEMORY* pMem)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglCreateInstance(
- const XGL_INSTANCE_CREATE_INFO* pCreateInfo,
- XGL_INSTANCE* pInstance)
+ICD_EXPORT VK_RESULT VKAPI vkCreateInstance(
+ const VK_INSTANCE_CREATE_INFO* pCreateInfo,
+ VK_INSTANCE* pInstance)
{
NULLDRV_LOG_FUNC;
struct nulldrv_instance *inst;
inst = (struct nulldrv_instance *) nulldrv_base_create(NULL, sizeof(*inst),
- XGL_DBG_OBJECT_INSTANCE);
+ VK_DBG_OBJECT_INSTANCE);
if (!inst)
- return XGL_ERROR_OUT_OF_MEMORY;
+ return VK_ERROR_OUT_OF_MEMORY;
inst->obj.base.get_info = NULL;
- *pInstance = (XGL_INSTANCE*)inst;
+ *pInstance = (VK_INSTANCE*)inst;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglDestroyInstance(
- XGL_INSTANCE pInstance)
+ICD_EXPORT VK_RESULT VKAPI vkDestroyInstance(
+ VK_INSTANCE pInstance)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglEnumerateGpus(
- XGL_INSTANCE instance,
+ICD_EXPORT VK_RESULT VKAPI vkEnumerateGpus(
+ VK_INSTANCE instance,
uint32_t maxGpus,
uint32_t* pGpuCount,
- XGL_PHYSICAL_GPU* pGpus)
+ VK_PHYSICAL_GPU* pGpus)
{
NULLDRV_LOG_FUNC;
- XGL_RESULT ret;
+ VK_RESULT ret;
struct nulldrv_gpu *gpu;
*pGpuCount = 1;
ret = nulldrv_gpu_add(0, 0, 0, &gpu);
- if (ret == XGL_SUCCESS)
- pGpus[0] = (XGL_PHYSICAL_GPU) gpu;
+ if (ret == VK_SUCCESS)
+ pGpus[0] = (VK_PHYSICAL_GPU) gpu;
return ret;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(
- XGL_PHYSICAL_GPU gpu,
+ICD_EXPORT VK_RESULT VKAPI vkEnumerateLayers(
+ VK_PHYSICAL_GPU gpu,
size_t maxLayerCount,
size_t maxStringSize,
size_t* pOutLayerCount,
@@ -1542,46 +1542,46 @@ ICD_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(
void* pReserved)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(
- XGL_INSTANCE instance,
- XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback,
+ICD_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(
+ VK_INSTANCE instance,
+ VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback,
void* pUserData)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(
- XGL_INSTANCE instance,
- XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
+ICD_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(
+ VK_INSTANCE instance,
+ VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglDbgSetGlobalOption(
- XGL_INSTANCE instance,
- XGL_DBG_GLOBAL_OPTION dbgOption,
+ICD_EXPORT VK_RESULT VKAPI vkDbgSetGlobalOption(
+ VK_INSTANCE instance,
+ VK_DBG_GLOBAL_OPTION dbgOption,
size_t dataSize,
const void* pData)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglDestroyObject(
- XGL_OBJECT object)
+ICD_EXPORT VK_RESULT VKAPI vkDestroyObject(
+ VK_OBJECT object)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglGetObjectInfo(
- XGL_BASE_OBJECT object,
- XGL_OBJECT_INFO_TYPE infoType,
+ICD_EXPORT VK_RESULT VKAPI vkGetObjectInfo(
+ VK_BASE_OBJECT object,
+ VK_OBJECT_INFO_TYPE infoType,
size_t* pDataSize,
void* pData)
{
@@ -1591,52 +1591,52 @@ ICD_EXPORT XGL_RESULT XGLAPI xglGetObjectInfo(
return base->get_info(base, infoType, pDataSize, pData);
}
-ICD_EXPORT XGL_RESULT XGLAPI xglBindObjectMemory(
- XGL_OBJECT object,
+ICD_EXPORT VK_RESULT VKAPI vkBindObjectMemory(
+ VK_OBJECT object,
uint32_t allocationIdx,
- XGL_GPU_MEMORY mem_,
- XGL_GPU_SIZE memOffset)
+ VK_GPU_MEMORY mem_,
+ VK_GPU_SIZE memOffset)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglBindObjectMemoryRange(
- XGL_OBJECT object,
+ICD_EXPORT VK_RESULT VKAPI vkBindObjectMemoryRange(
+ VK_OBJECT object,
uint32_t allocationIdx,
- XGL_GPU_SIZE rangeOffset,
- XGL_GPU_SIZE rangeSize,
- XGL_GPU_MEMORY mem,
- XGL_GPU_SIZE memOffset)
+ VK_GPU_SIZE rangeOffset,
+ VK_GPU_SIZE rangeSize,
+ VK_GPU_MEMORY mem,
+ VK_GPU_SIZE memOffset)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglBindImageMemoryRange(
- XGL_IMAGE image,
+ICD_EXPORT VK_RESULT VKAPI vkBindImageMemoryRange(
+ VK_IMAGE image,
uint32_t allocationIdx,
- const XGL_IMAGE_MEMORY_BIND_INFO* bindInfo,
- XGL_GPU_MEMORY mem,
- XGL_GPU_SIZE memOffset)
+ const VK_IMAGE_MEMORY_BIND_INFO* bindInfo,
+ VK_GPU_MEMORY mem,
+ VK_GPU_SIZE memOffset)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglDbgSetObjectTag(
- XGL_BASE_OBJECT object,
+ICD_EXPORT VK_RESULT VKAPI vkDbgSetObjectTag(
+ VK_BASE_OBJECT object,
size_t tagSize,
const void* pTag)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipeline(
- XGL_DEVICE device,
- const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
- XGL_PIPELINE* pPipeline)
+ICD_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipeline(
+ VK_DEVICE device,
+ const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
+ VK_PIPELINE* pPipeline)
{
NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
@@ -1645,11 +1645,11 @@ ICD_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipeline(
(struct nulldrv_pipeline **) pPipeline);
}
-ICD_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipelineDerivative(
- XGL_DEVICE device,
- const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
- XGL_PIPELINE basePipeline,
- XGL_PIPELINE* pPipeline)
+ICD_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipelineDerivative(
+ VK_DEVICE device,
+ const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
+ VK_PIPELINE basePipeline,
+ VK_PIPELINE* pPipeline)
{
NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
@@ -1658,136 +1658,136 @@ ICD_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipelineDerivative(
(struct nulldrv_pipeline **) pPipeline);
}
-ICD_EXPORT XGL_RESULT XGLAPI xglCreateComputePipeline(
- XGL_DEVICE device,
- const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo,
- XGL_PIPELINE* pPipeline)
+ICD_EXPORT VK_RESULT VKAPI vkCreateComputePipeline(
+ VK_DEVICE device,
+ const VK_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo,
+ VK_PIPELINE* pPipeline)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglStorePipeline(
- XGL_PIPELINE pipeline,
+ICD_EXPORT VK_RESULT VKAPI vkStorePipeline(
+ VK_PIPELINE pipeline,
size_t* pDataSize,
void* pData)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglLoadPipeline(
- XGL_DEVICE device,
+ICD_EXPORT VK_RESULT VKAPI vkLoadPipeline(
+ VK_DEVICE device,
size_t dataSize,
const void* pData,
- XGL_PIPELINE* pPipeline)
+ VK_PIPELINE* pPipeline)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglLoadPipelineDerivative(
- XGL_DEVICE device,
+ICD_EXPORT VK_RESULT VKAPI vkLoadPipelineDerivative(
+ VK_DEVICE device,
size_t dataSize,
const void* pData,
- XGL_PIPELINE basePipeline,
- XGL_PIPELINE* pPipeline)
+ VK_PIPELINE basePipeline,
+ VK_PIPELINE* pPipeline)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglCreateQueryPool(
- XGL_DEVICE device,
- const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo,
- XGL_QUERY_POOL* pQueryPool)
+ICD_EXPORT VK_RESULT VKAPI vkCreateQueryPool(
+ VK_DEVICE device,
+ const VK_QUERY_POOL_CREATE_INFO* pCreateInfo,
+ VK_QUERY_POOL* pQueryPool)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglGetQueryPoolResults(
- XGL_QUERY_POOL queryPool,
+ICD_EXPORT VK_RESULT VKAPI vkGetQueryPoolResults(
+ VK_QUERY_POOL queryPool,
uint32_t startQuery,
uint32_t queryCount,
size_t* pDataSize,
void* pData)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglQueueAddMemReference(
- XGL_QUEUE queue,
- XGL_GPU_MEMORY mem)
+ICD_EXPORT VK_RESULT VKAPI vkQueueAddMemReference(
+ VK_QUEUE queue,
+ VK_GPU_MEMORY mem)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglQueueRemoveMemReference(
- XGL_QUEUE queue,
- XGL_GPU_MEMORY mem)
+ICD_EXPORT VK_RESULT VKAPI vkQueueRemoveMemReference(
+ VK_QUEUE queue,
+ VK_GPU_MEMORY mem)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglQueueWaitIdle(
- XGL_QUEUE queue_)
+ICD_EXPORT VK_RESULT VKAPI vkQueueWaitIdle(
+ VK_QUEUE queue_)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglQueueSubmit(
- XGL_QUEUE queue_,
+ICD_EXPORT VK_RESULT VKAPI vkQueueSubmit(
+ VK_QUEUE queue_,
uint32_t cmdBufferCount,
- const XGL_CMD_BUFFER* pCmdBuffers,
- XGL_FENCE fence_)
+ const VK_CMD_BUFFER* pCmdBuffers,
+ VK_FENCE fence_)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglOpenSharedSemaphore(
- XGL_DEVICE device,
- const XGL_SEMAPHORE_OPEN_INFO* pOpenInfo,
- XGL_SEMAPHORE* pSemaphore)
+ICD_EXPORT VK_RESULT VKAPI vkOpenSharedSemaphore(
+ VK_DEVICE device,
+ const VK_SEMAPHORE_OPEN_INFO* pOpenInfo,
+ VK_SEMAPHORE* pSemaphore)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglCreateSemaphore(
- XGL_DEVICE device,
- const XGL_SEMAPHORE_CREATE_INFO* pCreateInfo,
- XGL_SEMAPHORE* pSemaphore)
+ICD_EXPORT VK_RESULT VKAPI vkCreateSemaphore(
+ VK_DEVICE device,
+ const VK_SEMAPHORE_CREATE_INFO* pCreateInfo,
+ VK_SEMAPHORE* pSemaphore)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglQueueSignalSemaphore(
- XGL_QUEUE queue,
- XGL_SEMAPHORE semaphore)
+ICD_EXPORT VK_RESULT VKAPI vkQueueSignalSemaphore(
+ VK_QUEUE queue,
+ VK_SEMAPHORE semaphore)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglQueueWaitSemaphore(
- XGL_QUEUE queue,
- XGL_SEMAPHORE semaphore)
+ICD_EXPORT VK_RESULT VKAPI vkQueueWaitSemaphore(
+ VK_QUEUE queue,
+ VK_SEMAPHORE semaphore)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglCreateSampler(
- XGL_DEVICE device,
- const XGL_SAMPLER_CREATE_INFO* pCreateInfo,
- XGL_SAMPLER* pSampler)
+ICD_EXPORT VK_RESULT VKAPI vkCreateSampler(
+ VK_DEVICE device,
+ const VK_SAMPLER_CREATE_INFO* pCreateInfo,
+ VK_SAMPLER* pSampler)
{
NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
@@ -1796,10 +1796,10 @@ ICD_EXPORT XGL_RESULT XGLAPI xglCreateSampler(
(struct nulldrv_sampler **) pSampler);
}
-ICD_EXPORT XGL_RESULT XGLAPI xglCreateShader(
- XGL_DEVICE device,
- const XGL_SHADER_CREATE_INFO* pCreateInfo,
- XGL_SHADER* pShader)
+ICD_EXPORT VK_RESULT VKAPI vkCreateShader(
+ VK_DEVICE device,
+ const VK_SHADER_CREATE_INFO* pCreateInfo,
+ VK_SHADER* pShader)
{
NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
@@ -1807,10 +1807,10 @@ ICD_EXPORT XGL_RESULT XGLAPI xglCreateShader(
return shader_create(dev, pCreateInfo, (struct nulldrv_shader **) pShader);
}
-ICD_EXPORT XGL_RESULT XGLAPI xglCreateDynamicViewportState(
- XGL_DEVICE device,
- const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo,
- XGL_DYNAMIC_VP_STATE_OBJECT* pState)
+ICD_EXPORT VK_RESULT VKAPI vkCreateDynamicViewportState(
+ VK_DEVICE device,
+ const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo,
+ VK_DYNAMIC_VP_STATE_OBJECT* pState)
{
NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
@@ -1819,10 +1819,10 @@ ICD_EXPORT XGL_RESULT XGLAPI xglCreateDynamicViewportState(
(struct nulldrv_dynamic_vp **) pState);
}
-ICD_EXPORT XGL_RESULT XGLAPI xglCreateDynamicRasterState(
- XGL_DEVICE device,
- const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo,
- XGL_DYNAMIC_RS_STATE_OBJECT* pState)
+ICD_EXPORT VK_RESULT VKAPI vkCreateDynamicRasterState(
+ VK_DEVICE device,
+ const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo,
+ VK_DYNAMIC_RS_STATE_OBJECT* pState)
{
NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
@@ -1831,10 +1831,10 @@ ICD_EXPORT XGL_RESULT XGLAPI xglCreateDynamicRasterState(
(struct nulldrv_dynamic_rs **) pState);
}
-ICD_EXPORT XGL_RESULT XGLAPI xglCreateDynamicColorBlendState(
- XGL_DEVICE device,
- const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo,
- XGL_DYNAMIC_CB_STATE_OBJECT* pState)
+ICD_EXPORT VK_RESULT VKAPI vkCreateDynamicColorBlendState(
+ VK_DEVICE device,
+ const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo,
+ VK_DYNAMIC_CB_STATE_OBJECT* pState)
{
NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
@@ -1843,10 +1843,10 @@ ICD_EXPORT XGL_RESULT XGLAPI xglCreateDynamicColorBlendState(
(struct nulldrv_dynamic_cb **) pState);
}
-ICD_EXPORT XGL_RESULT XGLAPI xglCreateDynamicDepthStencilState(
- XGL_DEVICE device,
- const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo,
- XGL_DYNAMIC_DS_STATE_OBJECT* pState)
+ICD_EXPORT VK_RESULT VKAPI vkCreateDynamicDepthStencilState(
+ VK_DEVICE device,
+ const VK_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo,
+ VK_DYNAMIC_DS_STATE_OBJECT* pState)
{
NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
@@ -1855,10 +1855,10 @@ ICD_EXPORT XGL_RESULT XGLAPI xglCreateDynamicDepthStencilState(
(struct nulldrv_dynamic_ds **) pState);
}
-ICD_EXPORT XGL_RESULT XGLAPI xglCreateBufferView(
- XGL_DEVICE device,
- const XGL_BUFFER_VIEW_CREATE_INFO* pCreateInfo,
- XGL_BUFFER_VIEW* pView)
+ICD_EXPORT VK_RESULT VKAPI vkCreateBufferView(
+ VK_DEVICE device,
+ const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo,
+ VK_BUFFER_VIEW* pView)
{
NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
@@ -1867,10 +1867,10 @@ ICD_EXPORT XGL_RESULT XGLAPI xglCreateBufferView(
(struct nulldrv_buf_view **) pView);
}
-ICD_EXPORT XGL_RESULT XGLAPI xglCreateImageView(
- XGL_DEVICE device,
- const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo,
- XGL_IMAGE_VIEW* pView)
+ICD_EXPORT VK_RESULT VKAPI vkCreateImageView(
+ VK_DEVICE device,
+ const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo,
+ VK_IMAGE_VIEW* pView)
{
NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
@@ -1879,10 +1879,10 @@ ICD_EXPORT XGL_RESULT XGLAPI xglCreateImageView(
(struct nulldrv_img_view **) pView);
}
-ICD_EXPORT XGL_RESULT XGLAPI xglCreateColorAttachmentView(
- XGL_DEVICE device,
- const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo,
- XGL_COLOR_ATTACHMENT_VIEW* pView)
+ICD_EXPORT VK_RESULT VKAPI vkCreateColorAttachmentView(
+ VK_DEVICE device,
+ const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo,
+ VK_COLOR_ATTACHMENT_VIEW* pView)
{
NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
@@ -1891,10 +1891,10 @@ ICD_EXPORT XGL_RESULT XGLAPI xglCreateColorAttachmentView(
(struct nulldrv_rt_view **) pView);
}
-ICD_EXPORT XGL_RESULT XGLAPI xglCreateDepthStencilView(
- XGL_DEVICE device,
- const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo,
- XGL_DEPTH_STENCIL_VIEW* pView)
+ICD_EXPORT VK_RESULT VKAPI vkCreateDepthStencilView(
+ VK_DEVICE device,
+ const VK_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo,
+ VK_DEPTH_STENCIL_VIEW* pView)
{
NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
@@ -1904,10 +1904,10 @@ ICD_EXPORT XGL_RESULT XGLAPI xglCreateDepthStencilView(
}
-ICD_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorSetLayout(
- XGL_DEVICE device,
- const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo,
- XGL_DESCRIPTOR_SET_LAYOUT* pSetLayout)
+ICD_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayout(
+ VK_DEVICE device,
+ const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo,
+ VK_DESCRIPTOR_SET_LAYOUT* pSetLayout)
{
NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
@@ -1916,11 +1916,11 @@ ICD_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorSetLayout(
(struct nulldrv_desc_layout **) pSetLayout);
}
-ICD_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorSetLayoutChain(
- XGL_DEVICE device,
+ICD_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayoutChain(
+ VK_DEVICE device,
uint32_t setLayoutArrayCount,
- const XGL_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray,
- XGL_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain)
+ const VK_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray,
+ VK_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain)
{
NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
@@ -1930,28 +1930,28 @@ ICD_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorSetLayoutChain(
(struct nulldrv_desc_layout_chain **) pLayoutChain);
}
-ICD_EXPORT XGL_RESULT XGLAPI xglBeginDescriptorPoolUpdate(
- XGL_DEVICE device,
- XGL_DESCRIPTOR_UPDATE_MODE updateMode)
+ICD_EXPORT VK_RESULT VKAPI vkBeginDescriptorPoolUpdate(
+ VK_DEVICE device,
+ VK_DESCRIPTOR_UPDATE_MODE updateMode)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglEndDescriptorPoolUpdate(
- XGL_DEVICE device,
- XGL_CMD_BUFFER cmd_)
+ICD_EXPORT VK_RESULT VKAPI vkEndDescriptorPoolUpdate(
+ VK_DEVICE device,
+ VK_CMD_BUFFER cmd_)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorPool(
- XGL_DEVICE device,
- XGL_DESCRIPTOR_POOL_USAGE poolUsage,
+ICD_EXPORT VK_RESULT VKAPI vkCreateDescriptorPool(
+ VK_DEVICE device,
+ VK_DESCRIPTOR_POOL_USAGE poolUsage,
uint32_t maxSets,
- const XGL_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo,
- XGL_DESCRIPTOR_POOL* pDescriptorPool)
+ const VK_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo,
+ VK_DESCRIPTOR_POOL* pDescriptorPool)
{
NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
@@ -1960,34 +1960,34 @@ ICD_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorPool(
(struct nulldrv_desc_pool **) pDescriptorPool);
}
-ICD_EXPORT XGL_RESULT XGLAPI xglResetDescriptorPool(
- XGL_DESCRIPTOR_POOL descriptorPool)
+ICD_EXPORT VK_RESULT VKAPI vkResetDescriptorPool(
+ VK_DESCRIPTOR_POOL descriptorPool)
{
NULLDRV_LOG_FUNC;
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglAllocDescriptorSets(
- XGL_DESCRIPTOR_POOL descriptorPool,
- XGL_DESCRIPTOR_SET_USAGE setUsage,
+ICD_EXPORT VK_RESULT VKAPI vkAllocDescriptorSets(
+ VK_DESCRIPTOR_POOL descriptorPool,
+ VK_DESCRIPTOR_SET_USAGE setUsage,
uint32_t count,
- const XGL_DESCRIPTOR_SET_LAYOUT* pSetLayouts,
- XGL_DESCRIPTOR_SET* pDescriptorSets,
+ const VK_DESCRIPTOR_SET_LAYOUT* pSetLayouts,
+ VK_DESCRIPTOR_SET* pDescriptorSets,
uint32_t* pCount)
{
NULLDRV_LOG_FUNC;
struct nulldrv_desc_pool *pool = nulldrv_desc_pool(descriptorPool);
struct nulldrv_dev *dev = pool->dev;
- XGL_RESULT ret = XGL_SUCCESS;
+ VK_RESULT ret = VK_SUCCESS;
uint32_t i;
for (i = 0; i < count; i++) {
const struct nulldrv_desc_layout *layout =
- nulldrv_desc_layout((XGL_DESCRIPTOR_SET_LAYOUT) pSetLayouts[i]);
+ nulldrv_desc_layout((VK_DESCRIPTOR_SET_LAYOUT) pSetLayouts[i]);
ret = nulldrv_desc_set_create(dev, pool, setUsage, layout,
(struct nulldrv_desc_set **) &pDescriptorSets[i]);
- if (ret != XGL_SUCCESS)
+ if (ret != VK_SUCCESS)
break;
}
@@ -1997,26 +1997,26 @@ ICD_EXPORT XGL_RESULT XGLAPI xglAllocDescriptorSets(
return ret;
}
-ICD_EXPORT void XGLAPI xglClearDescriptorSets(
- XGL_DESCRIPTOR_POOL descriptorPool,
+ICD_EXPORT void VKAPI vkClearDescriptorSets(
+ VK_DESCRIPTOR_POOL descriptorPool,
uint32_t count,
- const XGL_DESCRIPTOR_SET* pDescriptorSets)
+ const VK_DESCRIPTOR_SET* pDescriptorSets)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglUpdateDescriptors(
- XGL_DESCRIPTOR_SET descriptorSet,
+ICD_EXPORT void VKAPI vkUpdateDescriptors(
+ VK_DESCRIPTOR_SET descriptorSet,
uint32_t updateCount,
const void** ppUpdateArray)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT XGL_RESULT XGLAPI xglCreateFramebuffer(
- XGL_DEVICE device,
- const XGL_FRAMEBUFFER_CREATE_INFO* info,
- XGL_FRAMEBUFFER* fb_ret)
+ICD_EXPORT VK_RESULT VKAPI vkCreateFramebuffer(
+ VK_DEVICE device,
+ const VK_FRAMEBUFFER_CREATE_INFO* info,
+ VK_FRAMEBUFFER* fb_ret)
{
NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
@@ -2025,10 +2025,10 @@ ICD_EXPORT XGL_RESULT XGLAPI xglCreateFramebuffer(
}
-ICD_EXPORT XGL_RESULT XGLAPI xglCreateRenderPass(
- XGL_DEVICE device,
- const XGL_RENDER_PASS_CREATE_INFO* info,
- XGL_RENDER_PASS* rp_ret)
+ICD_EXPORT VK_RESULT VKAPI vkCreateRenderPass(
+ VK_DEVICE device,
+ const VK_RENDER_PASS_CREATE_INFO* info,
+ VK_RENDER_PASS* rp_ret)
{
NULLDRV_LOG_FUNC;
struct nulldrv_dev *dev = nulldrv_dev(device);
@@ -2036,16 +2036,16 @@ ICD_EXPORT XGL_RESULT XGLAPI xglCreateRenderPass(
return nulldrv_render_pass_create(dev, info, (struct nulldrv_render_pass **) rp_ret);
}
-ICD_EXPORT void XGLAPI xglCmdBeginRenderPass(
- XGL_CMD_BUFFER cmdBuffer,
- const XGL_RENDER_PASS_BEGIN* pRenderPassBegin)
+ICD_EXPORT void VKAPI vkCmdBeginRenderPass(
+ VK_CMD_BUFFER cmdBuffer,
+ const VK_RENDER_PASS_BEGIN* pRenderPassBegin)
{
NULLDRV_LOG_FUNC;
}
-ICD_EXPORT void XGLAPI xglCmdEndRenderPass(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_RENDER_PASS renderPass)
+ICD_EXPORT void VKAPI vkCmdEndRenderPass(
+ VK_CMD_BUFFER cmdBuffer,
+ VK_RENDER_PASS renderPass)
{
NULLDRV_LOG_FUNC;
}
@@ -2071,7 +2071,7 @@ ICD_EXPORT int xcbGetMessage(void *msg)
return 0;
}
-ICD_EXPORT XGL_RESULT xcbQueuePresent(void *queue, void *image, void* fence)
+ICD_EXPORT VK_RESULT xcbQueuePresent(void *queue, void *image, void* fence)
{
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
diff --git a/icd/nulldrv/nulldrv.h b/icd/nulldrv/nulldrv.h
index 28d73baf..22af6c6c 100644
--- a/icd/nulldrv/nulldrv.h
+++ b/icd/nulldrv/nulldrv.h
@@ -1,5 +1,5 @@
/*
- * XGL
+ * Vulkan
*
* Copyright (C) 2014 LunarG, Inc.
*
@@ -30,14 +30,14 @@
#include <string.h>
#include <assert.h>
-#include <xgl.h>
-#include <xglDbg.h>
-#include <xglIcd.h>
+#include <vulkan.h>
+#include <vkDbg.h>
+#include <vkIcd.h>
#if defined(PLATFORM_LINUX)
-#include <xglWsiX11Ext.h>
+#include <vkWsiX11Ext.h>
#else
-#include <xglWsiWinExt.h>
+#include <vkWsiWinExt.h>
#endif
#include "icd.h"
@@ -48,7 +48,7 @@
struct nulldrv_base {
void *loader_data;
uint32_t magic;
- XGL_RESULT (*get_info)(struct nulldrv_base *base, int type1,
+ VK_RESULT (*get_info)(struct nulldrv_base *base, int type1,
size_t *size, void *data);
};
@@ -100,12 +100,12 @@ struct nulldrv_fence {
struct nulldrv_img {
struct nulldrv_obj obj;
- XGL_IMAGE_TYPE type;
+ VK_IMAGE_TYPE type;
int32_t depth;
uint32_t mip_levels;
uint32_t array_size;
- XGL_FLAGS usage;
- XGL_IMAGE_FORMAT_CLASS format_class;
+ VK_FLAGS usage;
+ VK_IMAGE_FORMAT_CLASS format_class;
uint32_t samples;
size_t total_size;
};
@@ -113,7 +113,7 @@ struct nulldrv_img {
struct nulldrv_mem {
struct nulldrv_base base;
struct nulldrv_bo *bo;
- XGL_GPU_SIZE size;
+ VK_GPU_SIZE size;
};
struct nulldrv_ds_view {
@@ -135,8 +135,8 @@ struct nulldrv_img_view {
struct nulldrv_buf {
struct nulldrv_obj obj;
- XGL_GPU_SIZE size;
- XGL_FLAGS usage;
+ VK_GPU_SIZE size;
+ VK_FLAGS usage;
};
struct nulldrv_desc_layout {
generated by cgit v1.2.3 (git 2.39.1) at 2026-06-09 22:01:31 +0000