From: Jeremy Hayes Date: Fri, 23 Jan 2015 15:51:43 +0000 (-0700) Subject: Update XGL_FORMAT. X-Git-Tag: sdk-0.1.0~755 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=2b7e88a1fdefc49d78e80765745e87e00034c2a0;p=platform%2Fupstream%2FVulkan-LoaderAndValidationLayers.git Update XGL_FORMAT. --- diff --git a/demos/cube.c b/demos/cube.c index 8c68e31..b02e443 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 413431f..19a591b 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 8fa0d1c..d37917f 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 688ab4f..4119de1 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 9c41700..f1825f6 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/icd/intel/cmd_meta.c b/icd/intel/cmd_meta.c index 641215e..f8391e8 100644 --- a/icd/intel/cmd_meta.c +++ b/icd/intel/cmd_meta.c @@ -375,28 +375,25 @@ static bool cmd_meta_mem_dword_aligned(const struct intel_cmd *cmd, static XGL_FORMAT cmd_meta_img_raw_format(const struct intel_cmd *cmd, XGL_FORMAT format) { - format.numericFormat = XGL_NUM_FMT_UINT; - switch (icd_format_get_size(format)) { case 1: - format.channelFormat = XGL_CH_FMT_R8; + format = XGL_FMT_R8_UINT; break; case 2: - format.channelFormat = XGL_CH_FMT_R16; + format = XGL_FMT_R16_UINT; break; case 4: - format.channelFormat = XGL_CH_FMT_R32; + format = XGL_FMT_R32_UINT; break; case 8: - format.channelFormat = XGL_CH_FMT_R32G32; + format = XGL_FMT_R32G32_UINT; break; case 16: - format.channelFormat = XGL_CH_FMT_R32G32B32A32; + format = XGL_FMT_R32G32B32A32_UINT; break; default: assert(!"unsupported image format for raw blit op"); - format.channelFormat = XGL_CH_FMT_UNDEFINED; - format.numericFormat = XGL_NUM_FMT_UNDEFINED; + format = XGL_FMT_UNDEFINED; break; } @@ -423,12 +420,11 @@ ICD_EXPORT XGL_VOID XGLAPI xglCmdCopyBuffer( meta.height = 1; meta.samples = 1; - format.channelFormat = XGL_CH_FMT_UNDEFINED; - format.numericFormat = XGL_NUM_FMT_UINT; + format = XGL_FMT_UNDEFINED; for (i = 0; i < regionCount; i++) { const XGL_BUFFER_COPY *region = &pRegions[i]; - XGL_CHANNEL_FORMAT ch; + XGL_FORMAT fmt; meta.src.x = region->srcOffset; meta.dst.x = region->destOffset; @@ -445,7 +441,7 @@ ICD_EXPORT XGL_VOID XGLAPI xglCmdCopyBuffer( * INTEL_DEV_META_VS_COPY_MEM is untyped but expects the stride to * be 16 */ - ch = XGL_CH_FMT_R32G32B32A32; + fmt = XGL_FMT_R32G32B32A32_UINT; } else { if (cmd_gen(cmd) == INTEL_GEN(6)) { intel_dev_log(cmd->dev, XGL_DBG_MSG_ERROR, @@ -461,11 +457,11 @@ ICD_EXPORT XGL_VOID XGLAPI xglCmdCopyBuffer( * INTEL_DEV_META_VS_COPY_MEM_UNALIGNED is untyped but expects the * stride to be 4 */ - ch = XGL_CH_FMT_R8G8B8A8; + fmt = XGL_FMT_R8G8B8A8_UINT; } - if (format.channelFormat != ch) { - format.channelFormat = ch; + if (format != fmt) { + format = fmt; cmd_meta_set_src_for_buf(cmd, src, format, &meta); cmd_meta_set_dst_for_buf(cmd, dst, format, &meta); @@ -495,7 +491,7 @@ ICD_EXPORT XGL_VOID XGLAPI xglCmdCopyImage( return; } - if (icd_format_is_equal(src->layout.format, dst->layout.format)) { + if (src->layout.format == dst->layout.format) { raw_copy = true; raw_format = cmd_meta_img_raw_format(cmd, src->layout.format); } else if (icd_format_is_compressed(src->layout.format) || @@ -616,35 +612,34 @@ ICD_EXPORT XGL_VOID XGLAPI xglCmdCopyImageToBuffer( meta.mode = INTEL_CMD_META_VS_POINTS; img_format = cmd_meta_img_raw_format(cmd, img->layout.format); - buf_format.numericFormat = XGL_NUM_FMT_UINT; /* buf_format is ignored by hw, but we derive stride from it */ - switch (img_format.channelFormat) { - case XGL_CH_FMT_R8: + switch (img_format) { + case XGL_FMT_R8_UINT: meta.shader_id = INTEL_DEV_META_VS_COPY_R8_TO_MEM; - buf_format.channelFormat = XGL_CH_FMT_R8G8B8A8; + buf_format = XGL_FMT_R8G8B8A8_UINT; break; - case XGL_CH_FMT_R16: + case XGL_FMT_R16_UINT: meta.shader_id = INTEL_DEV_META_VS_COPY_R16_TO_MEM; - buf_format.channelFormat = XGL_CH_FMT_R8G8B8A8; + buf_format = XGL_FMT_R8G8B8A8_UINT; break; - case XGL_CH_FMT_R32: + case XGL_FMT_R32_UINT: meta.shader_id = INTEL_DEV_META_VS_COPY_R32_TO_MEM; - buf_format.channelFormat = XGL_CH_FMT_R32G32B32A32; + buf_format = XGL_FMT_R32G32B32A32_UINT; break; - case XGL_CH_FMT_R32G32: + case XGL_FMT_R32G32_UINT: meta.shader_id = INTEL_DEV_META_VS_COPY_R32G32_TO_MEM; - buf_format.channelFormat = XGL_CH_FMT_R32G32B32A32; + buf_format = XGL_FMT_R32G32B32A32_UINT; break; - case XGL_CH_FMT_R32G32B32A32: + case XGL_FMT_R32G32B32A32_UINT: meta.shader_id = INTEL_DEV_META_VS_COPY_R32G32B32A32_TO_MEM; - buf_format.channelFormat = XGL_CH_FMT_R32G32B32A32; + buf_format = XGL_FMT_R32G32B32A32_UINT; break; default: break; } - if (img_format.channelFormat == XGL_CH_FMT_UNDEFINED || + if (img_format == XGL_FMT_UNDEFINED || (cmd_gen(cmd) == INTEL_GEN(6) && icd_format_get_size(img_format) < 4)) { intel_dev_log(cmd->dev, XGL_DBG_MSG_ERROR, @@ -769,8 +764,7 @@ ICD_EXPORT XGL_VOID XGLAPI xglCmdUpdateBuffer( /* * INTEL_DEV_META_VS_COPY_MEM is untyped but expects the stride to be 16 */ - format.channelFormat = XGL_CH_FMT_R32G32B32A32; - format.numericFormat = XGL_NUM_FMT_UINT; + format = XGL_FMT_R32G32B32A32_UINT; cmd_meta_set_src_for_writer(cmd, INTEL_CMD_WRITER_STATE, offset + dataSize, format, &meta); @@ -812,8 +806,7 @@ ICD_EXPORT XGL_VOID XGLAPI xglCmdFillBuffer( /* * INTEL_DEV_META_VS_FILL_MEM is untyped but expects the stride to be 16 */ - format.channelFormat = XGL_CH_FMT_R32G32B32A32; - format.numericFormat = XGL_NUM_FMT_UINT; + format = XGL_FMT_R32G32B32A32_UINT; cmd_meta_set_dst_for_buf(cmd, dst, format, &meta); @@ -970,7 +963,7 @@ ICD_EXPORT XGL_VOID XGLAPI xglCmdResolveImage( XGL_UINT i; if (src->samples <= 1 || dst->samples > 1 || - !icd_format_is_equal(src->layout.format, dst->layout.format)) { + src->layout.format != dst->layout.format) { cmd->result = XGL_ERROR_UNKNOWN; return; } diff --git a/icd/intel/cmd_pipeline.c b/icd/intel/cmd_pipeline.c index aa03f66..5b69174 100644 --- a/icd/intel/cmd_pipeline.c +++ b/icd/intel/cmd_pipeline.c @@ -391,12 +391,12 @@ static void gen7_fill_3DSTATE_SF_body(const struct intel_cmd *cmd, if (cmd_gen(cmd) >= INTEL_GEN(7)) { int format; - switch (pipeline->db_format.channelFormat) { - case XGL_CH_FMT_R16: + switch (pipeline->db_format) { + case XGL_FMT_D16_UNORM: format = GEN6_ZFORMAT_D16_UNORM; break; - case XGL_CH_FMT_R32: - case XGL_CH_FMT_R32G8: + case XGL_FMT_D32_SFLOAT: + case XGL_FMT_D32_SFLOAT_S8_UINT: format = GEN6_ZFORMAT_D32_FLOAT; break; default: diff --git a/icd/intel/cmd_prepare.c b/icd/intel/cmd_prepare.c index a8f6165..3f45691 100644 --- a/icd/intel/cmd_prepare.c +++ b/icd/intel/cmd_prepare.c @@ -156,7 +156,7 @@ static void cmd_memory_barriers(struct intel_cmd *cmd, flush_flags |= cmd_get_flush_flags(cmd, img_get_layout_caches(img, image_memory_barrier->oldLayout), img_get_layout_caches(img, image_memory_barrier->newLayout), - (img->layout.format.numericFormat == XGL_NUM_FMT_DS)); + icd_format_is_ds(img->layout.format)); } break; default: diff --git a/icd/intel/format.c b/icd/intel/format.c index b390dec..2787433 100644 --- a/icd/intel/format.c +++ b/icd/intel/format.c @@ -377,277 +377,167 @@ static const struct intel_dp_cap intel_dp_caps[] = { #undef CAP }; -static const int intel_color_mapping[XGL_MAX_CH_FMT + 1][9] = { - [XGL_CH_FMT_B5G6R5] = { GEN6_FORMAT_B5G6R5_UNORM, - 0, - 0, - 0, - 0, - GEN6_FORMAT_B5G6R5_UNORM_SRGB, - 0, - 0, - 0, }, - [XGL_CH_FMT_R8] = { GEN6_FORMAT_R8_UNORM, - GEN6_FORMAT_R8_SNORM, - GEN6_FORMAT_R8_UINT, - GEN6_FORMAT_R8_SINT, - 0, - 0, - 0, - GEN6_FORMAT_R8_USCALED, - GEN6_FORMAT_R8_SSCALED, }, - [XGL_CH_FMT_R8G8] = { GEN6_FORMAT_R8G8_UNORM, - GEN6_FORMAT_R8G8_SNORM, - GEN6_FORMAT_R8G8_UINT, - GEN6_FORMAT_R8G8_SINT, - 0, - 0, - 0, - GEN6_FORMAT_R8G8_USCALED, - GEN6_FORMAT_R8G8_SSCALED, }, - [XGL_CH_FMT_R8G8B8A8] = { GEN6_FORMAT_R8G8B8A8_UNORM, - GEN6_FORMAT_R8G8B8A8_SNORM, - GEN6_FORMAT_R8G8B8A8_UINT, - GEN6_FORMAT_R8G8B8A8_SINT, - 0, - GEN6_FORMAT_R8G8B8A8_UNORM_SRGB, - 0, - GEN6_FORMAT_R8G8B8A8_USCALED, - GEN6_FORMAT_R8G8B8A8_SSCALED, }, - [XGL_CH_FMT_B8G8R8A8] = { GEN6_FORMAT_B8G8R8A8_UNORM, - 0, - 0, - 0, - 0, - GEN6_FORMAT_B8G8R8A8_UNORM_SRGB, - 0, - 0, - 0, }, - [XGL_CH_FMT_R11G11B10] = { 0, - 0, - 0, - 0, - GEN6_FORMAT_R11G11B10_FLOAT, - 0, - 0, - 0, - 0, }, - [XGL_CH_FMT_R10G10B10A2] = { GEN6_FORMAT_R10G10B10A2_UNORM, - GEN6_FORMAT_R10G10B10A2_SNORM, - GEN6_FORMAT_R10G10B10A2_UINT, - GEN6_FORMAT_R10G10B10A2_SINT, - 0, - 0, - 0, - GEN6_FORMAT_R10G10B10A2_USCALED, - GEN6_FORMAT_R10G10B10A2_SSCALED, }, - [XGL_CH_FMT_R16] = { GEN6_FORMAT_R16_UNORM, - GEN6_FORMAT_R16_SNORM, - GEN6_FORMAT_R16_UINT, - GEN6_FORMAT_R16_SINT, - GEN6_FORMAT_R16_FLOAT, - 0, - 0, - GEN6_FORMAT_R16_USCALED, - GEN6_FORMAT_R16_SSCALED, }, - [XGL_CH_FMT_R16G16] = { GEN6_FORMAT_R16G16_UNORM, - GEN6_FORMAT_R16G16_SNORM, - GEN6_FORMAT_R16G16_UINT, - GEN6_FORMAT_R16G16_SINT, - GEN6_FORMAT_R16G16_FLOAT, - 0, - 0, - GEN6_FORMAT_R16G16_USCALED, - GEN6_FORMAT_R16G16_SSCALED, }, - [XGL_CH_FMT_R16G16B16A16] = { GEN6_FORMAT_R16G16B16A16_UNORM, - GEN6_FORMAT_R16G16B16A16_SNORM, - GEN6_FORMAT_R16G16B16A16_UINT, - GEN6_FORMAT_R16G16B16A16_SINT, - GEN6_FORMAT_R16G16B16A16_FLOAT, - 0, - 0, - GEN6_FORMAT_R16G16B16A16_USCALED, - GEN6_FORMAT_R16G16B16A16_SSCALED, }, - [XGL_CH_FMT_R32] = { GEN6_FORMAT_R32_UNORM, - GEN6_FORMAT_R32_SNORM, - GEN6_FORMAT_R32_UINT, - GEN6_FORMAT_R32_SINT, - GEN6_FORMAT_R32_FLOAT, - 0, - 0, - GEN6_FORMAT_R32_USCALED, - GEN6_FORMAT_R32_SSCALED, }, - [XGL_CH_FMT_R32G32] = { GEN6_FORMAT_R32G32_UNORM, - GEN6_FORMAT_R32G32_SNORM, - GEN6_FORMAT_R32G32_UINT, - GEN6_FORMAT_R32G32_SINT, - GEN6_FORMAT_R32G32_FLOAT, - 0, - 0, - GEN6_FORMAT_R32G32_USCALED, - GEN6_FORMAT_R32G32_SSCALED, }, - [XGL_CH_FMT_R32G32B32] = { GEN6_FORMAT_R32G32B32_UNORM, - GEN6_FORMAT_R32G32B32_SNORM, - GEN6_FORMAT_R32G32B32_UINT, - GEN6_FORMAT_R32G32B32_SINT, - GEN6_FORMAT_R32G32B32_FLOAT, - 0, - 0, - GEN6_FORMAT_R32G32B32_USCALED, - GEN6_FORMAT_R32G32B32_SSCALED, }, - [XGL_CH_FMT_R32G32B32A32] = { GEN6_FORMAT_R32G32B32A32_UNORM, - GEN6_FORMAT_R32G32B32A32_SNORM, - GEN6_FORMAT_R32G32B32A32_UINT, - GEN6_FORMAT_R32G32B32A32_SINT, - GEN6_FORMAT_R32G32B32A32_FLOAT, - 0, - 0, - GEN6_FORMAT_R32G32B32A32_USCALED, - GEN6_FORMAT_R32G32B32A32_SSCALED, }, - [XGL_CH_FMT_R9G9B9E5] = { 0, - 0, - 0, - 0, - GEN6_FORMAT_R9G9B9E5_SHAREDEXP, - 0, - 0, - 0, - 0, }, - [XGL_CH_FMT_BC1] = { GEN6_FORMAT_BC1_UNORM, - 0, - 0, - 0, - 0, - GEN6_FORMAT_BC1_UNORM_SRGB, - 0, - 0, - 0, }, - [XGL_CH_FMT_BC2] = { GEN6_FORMAT_BC2_UNORM, - 0, - 0, - 0, - 0, - GEN6_FORMAT_BC2_UNORM_SRGB, - 0, - 0, - 0, }, - [XGL_CH_FMT_BC3] = { GEN6_FORMAT_BC3_UNORM, - 0, - 0, - 0, - 0, - GEN6_FORMAT_BC3_UNORM_SRGB, - 0, - 0, - 0, }, - [XGL_CH_FMT_BC4] = { GEN6_FORMAT_BC4_UNORM, - GEN6_FORMAT_BC4_SNORM, - 0, - 0, - 0, - 0, - 0, - 0, - 0, }, - [XGL_CH_FMT_BC5] = { GEN6_FORMAT_BC5_UNORM, - GEN6_FORMAT_BC5_SNORM, - 0, - 0, - 0, - 0, - 0, - 0, - 0, }, - [XGL_CH_FMT_BC6U] = { GEN6_FORMAT_BC6H_UF16, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, }, - [XGL_CH_FMT_BC6S] = { GEN6_FORMAT_BC6H_SF16, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, }, - [XGL_CH_FMT_BC7] = { GEN6_FORMAT_BC7_UNORM, - 0, - 0, - 0, - 0, - GEN6_FORMAT_BC7_UNORM_SRGB, - 0, - 0, - 0, }, - [XGL_CH_FMT_R8G8B8] = { GEN6_FORMAT_R8G8B8_UNORM, - GEN6_FORMAT_R8G8B8_SNORM, - GEN6_FORMAT_R8G8B8_UINT, - GEN6_FORMAT_R8G8B8_SINT, - 0, - GEN6_FORMAT_R8G8B8_UNORM_SRGB, - 0, - GEN6_FORMAT_R8G8B8_USCALED, - GEN6_FORMAT_R8G8B8_SSCALED, }, - [XGL_CH_FMT_R16G16B16] = { GEN6_FORMAT_R16G16B16_UNORM, - GEN6_FORMAT_R16G16B16_SNORM, - GEN6_FORMAT_R16G16B16_UINT, - GEN6_FORMAT_R16G16B16_SINT, - 0, - 0, - 0, - GEN6_FORMAT_R16G16B16_USCALED, - GEN6_FORMAT_R16G16B16_SSCALED, }, - [XGL_CH_FMT_B10G10R10A2] = { GEN6_FORMAT_B10G10R10A2_UNORM, - GEN6_FORMAT_B10G10R10A2_SNORM, - GEN6_FORMAT_B10G10R10A2_UINT, - GEN6_FORMAT_B10G10R10A2_SINT, - 0, - GEN6_FORMAT_B10G10R10A2_UNORM_SRGB, - 0, - GEN6_FORMAT_B10G10R10A2_USCALED, - GEN6_FORMAT_B10G10R10A2_SSCALED, }, - [XGL_CH_FMT_R64] = { 0, - 0, - 0, - 0, - GEN6_FORMAT_R64_FLOAT, - 0, - 0, - 0, - 0, }, - [XGL_CH_FMT_R64G64] = { 0, - 0, - 0, - 0, - GEN6_FORMAT_R64G64_FLOAT, - 0, - 0, - 0, - 0, }, - [XGL_CH_FMT_R64G64B64] = { 0, - 0, - 0, - 0, - GEN6_FORMAT_R64G64B64_FLOAT, - 0, - 0, - 0, - 0, }, - [XGL_CH_FMT_R64G64B64A64] = { 0, - 0, - 0, - 0, - GEN6_FORMAT_R64G64B64A64_FLOAT, - 0, - 0, - 0, - 0, }, +static const int intel_color_mapping[XGL_NUM_FMT] = { + [XGL_FMT_R4G4_UNORM] = 0, + [XGL_FMT_R4G4_USCALED] = 0, + [XGL_FMT_R4G4B4A4_UNORM] = 0, + [XGL_FMT_R4G4B4A4_USCALED] = 0, + [XGL_FMT_R5G6B5_UNORM] = 0, + [XGL_FMT_R5G6B5_USCALED] = 0, + [XGL_FMT_R5G5B5A1_UNORM] = 0, + [XGL_FMT_R5G5B5A1_USCALED] = 0, + [XGL_FMT_R8_UNORM] = GEN6_FORMAT_R8_UNORM, + [XGL_FMT_R8_SNORM] = GEN6_FORMAT_R8_SNORM, + [XGL_FMT_R8_USCALED] = GEN6_FORMAT_R8_USCALED, + [XGL_FMT_R8_SSCALED] = GEN6_FORMAT_R8_SSCALED, + [XGL_FMT_R8_UINT] = GEN6_FORMAT_R8_UINT, + [XGL_FMT_R8_SINT] = GEN6_FORMAT_R8_SINT, + [XGL_FMT_R8_SRGB] = 0, + [XGL_FMT_R8G8_UNORM] = GEN6_FORMAT_R8G8_UNORM, + [XGL_FMT_R8G8_SNORM] = GEN6_FORMAT_R8G8_SNORM, + [XGL_FMT_R8G8_USCALED] = GEN6_FORMAT_R8G8_USCALED, + [XGL_FMT_R8G8_SSCALED] = GEN6_FORMAT_R8G8_SSCALED, + [XGL_FMT_R8G8_UINT] = GEN6_FORMAT_R8G8_UINT, + [XGL_FMT_R8G8_SINT] = GEN6_FORMAT_R8G8_SINT, + [XGL_FMT_R8G8_SRGB] = 0, + [XGL_FMT_R8G8B8_UNORM] = GEN6_FORMAT_R8G8B8_UNORM, + [XGL_FMT_R8G8B8_SNORM] = GEN6_FORMAT_R8G8B8_SNORM, + [XGL_FMT_R8G8B8_USCALED] = GEN6_FORMAT_R8G8B8_USCALED, + [XGL_FMT_R8G8B8_SSCALED] = GEN6_FORMAT_R8G8B8_SSCALED, + [XGL_FMT_R8G8B8_UINT] = GEN6_FORMAT_R8G8B8_UINT, + [XGL_FMT_R8G8B8_SINT] = GEN6_FORMAT_R8G8B8_SINT, + [XGL_FMT_R8G8B8_SRGB] = GEN6_FORMAT_R8G8B8_UNORM_SRGB, + [XGL_FMT_R8G8B8A8_UNORM] = GEN6_FORMAT_R8G8B8A8_UNORM, + [XGL_FMT_R8G8B8A8_SNORM] = GEN6_FORMAT_R8G8B8A8_SNORM, + [XGL_FMT_R8G8B8A8_USCALED] = GEN6_FORMAT_R8G8B8A8_USCALED, + [XGL_FMT_R8G8B8A8_SSCALED] = GEN6_FORMAT_R8G8B8A8_SSCALED, + [XGL_FMT_R8G8B8A8_UINT] = GEN6_FORMAT_R8G8B8A8_UINT, + [XGL_FMT_R8G8B8A8_SINT] = GEN6_FORMAT_R8G8B8A8_SINT, + [XGL_FMT_R8G8B8A8_SRGB] = GEN6_FORMAT_R8G8B8A8_UNORM_SRGB, + [XGL_FMT_R10G10B10A2_UNORM] = GEN6_FORMAT_R10G10B10A2_UNORM, + [XGL_FMT_R10G10B10A2_SNORM] = GEN6_FORMAT_R10G10B10A2_SNORM, + [XGL_FMT_R10G10B10A2_USCALED] = GEN6_FORMAT_R10G10B10A2_USCALED, + [XGL_FMT_R10G10B10A2_SSCALED] = GEN6_FORMAT_R10G10B10A2_SSCALED, + [XGL_FMT_R10G10B10A2_UINT] = GEN6_FORMAT_R10G10B10A2_UINT, + [XGL_FMT_R10G10B10A2_SINT] = GEN6_FORMAT_R10G10B10A2_SINT, + [XGL_FMT_R16_UNORM] = GEN6_FORMAT_R16_UNORM, + [XGL_FMT_R16_SNORM] = GEN6_FORMAT_R16_SNORM, + [XGL_FMT_R16_USCALED] = GEN6_FORMAT_R16_USCALED, + [XGL_FMT_R16_SSCALED] = GEN6_FORMAT_R16_SSCALED, + [XGL_FMT_R16_UINT] = GEN6_FORMAT_R16_UINT, + [XGL_FMT_R16_SINT] = GEN6_FORMAT_R16_SINT, + [XGL_FMT_R16_SFLOAT] = GEN6_FORMAT_R16_FLOAT, + [XGL_FMT_R16G16_UNORM] = GEN6_FORMAT_R16G16_UNORM, + [XGL_FMT_R16G16_SNORM] = GEN6_FORMAT_R16G16_SNORM, + [XGL_FMT_R16G16_USCALED] = GEN6_FORMAT_R16G16_USCALED, + [XGL_FMT_R16G16_SSCALED] = GEN6_FORMAT_R16G16_SSCALED, + [XGL_FMT_R16G16_UINT] = GEN6_FORMAT_R16G16_UINT, + [XGL_FMT_R16G16_SINT] = GEN6_FORMAT_R16G16_SINT, + [XGL_FMT_R16G16_SFLOAT] = GEN6_FORMAT_R16G16_FLOAT, + [XGL_FMT_R16G16B16_UNORM] = GEN6_FORMAT_R16G16B16_UNORM, + [XGL_FMT_R16G16B16_SNORM] = GEN6_FORMAT_R16G16B16_SNORM, + [XGL_FMT_R16G16B16_USCALED] = GEN6_FORMAT_R16G16B16_USCALED, + [XGL_FMT_R16G16B16_SSCALED] = GEN6_FORMAT_R16G16B16_SSCALED, + [XGL_FMT_R16G16B16_UINT] = GEN6_FORMAT_R16G16B16_UINT, + [XGL_FMT_R16G16B16_SINT] = GEN6_FORMAT_R16G16B16_SINT, + [XGL_FMT_R16G16B16_SFLOAT] = 0, + [XGL_FMT_R16G16B16A16_UNORM] = GEN6_FORMAT_R16G16B16A16_UNORM, + [XGL_FMT_R16G16B16A16_SNORM] = GEN6_FORMAT_R16G16B16A16_SNORM, + [XGL_FMT_R16G16B16A16_USCALED] = GEN6_FORMAT_R16G16B16A16_USCALED, + [XGL_FMT_R16G16B16A16_SSCALED] = GEN6_FORMAT_R16G16B16A16_SSCALED, + [XGL_FMT_R16G16B16A16_UINT] = GEN6_FORMAT_R16G16B16A16_UINT, + [XGL_FMT_R16G16B16A16_SINT] = GEN6_FORMAT_R16G16B16A16_SINT, + [XGL_FMT_R16G16B16A16_SFLOAT] = GEN6_FORMAT_R16G16B16A16_FLOAT, + [XGL_FMT_R32_UINT] = GEN6_FORMAT_R32_UINT, + [XGL_FMT_R32_SINT] = GEN6_FORMAT_R32_SINT, + [XGL_FMT_R32_SFLOAT] = GEN6_FORMAT_R32_FLOAT, + [XGL_FMT_R32G32_UINT] = GEN6_FORMAT_R32G32_UINT, + [XGL_FMT_R32G32_SINT] = GEN6_FORMAT_R32G32_SINT, + [XGL_FMT_R32G32_SFLOAT] = GEN6_FORMAT_R32G32_FLOAT, + [XGL_FMT_R32G32B32_UINT] = GEN6_FORMAT_R32G32B32_UINT, + [XGL_FMT_R32G32B32_SINT] = GEN6_FORMAT_R32G32B32_SINT, + [XGL_FMT_R32G32B32_SFLOAT] = GEN6_FORMAT_R32G32B32_FLOAT, + [XGL_FMT_R32G32B32A32_UINT] = GEN6_FORMAT_R32G32B32A32_UINT, + [XGL_FMT_R32G32B32A32_SINT] = GEN6_FORMAT_R32G32B32A32_SINT, + [XGL_FMT_R32G32B32A32_SFLOAT] = GEN6_FORMAT_R32G32B32A32_FLOAT, + [XGL_FMT_R64_SFLOAT] = GEN6_FORMAT_R64_FLOAT, + [XGL_FMT_R64G64_SFLOAT] = GEN6_FORMAT_R64G64_FLOAT, + [XGL_FMT_R64G64B64_SFLOAT] = GEN6_FORMAT_R64G64B64_FLOAT, + [XGL_FMT_R64G64B64A64_SFLOAT] = GEN6_FORMAT_R64G64B64A64_FLOAT, + [XGL_FMT_R11G11B10_UFLOAT] = GEN6_FORMAT_R11G11B10_FLOAT, + [XGL_FMT_R9G9B9E5_UFLOAT] = GEN6_FORMAT_R9G9B9E5_SHAREDEXP, + [XGL_FMT_BC1_UNORM] = GEN6_FORMAT_BC1_UNORM, + [XGL_FMT_BC1_SRGB] = GEN6_FORMAT_BC1_UNORM_SRGB, + [XGL_FMT_BC2_UNORM] = GEN6_FORMAT_BC2_UNORM, + [XGL_FMT_BC2_SRGB] = GEN6_FORMAT_BC2_UNORM_SRGB, + [XGL_FMT_BC3_UNORM] = GEN6_FORMAT_BC3_UNORM, + [XGL_FMT_BC3_SRGB] = GEN6_FORMAT_BC3_UNORM_SRGB, + [XGL_FMT_BC4_UNORM] = GEN6_FORMAT_BC4_UNORM, + [XGL_FMT_BC4_SNORM] = GEN6_FORMAT_BC4_SNORM, + [XGL_FMT_BC5_UNORM] = GEN6_FORMAT_BC5_UNORM, + [XGL_FMT_BC5_SNORM] = GEN6_FORMAT_BC5_SNORM, + [XGL_FMT_BC6H_UFLOAT] = GEN6_FORMAT_BC6H_UF16, + [XGL_FMT_BC6H_SFLOAT] = GEN6_FORMAT_BC6H_SF16, + [XGL_FMT_BC7_UNORM] = GEN6_FORMAT_BC7_UNORM, + [XGL_FMT_BC7_SRGB] = GEN6_FORMAT_BC7_UNORM_SRGB, + /* TODO: Implement for remaining compressed formats. */ + [XGL_FMT_ETC2_R8G8B8_UNORM] = 0, + [XGL_FMT_ETC2_R8G8B8A1_UNORM] = 0, + [XGL_FMT_ETC2_R8G8B8A8_UNORM] = 0, + [XGL_FMT_EAC_R11_UNORM] = 0, + [XGL_FMT_EAC_R11_SNORM] = 0, + [XGL_FMT_EAC_R11G11_UNORM] = 0, + [XGL_FMT_EAC_R11G11_SNORM] = 0, + [XGL_FMT_ASTC_4x4_UNORM] = 0, + [XGL_FMT_ASTC_4x4_SRGB] = 0, + [XGL_FMT_ASTC_4x5_UNORM] = 0, + [XGL_FMT_ASTC_4x5_SRGB] = 0, + [XGL_FMT_ASTC_5x5_UNORM] = 0, + [XGL_FMT_ASTC_5x5_SRGB] = 0, + [XGL_FMT_ASTC_6x5_UNORM] = 0, + [XGL_FMT_ASTC_6x5_SRGB] = 0, + [XGL_FMT_ASTC_6x6_UNORM] = 0, + [XGL_FMT_ASTC_6x6_SRGB] = 0, + [XGL_FMT_ASTC_8x5_UNORM] = 0, + [XGL_FMT_ASTC_8x5_SRGB] = 0, + [XGL_FMT_ASTC_8x6_UNORM] = 0, + [XGL_FMT_ASTC_8x6_SRGB] = 0, + [XGL_FMT_ASTC_8x8_UNORM] = 0, + [XGL_FMT_ASTC_8x8_SRGB] = 0, + [XGL_FMT_ASTC_10x5_UNORM] = 0, + [XGL_FMT_ASTC_10x5_SRGB] = 0, + [XGL_FMT_ASTC_10x6_UNORM] = 0, + [XGL_FMT_ASTC_10x6_SRGB] = 0, + [XGL_FMT_ASTC_10x8_UNORM] = 0, + [XGL_FMT_ASTC_10x8_SRGB] = 0, + [XGL_FMT_ASTC_10x10_UNORM] = 0, + [XGL_FMT_ASTC_10x10_SRGB] = 0, + [XGL_FMT_ASTC_12x10_UNORM] = 0, + [XGL_FMT_ASTC_12x10_SRGB] = 0, + [XGL_FMT_ASTC_12x12_UNORM] = 0, + [XGL_FMT_ASTC_12x12_SRGB] = 0, + [XGL_FMT_B5G6R5_UNORM] = GEN6_FORMAT_B5G6R5_UNORM, + [XGL_FMT_B5G6R5_USCALED] = 0, + [XGL_FMT_B8G8R8_UNORM] = 0, + [XGL_FMT_B8G8R8_SNORM] = 0, + [XGL_FMT_B8G8R8_USCALED] = 0, + [XGL_FMT_B8G8R8_SSCALED] = 0, + [XGL_FMT_B8G8R8_UINT] = 0, + [XGL_FMT_B8G8R8_SINT] = 0, + [XGL_FMT_B8G8R8_SRGB] = GEN6_FORMAT_B5G6R5_UNORM_SRGB, + [XGL_FMT_B8G8R8A8_UNORM] = GEN6_FORMAT_B8G8R8A8_UNORM, + [XGL_FMT_B8G8R8A8_SNORM] = 0, + [XGL_FMT_B8G8R8A8_USCALED] = 0, + [XGL_FMT_B8G8R8A8_SSCALED] = 0, + [XGL_FMT_B8G8R8A8_UINT] = 0, + [XGL_FMT_B8G8R8A8_SINT] = 0, + [XGL_FMT_B8G8R8A8_SRGB] = GEN6_FORMAT_B8G8R8A8_UNORM_SRGB, + [XGL_FMT_B10G10R10A2_UNORM] = GEN6_FORMAT_B10G10R10A2_UNORM, + [XGL_FMT_B10G10R10A2_SNORM] = GEN6_FORMAT_B10G10R10A2_SNORM, + [XGL_FMT_B10G10R10A2_USCALED] = GEN6_FORMAT_B10G10R10A2_USCALED, + [XGL_FMT_B10G10R10A2_SSCALED] = GEN6_FORMAT_B10G10R10A2_SSCALED, + [XGL_FMT_B10G10R10A2_UINT] = GEN6_FORMAT_B10G10R10A2_UINT, + [XGL_FMT_B10G10R10A2_SINT] = GEN6_FORMAT_B10G10R10A2_SINT }; int intel_format_translate_color(const struct intel_gpu *gpu, @@ -655,14 +545,14 @@ int intel_format_translate_color(const struct intel_gpu *gpu, { int fmt; - assert(format.numericFormat != XGL_NUM_FMT_UNDEFINED && - format.numericFormat != XGL_NUM_FMT_DS); + assert(!icd_format_is_undef(format)); + assert(!icd_format_is_ds(format)); - fmt = intel_color_mapping[format.channelFormat][format.numericFormat - 1]; + fmt = intel_color_mapping[format]; + /* TODO: Implement for remaining compressed formats. */ /* GEN6_FORMAT_R32G32B32A32_FLOAT happens to be 0 */ - if (format.channelFormat == XGL_CH_FMT_R32G32B32A32 && - format.numericFormat == XGL_NUM_FMT_FLOAT) + if (format == XGL_FMT_R32G32B32A32_SFLOAT) assert(fmt == 0); else if (!fmt) fmt = -1; @@ -696,8 +586,7 @@ static XGL_FLAGS intel_format_get_color_features(const struct intel_dev *dev, } if (TEST(dev, sampler, sampling)) { - if (format.numericFormat == XGL_NUM_FMT_UINT || - format.numericFormat == XGL_NUM_FMT_SINT || + if (icd_format_is_int(format) || TEST(dev, sampler, filtering)) features |= XGL_FORMAT_IMAGE_SHADER_READ_BIT; } @@ -726,17 +615,20 @@ static XGL_FLAGS intel_format_get_ds_features(const struct intel_dev *dev, { XGL_FLAGS features; - assert(format.numericFormat == XGL_NUM_FMT_DS); + assert(icd_format_is_ds(format)); - switch (format.channelFormat) { - case XGL_CH_FMT_R8: + switch (format) { + case XGL_FMT_S8_UINT: features = XGL_FORMAT_STENCIL_ATTACHMENT_BIT;; break; - case XGL_CH_FMT_R16: - case XGL_CH_FMT_R32: + case XGL_FMT_D16_UNORM: + case XGL_FMT_D24_UNORM: + case XGL_FMT_D32_SFLOAT: features = XGL_FORMAT_DEPTH_ATTACHMENT_BIT; break; - case XGL_CH_FMT_R32G8: + case XGL_FMT_D16_UNORM_S8_UINT: + case XGL_FMT_D24_UNORM_S8_UINT: + case XGL_FMT_D32_SFLOAT_S8_UINT: features = XGL_FORMAT_DEPTH_ATTACHMENT_BIT | XGL_FORMAT_STENCIL_ATTACHMENT_BIT; break; @@ -751,9 +643,7 @@ static XGL_FLAGS intel_format_get_ds_features(const struct intel_dev *dev, static XGL_FLAGS intel_format_get_raw_features(const struct intel_dev *dev, XGL_FORMAT format) { - assert(format.numericFormat == XGL_NUM_FMT_UNDEFINED); - - return (format.channelFormat == XGL_CH_FMT_UNDEFINED) ? + return (format == XGL_FMT_UNDEFINED) ? XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT : 0; } @@ -761,33 +651,21 @@ static void intel_format_get_props(const struct intel_dev *dev, XGL_FORMAT format, XGL_FORMAT_PROPERTIES *props) { - switch (format.numericFormat) { - case XGL_NUM_FMT_UNDEFINED: + if (icd_format_is_undef(format)) { props->linearTilingFeatures = intel_format_get_raw_features(dev, format); props->optimalTilingFeatures = 0; - break; - case XGL_NUM_FMT_UNORM: - case XGL_NUM_FMT_SNORM: - case XGL_NUM_FMT_UINT: - case XGL_NUM_FMT_SINT: - case XGL_NUM_FMT_FLOAT: - case XGL_NUM_FMT_SRGB: - case XGL_NUM_FMT_USCALED: - case XGL_NUM_FMT_SSCALED: + } else if(icd_format_is_color(format)) { props->linearTilingFeatures = intel_format_get_color_features(dev, format); props->optimalTilingFeatures = props->linearTilingFeatures; - break; - case XGL_NUM_FMT_DS: + } else if(icd_format_is_ds(format)) { props->linearTilingFeatures = 0; props->optimalTilingFeatures = intel_format_get_ds_features(dev, format); - break; - default: + } else { props->linearTilingFeatures = 0; props->optimalTilingFeatures = 0; - break; } } diff --git a/icd/intel/format.h b/icd/intel/format.h index ffc3ebb..ee990d7 100644 --- a/icd/intel/format.h +++ b/icd/intel/format.h @@ -35,16 +35,25 @@ struct intel_gpu; static inline bool intel_format_is_depth(const struct intel_gpu *gpu, XGL_FORMAT format) { - return (format.numericFormat == XGL_NUM_FMT_DS && - (format.channelFormat == XGL_CH_FMT_R16 || - format.channelFormat == XGL_CH_FMT_R32)); + bool is_depth = false; + + switch (format) { + case XGL_FMT_D16_UNORM: + case XGL_FMT_D24_UNORM: + case XGL_FMT_D32_SFLOAT: + is_depth = true; + break; + default: + break; + } + + return is_depth; } static inline bool intel_format_is_stencil(const struct intel_gpu *gpu, XGL_FORMAT format) { - return (format.numericFormat == XGL_NUM_FMT_DS && - format.channelFormat == XGL_CH_FMT_R8); + return format == XGL_FMT_S8_UINT; } int intel_format_translate_color(const struct intel_gpu *gpu, diff --git a/icd/intel/img.c b/icd/intel/img.c index e52dff7..0579122 100644 --- a/icd/intel/img.c +++ b/icd/intel/img.c @@ -150,8 +150,8 @@ XGL_RESULT intel_img_create(struct intel_dev *dev, } s8_info = *info; - s8_info.format.channelFormat = XGL_CH_FMT_R8; - assert(info->format.numericFormat == XGL_NUM_FMT_DS); + s8_info.format = XGL_FMT_S8_UINT; + assert(icd_format_is_ds(info->format)); intel_layout_init(img->s8_layout, dev, &s8_info, scanout); diff --git a/icd/intel/layout.c b/icd/intel/layout.c index ccc11a8..18bc34c 100644 --- a/icd/intel/layout.c +++ b/icd/intel/layout.c @@ -402,12 +402,12 @@ layout_init_alignments(struct intel_layout *layout, layout->align_j = layout->block_height; } else if (info->usage & XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT) { if (intel_gpu_gen(params->gpu) >= INTEL_GEN(7)) { - switch (layout->format.channelFormat) { - case XGL_CH_FMT_R16: + switch (layout->format) { + case XGL_FMT_D16_UNORM: layout->align_i = 8; layout->align_j = 4; break; - case XGL_CH_FMT_R8: + case XGL_FMT_S8_UINT: layout->align_i = 8; layout->align_j = 8; break; @@ -417,8 +417,8 @@ layout_init_alignments(struct intel_layout *layout, break; } } else { - switch (layout->format.channelFormat) { - case XGL_CH_FMT_R8: + switch (layout->format) { + case XGL_FMT_S8_UINT: layout->align_i = 4; layout->align_j = 2; break; @@ -490,8 +490,8 @@ layout_get_valid_tilings(const struct intel_layout *layout, * "W-Major Tile Format is used for separate stencil." */ if (info->usage & XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT) { - switch (format.channelFormat) { - case XGL_CH_FMT_R8: + switch (format) { + case XGL_FMT_S8_UINT: valid_tilings &= LAYOUT_TILING_W; break; default: @@ -675,11 +675,11 @@ layout_init_size_and_format(struct intel_layout *layout, require_separate_stencil = (layout->aux == INTEL_LAYOUT_AUX_HIZ); } - if (format.numericFormat == XGL_NUM_FMT_DS) { - switch (format.channelFormat) { - case XGL_CH_FMT_R32G8: + if (icd_format_is_ds(format)) { + switch (format) { + case XGL_FMT_D32_SFLOAT_S8_UINT: if (require_separate_stencil) { - format.channelFormat = XGL_CH_FMT_R32; + format = XGL_FMT_D32_SFLOAT; layout->separate_stencil = true; } break; @@ -776,7 +776,7 @@ layout_want_hiz(const struct intel_layout *layout, * can result in incompatible formats. */ if (intel_gpu_gen(params->gpu) == INTEL_GEN(6) && - info->format.channelFormat == XGL_CH_FMT_R32G8 && + info->format == XGL_FMT_D32_SFLOAT_S8_UINT && info->mipLevels > 1) return false; @@ -1351,8 +1351,7 @@ intel_layout_get_slice_tile_offset(const struct intel_layout *layout, switch (layout->tiling) { case INTEL_TILING_NONE: /* W-tiled */ - if (layout->format.numericFormat == XGL_NUM_FMT_DS && - layout->format.channelFormat == XGL_CH_FMT_R8) { + if (layout->format == XGL_FMT_S8_UINT) { tile_w = 64; tile_h = 64; } diff --git a/icd/intel/layout.h b/icd/intel/layout.h index bf26190..f081e37 100644 --- a/icd/intel/layout.h +++ b/icd/intel/layout.h @@ -169,8 +169,7 @@ intel_layout_mem_to_raw(const struct intel_layout *layout, switch (layout->tiling) { case INTEL_TILING_NONE: - if (layout->format.numericFormat == XGL_NUM_FMT_DS && - layout->format.channelFormat == XGL_CH_FMT_R8) { + if (layout->format == XGL_FMT_S8_UINT) { /* W-tile */ tile_w = 64; tile_h = 64; diff --git a/icd/intel/view.c b/icd/intel/view.c index 7a2e901..5f0deea 100644 --- a/icd/intel/view.c +++ b/icd/intel/view.c @@ -823,19 +823,19 @@ ds_init_info(const struct intel_gpu *gpu, * * As for GEN7+, separate_stencil is always true. */ - switch (format.channelFormat) { - case XGL_CH_FMT_R16: + switch (format) { + case XGL_FMT_D16_UNORM: info->format = GEN6_ZFORMAT_D16_UNORM; break; - case XGL_CH_FMT_R32: + case XGL_FMT_D32_SFLOAT: info->format = GEN6_ZFORMAT_D32_FLOAT; break; - case XGL_CH_FMT_R32G8: + case XGL_FMT_D32_SFLOAT_S8_UINT: info->format = (separate_stencil) ? GEN6_ZFORMAT_D32_FLOAT : GEN6_ZFORMAT_D32_FLOAT_S8X24_UINT; break; - case XGL_CH_FMT_R8: + case XGL_FMT_S8_UINT: if (separate_stencil) { info->format = GEN6_ZFORMAT_D32_FLOAT; break; @@ -848,7 +848,7 @@ ds_init_info(const struct intel_gpu *gpu, break; } - if (format.channelFormat != XGL_CH_FMT_R8) + if (format != XGL_FMT_S8_UINT) info->zs.stride = img->layout.bo_stride; if (img->s8_layout) { @@ -873,7 +873,7 @@ ds_init_info(const struct intel_gpu *gpu, intel_layout_pos_to_mem(img->s8_layout, x, y, &x, &y); info->stencil.offset = intel_layout_mem_to_raw(img->s8_layout, x, y); } - } else if (format.channelFormat == XGL_CH_FMT_R8) { + } else if (format == XGL_FMT_S8_UINT) { info->stencil.stride = img->layout.bo_stride * 2; } @@ -1091,8 +1091,7 @@ XGL_RESULT intel_buf_view_create(struct intel_dev *dev, * must be XGL_FMT_R32G32B32A32_SFLOAT. */ if (info->viewType == XGL_BUFFER_VIEW_RAW) { - format.channelFormat = XGL_CH_FMT_R32G32B32A32; - format.numericFormat = XGL_NUM_FMT_FLOAT; + format = XGL_FMT_R32G32B32A32_SFLOAT; stride = 16; } else { format = info->format; diff --git a/icd/intel/wsi_x11.c b/icd/intel/wsi_x11.c index 061676c..0e12274 100644 --- a/icd/intel/wsi_x11.c +++ b/icd/intel/wsi_x11.c @@ -458,21 +458,14 @@ static bool wsi_x11_is_format_presentable(struct intel_wsi_x11 *x11, XGL_FORMAT format) { /* this is what DDX expects */ - switch (format.channelFormat) { - case XGL_CH_FMT_B5G6R5: - if (format.numericFormat == XGL_NUM_FMT_UNORM) - return true; - break; - case XGL_CH_FMT_B8G8R8A8: - if (format.numericFormat == XGL_NUM_FMT_UNORM || - format.numericFormat == XGL_NUM_FMT_SRGB) - return true; - break; + switch (format) { + case XGL_FMT_B5G6R5_UNORM: + case XGL_FMT_B8G8R8A8_UNORM: + case XGL_FMT_B8G8R8A8_SRGB: + return true; default: - break; + return false; } - - return false; } /** diff --git a/include/xgl.h b/include/xgl.h index 1452433..9520190 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 diff --git a/tests/blit_tests.cpp b/tests/blit_tests.cpp index 937db9a..e734b16 100644 --- a/tests/blit_tests.cpp +++ b/tests/blit_tests.cpp @@ -185,14 +185,14 @@ ImageChecker::ImageChecker(const XGL_IMAGE_CREATE_INFO &info) region.imageExtent = Image::extent(info_.extent, lv); if (info_.usage & XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT) { - if (info_.format.channelFormat != XGL_CH_FMT_R8) { + if (info_.format != XGL_FMT_S8_UINT) { region.imageSubresource.aspect = XGL_IMAGE_ASPECT_DEPTH; regions_.push_back(region); } - if (info_.format.channelFormat == XGL_CH_FMT_R16G8 || - info_.format.channelFormat == XGL_CH_FMT_R32G8 || - info_.format.channelFormat == XGL_CH_FMT_R8) { + if (info_.format == XGL_FMT_D16_UNORM_S8_UINT || + info_.format == XGL_FMT_D32_SFLOAT_S8_UINT || + info_.format == XGL_FMT_S8_UINT) { region.imageSubresource.aspect = XGL_IMAGE_ASPECT_STENCIL; regions_.push_back(region); } @@ -389,48 +389,178 @@ XGL_SIZE get_format_size(XGL_FORMAT format) static const struct format_info { XGL_SIZE size; XGL_UINT channel_count; - } 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 }, + } 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 }, }; - return format_table[format.channelFormat].size; + return format_table[format].size; } XGL_EXTENT3D get_mip_level_extent(const XGL_EXTENT3D &extent, XGL_UINT mip_level) @@ -836,10 +966,8 @@ class XglCmdBlitImageTest : public XglCmdBlitTest { protected: void init_test_formats(XGL_FLAGS features) { - first_linear_format_.channelFormat = XGL_CH_FMT_UNDEFINED; - first_linear_format_.numericFormat = XGL_NUM_FMT_UNDEFINED; - first_optimal_format_.channelFormat = XGL_CH_FMT_UNDEFINED; - first_optimal_format_.numericFormat = XGL_NUM_FMT_UNDEFINED; + first_linear_format_ = XGL_FMT_UNDEFINED; + first_optimal_format_ = XGL_FMT_UNDEFINED; for (std::vector::const_iterator it = dev_.formats().begin(); it != dev_.formats().end(); it++) { @@ -847,10 +975,10 @@ protected: test_formats_.push_back(*it); if (it->tiling == XGL_LINEAR_TILING && - first_linear_format_.channelFormat == XGL_CH_FMT_UNDEFINED) + first_linear_format_ == XGL_FMT_UNDEFINED) first_linear_format_ = it->format; if (it->tiling == XGL_OPTIMAL_TILING && - first_optimal_format_.channelFormat == XGL_CH_FMT_UNDEFINED) + first_optimal_format_ == XGL_FMT_UNDEFINED) first_optimal_format_ = it->format; } } @@ -965,6 +1093,13 @@ TEST_F(XglCmdCopyBufferToImageTest, Basic) { for (std::vector::const_iterator it = test_formats_.begin(); it != test_formats_.end(); it++) { + + // not sure what to do here + if (it->format == XGL_FMT_UNDEFINED || + (it->format >= XGL_FMT_B8G8R8_UNORM && + it->format <= XGL_FMT_B8G8R8_SRGB)) + continue; + XGL_IMAGE_CREATE_INFO img_info = xgl_testing::Image::create_info(); img_info.imageType = XGL_IMAGE_2D; img_info.format = it->format; @@ -1024,6 +1159,13 @@ TEST_F(XglCmdCopyImageToBufferTest, Basic) { for (std::vector::const_iterator it = test_formats_.begin(); it != test_formats_.end(); it++) { + + // not sure what to do here + if (it->format == XGL_FMT_UNDEFINED || + (it->format >= XGL_FMT_B8G8R8_UNORM && + it->format <= XGL_FMT_B8G8R8_SRGB)) + continue; + XGL_IMAGE_CREATE_INFO img_info = xgl_testing::Image::create_info(); img_info.imageType = XGL_IMAGE_2D; img_info.format = it->format; @@ -1096,6 +1238,13 @@ TEST_F(XglCmdCopyImageTest, Basic) { for (std::vector::const_iterator it = test_formats_.begin(); it != test_formats_.end(); it++) { + + // not sure what to do here + if (it->format == XGL_FMT_UNDEFINED || + (it->format >= XGL_FMT_B8G8R8_UNORM && + it->format <= XGL_FMT_B8G8R8_SRGB)) + continue; + XGL_IMAGE_CREATE_INFO img_info = xgl_testing::Image::create_info(); img_info.imageType = XGL_IMAGE_2D; img_info.format = it->format; @@ -1155,12 +1304,17 @@ TEST_F(XglCmdCloneImageDataTest, Basic) for (std::vector::const_iterator it = test_formats_.begin(); it != test_formats_.end(); it++) { // not sure what to do here - if (it->format.channelFormat == XGL_CH_FMT_UNDEFINED || - (it->format.channelFormat >= XGL_CH_FMT_BC1 && - it->format.channelFormat <= XGL_CH_FMT_BC7) || - it->format.channelFormat == XGL_CH_FMT_R64G64B64 || - it->format.channelFormat == XGL_CH_FMT_R64G64B64A64 || - it->format.numericFormat == XGL_NUM_FMT_DS) + if (it->format == XGL_FMT_UNDEFINED || + (it->format >= XGL_FMT_R32G32B32_UINT && + it->format <= XGL_FMT_R32G32B32_SFLOAT) || + (it->format >= XGL_FMT_B8G8R8_UNORM && + it->format <= XGL_FMT_B8G8R8_SRGB) || + (it->format >= XGL_FMT_BC1_UNORM && + it->format <= XGL_FMT_ASTC_12x12_SRGB) || + (it->format >= XGL_FMT_D16_UNORM && + it->format <= XGL_FMT_D32_SFLOAT_S8_UINT) || + it->format == XGL_FMT_R64G64B64_SFLOAT || + it->format == XGL_FMT_R64G64B64A64_SFLOAT) continue; XGL_IMAGE_CREATE_INFO img_info = xgl_testing::Image::create_info(); @@ -1208,23 +1362,21 @@ protected: std::vector raw; // TODO support all formats - if (format.numericFormat == XGL_NUM_FMT_UNORM) { - switch (format.channelFormat) { - case XGL_CH_FMT_R8G8B8A8: - raw.push_back(color[0] * 255.0f); - raw.push_back(color[1] * 255.0f); - raw.push_back(color[2] * 255.0f); - raw.push_back(color[3] * 255.0f); - break; - case XGL_CH_FMT_B8G8R8A8: - raw.push_back(color[2] * 255.0f); - raw.push_back(color[1] * 255.0f); - raw.push_back(color[0] * 255.0f); - raw.push_back(color[3] * 255.0f); - break; - default: - break; - } + switch (format) { + case XGL_FMT_R8G8B8A8_UNORM: + raw.push_back(color[0] * 255.0f); + raw.push_back(color[1] * 255.0f); + raw.push_back(color[2] * 255.0f); + raw.push_back(color[3] * 255.0f); + break; + case XGL_FMT_B8G8R8A8_UNORM: + raw.push_back(color[2] * 255.0f); + raw.push_back(color[1] * 255.0f); + raw.push_back(color[0] * 255.0f); + raw.push_back(color[3] * 255.0f); + break; + default: + break; } return raw; @@ -1235,23 +1387,21 @@ protected: std::vector raw; // TODO support all formats - if (format.numericFormat == XGL_NUM_FMT_UNORM) { - switch (format.channelFormat) { - case XGL_CH_FMT_R8G8B8A8: - raw.push_back(static_cast(color[0])); - raw.push_back(static_cast(color[1])); - raw.push_back(static_cast(color[2])); - raw.push_back(static_cast(color[3])); - break; - case XGL_CH_FMT_B8G8R8A8: - raw.push_back(static_cast(color[2])); - raw.push_back(static_cast(color[1])); - raw.push_back(static_cast(color[0])); - raw.push_back(static_cast(color[3])); - break; - default: - break; - } + switch (format) { + case XGL_FMT_R8G8B8A8_UNORM: + raw.push_back(static_cast(color[0])); + raw.push_back(static_cast(color[1])); + raw.push_back(static_cast(color[2])); + raw.push_back(static_cast(color[3])); + break; + case XGL_FMT_B8G8R8A8_UNORM: + raw.push_back(static_cast(color[2])); + raw.push_back(static_cast(color[1])); + raw.push_back(static_cast(color[0])); + raw.push_back(static_cast(color[3])); + break; + default: + break; } return raw; @@ -1399,13 +1549,19 @@ TEST_F(XglCmdClearColorImageRawTest, Basic) const XGL_UINT32 color[4] = { 0x11111111, 0x22222222, 0x33333333, 0x44444444 }; // not sure what to do here - if (it->format.channelFormat == XGL_CH_FMT_UNDEFINED || - it->format.channelFormat == XGL_CH_FMT_R32G32B32 || - it->format.channelFormat == XGL_CH_FMT_R8G8B8 || - it->format.channelFormat == XGL_CH_FMT_R16G16B16 || - it->format.channelFormat == XGL_CH_FMT_R64G64B64 || - it->format.channelFormat == XGL_CH_FMT_R64G64B64A64 || - it->format.numericFormat == XGL_NUM_FMT_DS) + if (it->format == XGL_FMT_UNDEFINED || + (it->format >= XGL_FMT_R8G8B8_UNORM && + it->format <= XGL_FMT_R8G8B8_SRGB) || + (it->format >= XGL_FMT_B8G8R8_UNORM && + it->format <= XGL_FMT_B8G8R8_SRGB) || + (it->format >= XGL_FMT_R16G16B16_UNORM && + it->format <= XGL_FMT_R16G16B16_SFLOAT) || + (it->format >= XGL_FMT_R32G32B32_UINT && + it->format <= XGL_FMT_R32G32B32_SFLOAT) || + it->format == XGL_FMT_R64G64B64_SFLOAT || + it->format == XGL_FMT_R64G64B64A64_SFLOAT || + (it->format >= XGL_FMT_D16_UNORM && + it->format <= XGL_FMT_D32_SFLOAT_S8_UINT)) continue; XGL_IMAGE_CREATE_INFO img_info = xgl_testing::Image::create_info(); @@ -1438,17 +1594,17 @@ protected: std::vector raw; // depth - switch (format.channelFormat) { - case XGL_CH_FMT_R16: - case XGL_CH_FMT_R16G8: + switch (format) { + case XGL_FMT_D16_UNORM: + case XGL_FMT_D16_UNORM_S8_UINT: { const uint16_t unorm = depth * 65535.0f; raw.push_back(unorm & 0xff); raw.push_back(unorm >> 8); } break; - case XGL_CH_FMT_R32: - case XGL_CH_FMT_R32G8: + case XGL_FMT_D32_SFLOAT: + case XGL_FMT_D32_SFLOAT_S8_UINT: { const union { XGL_FLOAT depth; @@ -1466,15 +1622,15 @@ protected: } // stencil - switch (format.channelFormat) { - case XGL_CH_FMT_R8: + switch (format) { + case XGL_FMT_S8_UINT: raw.push_back(stencil); break; - case XGL_CH_FMT_R16G8: + case XGL_FMT_D16_UNORM_S8_UINT: raw.push_back(stencil); raw.push_back(0); break; - case XGL_CH_FMT_R32G8: + case XGL_FMT_D32_SFLOAT_S8_UINT: raw.push_back(stencil); raw.push_back(0); raw.push_back(0); @@ -1567,7 +1723,10 @@ TEST_F(XglCmdClearDepthStencilTest, Basic) for (std::vector::const_iterator it = test_formats_.begin(); it != test_formats_.end(); it++) { // known driver issues - if (it->format.channelFormat == XGL_CH_FMT_R8) + if (it->format == XGL_FMT_S8_UINT || + it->format == XGL_FMT_D24_UNORM || + it->format == XGL_FMT_D16_UNORM_S8_UINT || + it->format == XGL_FMT_D24_UNORM_S8_UINT) continue; XGL_IMAGE_CREATE_INFO img_info = xgl_testing::Image::create_info(); diff --git a/tests/image_tests.cpp b/tests/image_tests.cpp index 5286a9a..9c7623a 100644 --- a/tests/image_tests.cpp +++ b/tests/image_tests.cpp @@ -127,8 +127,7 @@ void XglImageTest::CreateImage(XGL_UINT w, XGL_UINT h) mipCount++; } - fmt.channelFormat = XGL_CH_FMT_R8G8B8A8; - fmt.numericFormat = XGL_NUM_FMT_UINT; + fmt = XGL_FMT_R8G8B8A8_UINT; // TODO: Pick known good format rather than just expect common format /* * XXX: What should happen if given NULL HANDLE for the pData argument? @@ -272,8 +271,7 @@ TEST_F(XglImageTest, CreateImageViewTest) { XGL_FORMAT fmt; XGL_IMAGE_VIEW imageView; - fmt.channelFormat = XGL_CH_FMT_R8G8B8A8; - fmt.numericFormat = XGL_NUM_FMT_UINT; + fmt = XGL_FMT_R8G8B8A8_UINT; CreateImage(512, 256); diff --git a/tests/init.cpp b/tests/init.cpp index 4dd620c..aca08b8 100644 --- a/tests/init.cpp +++ b/tests/init.cpp @@ -488,8 +488,7 @@ void XglTest::CreateImageTest() mipCount++; } - fmt.channelFormat = XGL_CH_FMT_R8G8B8A8; - fmt.numericFormat = XGL_NUM_FMT_UINT; + fmt = XGL_FMT_R8G8B8A8_UINT; // TODO: Pick known good format rather than just expect common format /* * XXX: What should happen if given NULL HANDLE for the pData argument? diff --git a/tests/render_tests.cpp b/tests/render_tests.cpp index c7873e9..24db85f 100644 --- a/tests/render_tests.cpp +++ b/tests/render_tests.cpp @@ -341,8 +341,7 @@ void XglRenderTest::InitDepthStencil() // Clean up default state created by framework if (m_stateDepthStencil) xglDestroyObject(m_stateDepthStencil); - m_depth_stencil_fmt.channelFormat = XGL_CH_FMT_R16; - m_depth_stencil_fmt.numericFormat = XGL_NUM_FMT_DS; + m_depth_stencil_fmt = XGL_FMT_D16_UNORM; image.sType = XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO; image.pNext = NULL; @@ -781,12 +780,10 @@ TEST_F(XglRenderTest, TriangleWithVertexFetch) XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2]; vi_attribs[0].binding = 0; // index into vertexBindingDescriptions - vi_attribs[0].format.channelFormat = XGL_CH_FMT_R32G32B32A32; // format of source data - vi_attribs[0].format.numericFormat = XGL_NUM_FMT_FLOAT; + vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex vi_attribs[1].binding = 0; // index into vertexBindingDescriptions - vi_attribs[1].format.channelFormat = XGL_CH_FMT_R32G32B32A32; // format of source data - vi_attribs[1].format.numericFormat = XGL_NUM_FMT_FLOAT; + vi_attribs[1].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex pipelineobj.AddVertexInputAttribs(vi_attribs,2); @@ -854,8 +851,7 @@ TEST_F(XglRenderTest, TriangleMRT) XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attrib; vi_attrib.binding = 0; // index into vertexBindingDescriptions - vi_attrib.format.channelFormat = XGL_CH_FMT_R32G32; // format of source data - vi_attrib.format.numericFormat = XGL_NUM_FMT_FLOAT; + vi_attrib.format = XGL_FMT_R32G32_SFLOAT; // format of source data vi_attrib.offsetInBytes = 0; // Offset of first element in bytes from base of vertex pipelineobj.AddVertexInputAttribs(&vi_attrib, 1); @@ -967,12 +963,10 @@ TEST_F(XglRenderTest, QuadWithIndexedVertexFetch) XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2]; vi_attribs[0].binding = 0; // index into vertexBindingDescriptions - vi_attribs[0].format.channelFormat = XGL_CH_FMT_R32G32B32A32; // format of source data - vi_attribs[0].format.numericFormat = XGL_NUM_FMT_FLOAT; + vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex vi_attribs[1].binding = 0; // index into vertexBindingDescriptions - vi_attribs[1].format.channelFormat = XGL_CH_FMT_R32G32B32A32; // format of source data - vi_attribs[1].format.numericFormat = XGL_NUM_FMT_FLOAT; + vi_attribs[1].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex pipelineobj.AddVertexInputAttribs(vi_attribs,2); @@ -1062,12 +1056,10 @@ TEST_F(XglRenderTest, GreyandRedCirclesonBlue) XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2]; vi_attribs[0].binding = 0; // index into vertexBindingDescriptions - vi_attribs[0].format.channelFormat = XGL_CH_FMT_R32G32B32A32; // format of source data - vi_attribs[0].format.numericFormat = XGL_NUM_FMT_FLOAT; + vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex vi_attribs[1].binding = 0; // index into vertexBindingDescriptions - vi_attribs[1].format.channelFormat = XGL_CH_FMT_R32G32B32A32; // format of source data - vi_attribs[1].format.numericFormat = XGL_NUM_FMT_FLOAT; + vi_attribs[1].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex pipelineobj.AddVertexInputAttribs(vi_attribs,2); @@ -1156,12 +1148,10 @@ TEST_F(XglRenderTest, RedCirclesonBlue) XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2]; vi_attribs[0].binding = 0; // index into vertexBindingDescriptions - vi_attribs[0].format.channelFormat = XGL_CH_FMT_R32G32B32A32; // format of source data - vi_attribs[0].format.numericFormat = XGL_NUM_FMT_FLOAT; + vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex vi_attribs[1].binding = 0; // index into vertexBindingDescriptions - vi_attribs[1].format.channelFormat = XGL_CH_FMT_R32G32B32A32; // format of source data - vi_attribs[1].format.numericFormat = XGL_NUM_FMT_FLOAT; + vi_attribs[1].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex pipelineobj.AddVertexInputAttribs(vi_attribs,2); @@ -1260,12 +1250,10 @@ TEST_F(XglRenderTest, GreyCirclesonBlueFade) XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2]; vi_attribs[0].binding = 0; // index into vertexBindingDescriptions - vi_attribs[0].format.channelFormat = XGL_CH_FMT_R32G32B32A32; // format of source data - vi_attribs[0].format.numericFormat = XGL_NUM_FMT_FLOAT; + vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex vi_attribs[1].binding = 0; // index into vertexBindingDescriptions - vi_attribs[1].format.channelFormat = XGL_CH_FMT_R32G32B32A32; // format of source data - vi_attribs[1].format.numericFormat = XGL_NUM_FMT_FLOAT; + vi_attribs[1].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex pipelineobj.AddVertexInputAttribs(vi_attribs,2); @@ -1354,12 +1342,10 @@ TEST_F(XglRenderTest, GreyCirclesonBlueDiscard) XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2]; vi_attribs[0].binding = 0; // index into vertexBindingDescriptions - vi_attribs[0].format.channelFormat = XGL_CH_FMT_R32G32B32A32; // format of source data - vi_attribs[0].format.numericFormat = XGL_NUM_FMT_FLOAT; + vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex vi_attribs[1].binding = 0; // index into vertexBindingDescriptions - vi_attribs[1].format.channelFormat = XGL_CH_FMT_R32G32B32A32; // format of source data - vi_attribs[1].format.numericFormat = XGL_NUM_FMT_FLOAT; + vi_attribs[1].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex pipelineobj.AddVertexInputAttribs(vi_attribs,2); @@ -1592,12 +1578,10 @@ TEST_F(XglRenderTest, TriVertFetchAndVertID) XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2]; vi_attribs[0].binding = 0; // index into vertexBindingDescriptions - vi_attribs[0].format.channelFormat = XGL_CH_FMT_R32G32B32A32; // format of source data - vi_attribs[0].format.numericFormat = XGL_NUM_FMT_FLOAT; + vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex vi_attribs[1].binding = 0; // index into vertexBindingDescriptions - vi_attribs[1].format.channelFormat = XGL_CH_FMT_R32G32B32A32; // format of source data - vi_attribs[1].format.numericFormat = XGL_NUM_FMT_FLOAT; + vi_attribs[1].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex pipelineobj.AddVertexInputAttribs(vi_attribs,2); @@ -1685,12 +1669,10 @@ TEST_F(XglRenderTest, TriVertFetchDeadAttr) XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2]; vi_attribs[0].binding = 0; // index into vertexBindingDescriptions - vi_attribs[0].format.channelFormat = XGL_CH_FMT_R32G32B32A32; // format of source data - vi_attribs[0].format.numericFormat = XGL_NUM_FMT_FLOAT; + vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex vi_attribs[1].binding = 0; // index into vertexBindingDescriptions - vi_attribs[1].format.channelFormat = XGL_CH_FMT_R32G32B32A32; // format of source data - vi_attribs[1].format.numericFormat = XGL_NUM_FMT_FLOAT; + vi_attribs[1].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex pipelineobj.AddVertexInputAttribs(vi_attribs,2); @@ -1781,8 +1763,7 @@ TEST_F(XglRenderTest, CubeWithVertexFetchAndMVP) ds_state.back.stencilFailOp = XGL_STENCIL_OP_KEEP; ds_state.back.stencilPassOp = XGL_STENCIL_OP_KEEP; ds_state.back.stencilFunc = XGL_COMPARE_ALWAYS; - ds_state.format.channelFormat = XGL_CH_FMT_R32; - ds_state.format.numericFormat = XGL_NUM_FMT_DS; + ds_state.format = XGL_FMT_D32_SFLOAT; ds_state.front = ds_state.back; pipelineobj.SetDepthStencil(&ds_state); @@ -1800,12 +1781,10 @@ TEST_F(XglRenderTest, CubeWithVertexFetchAndMVP) // this is the current description of g_vbData XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2]; vi_attribs[0].binding = 0; // index into vertexBindingDescriptions - vi_attribs[0].format.channelFormat = XGL_CH_FMT_R32G32B32A32; // format of source data - vi_attribs[0].format.numericFormat = XGL_NUM_FMT_FLOAT; + vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex vi_attribs[1].binding = 0; // index into vertexBindingDescriptions - vi_attribs[1].format.channelFormat = XGL_CH_FMT_R32G32B32A32; // format of source data - vi_attribs[1].format.numericFormat = XGL_NUM_FMT_FLOAT; + vi_attribs[1].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex pipelineobj.AddVertexInputBindings(&vi_binding,1); @@ -2586,12 +2565,10 @@ TEST_F(XglRenderTest, CubeWithVertexFetchAndMVPAndTexture) // this is the current description of g_vbData XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2]; vi_attribs[0].binding = 0; // index into vertexBindingDescriptions - vi_attribs[0].format.channelFormat = XGL_CH_FMT_R32G32B32A32; // format of source data - vi_attribs[0].format.numericFormat = XGL_NUM_FMT_FLOAT; + vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex vi_attribs[1].binding = 0; // index into vertexBindingDescriptions - vi_attribs[1].format.channelFormat = XGL_CH_FMT_R32G32B32A32; // format of source data - vi_attribs[1].format.numericFormat = XGL_NUM_FMT_FLOAT; + vi_attribs[1].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex pipelineobj.AddVertexInputBindings(&vi_binding,1); @@ -2608,8 +2585,7 @@ TEST_F(XglRenderTest, CubeWithVertexFetchAndMVPAndTexture) ds_state.back.stencilFailOp = XGL_STENCIL_OP_KEEP; ds_state.back.stencilPassOp = XGL_STENCIL_OP_KEEP; ds_state.back.stencilFunc = XGL_COMPARE_ALWAYS; - ds_state.format.channelFormat = XGL_CH_FMT_R32; - ds_state.format.numericFormat = XGL_NUM_FMT_DS; + ds_state.format = XGL_FMT_D32_SFLOAT; ds_state.front = ds_state.back; pipelineobj.SetDepthStencil(&ds_state); diff --git a/tests/xglrenderframework.cpp b/tests/xglrenderframework.cpp index 77cd9bb..68f7baa 100644 --- a/tests/xglrenderframework.cpp +++ b/tests/xglrenderframework.cpp @@ -38,8 +38,7 @@ XglRenderFramework::XglRenderFramework() : { m_renderTargetCount = 1; - m_render_target_fmt.channelFormat = XGL_CH_FMT_R8G8B8A8; - m_render_target_fmt.numericFormat = XGL_NUM_FMT_UNORM; + m_render_target_fmt = XGL_FMT_R8G8B8A8_UNORM; m_depthStencilBinding.view = XGL_NULL_HANDLE; } @@ -82,8 +81,7 @@ void XglRenderFramework::InitState() { XGL_RESULT err; - m_render_target_fmt.channelFormat = XGL_CH_FMT_R8G8B8A8; - m_render_target_fmt.numericFormat = XGL_NUM_FMT_UNORM; + m_render_target_fmt = XGL_FMT_R8G8B8A8_UNORM; // create a raster state (solid, back-face culling) XGL_DYNAMIC_RS_STATE_CREATE_INFO raster = {}; @@ -372,7 +370,7 @@ void XglImage::init(XGL_UINT32 w, XGL_UINT32 h, XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO, XGL_NULL_HANDLE, obj(), - {XGL_CH_FMT_R8G8B8A8, XGL_NUM_FMT_UNORM}, + XGL_FMT_R8G8B8A8_UNORM, 0, 0, 1 @@ -396,7 +394,7 @@ XGL_RESULT XglImage::UnmapMemory() XglTextureObj::XglTextureObj(XglDevice *device) { m_device = device; - const XGL_FORMAT tex_format = { XGL_CH_FMT_B8G8R8A8, XGL_NUM_FMT_UNORM }; + const XGL_FORMAT tex_format = XGL_FMT_B8G8R8A8_UNORM; const uint32_t tex_colors[2] = { 0xffff0000, 0xff00ff00 }; memset(&m_textureViewInfo,0,sizeof(m_textureViewInfo)); @@ -632,19 +630,18 @@ void XglIndexBufferObj::CreateAndInitBuffer(int numIndexes, XGL_INDEX_TYPE index m_numVertices = numIndexes; m_indexType = indexType; - viewFormat.numericFormat = XGL_NUM_FMT_UINT; switch (indexType) { case XGL_INDEX_8: m_stride = 1; - viewFormat.channelFormat = XGL_CH_FMT_R8; + viewFormat = XGL_FMT_R8_UINT; break; case XGL_INDEX_16: m_stride = 2; - viewFormat.channelFormat = XGL_CH_FMT_R16; + viewFormat = XGL_FMT_R16_UINT; break; case XGL_INDEX_32: m_stride = 4; - viewFormat.channelFormat = XGL_CH_FMT_R32; + viewFormat = XGL_FMT_R32_UINT; break; default: assert(!"unknown index type"); @@ -664,8 +661,7 @@ void XglIndexBufferObj::CreateAndInitBuffer(int numIndexes, XGL_INDEX_TYPE index view_info.buffer = obj(); view_info.viewType = XGL_BUFFER_VIEW_TYPED; view_info.stride = m_stride; - view_info.format.channelFormat = viewFormat.channelFormat; - view_info.format.numericFormat = viewFormat.numericFormat; + view_info.format = viewFormat; view_info.channels.r = XGL_CHANNEL_SWIZZLE_R; view_info.channels.g = XGL_CHANNEL_SWIZZLE_G; view_info.channels.b = XGL_CHANNEL_SWIZZLE_B; @@ -782,8 +778,7 @@ XglPipelineObj::XglPipelineObj(XglDevice *device) m_ds_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO; m_ds_state.pNext = &m_ms_state, - m_ds_state.format.channelFormat = XGL_CH_FMT_R32; - m_ds_state.format.numericFormat = XGL_NUM_FMT_DS; + m_ds_state.format = XGL_FMT_D32_SFLOAT; m_ds_state.depthTestEnable = XGL_FALSE; m_ds_state.depthWriteEnable = XGL_FALSE; m_ds_state.depthBoundsEnable = XGL_FALSE; @@ -797,8 +792,7 @@ XglPipelineObj::XglPipelineObj(XglDevice *device) XGL_PIPELINE_CB_ATTACHMENT_STATE att = {}; att.blendEnable = XGL_FALSE; - att.format.channelFormat = XGL_CH_FMT_R8G8B8A8; - att.format.numericFormat = XGL_NUM_FMT_UNORM; + att.format = XGL_FMT_R8G8B8A8_UNORM; att.channelWriteMask = 0xf; AddColorAttachment(0, &att); diff --git a/tests/xgltestbinding.cpp b/tests/xgltestbinding.cpp index 88528af..c1864a2 100644 --- a/tests/xgltestbinding.cpp +++ b/tests/xgltestbinding.cpp @@ -440,21 +440,18 @@ void Device::init_queues() void Device::init_formats() { - for (int ch = XGL_CH_FMT_UNDEFINED; ch <= XGL_MAX_CH_FMT; ch++) { - for (int num = XGL_NUM_FMT_UNDEFINED; num <= XGL_MAX_NUM_FMT; num++) { - const XGL_FORMAT fmt = { static_cast(ch), - static_cast(num) }; - const XGL_FORMAT_PROPERTIES props = format_properties(fmt); - - if (props.linearTilingFeatures) { - const Format tmp = { fmt, XGL_LINEAR_TILING, props.linearTilingFeatures }; - formats_.push_back(tmp); - } - - if (props.optimalTilingFeatures) { - const Format tmp = { fmt, XGL_OPTIMAL_TILING, props.optimalTilingFeatures }; - formats_.push_back(tmp); - } + for (int f = XGL_FMT_BEGIN_RANGE; f <= XGL_FMT_END_RANGE; f++) { + const XGL_FORMAT fmt = static_cast(f); + const XGL_FORMAT_PROPERTIES props = format_properties(fmt); + + if (props.linearTilingFeatures) { + const Format tmp = { fmt, XGL_LINEAR_TILING, props.linearTilingFeatures }; + formats_.push_back(tmp); + } + + if (props.optimalTilingFeatures) { + const Format tmp = { fmt, XGL_OPTIMAL_TILING, props.optimalTilingFeatures }; + formats_.push_back(tmp); } }