From: Jeremy Hayes Date: Fri, 23 Jan 2015 15:51:43 +0000 (-0700) Subject: Update XGL_FORMAT. X-Git-Tag: submit/tizen/20181227.054638~6183 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=9958ea83bee443606c9856a2e5b8aa8ba8bf5e5c;p=platform%2Fupstream%2FVulkan-Tools.git Update XGL_FORMAT. --- diff --git a/demos/cube.c b/demos/cube.c index 8c68e317..b02e443b 100644 --- a/demos/cube.c +++ b/demos/cube.c @@ -449,7 +449,7 @@ static void demo_prepare_buffers(struct demo *demo) static void demo_prepare_depth(struct demo *demo) { - const XGL_FORMAT depth_format = { XGL_CH_FMT_R16, XGL_NUM_FMT_DS }; + const XGL_FORMAT depth_format = XGL_FMT_D16_UNORM; const XGL_IMAGE_CREATE_INFO image = { .sType = XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO, .pNext = NULL, @@ -687,7 +687,7 @@ bool loadTexture(char *filename, XGL_UINT8 *rgba_data, static void demo_prepare_textures(struct demo *demo) { - const XGL_FORMAT tex_format = { XGL_CH_FMT_R8G8B8A8, XGL_NUM_FMT_UNORM }; + const XGL_FORMAT tex_format = XGL_FMT_R8G8B8A8_UNORM; XGL_INT tex_width; XGL_INT tex_height; XGL_RESULT err; @@ -1523,8 +1523,7 @@ static void demo_init(struct demo *demo) demo->width = 500; demo->height = 500; - demo->format.channelFormat = XGL_CH_FMT_B8G8R8A8; - demo->format.numericFormat = XGL_NUM_FMT_UNORM; + demo->format = XGL_FMT_B8G8R8A8_UNORM; demo->spin_angle = 0.01f; demo->spin_increment = 0.01f; diff --git a/demos/tri.c b/demos/tri.c index 413431fc..19a591b9 100644 --- a/demos/tri.c +++ b/demos/tri.c @@ -267,7 +267,7 @@ static void demo_prepare_buffers(struct demo *demo) static void demo_prepare_depth(struct demo *demo) { - const XGL_FORMAT depth_format = { XGL_CH_FMT_R16, XGL_NUM_FMT_DS }; + const XGL_FORMAT depth_format = XGL_FMT_D16_UNORM; const XGL_IMAGE_CREATE_INFO image = { .sType = XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO, .pNext = NULL, @@ -358,7 +358,7 @@ static void demo_prepare_depth(struct demo *demo) static void demo_prepare_textures(struct demo *demo) { - const XGL_FORMAT tex_format = { XGL_CH_FMT_B8G8R8A8, XGL_NUM_FMT_UNORM }; + const XGL_FORMAT tex_format = XGL_FMT_B8G8R8A8_UNORM; const XGL_INT tex_width = 2; const XGL_INT tex_height = 2; const uint32_t tex_colors[DEMO_TEXTURE_COUNT][2] = { @@ -595,13 +595,11 @@ static void demo_prepare_vertices(struct demo *demo) demo->vertices.vi_bindings[0].stepRate = XGL_VERTEX_INPUT_STEP_RATE_VERTEX; demo->vertices.vi_attrs[0].binding = 0; - demo->vertices.vi_attrs[0].format.channelFormat = XGL_CH_FMT_R32G32B32; - demo->vertices.vi_attrs[0].format.numericFormat = XGL_NUM_FMT_FLOAT; + demo->vertices.vi_attrs[0].format = XGL_FMT_R32G32B32_SFLOAT; demo->vertices.vi_attrs[0].offsetInBytes = 0; demo->vertices.vi_attrs[1].binding = 0; - demo->vertices.vi_attrs[1].format.channelFormat = XGL_CH_FMT_R32G32; - demo->vertices.vi_attrs[1].format.numericFormat = XGL_NUM_FMT_FLOAT; + demo->vertices.vi_attrs[1].format = XGL_FMT_R32G32_SFLOAT; demo->vertices.vi_attrs[1].offsetInBytes = sizeof(float) * 3; } @@ -1076,8 +1074,7 @@ static void demo_init(struct demo *demo) demo->width = 300; demo->height = 300; - demo->format.channelFormat = XGL_CH_FMT_B8G8R8A8; - demo->format.numericFormat = XGL_NUM_FMT_UNORM; + demo->format = XGL_FMT_B8G8R8A8_UNORM; } static void demo_cleanup(struct demo *demo) diff --git a/demos/xglinfo.c b/demos/xglinfo.c index 8fa0d1c8..d37917f5 100644 --- a/demos/xglinfo.c +++ b/demos/xglinfo.c @@ -48,7 +48,7 @@ struct app_dev { XGL_DEVICE obj; - XGL_FORMAT_PROPERTIES format_props[XGL_MAX_CH_FMT][XGL_MAX_NUM_FMT]; + XGL_FORMAT_PROPERTIES format_props[XGL_NUM_FMT]; }; struct app_gpu { @@ -132,96 +132,200 @@ static const char *xgl_gpu_type_string(XGL_PHYSICAL_GPU_TYPE type) } } -static const char *xgl_channel_format_string(XGL_CHANNEL_FORMAT ch) +static const char *xgl_format_string(XGL_FORMAT fmt) { - switch (ch) { -#define STR(r) case XGL_CH_FMT_ ##r: return #r + switch (fmt) { +#define STR(r) case XGL_FMT_ ##r: return #r STR(UNDEFINED); - STR(R4G4); - STR(R4G4B4A4); - STR(R5G6B5); - STR(B5G6R5); - STR(R5G5B5A1); - STR(R8); - STR(R8G8); - STR(R8G8B8A8); - STR(B8G8R8A8); - STR(R10G11B11); - STR(R11G11B10); - STR(R10G10B10A2); - STR(R16); - STR(R16G16); - STR(R16G16B16A16); - STR(R32); - STR(R32G32); - STR(R32G32B32); - STR(R32G32B32A32); - STR(R16G8); - STR(R32G8); - STR(R9G9B9E5); - STR(BC1); - STR(BC2); - STR(BC3); - STR(BC4); - STR(BC5); - STR(BC6U); - STR(BC6S); - STR(BC7); - STR(R8G8B8); - STR(R16G16B16); - STR(B10G10R10A2); - STR(R64); - STR(R64G64); - STR(R64G64B64); - STR(R64G64B64A64); + STR(R4G4_UNORM); + STR(R4G4_USCALED); + STR(R4G4B4A4_UNORM); + STR(R4G4B4A4_USCALED); + STR(R5G6B5_UNORM); + STR(R5G6B5_USCALED); + STR(R5G5B5A1_UNORM); + STR(R5G5B5A1_USCALED); + STR(R8_UNORM); + STR(R8_SNORM); + STR(R8_USCALED); + STR(R8_SSCALED); + STR(R8_UINT); + STR(R8_SINT); + STR(R8_SRGB); + STR(R8G8_UNORM); + STR(R8G8_SNORM); + STR(R8G8_USCALED); + STR(R8G8_SSCALED); + STR(R8G8_UINT); + STR(R8G8_SINT); + STR(R8G8_SRGB); + STR(R8G8B8_UNORM); + STR(R8G8B8_SNORM); + STR(R8G8B8_USCALED); + STR(R8G8B8_SSCALED); + STR(R8G8B8_UINT); + STR(R8G8B8_SINT); + STR(R8G8B8_SRGB); + STR(R8G8B8A8_UNORM); + STR(R8G8B8A8_SNORM); + STR(R8G8B8A8_USCALED); + STR(R8G8B8A8_SSCALED); + STR(R8G8B8A8_UINT); + STR(R8G8B8A8_SINT); + STR(R8G8B8A8_SRGB); + STR(R10G10B10A2_UNORM); + STR(R10G10B10A2_SNORM); + STR(R10G10B10A2_USCALED); + STR(R10G10B10A2_SSCALED); + STR(R10G10B10A2_UINT); + STR(R10G10B10A2_SINT); + STR(R16_UNORM); + STR(R16_SNORM); + STR(R16_USCALED); + STR(R16_SSCALED); + STR(R16_UINT); + STR(R16_SINT); + STR(R16_SFLOAT); + STR(R16G16_UNORM); + STR(R16G16_SNORM); + STR(R16G16_USCALED); + STR(R16G16_SSCALED); + STR(R16G16_UINT); + STR(R16G16_SINT); + STR(R16G16_SFLOAT); + STR(R16G16B16_UNORM); + STR(R16G16B16_SNORM); + STR(R16G16B16_USCALED); + STR(R16G16B16_SSCALED); + STR(R16G16B16_UINT); + STR(R16G16B16_SINT); + STR(R16G16B16_SFLOAT); + STR(R16G16B16A16_UNORM); + STR(R16G16B16A16_SNORM); + STR(R16G16B16A16_USCALED); + STR(R16G16B16A16_SSCALED); + STR(R16G16B16A16_UINT); + STR(R16G16B16A16_SINT); + STR(R16G16B16A16_SFLOAT); + STR(R32_UINT); + STR(R32_SINT); + STR(R32_SFLOAT); + STR(R32G32_UINT); + STR(R32G32_SINT); + STR(R32G32_SFLOAT); + STR(R32G32B32_UINT); + STR(R32G32B32_SINT); + STR(R32G32B32_SFLOAT); + STR(R32G32B32A32_UINT); + STR(R32G32B32A32_SINT); + STR(R32G32B32A32_SFLOAT); + STR(R64_SFLOAT); + STR(R64G64_SFLOAT); + STR(R64G64B64_SFLOAT); + STR(R64G64B64A64_SFLOAT); + STR(R11G11B10_UFLOAT); + STR(R9G9B9E5_UFLOAT); + STR(D16_UNORM); + STR(D24_UNORM); + STR(D32_SFLOAT); + STR(S8_UINT); + STR(D16_UNORM_S8_UINT); + STR(D24_UNORM_S8_UINT); + STR(D32_SFLOAT_S8_UINT); + STR(BC1_UNORM); + STR(BC1_SRGB); + STR(BC2_UNORM); + STR(BC2_SRGB); + STR(BC3_UNORM); + STR(BC3_SRGB); + STR(BC4_UNORM); + STR(BC4_SNORM); + STR(BC5_UNORM); + STR(BC5_SNORM); + STR(BC6H_UFLOAT); + STR(BC6H_SFLOAT); + STR(BC7_UNORM); + STR(BC7_SRGB); + STR(ETC2_R8G8B8_UNORM); + STR(ETC2_R8G8B8A1_UNORM); + STR(ETC2_R8G8B8A8_UNORM); + STR(EAC_R11_UNORM); + STR(EAC_R11_SNORM); + STR(EAC_R11G11_UNORM); + STR(EAC_R11G11_SNORM); + STR(ASTC_4x4_UNORM); + STR(ASTC_4x4_SRGB); + STR(ASTC_4x5_UNORM); + STR(ASTC_4x5_SRGB); + STR(ASTC_5x5_UNORM); + STR(ASTC_5x5_SRGB); + STR(ASTC_6x5_UNORM); + STR(ASTC_6x5_SRGB); + STR(ASTC_6x6_UNORM); + STR(ASTC_6x6_SRGB); + STR(ASTC_8x5_UNORM); + STR(ASTC_8x5_SRGB); + STR(ASTC_8x6_UNORM); + STR(ASTC_8x6_SRGB); + STR(ASTC_8x8_UNORM); + STR(ASTC_8x8_SRGB); + STR(ASTC_10x5_UNORM); + STR(ASTC_10x5_SRGB); + STR(ASTC_10x6_UNORM); + STR(ASTC_10x6_SRGB); + STR(ASTC_10x8_UNORM); + STR(ASTC_10x8_SRGB); + STR(ASTC_10x10_UNORM); + STR(ASTC_10x10_SRGB); + STR(ASTC_12x10_UNORM); + STR(ASTC_12x10_SRGB); + STR(ASTC_12x12_UNORM); + STR(ASTC_12x12_SRGB); + STR(B5G6R5_UNORM); + STR(B5G6R5_USCALED); + STR(B8G8R8_UNORM); + STR(B8G8R8_SNORM); + STR(B8G8R8_USCALED); + STR(B8G8R8_SSCALED); + STR(B8G8R8_UINT); + STR(B8G8R8_SINT); + STR(B8G8R8_SRGB); + STR(B8G8R8A8_UNORM); + STR(B8G8R8A8_SNORM); + STR(B8G8R8A8_USCALED); + STR(B8G8R8A8_SSCALED); + STR(B8G8R8A8_UINT); + STR(B8G8R8A8_SINT); + STR(B8G8R8A8_SRGB); + STR(B10G10R10A2_UNORM); + STR(B10G10R10A2_SNORM); + STR(B10G10R10A2_USCALED); + STR(B10G10R10A2_SSCALED); + STR(B10G10R10A2_UINT); + STR(B10G10R10A2_SINT); #undef STR - default: return "UNKNOWN_CH"; - } -} - -static const char *xgl_numeric_format_string(XGL_NUM_FORMAT num) -{ - switch (num) { -#define STR(r) case XGL_NUM_FMT_ ##r: return #r - STR(UNDEFINED); - STR(UNORM); - STR(SNORM); - STR(UINT); - STR(SINT); - STR(FLOAT); - STR(SRGB); - STR(DS); - STR(USCALED); - STR(SSCALED); -#undef STR - default: return "UNKNOWN_NUM"; + default: return "UNKNOWN_FORMAT"; } } static void app_dev_init_formats(struct app_dev *dev) { - XGL_CHANNEL_FORMAT ch; - XGL_NUM_FORMAT num; - - for (ch = 0; ch < XGL_MAX_CH_FMT; ch++) { - for (num = 0; num < XGL_MAX_NUM_FMT; num++) { - const XGL_FORMAT fmt = { - .channelFormat = ch, - .numericFormat = num, - }; - XGL_RESULT err; - XGL_SIZE size = sizeof(dev->format_props[ch][num]); - - err = xglGetFormatInfo(dev->obj, fmt, - XGL_INFO_TYPE_FORMAT_PROPERTIES, - &size, &dev->format_props[ch][num]); - if (err) { - memset(&dev->format_props[ch][num], 0, - sizeof(dev->format_props[ch][num])); - } - else if (size != sizeof(dev->format_props[ch][num])) { - ERR_EXIT(XGL_ERROR_UNKNOWN); - } + XGL_FORMAT f; + + for (f = 0; f < XGL_NUM_FMT; f++) { + const XGL_FORMAT fmt = f; + XGL_RESULT err; + XGL_SIZE size = sizeof(dev->format_props[f]); + + err = xglGetFormatInfo(dev->obj, fmt, + XGL_INFO_TYPE_FORMAT_PROPERTIES, + &size, &dev->format_props[f]); + if (err) { + memset(&dev->format_props[f], 0, + sizeof(dev->format_props[f])); + } + else if (size != sizeof(dev->format_props[f])) { + ERR_EXIT(XGL_ERROR_UNKNOWN); } } } @@ -360,9 +464,9 @@ static void app_gpu_destroy(struct app_gpu *gpu) free(gpu->queue_props); } -static void app_dev_dump_format_props(const struct app_dev *dev, XGL_CHANNEL_FORMAT ch, XGL_NUM_FORMAT num) +static void app_dev_dump_format_props(const struct app_dev *dev, XGL_FORMAT fmt) { - const XGL_FORMAT_PROPERTIES *props = &dev->format_props[ch][num]; + const XGL_FORMAT_PROPERTIES *props = &dev->format_props[fmt]; struct { const char *name; XGL_FLAGS flags; @@ -377,8 +481,7 @@ static void app_dev_dump_format_props(const struct app_dev *dev, XGL_CHANNEL_FOR tilings[1].name = "optimal"; tilings[1].flags = props->optimalTilingFeatures; - printf("FORMAT_%s_%s\n", xgl_channel_format_string(ch), - xgl_numeric_format_string(num)); + printf("FORMAT_%s\n", xgl_format_string(fmt)); for (i = 0; i < ARRAY_SIZE(tilings); i++) { if (!tilings[i].flags) continue; @@ -404,12 +507,10 @@ static void app_dev_dump_format_props(const struct app_dev *dev, XGL_CHANNEL_FOR static void app_dev_dump(const struct app_dev *dev) { - XGL_CHANNEL_FORMAT ch; - XGL_NUM_FORMAT num; + XGL_FORMAT fmt; - for (ch = 0; ch < XGL_MAX_CH_FMT; ch++) { - for (num = 0; num < XGL_MAX_NUM_FMT; num++) - app_dev_dump_format_props(dev, ch, num); + for (fmt = 0; fmt < XGL_NUM_FMT; fmt++) { + app_dev_dump_format_props(dev, fmt); } } diff --git a/icd/common/icd-format.c b/icd/common/icd-format.c index 688ab4fc..4119de11 100644 --- a/icd/common/icd-format.c +++ b/icd/common/icd-format.c @@ -32,50 +32,445 @@ static const struct icd_format_info { XGL_SIZE size; XGL_UINT channel_count; -} icd_format_table[XGL_MAX_CH_FMT + 1] = { - [XGL_CH_FMT_UNDEFINED] = { 0, 0 }, - [XGL_CH_FMT_R4G4] = { 1, 2 }, - [XGL_CH_FMT_R4G4B4A4] = { 2, 4 }, - [XGL_CH_FMT_R5G6B5] = { 2, 3 }, - [XGL_CH_FMT_B5G6R5] = { 2, 3 }, - [XGL_CH_FMT_R5G5B5A1] = { 2, 4 }, - [XGL_CH_FMT_R8] = { 1, 1 }, - [XGL_CH_FMT_R8G8] = { 2, 2 }, - [XGL_CH_FMT_R8G8B8A8] = { 4, 4 }, - [XGL_CH_FMT_B8G8R8A8] = { 4, 4 }, - [XGL_CH_FMT_R10G11B11] = { 4, 3 }, - [XGL_CH_FMT_R11G11B10] = { 4, 3 }, - [XGL_CH_FMT_R10G10B10A2] = { 4, 4 }, - [XGL_CH_FMT_R16] = { 2, 1 }, - [XGL_CH_FMT_R16G16] = { 4, 2 }, - [XGL_CH_FMT_R16G16B16A16] = { 8, 4 }, - [XGL_CH_FMT_R32] = { 4, 1 }, - [XGL_CH_FMT_R32G32] = { 8, 2 }, - [XGL_CH_FMT_R32G32B32] = { 12, 3 }, - [XGL_CH_FMT_R32G32B32A32] = { 16, 4 }, - [XGL_CH_FMT_R16G8] = { 3, 2 }, - [XGL_CH_FMT_R32G8] = { 5, 2 }, - [XGL_CH_FMT_R9G9B9E5] = { 4, 3 }, - [XGL_CH_FMT_BC1] = { 8, 4 }, - [XGL_CH_FMT_BC2] = { 16, 4 }, - [XGL_CH_FMT_BC3] = { 16, 4 }, - [XGL_CH_FMT_BC4] = { 8, 4 }, - [XGL_CH_FMT_BC5] = { 16, 4 }, - [XGL_CH_FMT_BC6U] = { 16, 4 }, - [XGL_CH_FMT_BC6S] = { 16, 4 }, - [XGL_CH_FMT_BC7] = { 16, 4 }, - [XGL_CH_FMT_R8G8B8] = { 3, 3 }, - [XGL_CH_FMT_R16G16B16] = { 6, 3 }, - [XGL_CH_FMT_B10G10R10A2] = { 4, 4 }, - [XGL_CH_FMT_R64] = { 8, 1 }, - [XGL_CH_FMT_R64G64] = { 16, 2 }, - [XGL_CH_FMT_R64G64B64] = { 24, 3 }, - [XGL_CH_FMT_R64G64B64A64] = { 32, 4 }, +} 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_UNORM] = { 8, 4 }, + [XGL_FMT_BC1_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 }, + /* 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_4x5_UNORM] = { 0, 0 }, + [XGL_FMT_ASTC_4x5_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 }, }; +bool icd_format_is_ds(XGL_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: + is_ds = true; + break; + default: + break; + } + + return is_ds; +} + +bool icd_format_is_norm(XGL_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_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_4x5_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: + is_norm = true; + break; + default: + break; + } + + return is_norm; +}; + +bool icd_format_is_int(XGL_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: + is_int = true; + break; + default: + break; + } + + return is_int; +} + +bool icd_format_is_float(XGL_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: + is_float = true; + break; + default: + break; + } + + return is_float; +} + +bool icd_format_is_srgb(XGL_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_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_4x5_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: + is_srgb = true; + break; + default: + break; + } + + return is_srgb; +} + +bool icd_format_is_compressed(XGL_FORMAT format) +{ + switch (format) { + case XGL_FMT_BC1_UNORM: + case XGL_FMT_BC1_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_4x5_UNORM: + case XGL_FMT_ASTC_4x5_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: + return true; + default: + return false; + } +} + size_t icd_format_get_size(XGL_FORMAT format) { - return icd_format_table[format.channelFormat].size; + return icd_format_table[format].size; } XGL_IMAGE_FORMAT_CLASS icd_format_get_class(XGL_FORMAT format) @@ -146,7 +541,7 @@ XGL_IMAGE_FORMAT_CLASS icd_format_get_class(XGL_FORMAT format) unsigned int icd_format_get_channel_count(XGL_FORMAT format) { - return icd_format_table[format.channelFormat].channel_count; + return icd_format_table[format].channel_count; } /** @@ -158,157 +553,229 @@ void icd_format_get_raw_value(XGL_FORMAT format, void *value) { /* assume little-endian */ - switch (format.channelFormat) { - case XGL_CH_FMT_UNDEFINED: + switch (format) { + case XGL_FMT_UNDEFINED: break; - case XGL_CH_FMT_R4G4: + case XGL_FMT_R4G4_UNORM: + case XGL_FMT_R4G4_USCALED: ((uint8_t *) value)[0] = (color[0] & 0xf) << 0 | (color[1] & 0xf) << 4; break; - case XGL_CH_FMT_R4G4B4A4: + case XGL_FMT_R4G4B4A4_UNORM: + case XGL_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_CH_FMT_R5G6B5: + case XGL_FMT_R5G6B5_UNORM: + case XGL_FMT_R5G6B5_USCALED: ((uint16_t *) value)[0] = (color[0] & 0x1f) << 0 | (color[1] & 0x3f) << 5 | (color[2] & 0x1f) << 11; break; - case XGL_CH_FMT_B5G6R5: + case XGL_FMT_B5G6R5_UNORM: ((uint16_t *) value)[0] = (color[2] & 0x1f) << 0 | (color[1] & 0x3f) << 5 | (color[0] & 0x1f) << 11; break; - case XGL_CH_FMT_R5G5B5A1: + case XGL_FMT_R5G5B5A1_UNORM: + case XGL_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_CH_FMT_R8: + 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: ((uint8_t *) value)[0] = (uint8_t) color[0]; break; - case XGL_CH_FMT_R8G8: + 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: ((uint8_t *) value)[0] = (uint8_t) color[0]; ((uint8_t *) value)[1] = (uint8_t) color[1]; break; - case XGL_CH_FMT_R8G8B8A8: + 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: ((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_CH_FMT_B8G8R8A8: + case XGL_FMT_B8G8R8A8_UNORM: + case XGL_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_CH_FMT_R10G11B11: - ((uint32_t *) value)[0] = (color[0] & 0x3ff) << 0 | - (color[1] & 0x7ff) << 10 | - (color[2] & 0x7ff) << 21; - break; - case XGL_CH_FMT_R11G11B10: + case XGL_FMT_R11G11B10_UFLOAT: ((uint32_t *) value)[0] = (color[0] & 0x7ff) << 0 | (color[1] & 0x7ff) << 11 | (color[2] & 0x3ff) << 22; break; - case XGL_CH_FMT_R10G10B10A2: + 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: ((uint32_t *) value)[0] = (color[0] & 0x3ff) << 0 | (color[1] & 0x3ff) << 10 | (color[2] & 0x3ff) << 20 | (color[3] & 0x3) << 30; break; - case XGL_CH_FMT_R16: + 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: ((uint16_t *) value)[0] = (uint16_t) color[0]; break; - case XGL_CH_FMT_R16G16: + 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: ((uint16_t *) value)[0] = (uint16_t) color[0]; ((uint16_t *) value)[1] = (uint16_t) color[1]; break; - case XGL_CH_FMT_R16G16B16A16: + 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: ((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_CH_FMT_R32: + case XGL_FMT_R32_UINT: + case XGL_FMT_R32_SINT: + case XGL_FMT_R32_SFLOAT: ((uint32_t *) value)[0] = color[0]; break; - case XGL_CH_FMT_R32G32: + case XGL_FMT_R32G32_UINT: + case XGL_FMT_R32G32_SINT: + case XGL_FMT_R32G32_SFLOAT: ((uint32_t *) value)[0] = color[0]; ((uint32_t *) value)[1] = color[1]; break; - case XGL_CH_FMT_R32G32B32: + case XGL_FMT_R32G32B32_UINT: + case XGL_FMT_R32G32B32_SINT: + case XGL_FMT_R32G32B32_SFLOAT: ((uint32_t *) value)[0] = color[0]; ((uint32_t *) value)[1] = color[1]; ((uint32_t *) value)[2] = color[2]; break; - case XGL_CH_FMT_R32G32B32A32: + case XGL_FMT_R32G32B32A32_UINT: + case XGL_FMT_R32G32B32A32_SINT: + case XGL_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_CH_FMT_R16G8: + case XGL_FMT_D16_UNORM_S8_UINT: ((uint16_t *) value)[0] = (uint16_t) color[0]; ((char *) value)[2] = (uint8_t) color[1]; break; - case XGL_CH_FMT_R32G8: + case XGL_FMT_D32_SFLOAT_S8_UINT: ((uint32_t *) value)[0] = (uint32_t) color[0]; ((char *) value)[4] = (uint8_t) color[1]; break; - case XGL_CH_FMT_R9G9B9E5: + case XGL_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_CH_FMT_BC1: - case XGL_CH_FMT_BC4: + case XGL_FMT_BC1_UNORM: + case XGL_FMT_BC1_SRGB: + case XGL_FMT_BC4_UNORM: + case XGL_FMT_BC4_SNORM: memcpy(value, color, 8); break; - case XGL_CH_FMT_BC2: - case XGL_CH_FMT_BC3: - case XGL_CH_FMT_BC5: - case XGL_CH_FMT_BC6U: - case XGL_CH_FMT_BC6S: - case XGL_CH_FMT_BC7: + 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: memcpy(value, color, 16); break; - case XGL_CH_FMT_R8G8B8: + 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: ((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_CH_FMT_R16G16B16: + 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: ((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_CH_FMT_B10G10R10A2: + 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: ((uint32_t *) value)[0] = (color[2] & 0x3ff) << 0 | (color[1] & 0x3ff) << 10 | (color[0] & 0x3ff) << 20 | (color[3] & 0x3) << 30; break; - case XGL_CH_FMT_R64: + case XGL_FMT_R64_SFLOAT: /* higher 32 bits always 0 */ ((uint64_t *) value)[0] = color[0]; break; - case XGL_CH_FMT_R64G64: + case XGL_FMT_R64G64_SFLOAT: ((uint64_t *) value)[0] = color[0]; ((uint64_t *) value)[1] = color[1]; break; - case XGL_CH_FMT_R64G64B64: + case XGL_FMT_R64G64B64_SFLOAT: ((uint64_t *) value)[0] = color[0]; ((uint64_t *) value)[1] = color[1]; ((uint64_t *) value)[2] = color[2]; break; - case XGL_CH_FMT_R64G64B64A64: + case XGL_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 9c417001..f1825f66 100644 --- a/icd/common/icd-format.h +++ b/icd/common/icd-format.h @@ -33,69 +33,25 @@ static inline bool icd_format_is_undef(XGL_FORMAT format) { - return (format.numericFormat == XGL_NUM_FMT_UNDEFINED); + return (format == XGL_FMT_UNDEFINED); } -static inline bool icd_format_is_ds(XGL_FORMAT format) -{ - return (format.numericFormat == XGL_NUM_FMT_DS); -} +bool icd_format_is_ds(XGL_FORMAT format); static inline bool icd_format_is_color(XGL_FORMAT format) { return !(icd_format_is_undef(format) || icd_format_is_ds(format)); } -static inline bool icd_format_is_norm(XGL_FORMAT format) -{ - return (format.numericFormat == XGL_NUM_FMT_UNORM || - format.numericFormat == XGL_NUM_FMT_SNORM); -}; +bool icd_format_is_norm(XGL_FORMAT format); -static inline bool icd_format_is_int(XGL_FORMAT format) -{ - return (format.numericFormat == XGL_NUM_FMT_UINT || - format.numericFormat == XGL_NUM_FMT_SINT); -} +bool icd_format_is_int(XGL_FORMAT format); -static inline bool icd_format_is_float(XGL_FORMAT format) -{ - return (format.numericFormat == XGL_NUM_FMT_FLOAT); -} +bool icd_format_is_float(XGL_FORMAT format); -static inline bool icd_format_is_srgb(XGL_FORMAT format) -{ - return (format.numericFormat == XGL_NUM_FMT_SRGB); -} +bool icd_format_is_srgb(XGL_FORMAT format); -static inline bool icd_format_is_scaled(XGL_FORMAT format) -{ - return (format.numericFormat == XGL_NUM_FMT_USCALED || - format.numericFormat == XGL_NUM_FMT_SSCALED); -} - -static inline bool icd_format_is_compressed(XGL_FORMAT format) -{ - switch (format.channelFormat) { - case XGL_CH_FMT_BC1: - case XGL_CH_FMT_BC2: - case XGL_CH_FMT_BC3: - case XGL_CH_FMT_BC4: - case XGL_CH_FMT_BC5: - case XGL_CH_FMT_BC6U: - case XGL_CH_FMT_BC6S: - case XGL_CH_FMT_BC7: - return true; - default: - return false; - } -} - -static inline bool icd_format_is_equal(XGL_FORMAT a, XGL_FORMAT b) -{ - return (a.channelFormat == b.channelFormat && - a.numericFormat == b.numericFormat); -} +bool icd_format_is_compressed(XGL_FORMAT format); static inline int icd_format_get_block_width(XGL_FORMAT format) { diff --git a/include/xgl.h b/include/xgl.h index 14524330..95201905 100644 --- a/include/xgl.h +++ b/include/xgl.h @@ -54,7 +54,7 @@ #include "xglPlatform.h" // XGL API version supported by this file -#define XGL_API_VERSION XGL_MAKE_VERSION(0, 30, 7) +#define XGL_API_VERSION XGL_MAKE_VERSION(0, 30, 8) #ifdef __cplusplus extern "C" @@ -800,65 +800,6 @@ typedef enum _XGL_RESULT_CODE // ------------------------------------------------------------------------------------------------ // XGL format definitions -typedef enum _XGL_CHANNEL_FORMAT -{ - XGL_CH_FMT_UNDEFINED = 0, - XGL_CH_FMT_R4G4 = 1, - XGL_CH_FMT_R4G4B4A4 = 2, - XGL_CH_FMT_R5G6B5 = 3, - XGL_CH_FMT_B5G6R5 = 4, - XGL_CH_FMT_R5G5B5A1 = 5, - XGL_CH_FMT_R8 = 6, - XGL_CH_FMT_R8G8 = 7, - XGL_CH_FMT_R8G8B8A8 = 8, - XGL_CH_FMT_B8G8R8A8 = 9, - XGL_CH_FMT_R10G11B11 = 10, - XGL_CH_FMT_R11G11B10 = 11, - XGL_CH_FMT_R10G10B10A2 = 12, - XGL_CH_FMT_R16 = 13, - XGL_CH_FMT_R16G16 = 14, - XGL_CH_FMT_R16G16B16A16 = 15, - XGL_CH_FMT_R32 = 16, - XGL_CH_FMT_R32G32 = 17, - XGL_CH_FMT_R32G32B32 = 18, - XGL_CH_FMT_R32G32B32A32 = 19, - XGL_CH_FMT_R16G8 = 20, - XGL_CH_FMT_R32G8 = 21, - XGL_CH_FMT_R9G9B9E5 = 22, - XGL_CH_FMT_BC1 = 23, - XGL_CH_FMT_BC2 = 24, - XGL_CH_FMT_BC3 = 25, - XGL_CH_FMT_BC4 = 26, - XGL_CH_FMT_BC5 = 27, - XGL_CH_FMT_BC6U = 28, - XGL_CH_FMT_BC6S = 29, - XGL_CH_FMT_BC7 = 30, - XGL_CH_FMT_R8G8B8 = 31, - XGL_CH_FMT_R16G16B16 = 32, - XGL_CH_FMT_B10G10R10A2 = 33, - XGL_CH_FMT_R64 = 34, // Optional - XGL_CH_FMT_R64G64 = 35, // Optional - XGL_CH_FMT_R64G64B64 = 36, // Optional - XGL_CH_FMT_R64G64B64A64 = 37, // Optional - XGL_MAX_CH_FMT = XGL_CH_FMT_R64G64B64A64, - XGL_MAX_ENUM(_XGL_CHANNEL_FORMAT) -} XGL_CHANNEL_FORMAT; - -typedef enum _XGL_NUM_FORMAT -{ - XGL_NUM_FMT_UNDEFINED = 0, - XGL_NUM_FMT_UNORM = 1, - XGL_NUM_FMT_SNORM = 2, - XGL_NUM_FMT_UINT = 3, - XGL_NUM_FMT_SINT = 4, - XGL_NUM_FMT_FLOAT = 5, - XGL_NUM_FMT_SRGB = 6, - XGL_NUM_FMT_DS = 7, - XGL_NUM_FMT_USCALED = 8, - XGL_NUM_FMT_SSCALED = 9, - XGL_MAX_NUM_FMT = XGL_NUM_FMT_SSCALED, - XGL_MAX_ENUM(_XGL_NUM_FORMAT) -} XGL_NUM_FORMAT; typedef enum _XGL_VERTEX_INPUT_STEP_RATE { @@ -872,14 +813,180 @@ typedef enum _XGL_VERTEX_INPUT_STEP_RATE XGL_MAX_ENUM(_XGL_VERTEX_INPUT_STEP_RATE) } XGL_VERTEX_INPUT_STEP_RATE; -typedef struct _XGL_FORMAT -{ - XGL_CHANNEL_FORMAT channelFormat; - XGL_NUM_FORMAT numericFormat; - -// XGL_FMT_BEGIN_RANGE = XGL_FMT_UNDEFINED, ////LUGMAL -// XGL_FMT_END_RANGE = XGL_FMT_ASTC_12x12_SRGB, -// XGL_NUM_FMT = (XGL_FMT_END_RANGE - XGL_FMT_BEGIN_RANGE + 1), +typedef enum _XGL_FORMAT +{ + XGL_FMT_UNDEFINED = 0x00000000, + XGL_FMT_R4G4_UNORM = 0x00000001, + XGL_FMT_R4G4_USCALED = 0x00000002, + XGL_FMT_R4G4B4A4_UNORM = 0x00000003, + XGL_FMT_R4G4B4A4_USCALED = 0x00000004, + XGL_FMT_R5G6B5_UNORM = 0x00000005, + XGL_FMT_R5G6B5_USCALED = 0x00000006, + XGL_FMT_R5G5B5A1_UNORM = 0x00000007, + XGL_FMT_R5G5B5A1_USCALED = 0x00000008, + XGL_FMT_R8_UNORM = 0x00000009, + XGL_FMT_R8_SNORM = 0x0000000A, + XGL_FMT_R8_USCALED = 0x0000000B, + XGL_FMT_R8_SSCALED = 0x0000000C, + XGL_FMT_R8_UINT = 0x0000000D, + XGL_FMT_R8_SINT = 0x0000000E, + XGL_FMT_R8_SRGB = 0x0000000F, + XGL_FMT_R8G8_UNORM = 0x00000010, + XGL_FMT_R8G8_SNORM = 0x00000011, + XGL_FMT_R8G8_USCALED = 0x00000012, + XGL_FMT_R8G8_SSCALED = 0x00000013, + XGL_FMT_R8G8_UINT = 0x00000014, + XGL_FMT_R8G8_SINT = 0x00000015, + XGL_FMT_R8G8_SRGB = 0x00000016, + XGL_FMT_R8G8B8_UNORM = 0x00000017, + XGL_FMT_R8G8B8_SNORM = 0x00000018, + XGL_FMT_R8G8B8_USCALED = 0x00000019, + XGL_FMT_R8G8B8_SSCALED = 0x0000001A, + XGL_FMT_R8G8B8_UINT = 0x0000001B, + XGL_FMT_R8G8B8_SINT = 0x0000001C, + XGL_FMT_R8G8B8_SRGB = 0x0000001D, + XGL_FMT_R8G8B8A8_UNORM = 0x0000001E, + XGL_FMT_R8G8B8A8_SNORM = 0x0000001F, + XGL_FMT_R8G8B8A8_USCALED = 0x00000020, + XGL_FMT_R8G8B8A8_SSCALED = 0x00000021, + XGL_FMT_R8G8B8A8_UINT = 0x00000022, + XGL_FMT_R8G8B8A8_SINT = 0x00000023, + XGL_FMT_R8G8B8A8_SRGB = 0x00000024, + XGL_FMT_R10G10B10A2_UNORM = 0x00000025, + XGL_FMT_R10G10B10A2_SNORM = 0x00000026, + XGL_FMT_R10G10B10A2_USCALED = 0x00000027, + XGL_FMT_R10G10B10A2_SSCALED = 0x00000028, + XGL_FMT_R10G10B10A2_UINT = 0x00000029, + XGL_FMT_R10G10B10A2_SINT = 0x0000002A, + XGL_FMT_R16_UNORM = 0x0000002B, + XGL_FMT_R16_SNORM = 0x0000002C, + XGL_FMT_R16_USCALED = 0x0000002D, + XGL_FMT_R16_SSCALED = 0x0000002E, + XGL_FMT_R16_UINT = 0x0000002F, + XGL_FMT_R16_SINT = 0x00000030, + XGL_FMT_R16_SFLOAT = 0x00000031, + XGL_FMT_R16G16_UNORM = 0x00000032, + XGL_FMT_R16G16_SNORM = 0x00000033, + XGL_FMT_R16G16_USCALED = 0x00000034, + XGL_FMT_R16G16_SSCALED = 0x00000035, + XGL_FMT_R16G16_UINT = 0x00000036, + XGL_FMT_R16G16_SINT = 0x00000037, + XGL_FMT_R16G16_SFLOAT = 0x00000038, + XGL_FMT_R16G16B16_UNORM = 0x00000039, + XGL_FMT_R16G16B16_SNORM = 0x0000003A, + XGL_FMT_R16G16B16_USCALED = 0x0000003B, + XGL_FMT_R16G16B16_SSCALED = 0x0000003C, + XGL_FMT_R16G16B16_UINT = 0x0000003D, + XGL_FMT_R16G16B16_SINT = 0x0000003E, + XGL_FMT_R16G16B16_SFLOAT = 0x0000003F, + XGL_FMT_R16G16B16A16_UNORM = 0x00000040, + XGL_FMT_R16G16B16A16_SNORM = 0x00000041, + XGL_FMT_R16G16B16A16_USCALED = 0x00000042, + XGL_FMT_R16G16B16A16_SSCALED = 0x00000043, + XGL_FMT_R16G16B16A16_UINT = 0x00000044, + XGL_FMT_R16G16B16A16_SINT = 0x00000045, + XGL_FMT_R16G16B16A16_SFLOAT = 0x00000046, + XGL_FMT_R32_UINT = 0x00000047, + XGL_FMT_R32_SINT = 0x00000048, + XGL_FMT_R32_SFLOAT = 0x00000049, + XGL_FMT_R32G32_UINT = 0x0000004A, + XGL_FMT_R32G32_SINT = 0x0000004B, + XGL_FMT_R32G32_SFLOAT = 0x0000004C, + XGL_FMT_R32G32B32_UINT = 0x0000004D, + XGL_FMT_R32G32B32_SINT = 0x0000004E, + XGL_FMT_R32G32B32_SFLOAT = 0x0000004F, + XGL_FMT_R32G32B32A32_UINT = 0x00000050, + XGL_FMT_R32G32B32A32_SINT = 0x00000051, + XGL_FMT_R32G32B32A32_SFLOAT = 0x00000052, + XGL_FMT_R64_SFLOAT = 0x00000053, + XGL_FMT_R64G64_SFLOAT = 0x00000054, + XGL_FMT_R64G64B64_SFLOAT = 0x00000055, + XGL_FMT_R64G64B64A64_SFLOAT = 0x00000056, + XGL_FMT_R11G11B10_UFLOAT = 0x00000057, + XGL_FMT_R9G9B9E5_UFLOAT = 0x00000058, + XGL_FMT_D16_UNORM = 0x00000059, + XGL_FMT_D24_UNORM = 0x0000005A, + XGL_FMT_D32_SFLOAT = 0x0000005B, + XGL_FMT_S8_UINT = 0x0000005C, + XGL_FMT_D16_UNORM_S8_UINT = 0x0000005D, + XGL_FMT_D24_UNORM_S8_UINT = 0x0000005E, + XGL_FMT_D32_SFLOAT_S8_UINT = 0x0000005F, + XGL_FMT_BC1_UNORM = 0x00000060, + XGL_FMT_BC1_SRGB = 0x00000061, + XGL_FMT_BC2_UNORM = 0x00000062, + XGL_FMT_BC2_SRGB = 0x00000063, + XGL_FMT_BC3_UNORM = 0x00000064, + XGL_FMT_BC3_SRGB = 0x00000065, + XGL_FMT_BC4_UNORM = 0x00000066, + XGL_FMT_BC4_SNORM = 0x00000067, + XGL_FMT_BC5_UNORM = 0x00000068, + XGL_FMT_BC5_SNORM = 0x00000069, + XGL_FMT_BC6H_UFLOAT = 0x0000006A, + XGL_FMT_BC6H_SFLOAT = 0x0000006B, + XGL_FMT_BC7_UNORM = 0x0000006C, + XGL_FMT_BC7_SRGB = 0x0000006D, + XGL_FMT_ETC2_R8G8B8_UNORM = 0x0000006E, + XGL_FMT_ETC2_R8G8B8A1_UNORM = 0x0000006F, + XGL_FMT_ETC2_R8G8B8A8_UNORM = 0x00000070, + XGL_FMT_EAC_R11_UNORM = 0x00000071, + XGL_FMT_EAC_R11_SNORM = 0x00000072, + XGL_FMT_EAC_R11G11_UNORM = 0x00000073, + XGL_FMT_EAC_R11G11_SNORM = 0x00000074, + XGL_FMT_ASTC_4x4_UNORM = 0x00000075, + XGL_FMT_ASTC_4x4_SRGB = 0x00000076, + XGL_FMT_ASTC_4x5_UNORM = 0x00000077, + XGL_FMT_ASTC_4x5_SRGB = 0x00000078, + XGL_FMT_ASTC_5x5_UNORM = 0x00000079, + XGL_FMT_ASTC_5x5_SRGB = 0x0000007A, + XGL_FMT_ASTC_6x5_UNORM = 0x0000007B, + XGL_FMT_ASTC_6x5_SRGB = 0x0000007C, + XGL_FMT_ASTC_6x6_UNORM = 0x0000007D, + XGL_FMT_ASTC_6x6_SRGB = 0x0000007E, + XGL_FMT_ASTC_8x5_UNORM = 0x0000007F, + XGL_FMT_ASTC_8x5_SRGB = 0x00000080, + XGL_FMT_ASTC_8x6_UNORM = 0x00000081, + XGL_FMT_ASTC_8x6_SRGB = 0x00000082, + XGL_FMT_ASTC_8x8_UNORM = 0x00000083, + XGL_FMT_ASTC_8x8_SRGB = 0x00000084, + XGL_FMT_ASTC_10x5_UNORM = 0x00000085, + XGL_FMT_ASTC_10x5_SRGB = 0x00000086, + XGL_FMT_ASTC_10x6_UNORM = 0x00000087, + XGL_FMT_ASTC_10x6_SRGB = 0x00000088, + XGL_FMT_ASTC_10x8_UNORM = 0x00000089, + XGL_FMT_ASTC_10x8_SRGB = 0x0000008A, + XGL_FMT_ASTC_10x10_UNORM = 0x0000008B, + XGL_FMT_ASTC_10x10_SRGB = 0x0000008C, + XGL_FMT_ASTC_12x10_UNORM = 0x0000008D, + XGL_FMT_ASTC_12x10_SRGB = 0x0000008E, + XGL_FMT_ASTC_12x12_UNORM = 0x0000008F, + XGL_FMT_ASTC_12x12_SRGB = 0x00000090, + XGL_FMT_B5G6R5_UNORM = 0x00000091, + XGL_FMT_B5G6R5_USCALED = 0x00000092, + XGL_FMT_B8G8R8_UNORM = 0x00000093, + XGL_FMT_B8G8R8_SNORM = 0x00000094, + XGL_FMT_B8G8R8_USCALED = 0x00000095, + XGL_FMT_B8G8R8_SSCALED = 0x00000096, + XGL_FMT_B8G8R8_UINT = 0x00000097, + XGL_FMT_B8G8R8_SINT = 0x00000098, + XGL_FMT_B8G8R8_SRGB = 0x00000099, + XGL_FMT_B8G8R8A8_UNORM = 0x0000009A, + XGL_FMT_B8G8R8A8_SNORM = 0x0000009B, + XGL_FMT_B8G8R8A8_USCALED = 0x0000009C, + XGL_FMT_B8G8R8A8_SSCALED = 0x0000009D, + XGL_FMT_B8G8R8A8_UINT = 0x0000009E, + XGL_FMT_B8G8R8A8_SINT = 0x0000009F, + XGL_FMT_B8G8R8A8_SRGB = 0x000000A0, + XGL_FMT_B10G10R10A2_UNORM = 0x000000A1, + XGL_FMT_B10G10R10A2_SNORM = 0x000000A2, + XGL_FMT_B10G10R10A2_USCALED = 0x000000A3, + XGL_FMT_B10G10R10A2_SSCALED = 0x000000A4, + XGL_FMT_B10G10R10A2_UINT = 0x000000A5, + XGL_FMT_B10G10R10A2_SINT = 0x000000A6, + + XGL_FMT_BEGIN_RANGE = XGL_FMT_UNDEFINED, + XGL_FMT_END_RANGE = XGL_FMT_B10G10R10A2_SINT, + XGL_NUM_FMT = (XGL_FMT_END_RANGE - XGL_FMT_BEGIN_RANGE + 1), + XGL_MAX_ENUM(_XGL_FORMAT) } XGL_FORMAT; // Shader stage enumerant