From a4131c4e8a3027dbda941e43992fa2435801247e Mon Sep 17 00:00:00 2001 From: Courtney Goeltzenleuchter Date: Wed, 8 Apr 2015 15:36:08 -0600 Subject: 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) --- icd/common/icd-enumerate-drm.c | 12 +- icd/common/icd-enumerate-drm.h | 2 +- icd/common/icd-format.c | 996 ++++++++++++++++++++--------------------- icd/common/icd-format.h | 42 +- icd/common/icd-instance.c | 60 +-- icd/common/icd-instance.h | 30 +- icd/common/icd-spv.h | 2 +- icd/common/icd-utils.c | 2 +- icd/common/icd-utils.h | 2 +- icd/common/icd.h | 12 +- 10 files changed, 580 insertions(+), 580 deletions(-) (limited to 'icd/common') 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 #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 #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 -#include -#include +#include +#include +#include #if defined(PLATFORM_LINUX) -#include +#include #else -#include +#include #endif -- cgit v1.2.3