From 294ce9394f4a8952abe9fb9b58b52f161a55dc24 Mon Sep 17 00:00:00 2001 From: Ben Clayton Date: Thu, 6 Jan 2022 17:20:22 +0000 Subject: [PATCH] ast: Rename ImageFormat to TexelFormat This is what its called in the spec. Issue: tint:1361 Change-Id: I512c4224191fd2bbf04522da2093872f79ee02a6 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/75581 Reviewed-by: David Neto Kokoro: Kokoro Commit-Queue: Ben Clayton --- samples/main.cc | 78 ++++----- src/CMakeLists.txt | 2 +- src/ast/intrinsic_texture_helper_test.cc | 26 +-- src/ast/intrinsic_texture_helper_test.h | 4 +- src/ast/storage_texture.cc | 150 +++++++++--------- src/ast/storage_texture.h | 18 +-- src/ast/storage_texture_test.cc | 30 ++-- src/inspector/inspector.cc | 4 +- src/inspector/inspector_test.cc | 80 +++++----- src/inspector/resource_binding.cc | 150 +++++++++--------- src/inspector/resource_binding.h | 17 +- src/inspector/test_inspector_builder.cc | 2 +- src/inspector/test_inspector_builder.h | 4 +- src/intrinsic_table.cc | 4 +- src/intrinsic_table_test.cc | 4 +- src/program_builder.h | 8 +- src/reader/spirv/enum_converter.cc | 38 ++--- src/reader/spirv/enum_converter.h | 4 +- src/reader/spirv/enum_converter_test.cc | 114 ++++++------- src/reader/spirv/parser_impl.cc | 150 +++++++++--------- src/reader/spirv/parser_impl.h | 6 +- src/reader/spirv/parser_type.cc | 6 +- src/reader/spirv/parser_type.h | 6 +- src/reader/spirv/parser_type_test.cc | 16 +- src/reader/wgsl/parser_impl.cc | 78 ++++----- src/reader/wgsl/parser_impl.h | 6 +- ...st.cc => parser_impl_texel_format_test.cc} | 142 ++++++++--------- .../parser_impl_texture_sampler_types_test.cc | 4 +- src/resolver/assignment_validation_test.cc | 2 +- src/resolver/dependency_graph_test.cc | 2 +- src/resolver/intrinsic_test.cc | 2 +- src/resolver/resolver_validation.cc | 36 ++--- src/resolver/type_validation_test.cc | 82 +++++----- src/sem/storage_texture_type.cc | 82 +++++----- src/sem/storage_texture_type.h | 14 +- src/sem/storage_texture_type_test.cc | 30 ++-- src/transform/transform.cc | 2 +- src/writer/glsl/generator_impl_type_test.cc | 28 ++-- src/writer/hlsl/generator_impl.cc | 40 ++--- src/writer/hlsl/generator_impl_type_test.cc | 28 ++-- src/writer/msl/generator_impl_type_test.cc | 2 +- src/writer/spirv/builder.cc | 84 +++++----- src/writer/spirv/builder.h | 4 +- .../spirv/builder_format_conversion_test.cc | 74 ++++----- .../spirv/builder_global_variable_test.cc | 6 +- src/writer/spirv/builder_type_test.cc | 14 +- src/writer/wgsl/generator_impl.cc | 4 +- src/writer/wgsl/generator_impl.h | 2 +- src/writer/wgsl/generator_impl_type_test.cc | 82 +++++----- test/BUILD.gn | 2 +- 50 files changed, 887 insertions(+), 886 deletions(-) rename src/reader/wgsl/{parser_impl_image_storage_type_test.cc => parser_impl_texel_format_test.cc} (63%) diff --git a/samples/main.cc b/samples/main.cc index bcbbe3eacd..076ea2b9f2 100644 --- a/samples/main.cc +++ b/samples/main.cc @@ -253,80 +253,80 @@ std::string SampledKindToString( return "Unknown"; } -std::string ImageFormatToString( - tint::inspector::ResourceBinding::ImageFormat format) { +std::string TexelFormatToString( + tint::inspector::ResourceBinding::TexelFormat format) { switch (format) { - case tint::inspector::ResourceBinding::ImageFormat::kR8Unorm: + case tint::inspector::ResourceBinding::TexelFormat::kR8Unorm: return "R8Unorm"; - case tint::inspector::ResourceBinding::ImageFormat::kR8Snorm: + case tint::inspector::ResourceBinding::TexelFormat::kR8Snorm: return "R8Snorm"; - case tint::inspector::ResourceBinding::ImageFormat::kR8Uint: + case tint::inspector::ResourceBinding::TexelFormat::kR8Uint: return "R8Uint"; - case tint::inspector::ResourceBinding::ImageFormat::kR8Sint: + case tint::inspector::ResourceBinding::TexelFormat::kR8Sint: return "R8Sint"; - case tint::inspector::ResourceBinding::ImageFormat::kR16Uint: + case tint::inspector::ResourceBinding::TexelFormat::kR16Uint: return "R16Uint"; - case tint::inspector::ResourceBinding::ImageFormat::kR16Sint: + case tint::inspector::ResourceBinding::TexelFormat::kR16Sint: return "R16Sint"; - case tint::inspector::ResourceBinding::ImageFormat::kR16Float: + case tint::inspector::ResourceBinding::TexelFormat::kR16Float: return "R16Float"; - case tint::inspector::ResourceBinding::ImageFormat::kRg8Unorm: + case tint::inspector::ResourceBinding::TexelFormat::kRg8Unorm: return "Rg8Unorm"; - case tint::inspector::ResourceBinding::ImageFormat::kRg8Snorm: + case tint::inspector::ResourceBinding::TexelFormat::kRg8Snorm: return "Rg8Snorm"; - case tint::inspector::ResourceBinding::ImageFormat::kRg8Uint: + case tint::inspector::ResourceBinding::TexelFormat::kRg8Uint: return "Rg8Uint"; - case tint::inspector::ResourceBinding::ImageFormat::kRg8Sint: + case tint::inspector::ResourceBinding::TexelFormat::kRg8Sint: return "Rg8Sint"; - case tint::inspector::ResourceBinding::ImageFormat::kR32Uint: + case tint::inspector::ResourceBinding::TexelFormat::kR32Uint: return "R32Uint"; - case tint::inspector::ResourceBinding::ImageFormat::kR32Sint: + case tint::inspector::ResourceBinding::TexelFormat::kR32Sint: return "R32Sint"; - case tint::inspector::ResourceBinding::ImageFormat::kR32Float: + case tint::inspector::ResourceBinding::TexelFormat::kR32Float: return "R32Float"; - case tint::inspector::ResourceBinding::ImageFormat::kRg16Uint: + case tint::inspector::ResourceBinding::TexelFormat::kRg16Uint: return "Rg16Uint"; - case tint::inspector::ResourceBinding::ImageFormat::kRg16Sint: + case tint::inspector::ResourceBinding::TexelFormat::kRg16Sint: return "Rg16Sint"; - case tint::inspector::ResourceBinding::ImageFormat::kRg16Float: + case tint::inspector::ResourceBinding::TexelFormat::kRg16Float: return "Rg16Float"; - case tint::inspector::ResourceBinding::ImageFormat::kRgba8Unorm: + case tint::inspector::ResourceBinding::TexelFormat::kRgba8Unorm: return "Rgba8Unorm"; - case tint::inspector::ResourceBinding::ImageFormat::kRgba8UnormSrgb: + case tint::inspector::ResourceBinding::TexelFormat::kRgba8UnormSrgb: return "Rgba8UnormSrgb"; - case tint::inspector::ResourceBinding::ImageFormat::kRgba8Snorm: + case tint::inspector::ResourceBinding::TexelFormat::kRgba8Snorm: return "Rgba8Snorm"; - case tint::inspector::ResourceBinding::ImageFormat::kRgba8Uint: + case tint::inspector::ResourceBinding::TexelFormat::kRgba8Uint: return "Rgba8Uint"; - case tint::inspector::ResourceBinding::ImageFormat::kRgba8Sint: + case tint::inspector::ResourceBinding::TexelFormat::kRgba8Sint: return "Rgba8Sint"; - case tint::inspector::ResourceBinding::ImageFormat::kBgra8Unorm: + case tint::inspector::ResourceBinding::TexelFormat::kBgra8Unorm: return "Bgra8Unorm"; - case tint::inspector::ResourceBinding::ImageFormat::kBgra8UnormSrgb: + case tint::inspector::ResourceBinding::TexelFormat::kBgra8UnormSrgb: return "Bgra8UnormSrgb"; - case tint::inspector::ResourceBinding::ImageFormat::kRgb10A2Unorm: + case tint::inspector::ResourceBinding::TexelFormat::kRgb10A2Unorm: return "Rgb10A2Unorm"; - case tint::inspector::ResourceBinding::ImageFormat::kRg11B10Float: + case tint::inspector::ResourceBinding::TexelFormat::kRg11B10Float: return "Rg11B10Float"; - case tint::inspector::ResourceBinding::ImageFormat::kRg32Uint: + case tint::inspector::ResourceBinding::TexelFormat::kRg32Uint: return "Rg32Uint"; - case tint::inspector::ResourceBinding::ImageFormat::kRg32Sint: + case tint::inspector::ResourceBinding::TexelFormat::kRg32Sint: return "Rg32Sint"; - case tint::inspector::ResourceBinding::ImageFormat::kRg32Float: + case tint::inspector::ResourceBinding::TexelFormat::kRg32Float: return "Rg32Float"; - case tint::inspector::ResourceBinding::ImageFormat::kRgba16Uint: + case tint::inspector::ResourceBinding::TexelFormat::kRgba16Uint: return "Rgba16Uint"; - case tint::inspector::ResourceBinding::ImageFormat::kRgba16Sint: + case tint::inspector::ResourceBinding::TexelFormat::kRgba16Sint: return "Rgba16Sint"; - case tint::inspector::ResourceBinding::ImageFormat::kRgba16Float: + case tint::inspector::ResourceBinding::TexelFormat::kRgba16Float: return "Rgba16Float"; - case tint::inspector::ResourceBinding::ImageFormat::kRgba32Uint: + case tint::inspector::ResourceBinding::TexelFormat::kRgba32Uint: return "Rgba32Uint"; - case tint::inspector::ResourceBinding::ImageFormat::kRgba32Sint: + case tint::inspector::ResourceBinding::TexelFormat::kRgba32Sint: return "Rgba32Sint"; - case tint::inspector::ResourceBinding::ImageFormat::kRgba32Float: + case tint::inspector::ResourceBinding::TexelFormat::kRgba32Float: return "Rgba32Float"; - case tint::inspector::ResourceBinding::ImageFormat::kNone: + case tint::inspector::ResourceBinding::TexelFormat::kNone: return "None"; } return "Unknown"; @@ -1162,7 +1162,7 @@ int main(int argc, const char** argv) { std::cout << "\t\t sampled_kind = " << SampledKindToString(binding.sampled_kind) << std::endl; std::cout << "\t\t image_format = " - << ImageFormatToString(binding.image_format) << std::endl; + << TexelFormatToString(binding.image_format) << std::endl; } } std::cout << std::string(80, '-') << std::endl; diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 62fd9fc56a..4bea019746 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -840,7 +840,6 @@ if(${TINT_BUILD_TESTS}) reader/wgsl/parser_impl_global_decl_test.cc reader/wgsl/parser_impl_global_variable_decl_test.cc reader/wgsl/parser_impl_if_stmt_test.cc - reader/wgsl/parser_impl_image_storage_type_test.cc reader/wgsl/parser_impl_inclusive_or_expression_test.cc reader/wgsl/parser_impl_logical_and_expression_test.cc reader/wgsl/parser_impl_logical_or_expression_test.cc @@ -872,6 +871,7 @@ if(${TINT_BUILD_TESTS}) reader/wgsl/parser_impl_test.cc reader/wgsl/parser_impl_test_helper.cc reader/wgsl/parser_impl_test_helper.h + reader/wgsl/parser_impl_texel_format_test.cc reader/wgsl/parser_impl_texture_sampler_types_test.cc reader/wgsl/parser_impl_type_alias_test.cc reader/wgsl/parser_impl_type_decl_test.cc diff --git a/src/ast/intrinsic_texture_helper_test.cc b/src/ast/intrinsic_texture_helper_test.cc index 76c9a730ac..4273f1e201 100644 --- a/src/ast/intrinsic_texture_helper_test.cc +++ b/src/ast/intrinsic_texture_helper_test.cc @@ -63,7 +63,7 @@ TextureOverloadCase::TextureOverloadCase( ValidTextureOverload o, const char* d, Access acc, - ast::ImageFormat i, + ast::TexelFormat fmt, ast::TextureDimension dims, TextureDataType datatype, const char* f, @@ -72,7 +72,7 @@ TextureOverloadCase::TextureOverloadCase( description(d), texture_kind(TextureKind::kStorage), access(acc), - image_format(i), + texel_format(fmt), texture_dimension(dims), texture_data_type(datatype), function(f), @@ -128,7 +128,7 @@ std::ostream& operator<<(std::ostream& out, const TextureOverloadCase& data) { } out << "\n"; out << "access: " << data.access << "\n"; - out << "image_format: " << data.image_format << "\n"; + out << "texel_format: " << data.texel_format << "\n"; out << "texture_dimension: " << data.texture_dimension << "\n"; out << "texture_data_type: " << data.texture_data_type << "\n"; return out; @@ -179,7 +179,7 @@ const ast::Variable* TextureOverloadCase::BuildTextureVariable( decos); case ast::intrinsic::test::TextureKind::kStorage: { - auto* st = b->ty.storage_texture(texture_dimension, image_format, access); + auto* st = b->ty.storage_texture(texture_dimension, texel_format, access); return b->Global("texture", st, decos); } } @@ -422,7 +422,7 @@ std::vector TextureOverloadCase::ValidCases() { ValidTextureOverload::kDimensionsStorageWO1d, "textureDimensions(t : texture_storage_1d) -> i32", ast::Access::kWrite, - ast::ImageFormat::kRgba32Float, + ast::TexelFormat::kRgba32Float, ast::TextureDimension::k1d, TextureDataType::kF32, "textureDimensions", @@ -433,7 +433,7 @@ std::vector TextureOverloadCase::ValidCases() { "textureDimensions(t : texture_storage_2d) -> " "vec2", ast::Access::kWrite, - ast::ImageFormat::kRgba32Float, + ast::TexelFormat::kRgba32Float, ast::TextureDimension::k2d, TextureDataType::kF32, "textureDimensions", @@ -444,7 +444,7 @@ std::vector TextureOverloadCase::ValidCases() { "textureDimensions(t : texture_storage_2d_array) -> " "vec2", ast::Access::kWrite, - ast::ImageFormat::kRgba32Float, + ast::TexelFormat::kRgba32Float, ast::TextureDimension::k2dArray, TextureDataType::kF32, "textureDimensions", @@ -455,7 +455,7 @@ std::vector TextureOverloadCase::ValidCases() { "textureDimensions(t : texture_storage_3d) -> " "vec3", ast::Access::kWrite, - ast::ImageFormat::kRgba32Float, + ast::TexelFormat::kRgba32Float, ast::TextureDimension::k3d, TextureDataType::kF32, "textureDimensions", @@ -848,7 +848,7 @@ std::vector TextureOverloadCase::ValidCases() { ValidTextureOverload::kNumLayersStorageWO2dArray, "textureNumLayers(t : texture_storage_2d_array) -> i32", ast::Access::kWrite, - ast::ImageFormat::kRgba32Float, + ast::TexelFormat::kRgba32Float, ast::TextureDimension::k2dArray, TextureDataType::kF32, "textureNumLayers", @@ -2205,7 +2205,7 @@ std::vector TextureOverloadCase::ValidCases() { " coords : i32,\n" " value : vec4)", ast::Access::kWrite, - ast::ImageFormat::kRgba32Float, + ast::TexelFormat::kRgba32Float, ast::TextureDimension::k1d, TextureDataType::kF32, "textureStore", @@ -2221,7 +2221,7 @@ std::vector TextureOverloadCase::ValidCases() { " coords : vec2,\n" " value : vec4)", ast::Access::kWrite, - ast::ImageFormat::kRgba32Float, + ast::TexelFormat::kRgba32Float, ast::TextureDimension::k2d, TextureDataType::kF32, "textureStore", @@ -2238,7 +2238,7 @@ std::vector TextureOverloadCase::ValidCases() { " array_index : i32,\n" " value : vec4)", ast::Access::kWrite, - ast::ImageFormat::kRgba32Float, + ast::TexelFormat::kRgba32Float, ast::TextureDimension::k2dArray, TextureDataType::kF32, "textureStore", @@ -2255,7 +2255,7 @@ std::vector TextureOverloadCase::ValidCases() { " coords : vec3,\n" " value : vec4)", ast::Access::kWrite, - ast::ImageFormat::kRgba32Float, + ast::TexelFormat::kRgba32Float, ast::TextureDimension::k3d, TextureDataType::kF32, "textureStore", diff --git a/src/ast/intrinsic_texture_helper_test.h b/src/ast/intrinsic_texture_helper_test.h index 64b995a459..b5f4a343ae 100644 --- a/src/ast/intrinsic_texture_helper_test.h +++ b/src/ast/intrinsic_texture_helper_test.h @@ -207,7 +207,7 @@ struct TextureOverloadCase { TextureOverloadCase(ValidTextureOverload, const char*, Access, - ast::ImageFormat, + ast::TexelFormat, ast::TextureDimension, TextureDataType, const char*, @@ -248,7 +248,7 @@ struct TextureOverloadCase { Access const access = Access::kReadWrite; /// The image format for the storage texture /// Used only when texture_kind is kStorage - ast::ImageFormat const image_format = ast::ImageFormat::kNone; + ast::TexelFormat const texel_format = ast::TexelFormat::kNone; /// The dimensions of the texture parameter ast::TextureDimension const texture_dimension; /// The data type of the texture parameter diff --git a/src/ast/storage_texture.cc b/src/ast/storage_texture.cc index 5b8fdcda72..b074f5d319 100644 --- a/src/ast/storage_texture.cc +++ b/src/ast/storage_texture.cc @@ -26,114 +26,114 @@ namespace ast { // Note, these names match the names in the WGSL spec. This behaviour is used // in the WGSL writer to emit the texture format names. -std::ostream& operator<<(std::ostream& out, ImageFormat format) { +std::ostream& operator<<(std::ostream& out, TexelFormat format) { switch (format) { - case ImageFormat::kNone: + case TexelFormat::kNone: out << "none"; break; - case ImageFormat::kR8Unorm: + case TexelFormat::kR8Unorm: out << "r8unorm"; break; - case ImageFormat::kR8Snorm: + case TexelFormat::kR8Snorm: out << "r8snorm"; break; - case ImageFormat::kR8Uint: + case TexelFormat::kR8Uint: out << "r8uint"; break; - case ImageFormat::kR8Sint: + case TexelFormat::kR8Sint: out << "r8sint"; break; - case ImageFormat::kR16Uint: + case TexelFormat::kR16Uint: out << "r16uint"; break; - case ImageFormat::kR16Sint: + case TexelFormat::kR16Sint: out << "r16sint"; break; - case ImageFormat::kR16Float: + case TexelFormat::kR16Float: out << "r16float"; break; - case ImageFormat::kRg8Unorm: + case TexelFormat::kRg8Unorm: out << "rg8unorm"; break; - case ImageFormat::kRg8Snorm: + case TexelFormat::kRg8Snorm: out << "rg8snorm"; break; - case ImageFormat::kRg8Uint: + case TexelFormat::kRg8Uint: out << "rg8uint"; break; - case ImageFormat::kRg8Sint: + case TexelFormat::kRg8Sint: out << "rg8sint"; break; - case ImageFormat::kR32Uint: + case TexelFormat::kR32Uint: out << "r32uint"; break; - case ImageFormat::kR32Sint: + case TexelFormat::kR32Sint: out << "r32sint"; break; - case ImageFormat::kR32Float: + case TexelFormat::kR32Float: out << "r32float"; break; - case ImageFormat::kRg16Uint: + case TexelFormat::kRg16Uint: out << "rg16uint"; break; - case ImageFormat::kRg16Sint: + case TexelFormat::kRg16Sint: out << "rg16sint"; break; - case ImageFormat::kRg16Float: + case TexelFormat::kRg16Float: out << "rg16float"; break; - case ImageFormat::kRgba8Unorm: + case TexelFormat::kRgba8Unorm: out << "rgba8unorm"; break; - case ImageFormat::kRgba8UnormSrgb: + case TexelFormat::kRgba8UnormSrgb: out << "rgba8unorm_srgb"; break; - case ImageFormat::kRgba8Snorm: + case TexelFormat::kRgba8Snorm: out << "rgba8snorm"; break; - case ImageFormat::kRgba8Uint: + case TexelFormat::kRgba8Uint: out << "rgba8uint"; break; - case ImageFormat::kRgba8Sint: + case TexelFormat::kRgba8Sint: out << "rgba8sint"; break; - case ImageFormat::kBgra8Unorm: + case TexelFormat::kBgra8Unorm: out << "bgra8unorm"; break; - case ImageFormat::kBgra8UnormSrgb: + case TexelFormat::kBgra8UnormSrgb: out << "bgra8unorm_srgb"; break; - case ImageFormat::kRgb10A2Unorm: + case TexelFormat::kRgb10A2Unorm: out << "rgb10a2unorm"; break; - case ImageFormat::kRg11B10Float: + case TexelFormat::kRg11B10Float: out << "rg11b10float"; break; - case ImageFormat::kRg32Uint: + case TexelFormat::kRg32Uint: out << "rg32uint"; break; - case ImageFormat::kRg32Sint: + case TexelFormat::kRg32Sint: out << "rg32sint"; break; - case ImageFormat::kRg32Float: + case TexelFormat::kRg32Float: out << "rg32float"; break; - case ImageFormat::kRgba16Uint: + case TexelFormat::kRgba16Uint: out << "rgba16uint"; break; - case ImageFormat::kRgba16Sint: + case TexelFormat::kRgba16Sint: out << "rgba16sint"; break; - case ImageFormat::kRgba16Float: + case TexelFormat::kRgba16Float: out << "rgba16float"; break; - case ImageFormat::kRgba32Uint: + case TexelFormat::kRgba32Uint: out << "rgba32uint"; break; - case ImageFormat::kRgba32Sint: + case TexelFormat::kRgba32Sint: out << "rgba32sint"; break; - case ImageFormat::kRgba32Float: + case TexelFormat::kRgba32Float: out << "rgba32float"; break; } @@ -143,7 +143,7 @@ std::ostream& operator<<(std::ostream& out, ImageFormat format) { StorageTexture::StorageTexture(ProgramID pid, const Source& src, TextureDimension d, - ImageFormat fmt, + TexelFormat fmt, const Type* subtype, Access ac) : Base(pid, src, d), format(fmt), type(subtype), access(ac) {} @@ -165,53 +165,53 @@ const StorageTexture* StorageTexture::Clone(CloneContext* ctx) const { return ctx->dst->create(src, dim, format, ty, access); } -Type* StorageTexture::SubtypeFor(ImageFormat format, ProgramBuilder& builder) { +Type* StorageTexture::SubtypeFor(TexelFormat format, ProgramBuilder& builder) { switch (format) { - case ImageFormat::kR8Uint: - case ImageFormat::kR16Uint: - case ImageFormat::kRg8Uint: - case ImageFormat::kR32Uint: - case ImageFormat::kRg16Uint: - case ImageFormat::kRgba8Uint: - case ImageFormat::kRg32Uint: - case ImageFormat::kRgba16Uint: - case ImageFormat::kRgba32Uint: { + case TexelFormat::kR8Uint: + case TexelFormat::kR16Uint: + case TexelFormat::kRg8Uint: + case TexelFormat::kR32Uint: + case TexelFormat::kRg16Uint: + case TexelFormat::kRgba8Uint: + case TexelFormat::kRg32Uint: + case TexelFormat::kRgba16Uint: + case TexelFormat::kRgba32Uint: { return builder.create(); } - case ImageFormat::kR8Sint: - case ImageFormat::kR16Sint: - case ImageFormat::kRg8Sint: - case ImageFormat::kR32Sint: - case ImageFormat::kRg16Sint: - case ImageFormat::kRgba8Sint: - case ImageFormat::kRg32Sint: - case ImageFormat::kRgba16Sint: - case ImageFormat::kRgba32Sint: { + case TexelFormat::kR8Sint: + case TexelFormat::kR16Sint: + case TexelFormat::kRg8Sint: + case TexelFormat::kR32Sint: + case TexelFormat::kRg16Sint: + case TexelFormat::kRgba8Sint: + case TexelFormat::kRg32Sint: + case TexelFormat::kRgba16Sint: + case TexelFormat::kRgba32Sint: { return builder.create(); } - case ImageFormat::kR8Unorm: - case ImageFormat::kRg8Unorm: - case ImageFormat::kRgba8Unorm: - case ImageFormat::kRgba8UnormSrgb: - case ImageFormat::kBgra8Unorm: - case ImageFormat::kBgra8UnormSrgb: - case ImageFormat::kRgb10A2Unorm: - case ImageFormat::kR8Snorm: - case ImageFormat::kRg8Snorm: - case ImageFormat::kRgba8Snorm: - case ImageFormat::kR16Float: - case ImageFormat::kR32Float: - case ImageFormat::kRg16Float: - case ImageFormat::kRg11B10Float: - case ImageFormat::kRg32Float: - case ImageFormat::kRgba16Float: - case ImageFormat::kRgba32Float: { + case TexelFormat::kR8Unorm: + case TexelFormat::kRg8Unorm: + case TexelFormat::kRgba8Unorm: + case TexelFormat::kRgba8UnormSrgb: + case TexelFormat::kBgra8Unorm: + case TexelFormat::kBgra8UnormSrgb: + case TexelFormat::kRgb10A2Unorm: + case TexelFormat::kR8Snorm: + case TexelFormat::kRg8Snorm: + case TexelFormat::kRgba8Snorm: + case TexelFormat::kR16Float: + case TexelFormat::kR32Float: + case TexelFormat::kRg16Float: + case TexelFormat::kRg11B10Float: + case TexelFormat::kRg32Float: + case TexelFormat::kRgba16Float: + case TexelFormat::kRgba32Float: { return builder.create(); } - case ImageFormat::kNone: + case TexelFormat::kNone: break; } diff --git a/src/ast/storage_texture.h b/src/ast/storage_texture.h index 5e56abafa6..46cd2c8137 100644 --- a/src/ast/storage_texture.h +++ b/src/ast/storage_texture.h @@ -23,10 +23,8 @@ namespace tint { namespace ast { -class Manager; - -/// The image format in the storage texture -enum class ImageFormat { +/// The texel format in the storage texture +enum class TexelFormat { kNone = -1, kR8Unorm, kR8Snorm, @@ -66,9 +64,9 @@ enum class ImageFormat { }; /// @param out the std::ostream to write to -/// @param format the ImageFormat +/// @param format the TexelFormat /// @return the std::ostream so calls can be chained -std::ostream& operator<<(std::ostream& out, ImageFormat format); +std::ostream& operator<<(std::ostream& out, TexelFormat format); /// A storage texture type. class StorageTexture : public Castable { @@ -83,7 +81,7 @@ class StorageTexture : public Castable { StorageTexture(ProgramID pid, const Source& src, TextureDimension dim, - ImageFormat format, + TexelFormat format, const Type* subtype, Access access_control); @@ -103,11 +101,11 @@ class StorageTexture : public Castable { /// @param format the storage texture image format /// @param builder the ProgramBuilder used to build the returned type - /// @returns the storage texture subtype for the given ImageFormat - static Type* SubtypeFor(ImageFormat format, ProgramBuilder& builder); + /// @returns the storage texture subtype for the given TexelFormat + static Type* SubtypeFor(TexelFormat format, ProgramBuilder& builder); /// The image format - const ImageFormat format; + const TexelFormat format; /// The storage subtype const Type* const type; diff --git a/src/ast/storage_texture_test.cc b/src/ast/storage_texture_test.cc index ecd2c1342a..2fbf8ccf18 100644 --- a/src/ast/storage_texture_test.cc +++ b/src/ast/storage_texture_test.cc @@ -23,45 +23,45 @@ namespace { using AstStorageTextureTest = TestHelper; TEST_F(AstStorageTextureTest, IsTexture) { - auto* subtype = StorageTexture::SubtypeFor(ImageFormat::kRgba32Float, *this); + auto* subtype = StorageTexture::SubtypeFor(TexelFormat::kRgba32Float, *this); Texture* ty = create(TextureDimension::k2dArray, - ImageFormat::kRgba32Float, subtype, Access::kRead); + TexelFormat::kRgba32Float, subtype, Access::kRead); EXPECT_FALSE(ty->Is()); EXPECT_FALSE(ty->Is()); EXPECT_TRUE(ty->Is()); } TEST_F(AstStorageTextureTest, Dim) { - auto* subtype = StorageTexture::SubtypeFor(ImageFormat::kRgba32Float, *this); + auto* subtype = StorageTexture::SubtypeFor(TexelFormat::kRgba32Float, *this); auto* s = create(TextureDimension::k2dArray, - ImageFormat::kRgba32Float, subtype, Access::kRead); + TexelFormat::kRgba32Float, subtype, Access::kRead); EXPECT_EQ(s->dim, TextureDimension::k2dArray); } TEST_F(AstStorageTextureTest, Format) { - auto* subtype = StorageTexture::SubtypeFor(ImageFormat::kRgba32Float, *this); + auto* subtype = StorageTexture::SubtypeFor(TexelFormat::kRgba32Float, *this); auto* s = create(TextureDimension::k2dArray, - ImageFormat::kRgba32Float, subtype, Access::kRead); - EXPECT_EQ(s->format, ImageFormat::kRgba32Float); + TexelFormat::kRgba32Float, subtype, Access::kRead); + EXPECT_EQ(s->format, TexelFormat::kRgba32Float); } TEST_F(AstStorageTextureTest, FriendlyName) { - auto* subtype = StorageTexture::SubtypeFor(ImageFormat::kRgba32Float, *this); + auto* subtype = StorageTexture::SubtypeFor(TexelFormat::kRgba32Float, *this); auto* s = create(TextureDimension::k2dArray, - ImageFormat::kRgba32Float, subtype, Access::kRead); + TexelFormat::kRgba32Float, subtype, Access::kRead); EXPECT_EQ(s->FriendlyName(Symbols()), "texture_storage_2d_array"); } TEST_F(AstStorageTextureTest, F32) { - auto* subtype = StorageTexture::SubtypeFor(ImageFormat::kRgba32Float, *this); + auto* subtype = StorageTexture::SubtypeFor(TexelFormat::kRgba32Float, *this); Type* s = create(TextureDimension::k2dArray, - ImageFormat::kRgba32Float, subtype, Access::kRead); + TexelFormat::kRgba32Float, subtype, Access::kRead); ASSERT_TRUE(s->Is()); ASSERT_TRUE(s->Is()); @@ -69,9 +69,9 @@ TEST_F(AstStorageTextureTest, F32) { } TEST_F(AstStorageTextureTest, U32) { - auto* subtype = StorageTexture::SubtypeFor(ImageFormat::kRg32Uint, *this); + auto* subtype = StorageTexture::SubtypeFor(TexelFormat::kRg32Uint, *this); Type* s = - create(TextureDimension::k2dArray, ImageFormat::kRg32Uint, + create(TextureDimension::k2dArray, TexelFormat::kRg32Uint, subtype, Access::kRead); ASSERT_TRUE(s->Is()); @@ -80,10 +80,10 @@ TEST_F(AstStorageTextureTest, U32) { } TEST_F(AstStorageTextureTest, I32) { - auto* subtype = StorageTexture::SubtypeFor(ImageFormat::kRgba32Sint, *this); + auto* subtype = StorageTexture::SubtypeFor(TexelFormat::kRgba32Sint, *this); Type* s = create(TextureDimension::k2dArray, - ImageFormat::kRgba32Sint, subtype, Access::kRead); + TexelFormat::kRgba32Sint, subtype, Access::kRead); ASSERT_TRUE(s->Is()); ASSERT_TRUE(s->Is()); diff --git a/src/inspector/inspector.cc b/src/inspector/inspector.cc index c011a8e5c4..a9f2f65c6f 100644 --- a/src/inspector/inspector.cc +++ b/src/inspector/inspector.cc @@ -757,8 +757,8 @@ std::vector Inspector::GetStorageTextureResourceBindingsImpl( auto* base_type = texture_type->type(); entry.sampled_kind = BaseTypeToSampledKind(base_type); - entry.image_format = TypeImageFormatToResourceBindingImageFormat( - texture_type->image_format()); + entry.image_format = TypeTexelFormatToResourceBindingTexelFormat( + texture_type->texel_format()); result.push_back(entry); } diff --git a/src/inspector/inspector_test.cc b/src/inspector/inspector_test.cc index e2c0eae0b3..1c2d6da978 100644 --- a/src/inspector/inspector_test.cc +++ b/src/inspector/inspector_test.cc @@ -130,11 +130,11 @@ class InspectorGetDepthMultisampledTextureResourceBindingsTest typedef std::tuple DimensionParams; -typedef std::tuple - ImageFormatParams; -typedef std::tuple + TexelFormatParams; +typedef std::tuple GetStorageTextureTestParams; class InspectorGetStorageTextureResourceBindingsTestWithParam : public InspectorBuilder, @@ -1292,7 +1292,7 @@ TEST_F(InspectorGetResourceBindingsTest, Simple) { Func("depth_ms_func", {}, ty.void_(), {Ignore("depth_ms_texture")}); auto* st_type = MakeStorageTextureTypes(ast::TextureDimension::k2d, - ast::ImageFormat::kR32Uint); + ast::TexelFormat::kR32Uint); AddStorageTexture("st_var", st_type, 4, 0); MakeStorageTextureBodyFunction("st_func", "st_var", ty.vec2(), {}); @@ -2379,15 +2379,15 @@ TEST_F(InspectorGetStorageTextureResourceBindingsTest, Empty) { TEST_P(InspectorGetStorageTextureResourceBindingsTestWithParam, Simple) { DimensionParams dim_params; - ImageFormatParams format_params; + TexelFormatParams format_params; std::tie(dim_params, format_params) = GetParam(); ast::TextureDimension dim; ResourceBinding::TextureDimension expected_dim; std::tie(dim, expected_dim) = dim_params; - ast::ImageFormat format; - ResourceBinding::ImageFormat expected_format; + ast::TexelFormat format; + ResourceBinding::TexelFormat expected_format; ResourceBinding::SampledKind expected_kind; std::tie(format, expected_format, expected_kind) = format_params; @@ -2445,53 +2445,53 @@ INSTANTIATE_TEST_SUITE_P( std::make_tuple(ast::TextureDimension::k3d, ResourceBinding::TextureDimension::k3d)), testing::Values( - std::make_tuple(ast::ImageFormat::kR32Float, - ResourceBinding::ImageFormat::kR32Float, + std::make_tuple(ast::TexelFormat::kR32Float, + ResourceBinding::TexelFormat::kR32Float, ResourceBinding::SampledKind::kFloat), - std::make_tuple(ast::ImageFormat::kR32Sint, - ResourceBinding::ImageFormat::kR32Sint, + std::make_tuple(ast::TexelFormat::kR32Sint, + ResourceBinding::TexelFormat::kR32Sint, ResourceBinding::SampledKind::kSInt), - std::make_tuple(ast::ImageFormat::kR32Uint, - ResourceBinding::ImageFormat::kR32Uint, + std::make_tuple(ast::TexelFormat::kR32Uint, + ResourceBinding::TexelFormat::kR32Uint, ResourceBinding::SampledKind::kUInt), - std::make_tuple(ast::ImageFormat::kRg32Float, - ResourceBinding::ImageFormat::kRg32Float, + std::make_tuple(ast::TexelFormat::kRg32Float, + ResourceBinding::TexelFormat::kRg32Float, ResourceBinding::SampledKind::kFloat), - std::make_tuple(ast::ImageFormat::kRg32Sint, - ResourceBinding::ImageFormat::kRg32Sint, + std::make_tuple(ast::TexelFormat::kRg32Sint, + ResourceBinding::TexelFormat::kRg32Sint, ResourceBinding::SampledKind::kSInt), - std::make_tuple(ast::ImageFormat::kRg32Uint, - ResourceBinding::ImageFormat::kRg32Uint, + std::make_tuple(ast::TexelFormat::kRg32Uint, + ResourceBinding::TexelFormat::kRg32Uint, ResourceBinding::SampledKind::kUInt), - std::make_tuple(ast::ImageFormat::kRgba16Float, - ResourceBinding::ImageFormat::kRgba16Float, + std::make_tuple(ast::TexelFormat::kRgba16Float, + ResourceBinding::TexelFormat::kRgba16Float, ResourceBinding::SampledKind::kFloat), - std::make_tuple(ast::ImageFormat::kRgba16Sint, - ResourceBinding::ImageFormat::kRgba16Sint, + std::make_tuple(ast::TexelFormat::kRgba16Sint, + ResourceBinding::TexelFormat::kRgba16Sint, ResourceBinding::SampledKind::kSInt), - std::make_tuple(ast::ImageFormat::kRgba16Uint, - ResourceBinding::ImageFormat::kRgba16Uint, + std::make_tuple(ast::TexelFormat::kRgba16Uint, + ResourceBinding::TexelFormat::kRgba16Uint, ResourceBinding::SampledKind::kUInt), - std::make_tuple(ast::ImageFormat::kRgba32Float, - ResourceBinding::ImageFormat::kRgba32Float, + std::make_tuple(ast::TexelFormat::kRgba32Float, + ResourceBinding::TexelFormat::kRgba32Float, ResourceBinding::SampledKind::kFloat), - std::make_tuple(ast::ImageFormat::kRgba32Sint, - ResourceBinding::ImageFormat::kRgba32Sint, + std::make_tuple(ast::TexelFormat::kRgba32Sint, + ResourceBinding::TexelFormat::kRgba32Sint, ResourceBinding::SampledKind::kSInt), - std::make_tuple(ast::ImageFormat::kRgba32Uint, - ResourceBinding::ImageFormat::kRgba32Uint, + std::make_tuple(ast::TexelFormat::kRgba32Uint, + ResourceBinding::TexelFormat::kRgba32Uint, ResourceBinding::SampledKind::kUInt), - std::make_tuple(ast::ImageFormat::kRgba8Sint, - ResourceBinding::ImageFormat::kRgba8Sint, + std::make_tuple(ast::TexelFormat::kRgba8Sint, + ResourceBinding::TexelFormat::kRgba8Sint, ResourceBinding::SampledKind::kSInt), - std::make_tuple(ast::ImageFormat::kRgba8Snorm, - ResourceBinding::ImageFormat::kRgba8Snorm, + std::make_tuple(ast::TexelFormat::kRgba8Snorm, + ResourceBinding::TexelFormat::kRgba8Snorm, ResourceBinding::SampledKind::kFloat), - std::make_tuple(ast::ImageFormat::kRgba8Uint, - ResourceBinding::ImageFormat::kRgba8Uint, + std::make_tuple(ast::TexelFormat::kRgba8Uint, + ResourceBinding::TexelFormat::kRgba8Uint, ResourceBinding::SampledKind::kUInt), - std::make_tuple(ast::ImageFormat::kRgba8Unorm, - ResourceBinding::ImageFormat::kRgba8Unorm, + std::make_tuple(ast::TexelFormat::kRgba8Unorm, + ResourceBinding::TexelFormat::kRgba8Unorm, ResourceBinding::SampledKind::kFloat)))); TEST_P(InspectorGetDepthTextureResourceBindingsTestWithParam, diff --git a/src/inspector/resource_binding.cc b/src/inspector/resource_binding.cc index e9f6e8a204..e0862ba178 100644 --- a/src/inspector/resource_binding.cc +++ b/src/inspector/resource_binding.cc @@ -71,83 +71,83 @@ ResourceBinding::SampledKind BaseTypeToSampledKind(const sem::Type* base_type) { } } -ResourceBinding::ImageFormat TypeImageFormatToResourceBindingImageFormat( - const ast::ImageFormat& image_format) { +ResourceBinding::TexelFormat TypeTexelFormatToResourceBindingTexelFormat( + const ast::TexelFormat& image_format) { switch (image_format) { - case ast::ImageFormat::kR8Unorm: - return ResourceBinding::ImageFormat::kR8Unorm; - case ast::ImageFormat::kR8Snorm: - return ResourceBinding::ImageFormat::kR8Snorm; - case ast::ImageFormat::kR8Uint: - return ResourceBinding::ImageFormat::kR8Uint; - case ast::ImageFormat::kR8Sint: - return ResourceBinding::ImageFormat::kR8Sint; - case ast::ImageFormat::kR16Uint: - return ResourceBinding::ImageFormat::kR16Uint; - case ast::ImageFormat::kR16Sint: - return ResourceBinding::ImageFormat::kR16Sint; - case ast::ImageFormat::kR16Float: - return ResourceBinding::ImageFormat::kR16Float; - case ast::ImageFormat::kRg8Unorm: - return ResourceBinding::ImageFormat::kRg8Unorm; - case ast::ImageFormat::kRg8Snorm: - return ResourceBinding::ImageFormat::kRg8Snorm; - case ast::ImageFormat::kRg8Uint: - return ResourceBinding::ImageFormat::kRg8Uint; - case ast::ImageFormat::kRg8Sint: - return ResourceBinding::ImageFormat::kRg8Sint; - case ast::ImageFormat::kR32Uint: - return ResourceBinding::ImageFormat::kR32Uint; - case ast::ImageFormat::kR32Sint: - return ResourceBinding::ImageFormat::kR32Sint; - case ast::ImageFormat::kR32Float: - return ResourceBinding::ImageFormat::kR32Float; - case ast::ImageFormat::kRg16Uint: - return ResourceBinding::ImageFormat::kRg16Uint; - case ast::ImageFormat::kRg16Sint: - return ResourceBinding::ImageFormat::kRg16Sint; - case ast::ImageFormat::kRg16Float: - return ResourceBinding::ImageFormat::kRg16Float; - case ast::ImageFormat::kRgba8Unorm: - return ResourceBinding::ImageFormat::kRgba8Unorm; - case ast::ImageFormat::kRgba8UnormSrgb: - return ResourceBinding::ImageFormat::kRgba8UnormSrgb; - case ast::ImageFormat::kRgba8Snorm: - return ResourceBinding::ImageFormat::kRgba8Snorm; - case ast::ImageFormat::kRgba8Uint: - return ResourceBinding::ImageFormat::kRgba8Uint; - case ast::ImageFormat::kRgba8Sint: - return ResourceBinding::ImageFormat::kRgba8Sint; - case ast::ImageFormat::kBgra8Unorm: - return ResourceBinding::ImageFormat::kBgra8Unorm; - case ast::ImageFormat::kBgra8UnormSrgb: - return ResourceBinding::ImageFormat::kBgra8UnormSrgb; - case ast::ImageFormat::kRgb10A2Unorm: - return ResourceBinding::ImageFormat::kRgb10A2Unorm; - case ast::ImageFormat::kRg11B10Float: - return ResourceBinding::ImageFormat::kRg11B10Float; - case ast::ImageFormat::kRg32Uint: - return ResourceBinding::ImageFormat::kRg32Uint; - case ast::ImageFormat::kRg32Sint: - return ResourceBinding::ImageFormat::kRg32Sint; - case ast::ImageFormat::kRg32Float: - return ResourceBinding::ImageFormat::kRg32Float; - case ast::ImageFormat::kRgba16Uint: - return ResourceBinding::ImageFormat::kRgba16Uint; - case ast::ImageFormat::kRgba16Sint: - return ResourceBinding::ImageFormat::kRgba16Sint; - case ast::ImageFormat::kRgba16Float: - return ResourceBinding::ImageFormat::kRgba16Float; - case ast::ImageFormat::kRgba32Uint: - return ResourceBinding::ImageFormat::kRgba32Uint; - case ast::ImageFormat::kRgba32Sint: - return ResourceBinding::ImageFormat::kRgba32Sint; - case ast::ImageFormat::kRgba32Float: - return ResourceBinding::ImageFormat::kRgba32Float; - case ast::ImageFormat::kNone: - return ResourceBinding::ImageFormat::kNone; + case ast::TexelFormat::kR8Unorm: + return ResourceBinding::TexelFormat::kR8Unorm; + case ast::TexelFormat::kR8Snorm: + return ResourceBinding::TexelFormat::kR8Snorm; + case ast::TexelFormat::kR8Uint: + return ResourceBinding::TexelFormat::kR8Uint; + case ast::TexelFormat::kR8Sint: + return ResourceBinding::TexelFormat::kR8Sint; + case ast::TexelFormat::kR16Uint: + return ResourceBinding::TexelFormat::kR16Uint; + case ast::TexelFormat::kR16Sint: + return ResourceBinding::TexelFormat::kR16Sint; + case ast::TexelFormat::kR16Float: + return ResourceBinding::TexelFormat::kR16Float; + case ast::TexelFormat::kRg8Unorm: + return ResourceBinding::TexelFormat::kRg8Unorm; + case ast::TexelFormat::kRg8Snorm: + return ResourceBinding::TexelFormat::kRg8Snorm; + case ast::TexelFormat::kRg8Uint: + return ResourceBinding::TexelFormat::kRg8Uint; + case ast::TexelFormat::kRg8Sint: + return ResourceBinding::TexelFormat::kRg8Sint; + case ast::TexelFormat::kR32Uint: + return ResourceBinding::TexelFormat::kR32Uint; + case ast::TexelFormat::kR32Sint: + return ResourceBinding::TexelFormat::kR32Sint; + case ast::TexelFormat::kR32Float: + return ResourceBinding::TexelFormat::kR32Float; + case ast::TexelFormat::kRg16Uint: + return ResourceBinding::TexelFormat::kRg16Uint; + case ast::TexelFormat::kRg16Sint: + return ResourceBinding::TexelFormat::kRg16Sint; + case ast::TexelFormat::kRg16Float: + return ResourceBinding::TexelFormat::kRg16Float; + case ast::TexelFormat::kRgba8Unorm: + return ResourceBinding::TexelFormat::kRgba8Unorm; + case ast::TexelFormat::kRgba8UnormSrgb: + return ResourceBinding::TexelFormat::kRgba8UnormSrgb; + case ast::TexelFormat::kRgba8Snorm: + return ResourceBinding::TexelFormat::kRgba8Snorm; + case ast::TexelFormat::kRgba8Uint: + return ResourceBinding::TexelFormat::kRgba8Uint; + case ast::TexelFormat::kRgba8Sint: + return ResourceBinding::TexelFormat::kRgba8Sint; + case ast::TexelFormat::kBgra8Unorm: + return ResourceBinding::TexelFormat::kBgra8Unorm; + case ast::TexelFormat::kBgra8UnormSrgb: + return ResourceBinding::TexelFormat::kBgra8UnormSrgb; + case ast::TexelFormat::kRgb10A2Unorm: + return ResourceBinding::TexelFormat::kRgb10A2Unorm; + case ast::TexelFormat::kRg11B10Float: + return ResourceBinding::TexelFormat::kRg11B10Float; + case ast::TexelFormat::kRg32Uint: + return ResourceBinding::TexelFormat::kRg32Uint; + case ast::TexelFormat::kRg32Sint: + return ResourceBinding::TexelFormat::kRg32Sint; + case ast::TexelFormat::kRg32Float: + return ResourceBinding::TexelFormat::kRg32Float; + case ast::TexelFormat::kRgba16Uint: + return ResourceBinding::TexelFormat::kRgba16Uint; + case ast::TexelFormat::kRgba16Sint: + return ResourceBinding::TexelFormat::kRgba16Sint; + case ast::TexelFormat::kRgba16Float: + return ResourceBinding::TexelFormat::kRgba16Float; + case ast::TexelFormat::kRgba32Uint: + return ResourceBinding::TexelFormat::kRgba32Uint; + case ast::TexelFormat::kRgba32Sint: + return ResourceBinding::TexelFormat::kRgba32Sint; + case ast::TexelFormat::kRgba32Float: + return ResourceBinding::TexelFormat::kRgba32Float; + case ast::TexelFormat::kNone: + return ResourceBinding::TexelFormat::kNone; } - return ResourceBinding::ImageFormat::kNone; + return ResourceBinding::TexelFormat::kNone; } } // namespace inspector diff --git a/src/inspector/resource_binding.h b/src/inspector/resource_binding.h index 6558019b02..cb84917a8a 100644 --- a/src/inspector/resource_binding.h +++ b/src/inspector/resource_binding.h @@ -47,8 +47,8 @@ struct ResourceBinding { /// in SPIR-V OpTypeImage. enum class SampledKind { kUnknown = -1, kFloat, kUInt, kSInt }; - /// Enumerator of texture image formats - enum class ImageFormat { + /// Enumerator of texel image formats + enum class TexelFormat { kNone = -1, kR8Unorm, kR8Snorm, @@ -87,6 +87,9 @@ struct ResourceBinding { kRgba32Float, }; + /// Renamed field [DEPRECATED] + using ImageFormat = TexelFormat; + /// kXXX maps to entries returned by GetXXXResourceBindings call. enum class ResourceType { kUniformBuffer, @@ -118,7 +121,7 @@ struct ResourceBinding { /// Kind of data being sampled, if defined. SampledKind sampled_kind; /// Format of data, if defined. - ImageFormat image_format; + TexelFormat image_format; }; /// Convert from internal ast::TextureDimension to public @@ -134,12 +137,12 @@ TypeTextureDimensionToResourceBindingTextureDimension( /// @returns the publicly visible equivalent ResourceBinding::SampledKind BaseTypeToSampledKind(const sem::Type* base_type); -/// Convert from internal ast::ImageFormat to public -/// ResourceBinding::ImageFormat +/// Convert from internal ast::TexelFormat to public +/// ResourceBinding::TexelFormat /// @param image_format internal value to convert from /// @returns the publicly visible equivalent -ResourceBinding::ImageFormat TypeImageFormatToResourceBindingImageFormat( - const ast::ImageFormat& image_format); +ResourceBinding::TexelFormat TypeTexelFormatToResourceBindingTexelFormat( + const ast::TexelFormat& image_format); } // namespace inspector } // namespace tint diff --git a/src/inspector/test_inspector_builder.cc b/src/inspector/test_inspector_builder.cc index 55c16f67da..3548eea7da 100644 --- a/src/inspector/test_inspector_builder.cc +++ b/src/inspector/test_inspector_builder.cc @@ -321,7 +321,7 @@ const ast::Type* InspectorBuilder::GetCoordsType(ast::TextureDimension dim, const ast::Type* InspectorBuilder::MakeStorageTextureTypes( ast::TextureDimension dim, - ast::ImageFormat format) { + ast::TexelFormat format) { return ty.storage_texture(dim, format, ast::Access::kWrite); } diff --git a/src/inspector/test_inspector_builder.h b/src/inspector/test_inspector_builder.h index e3783ab573..b0414194ff 100644 --- a/src/inspector/test_inspector_builder.h +++ b/src/inspector/test_inspector_builder.h @@ -332,10 +332,10 @@ class InspectorBuilder : public ProgramBuilder { /// Generates appropriate types for a Read-Only StorageTexture /// @param dim the texture dimension of the storage texture - /// @param format the image format of the storage texture + /// @param format the texel format of the storage texture /// @returns the storage texture type const ast::Type* MakeStorageTextureTypes(ast::TextureDimension dim, - ast::ImageFormat format); + ast::TexelFormat format); /// Adds a storage texture variable to the program /// @param name the name of the variable diff --git a/src/intrinsic_table.cc b/src/intrinsic_table.cc index 7c0f13d933..23c9e30add 100644 --- a/src/intrinsic_table.cc +++ b/src/intrinsic_table.cc @@ -290,7 +290,7 @@ class OpenNumberMatcher : public NumberMatcher { // TODO(bclayton): See if we can move more of this hand-rolled code to the // template //////////////////////////////////////////////////////////////////////////////// -using TexelFormat = ast::ImageFormat; +using TexelFormat = ast::TexelFormat; using Access = ast::Access; using StorageClass = ast::StorageClass; using ParameterUsage = sem::ParameterUsage; @@ -619,7 +619,7 @@ bool match_texture_storage(const sem::Type* ty, } if (auto* v = ty->As()) { if (v->dim() == dim) { - F = Number(static_cast(v->image_format())); + F = Number(static_cast(v->texel_format())); A = Number(static_cast(v->access())); return true; } diff --git a/src/intrinsic_table_test.cc b/src/intrinsic_table_test.cc index e1614b07a4..dbb759e99f 100644 --- a/src/intrinsic_table_test.cc +++ b/src/intrinsic_table_test.cc @@ -394,9 +394,9 @@ TEST_F(IntrinsicTableTest, MatchWOStorageTexture) { auto* vec2_i32 = create(i32, 2); auto* vec4_f32 = create(f32, 4); auto* subtype = - sem::StorageTexture::SubtypeFor(ast::ImageFormat::kR32Float, Types()); + sem::StorageTexture::SubtypeFor(ast::TexelFormat::kR32Float, Types()); auto* tex = create(ast::TextureDimension::k2d, - ast::ImageFormat::kR32Float, + ast::TexelFormat::kR32Float, ast::Access::kWrite, subtype); auto* result = table->Lookup(IntrinsicType::kTextureStore, diff --git a/src/program_builder.h b/src/program_builder.h index b724328dfd..2d97ad628f 100644 --- a/src/program_builder.h +++ b/src/program_builder.h @@ -901,11 +901,11 @@ class ProgramBuilder { } /// @param dims the dimensionality of the texture - /// @param format the image format of the texture + /// @param format the texel format of the texture /// @param access the access control of the texture /// @returns the storage texture const ast::StorageTexture* storage_texture(ast::TextureDimension dims, - ast::ImageFormat format, + ast::TexelFormat format, ast::Access access) const { auto* subtype = ast::StorageTexture::SubtypeFor(format, *builder); return builder->create(dims, format, subtype, @@ -914,12 +914,12 @@ class ProgramBuilder { /// @param source the Source of the node /// @param dims the dimensionality of the texture - /// @param format the image format of the texture + /// @param format the texel format of the texture /// @param access the access control of the texture /// @returns the storage texture const ast::StorageTexture* storage_texture(const Source& source, ast::TextureDimension dims, - ast::ImageFormat format, + ast::TexelFormat format, ast::Access access) const { auto* subtype = ast::StorageTexture::SubtypeFor(format, *builder); return builder->create(source, dims, format, subtype, diff --git a/src/reader/spirv/enum_converter.cc b/src/reader/spirv/enum_converter.cc index 82421cc1c9..843076e1ed 100644 --- a/src/reader/spirv/enum_converter.cc +++ b/src/reader/spirv/enum_converter.cc @@ -130,53 +130,53 @@ ast::TextureDimension EnumConverter::ToDim(SpvDim dim, bool arrayed) { return ast::TextureDimension::kNone; } -ast::ImageFormat EnumConverter::ToImageFormat(SpvImageFormat fmt) { +ast::TexelFormat EnumConverter::ToTexelFormat(SpvImageFormat fmt) { switch (fmt) { case SpvImageFormatUnknown: - return ast::ImageFormat::kNone; + return ast::TexelFormat::kNone; // 8 bit channels case SpvImageFormatRgba8: - return ast::ImageFormat::kRgba8Unorm; + return ast::TexelFormat::kRgba8Unorm; case SpvImageFormatRgba8Snorm: - return ast::ImageFormat::kRgba8Snorm; + return ast::TexelFormat::kRgba8Snorm; case SpvImageFormatRgba8ui: - return ast::ImageFormat::kRgba8Uint; + return ast::TexelFormat::kRgba8Uint; case SpvImageFormatRgba8i: - return ast::ImageFormat::kRgba8Sint; + return ast::TexelFormat::kRgba8Sint; // 16 bit channels case SpvImageFormatRgba16ui: - return ast::ImageFormat::kRgba16Uint; + return ast::TexelFormat::kRgba16Uint; case SpvImageFormatRgba16i: - return ast::ImageFormat::kRgba16Sint; + return ast::TexelFormat::kRgba16Sint; case SpvImageFormatRgba16f: - return ast::ImageFormat::kRgba16Float; + return ast::TexelFormat::kRgba16Float; // 32 bit channels case SpvImageFormatR32ui: - return ast::ImageFormat::kR32Uint; + return ast::TexelFormat::kR32Uint; case SpvImageFormatR32i: - return ast::ImageFormat::kR32Sint; + return ast::TexelFormat::kR32Sint; case SpvImageFormatR32f: - return ast::ImageFormat::kR32Float; + return ast::TexelFormat::kR32Float; case SpvImageFormatRg32ui: - return ast::ImageFormat::kRg32Uint; + return ast::TexelFormat::kRg32Uint; case SpvImageFormatRg32i: - return ast::ImageFormat::kRg32Sint; + return ast::TexelFormat::kRg32Sint; case SpvImageFormatRg32f: - return ast::ImageFormat::kRg32Float; + return ast::TexelFormat::kRg32Float; case SpvImageFormatRgba32ui: - return ast::ImageFormat::kRgba32Uint; + return ast::TexelFormat::kRgba32Uint; case SpvImageFormatRgba32i: - return ast::ImageFormat::kRgba32Sint; + return ast::TexelFormat::kRgba32Sint; case SpvImageFormatRgba32f: - return ast::ImageFormat::kRgba32Float; + return ast::TexelFormat::kRgba32Float; default: break; } Fail() << "invalid image format: " << int(fmt); - return ast::ImageFormat::kNone; + return ast::TexelFormat::kNone; } } // namespace spirv diff --git a/src/reader/spirv/enum_converter.h b/src/reader/spirv/enum_converter.h index 25b497101d..66f0c7b580 100644 --- a/src/reader/spirv/enum_converter.h +++ b/src/reader/spirv/enum_converter.h @@ -60,11 +60,11 @@ class EnumConverter { /// @returns a Tint AST texture dimension ast::TextureDimension ToDim(SpvDim dim, bool arrayed); - /// Converts a SPIR-V Image Format to a Tint ImageFormat + /// Converts a SPIR-V Image Format to a TexelFormat /// On failure, logs an error and returns kNone /// @param fmt the SPIR-V format /// @returns a Tint AST format - ast::ImageFormat ToImageFormat(SpvImageFormat fmt); + ast::TexelFormat ToTexelFormat(SpvImageFormat fmt); private: /// Registers a failure and returns a stream for log diagnostics. diff --git a/src/reader/spirv/enum_converter_test.cc b/src/reader/spirv/enum_converter_test.cc index d19054ea97..4c9cf5c856 100644 --- a/src/reader/spirv/enum_converter_test.cc +++ b/src/reader/spirv/enum_converter_test.cc @@ -312,21 +312,21 @@ INSTANTIATE_TEST_SUITE_P( DimCase{SpvDimBuffer, true, false, ast::TextureDimension::kNone}, DimCase{SpvDimSubpassData, true, false, ast::TextureDimension::kNone})); -// ImageFormat +// TexelFormat -struct ImageFormatCase { +struct TexelFormatCase { SpvImageFormat format; bool expect_success; - ast::ImageFormat expected; + ast::TexelFormat expected; }; -inline std::ostream& operator<<(std::ostream& out, ImageFormatCase ifc) { - out << "ImageFormatCase{ SpvImageFormat:" << int(ifc.format) +inline std::ostream& operator<<(std::ostream& out, TexelFormatCase ifc) { + out << "TexelFormatCase{ SpvImageFormat:" << int(ifc.format) << " expect_success?:" << int(ifc.expect_success) << " expected:" << int(ifc.expected) << "}"; return out; } -class SpvImageFormatTest : public testing::TestWithParam { +class SpvImageFormatTest : public testing::TestWithParam { public: SpvImageFormatTest() : success_(true), @@ -345,7 +345,7 @@ class SpvImageFormatTest : public testing::TestWithParam { TEST_P(SpvImageFormatTest, Samples) { const auto params = GetParam(); - const auto result = converter_.ToImageFormat(params.format); + const auto result = converter_.ToTexelFormat(params.format); EXPECT_EQ(success_, params.expect_success) << params; if (params.expect_success) { EXPECT_EQ(result, params.expected); @@ -361,68 +361,68 @@ INSTANTIATE_TEST_SUITE_P( SpvImageFormatTest, testing::Values( // Unknown. This is used for sampled images. - ImageFormatCase{SpvImageFormatUnknown, true, ast::ImageFormat::kNone}, + TexelFormatCase{SpvImageFormatUnknown, true, ast::TexelFormat::kNone}, // 8 bit channels - ImageFormatCase{SpvImageFormatRgba8, true, - ast::ImageFormat::kRgba8Unorm}, - ImageFormatCase{SpvImageFormatRgba8Snorm, true, - ast::ImageFormat::kRgba8Snorm}, - ImageFormatCase{SpvImageFormatRgba8ui, true, - ast::ImageFormat::kRgba8Uint}, - ImageFormatCase{SpvImageFormatRgba8i, true, - ast::ImageFormat::kRgba8Sint}, + TexelFormatCase{SpvImageFormatRgba8, true, + ast::TexelFormat::kRgba8Unorm}, + TexelFormatCase{SpvImageFormatRgba8Snorm, true, + ast::TexelFormat::kRgba8Snorm}, + TexelFormatCase{SpvImageFormatRgba8ui, true, + ast::TexelFormat::kRgba8Uint}, + TexelFormatCase{SpvImageFormatRgba8i, true, + ast::TexelFormat::kRgba8Sint}, // 16 bit channels - ImageFormatCase{SpvImageFormatRgba16ui, true, - ast::ImageFormat::kRgba16Uint}, - ImageFormatCase{SpvImageFormatRgba16i, true, - ast::ImageFormat::kRgba16Sint}, - ImageFormatCase{SpvImageFormatRgba16f, true, - ast::ImageFormat::kRgba16Float}, + TexelFormatCase{SpvImageFormatRgba16ui, true, + ast::TexelFormat::kRgba16Uint}, + TexelFormatCase{SpvImageFormatRgba16i, true, + ast::TexelFormat::kRgba16Sint}, + TexelFormatCase{SpvImageFormatRgba16f, true, + ast::TexelFormat::kRgba16Float}, // 32 bit channels // ... 1 channel - ImageFormatCase{SpvImageFormatR32ui, true, ast::ImageFormat::kR32Uint}, - ImageFormatCase{SpvImageFormatR32i, true, ast::ImageFormat::kR32Sint}, - ImageFormatCase{SpvImageFormatR32f, true, ast::ImageFormat::kR32Float}, + TexelFormatCase{SpvImageFormatR32ui, true, ast::TexelFormat::kR32Uint}, + TexelFormatCase{SpvImageFormatR32i, true, ast::TexelFormat::kR32Sint}, + TexelFormatCase{SpvImageFormatR32f, true, ast::TexelFormat::kR32Float}, // ... 2 channels - ImageFormatCase{SpvImageFormatRg32ui, true, - ast::ImageFormat::kRg32Uint}, - ImageFormatCase{SpvImageFormatRg32i, true, ast::ImageFormat::kRg32Sint}, - ImageFormatCase{SpvImageFormatRg32f, true, - ast::ImageFormat::kRg32Float}, + TexelFormatCase{SpvImageFormatRg32ui, true, + ast::TexelFormat::kRg32Uint}, + TexelFormatCase{SpvImageFormatRg32i, true, ast::TexelFormat::kRg32Sint}, + TexelFormatCase{SpvImageFormatRg32f, true, + ast::TexelFormat::kRg32Float}, // ... 4 channels - ImageFormatCase{SpvImageFormatRgba32ui, true, - ast::ImageFormat::kRgba32Uint}, - ImageFormatCase{SpvImageFormatRgba32i, true, - ast::ImageFormat::kRgba32Sint}, - ImageFormatCase{SpvImageFormatRgba32f, true, - ast::ImageFormat::kRgba32Float})); + TexelFormatCase{SpvImageFormatRgba32ui, true, + ast::TexelFormat::kRgba32Uint}, + TexelFormatCase{SpvImageFormatRgba32i, true, + ast::TexelFormat::kRgba32Sint}, + TexelFormatCase{SpvImageFormatRgba32f, true, + ast::TexelFormat::kRgba32Float})); INSTANTIATE_TEST_SUITE_P( EnumConverterBad, SpvImageFormatTest, testing::Values( // Scanning in order from the SPIR-V spec. - ImageFormatCase{SpvImageFormatRg16f, false, ast::ImageFormat::kNone}, - ImageFormatCase{SpvImageFormatR11fG11fB10f, false, - ast::ImageFormat::kNone}, - ImageFormatCase{SpvImageFormatR16f, false, ast::ImageFormat::kNone}, - ImageFormatCase{SpvImageFormatRgb10A2, false, ast::ImageFormat::kNone}, - ImageFormatCase{SpvImageFormatRg16, false, ast::ImageFormat::kNone}, - ImageFormatCase{SpvImageFormatRg8, false, ast::ImageFormat::kNone}, - ImageFormatCase{SpvImageFormatR16, false, ast::ImageFormat::kNone}, - ImageFormatCase{SpvImageFormatR8, false, ast::ImageFormat::kNone}, - ImageFormatCase{SpvImageFormatRgba16Snorm, false, - ast::ImageFormat::kNone}, - ImageFormatCase{SpvImageFormatRg16Snorm, false, - ast::ImageFormat::kNone}, - ImageFormatCase{SpvImageFormatRg8Snorm, false, ast::ImageFormat::kNone}, - ImageFormatCase{SpvImageFormatRg16i, false, ast::ImageFormat::kNone}, - ImageFormatCase{SpvImageFormatRg8i, false, ast::ImageFormat::kNone}, - ImageFormatCase{SpvImageFormatR8i, false, ast::ImageFormat::kNone}, - ImageFormatCase{SpvImageFormatRgb10a2ui, false, - ast::ImageFormat::kNone}, - ImageFormatCase{SpvImageFormatRg16ui, false, ast::ImageFormat::kNone}, - ImageFormatCase{SpvImageFormatRg8ui, false, ast::ImageFormat::kNone})); + TexelFormatCase{SpvImageFormatRg16f, false, ast::TexelFormat::kNone}, + TexelFormatCase{SpvImageFormatR11fG11fB10f, false, + ast::TexelFormat::kNone}, + TexelFormatCase{SpvImageFormatR16f, false, ast::TexelFormat::kNone}, + TexelFormatCase{SpvImageFormatRgb10A2, false, ast::TexelFormat::kNone}, + TexelFormatCase{SpvImageFormatRg16, false, ast::TexelFormat::kNone}, + TexelFormatCase{SpvImageFormatRg8, false, ast::TexelFormat::kNone}, + TexelFormatCase{SpvImageFormatR16, false, ast::TexelFormat::kNone}, + TexelFormatCase{SpvImageFormatR8, false, ast::TexelFormat::kNone}, + TexelFormatCase{SpvImageFormatRgba16Snorm, false, + ast::TexelFormat::kNone}, + TexelFormatCase{SpvImageFormatRg16Snorm, false, + ast::TexelFormat::kNone}, + TexelFormatCase{SpvImageFormatRg8Snorm, false, ast::TexelFormat::kNone}, + TexelFormatCase{SpvImageFormatRg16i, false, ast::TexelFormat::kNone}, + TexelFormatCase{SpvImageFormatRg8i, false, ast::TexelFormat::kNone}, + TexelFormatCase{SpvImageFormatR8i, false, ast::TexelFormat::kNone}, + TexelFormatCase{SpvImageFormatRgb10a2ui, false, + ast::TexelFormat::kNone}, + TexelFormatCase{SpvImageFormatRg16ui, false, ast::TexelFormat::kNone}, + TexelFormatCase{SpvImageFormatRg8ui, false, ast::TexelFormat::kNone})); } // namespace } // namespace spirv diff --git a/src/reader/spirv/parser_impl.cc b/src/reader/spirv/parser_impl.cc index 92e57d1fb2..8a5f48bf15 100644 --- a/src/reader/spirv/parser_impl.cc +++ b/src/reader/spirv/parser_impl.cc @@ -2505,8 +2505,8 @@ const Pointer* ParserImpl::GetTypeForHandleVar( } } else { const auto access = ast::Access::kWrite; - const auto format = enum_converter_.ToImageFormat(image_type->format()); - if (format == ast::ImageFormat::kNone) { + const auto format = enum_converter_.ToTexelFormat(image_type->format()); + if (format == ast::TexelFormat::kNone) { return nullptr; } ast_store_type = ty_.StorageTexture(dim, format, access); @@ -2526,47 +2526,47 @@ const Pointer* ParserImpl::GetTypeForHandleVar( return result; } -const Type* ParserImpl::GetComponentTypeForFormat(ast::ImageFormat format) { +const Type* ParserImpl::GetComponentTypeForFormat(ast::TexelFormat format) { switch (format) { - case ast::ImageFormat::kR8Uint: - case ast::ImageFormat::kR16Uint: - case ast::ImageFormat::kRg8Uint: - case ast::ImageFormat::kR32Uint: - case ast::ImageFormat::kRg16Uint: - case ast::ImageFormat::kRgba8Uint: - case ast::ImageFormat::kRg32Uint: - case ast::ImageFormat::kRgba16Uint: - case ast::ImageFormat::kRgba32Uint: + case ast::TexelFormat::kR8Uint: + case ast::TexelFormat::kR16Uint: + case ast::TexelFormat::kRg8Uint: + case ast::TexelFormat::kR32Uint: + case ast::TexelFormat::kRg16Uint: + case ast::TexelFormat::kRgba8Uint: + case ast::TexelFormat::kRg32Uint: + case ast::TexelFormat::kRgba16Uint: + case ast::TexelFormat::kRgba32Uint: return ty_.U32(); - case ast::ImageFormat::kR8Sint: - case ast::ImageFormat::kR16Sint: - case ast::ImageFormat::kRg8Sint: - case ast::ImageFormat::kR32Sint: - case ast::ImageFormat::kRg16Sint: - case ast::ImageFormat::kRgba8Sint: - case ast::ImageFormat::kRg32Sint: - case ast::ImageFormat::kRgba16Sint: - case ast::ImageFormat::kRgba32Sint: + case ast::TexelFormat::kR8Sint: + case ast::TexelFormat::kR16Sint: + case ast::TexelFormat::kRg8Sint: + case ast::TexelFormat::kR32Sint: + case ast::TexelFormat::kRg16Sint: + case ast::TexelFormat::kRgba8Sint: + case ast::TexelFormat::kRg32Sint: + case ast::TexelFormat::kRgba16Sint: + case ast::TexelFormat::kRgba32Sint: return ty_.I32(); - case ast::ImageFormat::kR8Unorm: - case ast::ImageFormat::kRg8Unorm: - case ast::ImageFormat::kRgba8Unorm: - case ast::ImageFormat::kRgba8UnormSrgb: - case ast::ImageFormat::kBgra8Unorm: - case ast::ImageFormat::kBgra8UnormSrgb: - case ast::ImageFormat::kRgb10A2Unorm: - case ast::ImageFormat::kR8Snorm: - case ast::ImageFormat::kRg8Snorm: - case ast::ImageFormat::kRgba8Snorm: - case ast::ImageFormat::kR16Float: - case ast::ImageFormat::kR32Float: - case ast::ImageFormat::kRg16Float: - case ast::ImageFormat::kRg11B10Float: - case ast::ImageFormat::kRg32Float: - case ast::ImageFormat::kRgba16Float: - case ast::ImageFormat::kRgba32Float: + case ast::TexelFormat::kR8Unorm: + case ast::TexelFormat::kRg8Unorm: + case ast::TexelFormat::kRgba8Unorm: + case ast::TexelFormat::kRgba8UnormSrgb: + case ast::TexelFormat::kBgra8Unorm: + case ast::TexelFormat::kBgra8UnormSrgb: + case ast::TexelFormat::kRgb10A2Unorm: + case ast::TexelFormat::kR8Snorm: + case ast::TexelFormat::kRg8Snorm: + case ast::TexelFormat::kRgba8Snorm: + case ast::TexelFormat::kR16Float: + case ast::TexelFormat::kR32Float: + case ast::TexelFormat::kRg16Float: + case ast::TexelFormat::kRg11B10Float: + case ast::TexelFormat::kRg32Float: + case ast::TexelFormat::kRgba16Float: + case ast::TexelFormat::kRgba32Float: return ty_.F32(); default: break; @@ -2575,49 +2575,49 @@ const Type* ParserImpl::GetComponentTypeForFormat(ast::ImageFormat format) { return nullptr; } -unsigned ParserImpl::GetChannelCountForFormat(ast::ImageFormat format) { +unsigned ParserImpl::GetChannelCountForFormat(ast::TexelFormat format) { switch (format) { - case ast::ImageFormat::kR16Float: - case ast::ImageFormat::kR16Sint: - case ast::ImageFormat::kR16Uint: - case ast::ImageFormat::kR32Float: - case ast::ImageFormat::kR32Sint: - case ast::ImageFormat::kR32Uint: - case ast::ImageFormat::kR8Sint: - case ast::ImageFormat::kR8Snorm: - case ast::ImageFormat::kR8Uint: - case ast::ImageFormat::kR8Unorm: + case ast::TexelFormat::kR16Float: + case ast::TexelFormat::kR16Sint: + case ast::TexelFormat::kR16Uint: + case ast::TexelFormat::kR32Float: + case ast::TexelFormat::kR32Sint: + case ast::TexelFormat::kR32Uint: + case ast::TexelFormat::kR8Sint: + case ast::TexelFormat::kR8Snorm: + case ast::TexelFormat::kR8Uint: + case ast::TexelFormat::kR8Unorm: // One channel return 1; - case ast::ImageFormat::kRg11B10Float: - case ast::ImageFormat::kRg16Float: - case ast::ImageFormat::kRg16Sint: - case ast::ImageFormat::kRg16Uint: - case ast::ImageFormat::kRg32Float: - case ast::ImageFormat::kRg32Sint: - case ast::ImageFormat::kRg32Uint: - case ast::ImageFormat::kRg8Sint: - case ast::ImageFormat::kRg8Snorm: - case ast::ImageFormat::kRg8Uint: - case ast::ImageFormat::kRg8Unorm: + case ast::TexelFormat::kRg11B10Float: + case ast::TexelFormat::kRg16Float: + case ast::TexelFormat::kRg16Sint: + case ast::TexelFormat::kRg16Uint: + case ast::TexelFormat::kRg32Float: + case ast::TexelFormat::kRg32Sint: + case ast::TexelFormat::kRg32Uint: + case ast::TexelFormat::kRg8Sint: + case ast::TexelFormat::kRg8Snorm: + case ast::TexelFormat::kRg8Uint: + case ast::TexelFormat::kRg8Unorm: // Two channels return 2; - case ast::ImageFormat::kBgra8Unorm: - case ast::ImageFormat::kBgra8UnormSrgb: - case ast::ImageFormat::kRgb10A2Unorm: - case ast::ImageFormat::kRgba16Float: - case ast::ImageFormat::kRgba16Sint: - case ast::ImageFormat::kRgba16Uint: - case ast::ImageFormat::kRgba32Float: - case ast::ImageFormat::kRgba32Sint: - case ast::ImageFormat::kRgba32Uint: - case ast::ImageFormat::kRgba8Sint: - case ast::ImageFormat::kRgba8Snorm: - case ast::ImageFormat::kRgba8Uint: - case ast::ImageFormat::kRgba8Unorm: - case ast::ImageFormat::kRgba8UnormSrgb: + case ast::TexelFormat::kBgra8Unorm: + case ast::TexelFormat::kBgra8UnormSrgb: + case ast::TexelFormat::kRgb10A2Unorm: + case ast::TexelFormat::kRgba16Float: + case ast::TexelFormat::kRgba16Sint: + case ast::TexelFormat::kRgba16Uint: + case ast::TexelFormat::kRgba32Float: + case ast::TexelFormat::kRgba32Sint: + case ast::TexelFormat::kRgba32Uint: + case ast::TexelFormat::kRgba8Sint: + case ast::TexelFormat::kRgba8Snorm: + case ast::TexelFormat::kRgba8Uint: + case ast::TexelFormat::kRgba8Unorm: + case ast::TexelFormat::kRgba8UnormSrgb: // Four channels return 4; @@ -2628,7 +2628,7 @@ unsigned ParserImpl::GetChannelCountForFormat(ast::ImageFormat format) { return 0; } -const Type* ParserImpl::GetTexelTypeForFormat(ast::ImageFormat format) { +const Type* ParserImpl::GetTexelTypeForFormat(ast::TexelFormat format) { const auto* component_type = GetComponentTypeForFormat(format); if (!component_type) { return nullptr; diff --git a/src/reader/spirv/parser_impl.h b/src/reader/spirv/parser_impl.h index de9f71a205..4a31473ace 100644 --- a/src/reader/spirv/parser_impl.h +++ b/src/reader/spirv/parser_impl.h @@ -637,19 +637,19 @@ class ParserImpl : Reader { /// format. /// @param format image texel format /// @returns the component type, one of f32, i32, u32 - const Type* GetComponentTypeForFormat(ast::ImageFormat format); + const Type* GetComponentTypeForFormat(ast::TexelFormat format); /// Returns the number of channels in the given image format. /// @param format image texel format /// @returns the number of channels in the format - unsigned GetChannelCountForFormat(ast::ImageFormat format); + unsigned GetChannelCountForFormat(ast::TexelFormat format); /// Returns the texel type corresponding to the given image format. /// This the WGSL type used for the texel parameter to textureStore. /// It's always a 4-element vector. /// @param format image texel format /// @returns the texel format - const Type* GetTexelTypeForFormat(ast::ImageFormat format); + const Type* GetTexelTypeForFormat(ast::TexelFormat format); /// Returns the SPIR-V instruction with the given ID, or nullptr. /// @param id the SPIR-V result ID diff --git a/src/reader/spirv/parser_type.cc b/src/reader/spirv/parser_type.cc index 63d51238d9..846ad69b42 100644 --- a/src/reader/spirv/parser_type.cc +++ b/src/reader/spirv/parser_type.cc @@ -19,8 +19,8 @@ #include #include "src/program_builder.h" -#include "src/utils/map.h" #include "src/utils/hash.h" +#include "src/utils/map.h" TINT_INSTANTIATE_TYPEINFO(tint::reader::spirv::Type); TINT_INSTANTIATE_TYPEINFO(tint::reader::spirv::Void); @@ -237,7 +237,7 @@ const ast::Type* SampledTexture::Build(ProgramBuilder& b) const { } StorageTexture::StorageTexture(ast::TextureDimension d, - ast::ImageFormat f, + ast::TexelFormat f, ast::Access a) : Base(d), format(f), access(a) {} StorageTexture::StorageTexture(const StorageTexture&) = default; @@ -532,7 +532,7 @@ const spirv::SampledTexture* TypeManager::SampledTexture( const spirv::StorageTexture* TypeManager::StorageTexture( ast::TextureDimension dims, - ast::ImageFormat fmt, + ast::TexelFormat fmt, ast::Access access) { return utils::GetOrCreate( state->storage_textures_, spirv::StorageTexture(dims, fmt, access), [&] { diff --git a/src/reader/spirv/parser_type.h b/src/reader/spirv/parser_type.h index 4466a63d1e..9317ddeb0e 100644 --- a/src/reader/spirv/parser_type.h +++ b/src/reader/spirv/parser_type.h @@ -422,7 +422,7 @@ struct StorageTexture : public Castable { /// @param d the texture dimensions /// @param f the storage image format /// @param a the access control - StorageTexture(ast::TextureDimension d, ast::ImageFormat f, ast::Access a); + StorageTexture(ast::TextureDimension d, ast::TexelFormat f, ast::Access a); /// Copy constructor /// @param other the other type to copy @@ -438,7 +438,7 @@ struct StorageTexture : public Castable { #endif // NDEBUG /// the storage image format - ast::ImageFormat const format; + ast::TexelFormat const format; /// the access control ast::Access const access; @@ -595,7 +595,7 @@ class TypeManager { /// @return a StorageTexture type. Repeated calls with the same arguments will /// return the same pointer. const spirv::StorageTexture* StorageTexture(ast::TextureDimension d, - ast::ImageFormat f, + ast::TexelFormat f, ast::Access a); private: diff --git a/src/reader/spirv/parser_type_test.cc b/src/reader/spirv/parser_type_test.cc index 8818e3f03e..c683cdd9bc 100644 --- a/src/reader/spirv/parser_type_test.cc +++ b/src/reader/spirv/parser_type_test.cc @@ -46,9 +46,9 @@ TEST(SpvParserTypeTest, SameArgumentsGivesSamePointer) { EXPECT_EQ(ty.SampledTexture(ast::TextureDimension::k2d, ty.I32()), ty.SampledTexture(ast::TextureDimension::k2d, ty.I32())); EXPECT_EQ(ty.StorageTexture(ast::TextureDimension::k2d, - ast::ImageFormat::kR16Sint, ast::Access::kRead), + ast::TexelFormat::kR16Sint, ast::Access::kRead), ty.StorageTexture(ast::TextureDimension::k2d, - ast::ImageFormat::kR16Sint, ast::Access::kRead)); + ast::TexelFormat::kR16Sint, ast::Access::kRead)); } TEST(SpvParserTypeTest, DifferentArgumentsGivesDifferentPointer) { @@ -83,17 +83,17 @@ TEST(SpvParserTypeTest, DifferentArgumentsGivesDifferentPointer) { EXPECT_NE(ty.SampledTexture(ast::TextureDimension::k2d, ty.I32()), ty.SampledTexture(ast::TextureDimension::k2d, ty.U32())); EXPECT_NE(ty.StorageTexture(ast::TextureDimension::k2d, - ast::ImageFormat::kR16Sint, ast::Access::kRead), + ast::TexelFormat::kR16Sint, ast::Access::kRead), ty.StorageTexture(ast::TextureDimension::k3d, - ast::ImageFormat::kR16Sint, ast::Access::kRead)); + ast::TexelFormat::kR16Sint, ast::Access::kRead)); EXPECT_NE(ty.StorageTexture(ast::TextureDimension::k2d, - ast::ImageFormat::kR16Sint, ast::Access::kRead), + ast::TexelFormat::kR16Sint, ast::Access::kRead), ty.StorageTexture(ast::TextureDimension::k2d, - ast::ImageFormat::kR32Sint, ast::Access::kRead)); + ast::TexelFormat::kR32Sint, ast::Access::kRead)); EXPECT_NE(ty.StorageTexture(ast::TextureDimension::k2d, - ast::ImageFormat::kR16Sint, ast::Access::kRead), + ast::TexelFormat::kR16Sint, ast::Access::kRead), ty.StorageTexture(ast::TextureDimension::k2d, - ast::ImageFormat::kR16Sint, ast::Access::kWrite)); + ast::TexelFormat::kR16Sint, ast::Access::kWrite)); } } // namespace diff --git a/src/reader/wgsl/parser_impl.cc b/src/reader/wgsl/parser_impl.cc index 725312d2b7..adb259b2fa 100644 --- a/src/reader/wgsl/parser_impl.cc +++ b/src/reader/wgsl/parser_impl.cc @@ -563,7 +563,7 @@ Maybe ParserImpl::variable_decl(bool allow_inferred) { // | depth_texture_type // | sampled_texture_type LESS_THAN type_decl GREATER_THAN // | multisampled_texture_type LESS_THAN type_decl GREATER_THAN -// | storage_texture_type LESS_THAN image_storage_type +// | storage_texture_type LESS_THAN texel_format // COMMA access GREATER_THAN Maybe ParserImpl::texture_sampler_types() { auto type = sampler_type(); @@ -607,9 +607,9 @@ Maybe ParserImpl::texture_sampler_types() { if (storage.matched) { const char* use = "storage texture type"; using StorageTextureInfo = - std::pair; + std::pair; auto params = expect_lt_gt_block(use, [&]() -> Expect { - auto format = expect_image_storage_type(use); + auto format = expect_texel_format(use); if (format.errored) { return Failure::kErrored; } @@ -781,115 +781,115 @@ Maybe ParserImpl::depth_texture_type() { // | RGBA32UINT // | RGBA32SINT // | RGBA32FLOAT -Expect ParserImpl::expect_image_storage_type( +Expect ParserImpl::expect_texel_format( const std::string& use) { auto tok = next(); if (tok.IsIdentifier()) { auto s = tok.to_str(); if (s == "bgra8unorm") { - return ast::ImageFormat::kBgra8Unorm; + return ast::TexelFormat::kBgra8Unorm; } if (s == "bgra8unorm_srgb") { - return ast::ImageFormat::kBgra8UnormSrgb; + return ast::TexelFormat::kBgra8UnormSrgb; } if (s == "r16float") { - return ast::ImageFormat::kR16Float; + return ast::TexelFormat::kR16Float; } if (s == "r16sint") { - return ast::ImageFormat::kR16Sint; + return ast::TexelFormat::kR16Sint; } if (s == "r16uint") { - return ast::ImageFormat::kR16Uint; + return ast::TexelFormat::kR16Uint; } if (s == "r32float") { - return ast::ImageFormat::kR32Float; + return ast::TexelFormat::kR32Float; } if (s == "r32sint") { - return ast::ImageFormat::kR32Sint; + return ast::TexelFormat::kR32Sint; } if (s == "r32uint") { - return ast::ImageFormat::kR32Uint; + return ast::TexelFormat::kR32Uint; } if (s == "r8sint") { - return ast::ImageFormat::kR8Sint; + return ast::TexelFormat::kR8Sint; } if (s == "r8snorm") { - return ast::ImageFormat::kR8Snorm; + return ast::TexelFormat::kR8Snorm; } if (s == "r8uint") { - return ast::ImageFormat::kR8Uint; + return ast::TexelFormat::kR8Uint; } if (s == "r8unorm") { - return ast::ImageFormat::kR8Unorm; + return ast::TexelFormat::kR8Unorm; } if (s == "rg11b10float") { - return ast::ImageFormat::kRg11B10Float; + return ast::TexelFormat::kRg11B10Float; } if (s == "rg16float") { - return ast::ImageFormat::kRg16Float; + return ast::TexelFormat::kRg16Float; } if (s == "rg16sint") { - return ast::ImageFormat::kRg16Sint; + return ast::TexelFormat::kRg16Sint; } if (s == "rg16uint") { - return ast::ImageFormat::kRg16Uint; + return ast::TexelFormat::kRg16Uint; } if (s == "rg32float") { - return ast::ImageFormat::kRg32Float; + return ast::TexelFormat::kRg32Float; } if (s == "rg32sint") { - return ast::ImageFormat::kRg32Sint; + return ast::TexelFormat::kRg32Sint; } if (s == "rg32uint") { - return ast::ImageFormat::kRg32Uint; + return ast::TexelFormat::kRg32Uint; } if (s == "rg8sint") { - return ast::ImageFormat::kRg8Sint; + return ast::TexelFormat::kRg8Sint; } if (s == "rg8snorm") { - return ast::ImageFormat::kRg8Snorm; + return ast::TexelFormat::kRg8Snorm; } if (s == "rg8uint") { - return ast::ImageFormat::kRg8Uint; + return ast::TexelFormat::kRg8Uint; } if (s == "rg8unorm") { - return ast::ImageFormat::kRg8Unorm; + return ast::TexelFormat::kRg8Unorm; } if (s == "rgb10a2unorm") { - return ast::ImageFormat::kRgb10A2Unorm; + return ast::TexelFormat::kRgb10A2Unorm; } if (s == "rgba16float") { - return ast::ImageFormat::kRgba16Float; + return ast::TexelFormat::kRgba16Float; } if (s == "rgba16sint") { - return ast::ImageFormat::kRgba16Sint; + return ast::TexelFormat::kRgba16Sint; } if (s == "rgba16uint") { - return ast::ImageFormat::kRgba16Uint; + return ast::TexelFormat::kRgba16Uint; } if (s == "rgba32float") { - return ast::ImageFormat::kRgba32Float; + return ast::TexelFormat::kRgba32Float; } if (s == "rgba32sint") { - return ast::ImageFormat::kRgba32Sint; + return ast::TexelFormat::kRgba32Sint; } if (s == "rgba32uint") { - return ast::ImageFormat::kRgba32Uint; + return ast::TexelFormat::kRgba32Uint; } if (s == "rgba8sint") { - return ast::ImageFormat::kRgba8Sint; + return ast::TexelFormat::kRgba8Sint; } if (s == "rgba8snorm") { - return ast::ImageFormat::kRgba8Snorm; + return ast::TexelFormat::kRgba8Snorm; } if (s == "rgba8uint") { - return ast::ImageFormat::kRgba8Uint; + return ast::TexelFormat::kRgba8Uint; } if (s == "rgba8unorm") { - return ast::ImageFormat::kRgba8Unorm; + return ast::TexelFormat::kRgba8Unorm; } if (s == "rgba8unorm_srgb") { - return ast::ImageFormat::kRgba8UnormSrgb; + return ast::TexelFormat::kRgba8UnormSrgb; } } return add_error(tok.source(), "invalid format", use); diff --git a/src/reader/wgsl/parser_impl.h b/src/reader/wgsl/parser_impl.h index 6f51e0efae..203715047e 100644 --- a/src/reader/wgsl/parser_impl.h +++ b/src/reader/wgsl/parser_impl.h @@ -469,10 +469,10 @@ class ParserImpl { /// Parses a 'texture_external_type' grammar element /// @returns the parsed Type or nullptr if none matched Maybe external_texture_type(); - /// Parses a `image_storage_type` grammar element + /// Parses a `texel_format` grammar element /// @param use a description of what was being parsed if an error was raised - /// @returns returns the image format or kNone if none matched. - Expect expect_image_storage_type(const std::string& use); + /// @returns returns the texel format or kNone if none matched. + Expect expect_texel_format(const std::string& use); /// Parses a `function_header` grammar element /// @returns the parsed function header Maybe function_header(); diff --git a/src/reader/wgsl/parser_impl_image_storage_type_test.cc b/src/reader/wgsl/parser_impl_texel_format_test.cc similarity index 63% rename from src/reader/wgsl/parser_impl_image_storage_type_test.cc rename to src/reader/wgsl/parser_impl_texel_format_test.cc index bafb777668..8a0d5a7967 100644 --- a/src/reader/wgsl/parser_impl_image_storage_type_test.cc +++ b/src/reader/wgsl/parser_impl_texel_format_test.cc @@ -21,7 +21,7 @@ namespace { TEST_F(ParserImplTest, ImageStorageType_Invalid) { auto p = parser("1234"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_TRUE(t.errored); EXPECT_TRUE(p->has_error()); EXPECT_EQ(p->error(), "1:1: invalid format for test"); @@ -29,281 +29,281 @@ TEST_F(ParserImplTest, ImageStorageType_Invalid) { TEST_F(ParserImplTest, ImageStorageType_R8Unorm) { auto p = parser("r8unorm"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kR8Unorm); + EXPECT_EQ(t.value, ast::TexelFormat::kR8Unorm); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_R8Snorm) { auto p = parser("r8snorm"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kR8Snorm); + EXPECT_EQ(t.value, ast::TexelFormat::kR8Snorm); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_R8Uint) { auto p = parser("r8uint"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kR8Uint); + EXPECT_EQ(t.value, ast::TexelFormat::kR8Uint); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_R8Sint) { auto p = parser("r8sint"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kR8Sint); + EXPECT_EQ(t.value, ast::TexelFormat::kR8Sint); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_R16Uint) { auto p = parser("r16uint"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kR16Uint); + EXPECT_EQ(t.value, ast::TexelFormat::kR16Uint); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_R16Sint) { auto p = parser("r16sint"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kR16Sint); + EXPECT_EQ(t.value, ast::TexelFormat::kR16Sint); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_R16Float) { auto p = parser("r16float"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kR16Float); + EXPECT_EQ(t.value, ast::TexelFormat::kR16Float); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_Rg8Unorm) { auto p = parser("rg8unorm"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kRg8Unorm); + EXPECT_EQ(t.value, ast::TexelFormat::kRg8Unorm); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_Rg8Snorm) { auto p = parser("rg8snorm"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kRg8Snorm); + EXPECT_EQ(t.value, ast::TexelFormat::kRg8Snorm); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_Rg8Uint) { auto p = parser("rg8uint"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kRg8Uint); + EXPECT_EQ(t.value, ast::TexelFormat::kRg8Uint); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_Rg8Sint) { auto p = parser("rg8sint"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kRg8Sint); + EXPECT_EQ(t.value, ast::TexelFormat::kRg8Sint); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_R32Uint) { auto p = parser("r32uint"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kR32Uint); + EXPECT_EQ(t.value, ast::TexelFormat::kR32Uint); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_R32Sint) { auto p = parser("r32sint"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kR32Sint); + EXPECT_EQ(t.value, ast::TexelFormat::kR32Sint); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_R32Float) { auto p = parser("r32float"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kR32Float); + EXPECT_EQ(t.value, ast::TexelFormat::kR32Float); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_Rg16Uint) { auto p = parser("rg16uint"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kRg16Uint); + EXPECT_EQ(t.value, ast::TexelFormat::kRg16Uint); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_Rg16Sint) { auto p = parser("rg16sint"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kRg16Sint); + EXPECT_EQ(t.value, ast::TexelFormat::kRg16Sint); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_Rg16Float) { auto p = parser("rg16float"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kRg16Float); + EXPECT_EQ(t.value, ast::TexelFormat::kRg16Float); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_Rgba8Unorm) { auto p = parser("rgba8unorm"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kRgba8Unorm); + EXPECT_EQ(t.value, ast::TexelFormat::kRgba8Unorm); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_Rgba8UnormSrgb) { auto p = parser("rgba8unorm_srgb"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kRgba8UnormSrgb); + EXPECT_EQ(t.value, ast::TexelFormat::kRgba8UnormSrgb); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_Rgba8Snorm) { auto p = parser("rgba8snorm"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kRgba8Snorm); + EXPECT_EQ(t.value, ast::TexelFormat::kRgba8Snorm); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_Rgba8Uint) { auto p = parser("rgba8uint"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kRgba8Uint); + EXPECT_EQ(t.value, ast::TexelFormat::kRgba8Uint); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_Rgba8Sint) { auto p = parser("rgba8sint"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kRgba8Sint); + EXPECT_EQ(t.value, ast::TexelFormat::kRgba8Sint); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_Bgra8Unorm) { auto p = parser("bgra8unorm"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kBgra8Unorm); + EXPECT_EQ(t.value, ast::TexelFormat::kBgra8Unorm); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_Bgra8UnormSrgb) { auto p = parser("bgra8unorm_srgb"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kBgra8UnormSrgb); + EXPECT_EQ(t.value, ast::TexelFormat::kBgra8UnormSrgb); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_Rgb10A2Unorm) { auto p = parser("rgb10a2unorm"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kRgb10A2Unorm); + EXPECT_EQ(t.value, ast::TexelFormat::kRgb10A2Unorm); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_Rg11B10Float) { auto p = parser("rg11b10float"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kRg11B10Float); + EXPECT_EQ(t.value, ast::TexelFormat::kRg11B10Float); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_Rg32Uint) { auto p = parser("rg32uint"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kRg32Uint); + EXPECT_EQ(t.value, ast::TexelFormat::kRg32Uint); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_Rg32Sint) { auto p = parser("rg32sint"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kRg32Sint); + EXPECT_EQ(t.value, ast::TexelFormat::kRg32Sint); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_Rg32Float) { auto p = parser("rg32float"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kRg32Float); + EXPECT_EQ(t.value, ast::TexelFormat::kRg32Float); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_Rgba16Uint) { auto p = parser("rgba16uint"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kRgba16Uint); + EXPECT_EQ(t.value, ast::TexelFormat::kRgba16Uint); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_Rgba16Sint) { auto p = parser("rgba16sint"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kRgba16Sint); + EXPECT_EQ(t.value, ast::TexelFormat::kRgba16Sint); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_Rgba16Float) { auto p = parser("rgba16float"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kRgba16Float); + EXPECT_EQ(t.value, ast::TexelFormat::kRgba16Float); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_Rgba32Uint) { auto p = parser("rgba32uint"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kRgba32Uint); + EXPECT_EQ(t.value, ast::TexelFormat::kRgba32Uint); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_Rgba32Sint) { auto p = parser("rgba32sint"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kRgba32Sint); + EXPECT_EQ(t.value, ast::TexelFormat::kRgba32Sint); EXPECT_FALSE(p->has_error()); } TEST_F(ParserImplTest, ImageStorageType_Rgba32Float) { auto p = parser("rgba32float"); - auto t = p->expect_image_storage_type("test"); + auto t = p->expect_texel_format("test"); EXPECT_FALSE(t.errored); - EXPECT_EQ(t.value, ast::ImageFormat::kRgba32Float); + EXPECT_EQ(t.value, ast::TexelFormat::kRgba32Float); EXPECT_FALSE(p->has_error()); } diff --git a/src/reader/wgsl/parser_impl_texture_sampler_types_test.cc b/src/reader/wgsl/parser_impl_texture_sampler_types_test.cc index fbd8127127..0b4af5caa6 100644 --- a/src/reader/wgsl/parser_impl_texture_sampler_types_test.cc +++ b/src/reader/wgsl/parser_impl_texture_sampler_types_test.cc @@ -194,7 +194,7 @@ TEST_F(ParserImplTest, TextureSamplerTypes_StorageTexture_Readonly1dR8Unorm) { ASSERT_TRUE(t->Is()); ASSERT_TRUE(t->Is()); - EXPECT_EQ(t->As()->format, ast::ImageFormat::kR8Unorm); + EXPECT_EQ(t->As()->format, ast::TexelFormat::kR8Unorm); EXPECT_EQ(t->As()->access, ast::Access::kRead); EXPECT_EQ(t->As()->dim, ast::TextureDimension::k1d); EXPECT_EQ(t->source.range, (Source::Range{{1u, 1u}, {1u, 34u}})); @@ -210,7 +210,7 @@ TEST_F(ParserImplTest, TextureSamplerTypes_StorageTexture_Writeonly2dR16Float) { ASSERT_TRUE(t->Is()); ASSERT_TRUE(t->Is()); - EXPECT_EQ(t->As()->format, ast::ImageFormat::kR16Float); + EXPECT_EQ(t->As()->format, ast::TexelFormat::kR16Float); EXPECT_EQ(t->As()->access, ast::Access::kWrite); EXPECT_EQ(t->As()->dim, ast::TextureDimension::k2d); EXPECT_EQ(t->source.range, (Source::Range{{1u, 1u}, {1u, 36u}})); diff --git a/src/resolver/assignment_validation_test.cc b/src/resolver/assignment_validation_test.cc index 1981c876cc..f5731615a4 100644 --- a/src/resolver/assignment_validation_test.cc +++ b/src/resolver/assignment_validation_test.cc @@ -227,7 +227,7 @@ TEST_F(ResolverAssignmentValidationTest, AssignNonConstructible_Handle) { auto make_type = [&] { return ty.storage_texture(ast::TextureDimension::k1d, - ast::ImageFormat::kRgba8Unorm, + ast::TexelFormat::kRgba8Unorm, ast::Access::kWrite); }; diff --git a/src/resolver/dependency_graph_test.cc b/src/resolver/dependency_graph_test.cc index dcbcd7272d..7186ef9cff 100644 --- a/src/resolver/dependency_graph_test.cc +++ b/src/resolver/dependency_graph_test.cc @@ -1316,7 +1316,7 @@ TEST_F(ResolverDependencyGraphTraversalTest, SymbolsReached) { Global(Sym(), ty.external_texture()); Global(Sym(), ty.multisampled_texture(ast::TextureDimension::k2d, T)); Global(Sym(), ty.storage_texture(ast::TextureDimension::k2d, - ast::ImageFormat::kR16Float, + ast::TexelFormat::kR16Float, ast::Access::kRead)); // Global(Sym(), ty.sampler(ast::SamplerKind::kSampler)); Func(Sym(), {}, ty.void_(), {}); diff --git a/src/resolver/intrinsic_test.cc b/src/resolver/intrinsic_test.cc index c0ba99dfdf..ffe9388430 100644 --- a/src/resolver/intrinsic_test.cc +++ b/src/resolver/intrinsic_test.cc @@ -222,7 +222,7 @@ inline std::ostream& operator<<(std::ostream& out, Texture data) { struct TextureTestParams { ast::TextureDimension dim; Texture type = Texture::kF32; - ast::ImageFormat format = ast::ImageFormat::kR16Float; + ast::TexelFormat format = ast::TexelFormat::kR16Float; }; inline std::ostream& operator<<(std::ostream& out, TextureTestParams data) { out << data.dim << "_" << data.type; diff --git a/src/resolver/resolver_validation.cc b/src/resolver/resolver_validation.cc index 117eb25688..a457ec3304 100644 --- a/src/resolver/resolver_validation.cc +++ b/src/resolver/resolver_validation.cc @@ -95,24 +95,24 @@ bool IsValidStorageTextureDimension(ast::TextureDimension dim) { } } -bool IsValidStorageTextureImageFormat(ast::ImageFormat format) { +bool IsValidStorageTextureTexelFormat(ast::TexelFormat format) { switch (format) { - case ast::ImageFormat::kR32Uint: - case ast::ImageFormat::kR32Sint: - case ast::ImageFormat::kR32Float: - case ast::ImageFormat::kRg32Uint: - case ast::ImageFormat::kRg32Sint: - case ast::ImageFormat::kRg32Float: - case ast::ImageFormat::kRgba8Unorm: - case ast::ImageFormat::kRgba8Snorm: - case ast::ImageFormat::kRgba8Uint: - case ast::ImageFormat::kRgba8Sint: - case ast::ImageFormat::kRgba16Uint: - case ast::ImageFormat::kRgba16Sint: - case ast::ImageFormat::kRgba16Float: - case ast::ImageFormat::kRgba32Uint: - case ast::ImageFormat::kRgba32Sint: - case ast::ImageFormat::kRgba32Float: + case ast::TexelFormat::kR32Uint: + case ast::TexelFormat::kR32Sint: + case ast::TexelFormat::kR32Float: + case ast::TexelFormat::kRg32Uint: + case ast::TexelFormat::kRg32Sint: + case ast::TexelFormat::kRg32Float: + case ast::TexelFormat::kRgba8Unorm: + case ast::TexelFormat::kRgba8Snorm: + case ast::TexelFormat::kRgba8Uint: + case ast::TexelFormat::kRgba8Sint: + case ast::TexelFormat::kRgba16Uint: + case ast::TexelFormat::kRgba16Sint: + case ast::TexelFormat::kRgba16Float: + case ast::TexelFormat::kRgba32Uint: + case ast::TexelFormat::kRgba32Sint: + case ast::TexelFormat::kRgba32Float: return true; default: return false; @@ -182,7 +182,7 @@ bool Resolver::ValidateStorageTexture(const ast::StorageTexture* t) { return false; } - if (!IsValidStorageTextureImageFormat(t->format)) { + if (!IsValidStorageTextureTexelFormat(t->format)) { AddError( "image format must be one of the texel formats specified for storage " "textues in https://gpuweb.github.io/gpuweb/wgsl/#texel-formats", diff --git a/src/resolver/type_validation_test.cc b/src/resolver/type_validation_test.cc index aa9a7be072..9da7dfa7cc 100644 --- a/src/resolver/type_validation_test.cc +++ b/src/resolver/type_validation_test.cc @@ -837,7 +837,7 @@ TEST_P(StorageTextureDimensionTest, All) { auto* st = ty.storage_texture(Source{{12, 34}}, params.dim, - ast::ImageFormat::kR32Uint, ast::Access::kWrite); + ast::TexelFormat::kR32Uint, ast::Access::kWrite); Global("a", st, ast::StorageClass::kNone, ast::DecorationList{GroupAndBinding(0, 0)}); @@ -856,46 +856,46 @@ INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest, testing::ValuesIn(Dimension_cases)); struct FormatParams { - ast::ImageFormat format; + ast::TexelFormat format; bool is_valid; }; static constexpr FormatParams format_cases[] = { - FormatParams{ast::ImageFormat::kBgra8Unorm, false}, - FormatParams{ast::ImageFormat::kBgra8UnormSrgb, false}, - FormatParams{ast::ImageFormat::kR16Float, false}, - FormatParams{ast::ImageFormat::kR16Sint, false}, - FormatParams{ast::ImageFormat::kR16Uint, false}, - FormatParams{ast::ImageFormat::kR32Float, true}, - FormatParams{ast::ImageFormat::kR32Sint, true}, - FormatParams{ast::ImageFormat::kR32Uint, true}, - FormatParams{ast::ImageFormat::kR8Sint, false}, - FormatParams{ast::ImageFormat::kR8Snorm, false}, - FormatParams{ast::ImageFormat::kR8Uint, false}, - FormatParams{ast::ImageFormat::kR8Unorm, false}, - FormatParams{ast::ImageFormat::kRg11B10Float, false}, - FormatParams{ast::ImageFormat::kRg16Float, false}, - FormatParams{ast::ImageFormat::kRg16Sint, false}, - FormatParams{ast::ImageFormat::kRg16Uint, false}, - FormatParams{ast::ImageFormat::kRg32Float, true}, - FormatParams{ast::ImageFormat::kRg32Sint, true}, - FormatParams{ast::ImageFormat::kRg32Uint, true}, - FormatParams{ast::ImageFormat::kRg8Sint, false}, - FormatParams{ast::ImageFormat::kRg8Snorm, false}, - FormatParams{ast::ImageFormat::kRg8Uint, false}, - FormatParams{ast::ImageFormat::kRg8Unorm, false}, - FormatParams{ast::ImageFormat::kRgb10A2Unorm, false}, - FormatParams{ast::ImageFormat::kRgba16Float, true}, - FormatParams{ast::ImageFormat::kRgba16Sint, true}, - FormatParams{ast::ImageFormat::kRgba16Uint, true}, - FormatParams{ast::ImageFormat::kRgba32Float, true}, - FormatParams{ast::ImageFormat::kRgba32Sint, true}, - FormatParams{ast::ImageFormat::kRgba32Uint, true}, - FormatParams{ast::ImageFormat::kRgba8Sint, true}, - FormatParams{ast::ImageFormat::kRgba8Snorm, true}, - FormatParams{ast::ImageFormat::kRgba8Uint, true}, - FormatParams{ast::ImageFormat::kRgba8Unorm, true}, - FormatParams{ast::ImageFormat::kRgba8UnormSrgb, false}}; + FormatParams{ast::TexelFormat::kBgra8Unorm, false}, + FormatParams{ast::TexelFormat::kBgra8UnormSrgb, false}, + FormatParams{ast::TexelFormat::kR16Float, false}, + FormatParams{ast::TexelFormat::kR16Sint, false}, + FormatParams{ast::TexelFormat::kR16Uint, false}, + FormatParams{ast::TexelFormat::kR32Float, true}, + FormatParams{ast::TexelFormat::kR32Sint, true}, + FormatParams{ast::TexelFormat::kR32Uint, true}, + FormatParams{ast::TexelFormat::kR8Sint, false}, + FormatParams{ast::TexelFormat::kR8Snorm, false}, + FormatParams{ast::TexelFormat::kR8Uint, false}, + FormatParams{ast::TexelFormat::kR8Unorm, false}, + FormatParams{ast::TexelFormat::kRg11B10Float, false}, + FormatParams{ast::TexelFormat::kRg16Float, false}, + FormatParams{ast::TexelFormat::kRg16Sint, false}, + FormatParams{ast::TexelFormat::kRg16Uint, false}, + FormatParams{ast::TexelFormat::kRg32Float, true}, + FormatParams{ast::TexelFormat::kRg32Sint, true}, + FormatParams{ast::TexelFormat::kRg32Uint, true}, + FormatParams{ast::TexelFormat::kRg8Sint, false}, + FormatParams{ast::TexelFormat::kRg8Snorm, false}, + FormatParams{ast::TexelFormat::kRg8Uint, false}, + FormatParams{ast::TexelFormat::kRg8Unorm, false}, + FormatParams{ast::TexelFormat::kRgb10A2Unorm, false}, + FormatParams{ast::TexelFormat::kRgba16Float, true}, + FormatParams{ast::TexelFormat::kRgba16Sint, true}, + FormatParams{ast::TexelFormat::kRgba16Uint, true}, + FormatParams{ast::TexelFormat::kRgba32Float, true}, + FormatParams{ast::TexelFormat::kRgba32Sint, true}, + FormatParams{ast::TexelFormat::kRgba32Uint, true}, + FormatParams{ast::TexelFormat::kRgba8Sint, true}, + FormatParams{ast::TexelFormat::kRgba8Snorm, true}, + FormatParams{ast::TexelFormat::kRgba8Uint, true}, + FormatParams{ast::TexelFormat::kRgba8Unorm, true}, + FormatParams{ast::TexelFormat::kRgba8UnormSrgb, false}}; using StorageTextureFormatTest = ResolverTestWithParam; TEST_P(StorageTextureFormatTest, All) { @@ -951,7 +951,7 @@ TEST_F(StorageTextureAccessTest, MissingAccess_Fail) { auto* st = ty.storage_texture(Source{{12, 34}}, ast::TextureDimension::k1d, - ast::ImageFormat::kR32Uint, ast::Access::kUndefined); + ast::TexelFormat::kR32Uint, ast::Access::kUndefined); Global("a", st, ast::StorageClass::kNone, ast::DecorationList{GroupAndBinding(0, 0)}); @@ -967,7 +967,7 @@ TEST_F(StorageTextureAccessTest, RWAccess_Fail) { auto* st = ty.storage_texture(Source{{12, 34}}, ast::TextureDimension::k1d, - ast::ImageFormat::kR32Uint, ast::Access::kReadWrite); + ast::TexelFormat::kR32Uint, ast::Access::kReadWrite); Global("a", st, ast::StorageClass::kNone, nullptr, ast::DecorationList{GroupAndBinding(0, 0)}); @@ -983,7 +983,7 @@ TEST_F(StorageTextureAccessTest, ReadOnlyAccess_Fail) { // var a : texture_storage_1d; auto* st = ty.storage_texture(Source{{12, 34}}, ast::TextureDimension::k1d, - ast::ImageFormat::kR32Uint, ast::Access::kRead); + ast::TexelFormat::kR32Uint, ast::Access::kRead); Global("a", st, ast::StorageClass::kNone, nullptr, ast::DecorationList{GroupAndBinding(0, 0)}); @@ -999,7 +999,7 @@ TEST_F(StorageTextureAccessTest, WriteOnlyAccess_Pass) { // var a : texture_storage_1d; auto* st = - ty.storage_texture(ast::TextureDimension::k1d, ast::ImageFormat::kR32Uint, + ty.storage_texture(ast::TextureDimension::k1d, ast::TexelFormat::kR32Uint, ast::Access::kWrite); Global("a", st, ast::StorageClass::kNone, nullptr, diff --git a/src/sem/storage_texture_type.cc b/src/sem/storage_texture_type.cc index d690354721..8f796dbdd4 100644 --- a/src/sem/storage_texture_type.cc +++ b/src/sem/storage_texture_type.cc @@ -22,10 +22,10 @@ namespace tint { namespace sem { StorageTexture::StorageTexture(ast::TextureDimension dim, - ast::ImageFormat format, + ast::TexelFormat format, ast::Access access, sem::Type* subtype) - : Base(dim), image_format_(format), access_(access), subtype_(subtype) {} + : Base(dim), texel_format_(format), access_(access), subtype_(subtype) {} StorageTexture::StorageTexture(StorageTexture&&) = default; @@ -33,66 +33,66 @@ StorageTexture::~StorageTexture() = default; std::string StorageTexture::type_name() const { std::ostringstream out; - out << "__storage_texture_" << dim() << "_" << image_format_ << "_" + out << "__storage_texture_" << dim() << "_" << texel_format_ << "_" << access_; return out.str(); } std::string StorageTexture::FriendlyName(const SymbolTable&) const { std::ostringstream out; - out << "texture_storage_" << dim() << "<" << image_format_ << ", " << access_ + out << "texture_storage_" << dim() << "<" << texel_format_ << ", " << access_ << ">"; return out.str(); } -sem::Type* StorageTexture::SubtypeFor(ast::ImageFormat format, +sem::Type* StorageTexture::SubtypeFor(ast::TexelFormat format, sem::Manager& type_mgr) { switch (format) { - case ast::ImageFormat::kR8Uint: - case ast::ImageFormat::kR16Uint: - case ast::ImageFormat::kRg8Uint: - case ast::ImageFormat::kR32Uint: - case ast::ImageFormat::kRg16Uint: - case ast::ImageFormat::kRgba8Uint: - case ast::ImageFormat::kRg32Uint: - case ast::ImageFormat::kRgba16Uint: - case ast::ImageFormat::kRgba32Uint: { + case ast::TexelFormat::kR8Uint: + case ast::TexelFormat::kR16Uint: + case ast::TexelFormat::kRg8Uint: + case ast::TexelFormat::kR32Uint: + case ast::TexelFormat::kRg16Uint: + case ast::TexelFormat::kRgba8Uint: + case ast::TexelFormat::kRg32Uint: + case ast::TexelFormat::kRgba16Uint: + case ast::TexelFormat::kRgba32Uint: { return type_mgr.Get(); } - case ast::ImageFormat::kR8Sint: - case ast::ImageFormat::kR16Sint: - case ast::ImageFormat::kRg8Sint: - case ast::ImageFormat::kR32Sint: - case ast::ImageFormat::kRg16Sint: - case ast::ImageFormat::kRgba8Sint: - case ast::ImageFormat::kRg32Sint: - case ast::ImageFormat::kRgba16Sint: - case ast::ImageFormat::kRgba32Sint: { + case ast::TexelFormat::kR8Sint: + case ast::TexelFormat::kR16Sint: + case ast::TexelFormat::kRg8Sint: + case ast::TexelFormat::kR32Sint: + case ast::TexelFormat::kRg16Sint: + case ast::TexelFormat::kRgba8Sint: + case ast::TexelFormat::kRg32Sint: + case ast::TexelFormat::kRgba16Sint: + case ast::TexelFormat::kRgba32Sint: { return type_mgr.Get(); } - case ast::ImageFormat::kR8Unorm: - case ast::ImageFormat::kRg8Unorm: - case ast::ImageFormat::kRgba8Unorm: - case ast::ImageFormat::kRgba8UnormSrgb: - case ast::ImageFormat::kBgra8Unorm: - case ast::ImageFormat::kBgra8UnormSrgb: - case ast::ImageFormat::kRgb10A2Unorm: - case ast::ImageFormat::kR8Snorm: - case ast::ImageFormat::kRg8Snorm: - case ast::ImageFormat::kRgba8Snorm: - case ast::ImageFormat::kR16Float: - case ast::ImageFormat::kR32Float: - case ast::ImageFormat::kRg16Float: - case ast::ImageFormat::kRg11B10Float: - case ast::ImageFormat::kRg32Float: - case ast::ImageFormat::kRgba16Float: - case ast::ImageFormat::kRgba32Float: { + case ast::TexelFormat::kR8Unorm: + case ast::TexelFormat::kRg8Unorm: + case ast::TexelFormat::kRgba8Unorm: + case ast::TexelFormat::kRgba8UnormSrgb: + case ast::TexelFormat::kBgra8Unorm: + case ast::TexelFormat::kBgra8UnormSrgb: + case ast::TexelFormat::kRgb10A2Unorm: + case ast::TexelFormat::kR8Snorm: + case ast::TexelFormat::kRg8Snorm: + case ast::TexelFormat::kRgba8Snorm: + case ast::TexelFormat::kR16Float: + case ast::TexelFormat::kR32Float: + case ast::TexelFormat::kRg16Float: + case ast::TexelFormat::kRg11B10Float: + case ast::TexelFormat::kRg32Float: + case ast::TexelFormat::kRgba16Float: + case ast::TexelFormat::kRgba32Float: { return type_mgr.Get(); } - case ast::ImageFormat::kNone: + case ast::TexelFormat::kNone: break; } diff --git a/src/sem/storage_texture_type.h b/src/sem/storage_texture_type.h index 216ed280a0..4881db88f4 100644 --- a/src/sem/storage_texture_type.h +++ b/src/sem/storage_texture_type.h @@ -31,11 +31,11 @@ class StorageTexture : public Castable { public: /// Constructor /// @param dim the dimensionality of the texture - /// @param format the image format of the texture + /// @param format the texel format of the texture /// @param access the access control type of the texture /// @param subtype the storage subtype. Use SubtypeFor() to calculate this. StorageTexture(ast::TextureDimension dim, - ast::ImageFormat format, + ast::TexelFormat format, ast::Access access, sem::Type* subtype); @@ -46,8 +46,8 @@ class StorageTexture : public Castable { /// @returns the storage subtype Type* type() const { return subtype_; } - /// @returns the image format - ast::ImageFormat image_format() const { return image_format_; } + /// @returns the texel format + ast::TexelFormat texel_format() const { return texel_format_; } /// @returns the access control ast::Access access() const { return access_; } @@ -62,11 +62,11 @@ class StorageTexture : public Castable { /// @param format the storage texture image format /// @param type_mgr the sem::Manager used to build the returned type - /// @returns the storage texture subtype for the given ImageFormat - static sem::Type* SubtypeFor(ast::ImageFormat format, sem::Manager& type_mgr); + /// @returns the storage texture subtype for the given TexelFormat + static sem::Type* SubtypeFor(ast::TexelFormat format, sem::Manager& type_mgr); private: - ast::ImageFormat const image_format_; + ast::TexelFormat const texel_format_; ast::Access const access_; Type* const subtype_; }; diff --git a/src/sem/storage_texture_type_test.cc b/src/sem/storage_texture_type_test.cc index 8917af0003..45e75d667f 100644 --- a/src/sem/storage_texture_type_test.cc +++ b/src/sem/storage_texture_type_test.cc @@ -27,27 +27,27 @@ using StorageTextureTest = TestHelper; TEST_F(StorageTextureTest, Dim) { auto* subtype = - StorageTexture::SubtypeFor(ast::ImageFormat::kRgba32Float, Types()); + StorageTexture::SubtypeFor(ast::TexelFormat::kRgba32Float, Types()); auto* s = create(ast::TextureDimension::k2dArray, - ast::ImageFormat::kRgba32Float, + ast::TexelFormat::kRgba32Float, ast::Access::kReadWrite, subtype); EXPECT_EQ(s->dim(), ast::TextureDimension::k2dArray); } TEST_F(StorageTextureTest, Format) { auto* subtype = - StorageTexture::SubtypeFor(ast::ImageFormat::kRgba32Float, Types()); + StorageTexture::SubtypeFor(ast::TexelFormat::kRgba32Float, Types()); auto* s = create(ast::TextureDimension::k2dArray, - ast::ImageFormat::kRgba32Float, + ast::TexelFormat::kRgba32Float, ast::Access::kReadWrite, subtype); - EXPECT_EQ(s->image_format(), ast::ImageFormat::kRgba32Float); + EXPECT_EQ(s->texel_format(), ast::TexelFormat::kRgba32Float); } TEST_F(StorageTextureTest, TypeName) { auto* subtype = - StorageTexture::SubtypeFor(ast::ImageFormat::kRgba32Float, Types()); + StorageTexture::SubtypeFor(ast::TexelFormat::kRgba32Float, Types()); auto* s = create(ast::TextureDimension::k2dArray, - ast::ImageFormat::kRgba32Float, + ast::TexelFormat::kRgba32Float, ast::Access::kReadWrite, subtype); EXPECT_EQ(s->type_name(), "__storage_texture_2d_array_rgba32float_read_write"); @@ -55,9 +55,9 @@ TEST_F(StorageTextureTest, TypeName) { TEST_F(StorageTextureTest, FriendlyName) { auto* subtype = - StorageTexture::SubtypeFor(ast::ImageFormat::kRgba32Float, Types()); + StorageTexture::SubtypeFor(ast::TexelFormat::kRgba32Float, Types()); auto* s = create(ast::TextureDimension::k2dArray, - ast::ImageFormat::kRgba32Float, + ast::TexelFormat::kRgba32Float, ast::Access::kReadWrite, subtype); EXPECT_EQ(s->FriendlyName(Symbols()), "texture_storage_2d_array"); @@ -65,9 +65,9 @@ TEST_F(StorageTextureTest, FriendlyName) { TEST_F(StorageTextureTest, F32) { auto* subtype = - sem::StorageTexture::SubtypeFor(ast::ImageFormat::kRgba32Float, Types()); + sem::StorageTexture::SubtypeFor(ast::TexelFormat::kRgba32Float, Types()); Type* s = create(ast::TextureDimension::k2dArray, - ast::ImageFormat::kRgba32Float, + ast::TexelFormat::kRgba32Float, ast::Access::kReadWrite, subtype); auto program = Build(); @@ -80,9 +80,9 @@ TEST_F(StorageTextureTest, F32) { TEST_F(StorageTextureTest, U32) { auto* subtype = - sem::StorageTexture::SubtypeFor(ast::ImageFormat::kRg32Uint, Types()); + sem::StorageTexture::SubtypeFor(ast::TexelFormat::kRg32Uint, Types()); Type* s = create(ast::TextureDimension::k2dArray, - ast::ImageFormat::kRg32Uint, + ast::TexelFormat::kRg32Uint, ast::Access::kReadWrite, subtype); auto program = Build(); @@ -95,9 +95,9 @@ TEST_F(StorageTextureTest, U32) { TEST_F(StorageTextureTest, I32) { auto* subtype = - sem::StorageTexture::SubtypeFor(ast::ImageFormat::kRgba32Sint, Types()); + sem::StorageTexture::SubtypeFor(ast::TexelFormat::kRgba32Sint, Types()); Type* s = create(ast::TextureDimension::k2dArray, - ast::ImageFormat::kRgba32Sint, + ast::TexelFormat::kRgba32Sint, ast::Access::kReadWrite, subtype); auto program = Build(); diff --git a/src/transform/transform.cc b/src/transform/transform.cc index bf94f08da3..a7ad0a2abd 100644 --- a/src/transform/transform.cc +++ b/src/transform/transform.cc @@ -152,7 +152,7 @@ const ast::Type* Transform::CreateASTTypeFor(CloneContext& ctx, } if (auto* t = ty->As()) { return ctx.dst->create( - t->dim(), t->image_format(), CreateASTTypeFor(ctx, t->type()), + t->dim(), t->texel_format(), CreateASTTypeFor(ctx, t->type()), t->access()); } if (auto* s = ty->As()) { diff --git a/src/writer/glsl/generator_impl_type_test.cc b/src/writer/glsl/generator_impl_type_test.cc index 32b2142f96..2a042cd8ad 100644 --- a/src/writer/glsl/generator_impl_type_test.cc +++ b/src/writer/glsl/generator_impl_type_test.cc @@ -507,7 +507,7 @@ TEST_F(GlslGeneratorImplTest_Type, EmitMultisampledTexture) { struct GlslStorageTextureData { ast::TextureDimension dim; - ast::ImageFormat imgfmt; + ast::TexelFormat imgfmt; std::string result; }; inline std::ostream& operator<<(std::ostream& out, @@ -539,32 +539,32 @@ INSTANTIATE_TEST_SUITE_P( GlslStorageTexturesTest, testing::Values( GlslStorageTextureData{ast::TextureDimension::k1d, - ast::ImageFormat::kRgba8Unorm, "image1D tex;"}, + ast::TexelFormat::kRgba8Unorm, "image1D tex;"}, GlslStorageTextureData{ast::TextureDimension::k2d, - ast::ImageFormat::kRgba16Float, "image2D tex;"}, + ast::TexelFormat::kRgba16Float, "image2D tex;"}, GlslStorageTextureData{ast::TextureDimension::k2dArray, - ast::ImageFormat::kR32Float, + ast::TexelFormat::kR32Float, "image2DArray tex;"}, GlslStorageTextureData{ast::TextureDimension::k3d, - ast::ImageFormat::kRg32Float, "image3D tex;"}, + ast::TexelFormat::kRg32Float, "image3D tex;"}, GlslStorageTextureData{ast::TextureDimension::k1d, - ast::ImageFormat::kRgba32Float, "image1D tex;"}, + ast::TexelFormat::kRgba32Float, "image1D tex;"}, GlslStorageTextureData{ast::TextureDimension::k2d, - ast::ImageFormat::kRgba16Uint, "image2D tex;"}, + ast::TexelFormat::kRgba16Uint, "image2D tex;"}, GlslStorageTextureData{ast::TextureDimension::k2dArray, - ast::ImageFormat::kR32Uint, "image2DArray tex;"}, + ast::TexelFormat::kR32Uint, "image2DArray tex;"}, GlslStorageTextureData{ast::TextureDimension::k3d, - ast::ImageFormat::kRg32Uint, "image3D tex;"}, + ast::TexelFormat::kRg32Uint, "image3D tex;"}, GlslStorageTextureData{ast::TextureDimension::k1d, - ast::ImageFormat::kRgba32Uint, "image1D tex;"}, + ast::TexelFormat::kRgba32Uint, "image1D tex;"}, GlslStorageTextureData{ast::TextureDimension::k2d, - ast::ImageFormat::kRgba16Sint, "image2D tex;"}, + ast::TexelFormat::kRgba16Sint, "image2D tex;"}, GlslStorageTextureData{ast::TextureDimension::k2dArray, - ast::ImageFormat::kR32Sint, "image2DArray tex;"}, + ast::TexelFormat::kR32Sint, "image2DArray tex;"}, GlslStorageTextureData{ast::TextureDimension::k3d, - ast::ImageFormat::kRg32Sint, "image3D tex;"}, + ast::TexelFormat::kRg32Sint, "image3D tex;"}, GlslStorageTextureData{ast::TextureDimension::k1d, - ast::ImageFormat::kRgba32Sint, "image1D tex;"})); + ast::TexelFormat::kRgba32Sint, "image1D tex;"})); } // namespace } // namespace glsl diff --git a/src/writer/hlsl/generator_impl.cc b/src/writer/hlsl/generator_impl.cc index 361684fc22..76dc529d61 100644 --- a/src/writer/hlsl/generator_impl.cc +++ b/src/writer/hlsl/generator_impl.cc @@ -76,26 +76,26 @@ namespace { const char kTempNamePrefix[] = "tint_tmp"; const char kSpecConstantPrefix[] = "WGSL_SPEC_CONSTANT_"; -const char* image_format_to_rwtexture_type(ast::ImageFormat image_format) { +const char* image_format_to_rwtexture_type(ast::TexelFormat image_format) { switch (image_format) { - case ast::ImageFormat::kRgba8Unorm: - case ast::ImageFormat::kRgba8Snorm: - case ast::ImageFormat::kRgba16Float: - case ast::ImageFormat::kR32Float: - case ast::ImageFormat::kRg32Float: - case ast::ImageFormat::kRgba32Float: + case ast::TexelFormat::kRgba8Unorm: + case ast::TexelFormat::kRgba8Snorm: + case ast::TexelFormat::kRgba16Float: + case ast::TexelFormat::kR32Float: + case ast::TexelFormat::kRg32Float: + case ast::TexelFormat::kRgba32Float: return "float4"; - case ast::ImageFormat::kRgba8Uint: - case ast::ImageFormat::kRgba16Uint: - case ast::ImageFormat::kR32Uint: - case ast::ImageFormat::kRg32Uint: - case ast::ImageFormat::kRgba32Uint: + case ast::TexelFormat::kRgba8Uint: + case ast::TexelFormat::kRgba16Uint: + case ast::TexelFormat::kR32Uint: + case ast::TexelFormat::kRg32Uint: + case ast::TexelFormat::kRgba32Uint: return "uint4"; - case ast::ImageFormat::kRgba8Sint: - case ast::ImageFormat::kRgba16Sint: - case ast::ImageFormat::kR32Sint: - case ast::ImageFormat::kRg32Sint: - case ast::ImageFormat::kRgba32Sint: + case ast::TexelFormat::kRgba8Sint: + case ast::TexelFormat::kRgba16Sint: + case ast::TexelFormat::kR32Sint: + case ast::TexelFormat::kRg32Sint: + case ast::TexelFormat::kRgba32Sint: return "int4"; default: return nullptr; @@ -3623,11 +3623,11 @@ bool GeneratorImpl::EmitType(std::ostream& out, } if (storage) { - auto* component = image_format_to_rwtexture_type(storage->image_format()); + auto* component = image_format_to_rwtexture_type(storage->texel_format()); if (component == nullptr) { TINT_ICE(Writer, diagnostics_) - << "Unsupported StorageTexture ImageFormat: " - << static_cast(storage->image_format()); + << "Unsupported StorageTexture TexelFormat: " + << static_cast(storage->texel_format()); return false; } out << "<" << component << ">"; diff --git a/src/writer/hlsl/generator_impl_type_test.cc b/src/writer/hlsl/generator_impl_type_test.cc index 2ed4d66402..5f8f55c638 100644 --- a/src/writer/hlsl/generator_impl_type_test.cc +++ b/src/writer/hlsl/generator_impl_type_test.cc @@ -532,7 +532,7 @@ TEST_F(HlslGeneratorImplTest_Type, EmitMultisampledTexture) { struct HlslStorageTextureData { ast::TextureDimension dim; - ast::ImageFormat imgfmt; + ast::TexelFormat imgfmt; std::string result; }; inline std::ostream& operator<<(std::ostream& out, @@ -561,43 +561,43 @@ INSTANTIATE_TEST_SUITE_P( HlslStorageTexturesTest, testing::Values( HlslStorageTextureData{ - ast::TextureDimension::k1d, ast::ImageFormat::kRgba8Unorm, + ast::TextureDimension::k1d, ast::TexelFormat::kRgba8Unorm, "RWTexture1D tex : register(u1, space2);"}, HlslStorageTextureData{ - ast::TextureDimension::k2d, ast::ImageFormat::kRgba16Float, + ast::TextureDimension::k2d, ast::TexelFormat::kRgba16Float, "RWTexture2D tex : register(u1, space2);"}, HlslStorageTextureData{ - ast::TextureDimension::k2dArray, ast::ImageFormat::kR32Float, + ast::TextureDimension::k2dArray, ast::TexelFormat::kR32Float, "RWTexture2DArray tex : register(u1, space2);"}, HlslStorageTextureData{ - ast::TextureDimension::k3d, ast::ImageFormat::kRg32Float, + ast::TextureDimension::k3d, ast::TexelFormat::kRg32Float, "RWTexture3D tex : register(u1, space2);"}, HlslStorageTextureData{ - ast::TextureDimension::k1d, ast::ImageFormat::kRgba32Float, + ast::TextureDimension::k1d, ast::TexelFormat::kRgba32Float, "RWTexture1D tex : register(u1, space2);"}, HlslStorageTextureData{ - ast::TextureDimension::k2d, ast::ImageFormat::kRgba16Uint, + ast::TextureDimension::k2d, ast::TexelFormat::kRgba16Uint, "RWTexture2D tex : register(u1, space2);"}, HlslStorageTextureData{ - ast::TextureDimension::k2dArray, ast::ImageFormat::kR32Uint, + ast::TextureDimension::k2dArray, ast::TexelFormat::kR32Uint, "RWTexture2DArray tex : register(u1, space2);"}, HlslStorageTextureData{ - ast::TextureDimension::k3d, ast::ImageFormat::kRg32Uint, + ast::TextureDimension::k3d, ast::TexelFormat::kRg32Uint, "RWTexture3D tex : register(u1, space2);"}, HlslStorageTextureData{ - ast::TextureDimension::k1d, ast::ImageFormat::kRgba32Uint, + ast::TextureDimension::k1d, ast::TexelFormat::kRgba32Uint, "RWTexture1D tex : register(u1, space2);"}, HlslStorageTextureData{ast::TextureDimension::k2d, - ast::ImageFormat::kRgba16Sint, + ast::TexelFormat::kRgba16Sint, "RWTexture2D tex : register(u1, space2);"}, HlslStorageTextureData{ - ast::TextureDimension::k2dArray, ast::ImageFormat::kR32Sint, + ast::TextureDimension::k2dArray, ast::TexelFormat::kR32Sint, "RWTexture2DArray tex : register(u1, space2);"}, HlslStorageTextureData{ast::TextureDimension::k3d, - ast::ImageFormat::kRg32Sint, + ast::TexelFormat::kRg32Sint, "RWTexture3D tex : register(u1, space2);"}, HlslStorageTextureData{ - ast::TextureDimension::k1d, ast::ImageFormat::kRgba32Sint, + ast::TextureDimension::k1d, ast::TexelFormat::kRgba32Sint, "RWTexture1D tex : register(u1, space2);"})); } // namespace diff --git a/src/writer/msl/generator_impl_type_test.cc b/src/writer/msl/generator_impl_type_test.cc index f154f64623..9815a58ab5 100644 --- a/src/writer/msl/generator_impl_type_test.cc +++ b/src/writer/msl/generator_impl_type_test.cc @@ -852,7 +852,7 @@ using MslStorageTexturesTest = TestParamHelper; TEST_P(MslStorageTexturesTest, Emit) { auto params = GetParam(); - auto* s = ty.storage_texture(params.dim, ast::ImageFormat::kR32Float, + auto* s = ty.storage_texture(params.dim, ast::TexelFormat::kR32Float, ast::Access::kWrite); Global("test_var", s, ast::DecorationList{ diff --git a/src/writer/spirv/builder.cc b/src/writer/spirv/builder.cc index 1a1d883fa7..19cae1501f 100644 --- a/src/writer/spirv/builder.cc +++ b/src/writer/spirv/builder.cc @@ -3916,17 +3916,17 @@ uint32_t Builder::GenerateTypeIfNeeded(const sem::Type* type) { // the access type. Doing this ensures we de-dupe. type_name_to_id_[builder_ .create( - st->dim(), st->image_format(), + st->dim(), st->texel_format(), ast::Access::kRead, st->type()) ->type_name()] = id; type_name_to_id_[builder_ .create( - st->dim(), st->image_format(), + st->dim(), st->texel_format(), ast::Access::kWrite, st->type()) ->type_name()] = id; type_name_to_id_[builder_ .create( - st->dim(), st->image_format(), + st->dim(), st->texel_format(), ast::Access::kReadWrite, st->type()) ->type_name()] = id; } @@ -4014,7 +4014,7 @@ bool Builder::GenerateTextureType(const sem::Texture* texture, uint32_t format_literal = SpvImageFormat_::SpvImageFormatUnknown; if (auto* t = texture->As()) { - format_literal = convert_image_format_to_spv(t->image_format()); + format_literal = convert_texel_format_to_spv(t->texel_format()); } push_type(spv::Op::OpTypeImage, @@ -4291,99 +4291,99 @@ void Builder::AddInterpolationDecorations(uint32_t id, } } -SpvImageFormat Builder::convert_image_format_to_spv( - const ast::ImageFormat format) { +SpvImageFormat Builder::convert_texel_format_to_spv( + const ast::TexelFormat format) { switch (format) { - case ast::ImageFormat::kR8Unorm: + case ast::TexelFormat::kR8Unorm: push_capability(SpvCapabilityStorageImageExtendedFormats); return SpvImageFormatR8; - case ast::ImageFormat::kR8Snorm: + case ast::TexelFormat::kR8Snorm: push_capability(SpvCapabilityStorageImageExtendedFormats); return SpvImageFormatR8Snorm; - case ast::ImageFormat::kR8Uint: + case ast::TexelFormat::kR8Uint: push_capability(SpvCapabilityStorageImageExtendedFormats); return SpvImageFormatR8ui; - case ast::ImageFormat::kR8Sint: + case ast::TexelFormat::kR8Sint: push_capability(SpvCapabilityStorageImageExtendedFormats); return SpvImageFormatR8i; - case ast::ImageFormat::kR16Uint: + case ast::TexelFormat::kR16Uint: push_capability(SpvCapabilityStorageImageExtendedFormats); return SpvImageFormatR16ui; - case ast::ImageFormat::kR16Sint: + case ast::TexelFormat::kR16Sint: push_capability(SpvCapabilityStorageImageExtendedFormats); return SpvImageFormatR16i; - case ast::ImageFormat::kR16Float: + case ast::TexelFormat::kR16Float: push_capability(SpvCapabilityStorageImageExtendedFormats); return SpvImageFormatR16f; - case ast::ImageFormat::kRg8Unorm: + case ast::TexelFormat::kRg8Unorm: push_capability(SpvCapabilityStorageImageExtendedFormats); return SpvImageFormatRg8; - case ast::ImageFormat::kRg8Snorm: + case ast::TexelFormat::kRg8Snorm: push_capability(SpvCapabilityStorageImageExtendedFormats); return SpvImageFormatRg8Snorm; - case ast::ImageFormat::kRg8Uint: + case ast::TexelFormat::kRg8Uint: push_capability(SpvCapabilityStorageImageExtendedFormats); return SpvImageFormatRg8ui; - case ast::ImageFormat::kRg8Sint: + case ast::TexelFormat::kRg8Sint: push_capability(SpvCapabilityStorageImageExtendedFormats); return SpvImageFormatRg8i; - case ast::ImageFormat::kR32Uint: + case ast::TexelFormat::kR32Uint: return SpvImageFormatR32ui; - case ast::ImageFormat::kR32Sint: + case ast::TexelFormat::kR32Sint: return SpvImageFormatR32i; - case ast::ImageFormat::kR32Float: + case ast::TexelFormat::kR32Float: return SpvImageFormatR32f; - case ast::ImageFormat::kRg16Uint: + case ast::TexelFormat::kRg16Uint: push_capability(SpvCapabilityStorageImageExtendedFormats); return SpvImageFormatRg16ui; - case ast::ImageFormat::kRg16Sint: + case ast::TexelFormat::kRg16Sint: push_capability(SpvCapabilityStorageImageExtendedFormats); return SpvImageFormatRg16i; - case ast::ImageFormat::kRg16Float: + case ast::TexelFormat::kRg16Float: push_capability(SpvCapabilityStorageImageExtendedFormats); return SpvImageFormatRg16f; - case ast::ImageFormat::kRgba8Unorm: + case ast::TexelFormat::kRgba8Unorm: return SpvImageFormatRgba8; - case ast::ImageFormat::kRgba8UnormSrgb: + case ast::TexelFormat::kRgba8UnormSrgb: return SpvImageFormatUnknown; - case ast::ImageFormat::kRgba8Snorm: + case ast::TexelFormat::kRgba8Snorm: return SpvImageFormatRgba8Snorm; - case ast::ImageFormat::kRgba8Uint: + case ast::TexelFormat::kRgba8Uint: return SpvImageFormatRgba8ui; - case ast::ImageFormat::kRgba8Sint: + case ast::TexelFormat::kRgba8Sint: return SpvImageFormatRgba8i; - case ast::ImageFormat::kBgra8Unorm: + case ast::TexelFormat::kBgra8Unorm: return SpvImageFormatUnknown; - case ast::ImageFormat::kBgra8UnormSrgb: + case ast::TexelFormat::kBgra8UnormSrgb: return SpvImageFormatUnknown; - case ast::ImageFormat::kRgb10A2Unorm: + case ast::TexelFormat::kRgb10A2Unorm: push_capability(SpvCapabilityStorageImageExtendedFormats); return SpvImageFormatRgb10A2; - case ast::ImageFormat::kRg11B10Float: + case ast::TexelFormat::kRg11B10Float: push_capability(SpvCapabilityStorageImageExtendedFormats); return SpvImageFormatR11fG11fB10f; - case ast::ImageFormat::kRg32Uint: + case ast::TexelFormat::kRg32Uint: push_capability(SpvCapabilityStorageImageExtendedFormats); return SpvImageFormatRg32ui; - case ast::ImageFormat::kRg32Sint: + case ast::TexelFormat::kRg32Sint: push_capability(SpvCapabilityStorageImageExtendedFormats); return SpvImageFormatRg32i; - case ast::ImageFormat::kRg32Float: + case ast::TexelFormat::kRg32Float: push_capability(SpvCapabilityStorageImageExtendedFormats); return SpvImageFormatRg32f; - case ast::ImageFormat::kRgba16Uint: + case ast::TexelFormat::kRgba16Uint: return SpvImageFormatRgba16ui; - case ast::ImageFormat::kRgba16Sint: + case ast::TexelFormat::kRgba16Sint: return SpvImageFormatRgba16i; - case ast::ImageFormat::kRgba16Float: + case ast::TexelFormat::kRgba16Float: return SpvImageFormatRgba16f; - case ast::ImageFormat::kRgba32Uint: + case ast::TexelFormat::kRgba32Uint: return SpvImageFormatRgba32ui; - case ast::ImageFormat::kRgba32Sint: + case ast::TexelFormat::kRgba32Sint: return SpvImageFormatRgba32i; - case ast::ImageFormat::kRgba32Float: + case ast::TexelFormat::kRgba32Float: return SpvImageFormatRgba32f; - case ast::ImageFormat::kNone: + case ast::TexelFormat::kNone: return SpvImageFormatUnknown; } return SpvImageFormatUnknown; diff --git a/src/writer/spirv/builder.h b/src/writer/spirv/builder.h index fdfc3b30e9..3c08ebe36d 100644 --- a/src/writer/spirv/builder.h +++ b/src/writer/spirv/builder.h @@ -555,10 +555,10 @@ class Builder { const sem::Matrix* type, spv::Op op); - /// Converts AST image format to SPIR-V and pushes an appropriate capability. + /// Converts TexelFormat to SPIR-V and pushes an appropriate capability. /// @param format AST image format type /// @returns SPIR-V image format type - SpvImageFormat convert_image_format_to_spv(const ast::ImageFormat format); + SpvImageFormat convert_texel_format_to_spv(const ast::TexelFormat format); /// Determines if the given type constructor is created from constant values /// @param expr the expression to check diff --git a/src/writer/spirv/builder_format_conversion_test.cc b/src/writer/spirv/builder_format_conversion_test.cc index 8bfbb733df..c7ec41fbfd 100644 --- a/src/writer/spirv/builder_format_conversion_test.cc +++ b/src/writer/spirv/builder_format_conversion_test.cc @@ -21,7 +21,7 @@ namespace spirv { namespace { struct TestData { - ast::ImageFormat ast_format; + ast::TexelFormat ast_format; SpvImageFormat_ spv_format; bool extended_format = false; }; @@ -36,7 +36,7 @@ TEST_P(ImageFormatConversionTest, ImageFormatConversion) { spirv::Builder& b = Build(); - EXPECT_EQ(b.convert_image_format_to_spv(param.ast_format), param.spv_format); + EXPECT_EQ(b.convert_texel_format_to_spv(param.ast_format), param.spv_format); if (param.extended_format) { EXPECT_EQ(DumpInstructions(b.capabilities()), @@ -51,42 +51,42 @@ INSTANTIATE_TEST_SUITE_P( BuilderTest, ImageFormatConversionTest, testing::Values( - TestData{ast::ImageFormat::kR8Unorm, SpvImageFormatR8, true}, - TestData{ast::ImageFormat::kR8Snorm, SpvImageFormatR8Snorm, true}, - TestData{ast::ImageFormat::kR8Uint, SpvImageFormatR8ui, true}, - TestData{ast::ImageFormat::kR8Sint, SpvImageFormatR8i, true}, - TestData{ast::ImageFormat::kR16Uint, SpvImageFormatR16ui, true}, - TestData{ast::ImageFormat::kR16Sint, SpvImageFormatR16i, true}, - TestData{ast::ImageFormat::kR16Float, SpvImageFormatR16f, true}, - TestData{ast::ImageFormat::kRg8Unorm, SpvImageFormatRg8, true}, - TestData{ast::ImageFormat::kRg8Snorm, SpvImageFormatRg8Snorm, true}, - TestData{ast::ImageFormat::kRg8Uint, SpvImageFormatRg8ui, true}, - TestData{ast::ImageFormat::kRg8Sint, SpvImageFormatRg8i, true}, - TestData{ast::ImageFormat::kR32Uint, SpvImageFormatR32ui}, - TestData{ast::ImageFormat::kR32Sint, SpvImageFormatR32i}, - TestData{ast::ImageFormat::kR32Float, SpvImageFormatR32f}, - TestData{ast::ImageFormat::kRg16Uint, SpvImageFormatRg16ui, true}, - TestData{ast::ImageFormat::kRg16Sint, SpvImageFormatRg16i, true}, - TestData{ast::ImageFormat::kRg16Float, SpvImageFormatRg16f, true}, - TestData{ast::ImageFormat::kRgba8Unorm, SpvImageFormatRgba8}, - TestData{ast::ImageFormat::kRgba8UnormSrgb, SpvImageFormatUnknown}, - TestData{ast::ImageFormat::kRgba8Snorm, SpvImageFormatRgba8Snorm}, - TestData{ast::ImageFormat::kRgba8Uint, SpvImageFormatRgba8ui}, - TestData{ast::ImageFormat::kRgba8Sint, SpvImageFormatRgba8i}, - TestData{ast::ImageFormat::kBgra8Unorm, SpvImageFormatUnknown}, - TestData{ast::ImageFormat::kBgra8UnormSrgb, SpvImageFormatUnknown}, - TestData{ast::ImageFormat::kRgb10A2Unorm, SpvImageFormatRgb10A2, true}, - TestData{ast::ImageFormat::kRg11B10Float, SpvImageFormatR11fG11fB10f, + TestData{ast::TexelFormat::kR8Unorm, SpvImageFormatR8, true}, + TestData{ast::TexelFormat::kR8Snorm, SpvImageFormatR8Snorm, true}, + TestData{ast::TexelFormat::kR8Uint, SpvImageFormatR8ui, true}, + TestData{ast::TexelFormat::kR8Sint, SpvImageFormatR8i, true}, + TestData{ast::TexelFormat::kR16Uint, SpvImageFormatR16ui, true}, + TestData{ast::TexelFormat::kR16Sint, SpvImageFormatR16i, true}, + TestData{ast::TexelFormat::kR16Float, SpvImageFormatR16f, true}, + TestData{ast::TexelFormat::kRg8Unorm, SpvImageFormatRg8, true}, + TestData{ast::TexelFormat::kRg8Snorm, SpvImageFormatRg8Snorm, true}, + TestData{ast::TexelFormat::kRg8Uint, SpvImageFormatRg8ui, true}, + TestData{ast::TexelFormat::kRg8Sint, SpvImageFormatRg8i, true}, + TestData{ast::TexelFormat::kR32Uint, SpvImageFormatR32ui}, + TestData{ast::TexelFormat::kR32Sint, SpvImageFormatR32i}, + TestData{ast::TexelFormat::kR32Float, SpvImageFormatR32f}, + TestData{ast::TexelFormat::kRg16Uint, SpvImageFormatRg16ui, true}, + TestData{ast::TexelFormat::kRg16Sint, SpvImageFormatRg16i, true}, + TestData{ast::TexelFormat::kRg16Float, SpvImageFormatRg16f, true}, + TestData{ast::TexelFormat::kRgba8Unorm, SpvImageFormatRgba8}, + TestData{ast::TexelFormat::kRgba8UnormSrgb, SpvImageFormatUnknown}, + TestData{ast::TexelFormat::kRgba8Snorm, SpvImageFormatRgba8Snorm}, + TestData{ast::TexelFormat::kRgba8Uint, SpvImageFormatRgba8ui}, + TestData{ast::TexelFormat::kRgba8Sint, SpvImageFormatRgba8i}, + TestData{ast::TexelFormat::kBgra8Unorm, SpvImageFormatUnknown}, + TestData{ast::TexelFormat::kBgra8UnormSrgb, SpvImageFormatUnknown}, + TestData{ast::TexelFormat::kRgb10A2Unorm, SpvImageFormatRgb10A2, true}, + TestData{ast::TexelFormat::kRg11B10Float, SpvImageFormatR11fG11fB10f, true}, - TestData{ast::ImageFormat::kRg32Uint, SpvImageFormatRg32ui, true}, - TestData{ast::ImageFormat::kRg32Sint, SpvImageFormatRg32i, true}, - TestData{ast::ImageFormat::kRg32Float, SpvImageFormatRg32f, true}, - TestData{ast::ImageFormat::kRgba16Uint, SpvImageFormatRgba16ui}, - TestData{ast::ImageFormat::kRgba16Sint, SpvImageFormatRgba16i}, - TestData{ast::ImageFormat::kRgba16Float, SpvImageFormatRgba16f}, - TestData{ast::ImageFormat::kRgba32Uint, SpvImageFormatRgba32ui}, - TestData{ast::ImageFormat::kRgba32Sint, SpvImageFormatRgba32i}, - TestData{ast::ImageFormat::kRgba32Float, SpvImageFormatRgba32f})); + TestData{ast::TexelFormat::kRg32Uint, SpvImageFormatRg32ui, true}, + TestData{ast::TexelFormat::kRg32Sint, SpvImageFormatRg32i, true}, + TestData{ast::TexelFormat::kRg32Float, SpvImageFormatRg32f, true}, + TestData{ast::TexelFormat::kRgba16Uint, SpvImageFormatRgba16ui}, + TestData{ast::TexelFormat::kRgba16Sint, SpvImageFormatRgba16i}, + TestData{ast::TexelFormat::kRgba16Float, SpvImageFormatRgba16f}, + TestData{ast::TexelFormat::kRgba32Uint, SpvImageFormatRgba32ui}, + TestData{ast::TexelFormat::kRgba32Sint, SpvImageFormatRgba32i}, + TestData{ast::TexelFormat::kRgba32Float, SpvImageFormatRgba32f})); } // namespace } // namespace spirv diff --git a/src/writer/spirv/builder_global_variable_test.cc b/src/writer/spirv/builder_global_variable_test.cc index 9e0cfd1ec9..c372603972 100644 --- a/src/writer/spirv/builder_global_variable_test.cc +++ b/src/writer/spirv/builder_global_variable_test.cc @@ -552,7 +552,7 @@ TEST_F(BuilderTest, GlobalVar_TextureStorageWriteOnly) { // var a : texture_storage_2d; auto* type = - ty.storage_texture(ast::TextureDimension::k2d, ast::ImageFormat::kR32Uint, + ty.storage_texture(ast::TextureDimension::k2d, ast::TexelFormat::kR32Uint, ast::Access::kWrite); auto* var_a = Global("a", type, @@ -585,7 +585,7 @@ TEST_F(BuilderTest, DISABLED_GlobalVar_TextureStorageWithDifferentAccess) { // var b : texture_storage_2d; auto* type_a = - ty.storage_texture(ast::TextureDimension::k2d, ast::ImageFormat::kR32Uint, + ty.storage_texture(ast::TextureDimension::k2d, ast::TexelFormat::kR32Uint, ast::Access::kReadWrite); auto* var_a = Global("a", type_a, ast::StorageClass::kNone, ast::DecorationList{ @@ -594,7 +594,7 @@ TEST_F(BuilderTest, DISABLED_GlobalVar_TextureStorageWithDifferentAccess) { }); auto* type_b = - ty.storage_texture(ast::TextureDimension::k2d, ast::ImageFormat::kR32Uint, + ty.storage_texture(ast::TextureDimension::k2d, ast::TexelFormat::kR32Uint, ast::Access::kWrite); auto* var_b = Global("b", type_b, ast::StorageClass::kNone, ast::DecorationList{ diff --git a/src/writer/spirv/builder_type_test.cc b/src/writer/spirv/builder_type_test.cc index 9988365d16..9eb0815356 100644 --- a/src/writer/spirv/builder_type_test.cc +++ b/src/writer/spirv/builder_type_test.cc @@ -791,7 +791,7 @@ TEST_F(BuilderTest_Type, SampledTexture_Generate_CubeArray) { TEST_F(BuilderTest_Type, StorageTexture_Generate_1d) { auto* s = ty.storage_texture(ast::TextureDimension::k1d, - ast::ImageFormat::kR32Float, ast::Access::kWrite); + ast::TexelFormat::kR32Float, ast::Access::kWrite); Global("test_var", s, ast::DecorationList{ @@ -811,7 +811,7 @@ TEST_F(BuilderTest_Type, StorageTexture_Generate_1d) { TEST_F(BuilderTest_Type, StorageTexture_Generate_2d) { auto* s = ty.storage_texture(ast::TextureDimension::k2d, - ast::ImageFormat::kR32Float, ast::Access::kWrite); + ast::TexelFormat::kR32Float, ast::Access::kWrite); Global("test_var", s, ast::DecorationList{ @@ -831,7 +831,7 @@ TEST_F(BuilderTest_Type, StorageTexture_Generate_2d) { TEST_F(BuilderTest_Type, StorageTexture_Generate_2dArray) { auto* s = ty.storage_texture(ast::TextureDimension::k2dArray, - ast::ImageFormat::kR32Float, ast::Access::kWrite); + ast::TexelFormat::kR32Float, ast::Access::kWrite); Global("test_var", s, ast::DecorationList{ @@ -851,7 +851,7 @@ TEST_F(BuilderTest_Type, StorageTexture_Generate_2dArray) { TEST_F(BuilderTest_Type, StorageTexture_Generate_3d) { auto* s = ty.storage_texture(ast::TextureDimension::k3d, - ast::ImageFormat::kR32Float, ast::Access::kWrite); + ast::TexelFormat::kR32Float, ast::Access::kWrite); Global("test_var", s, ast::DecorationList{ @@ -872,7 +872,7 @@ TEST_F(BuilderTest_Type, StorageTexture_Generate_SampledTypeFloat_Format_r32float) { auto* s = ty.storage_texture(ast::TextureDimension::k2d, - ast::ImageFormat::kR32Float, ast::Access::kWrite); + ast::TexelFormat::kR32Float, ast::Access::kWrite); Global("test_var", s, ast::DecorationList{ @@ -892,7 +892,7 @@ TEST_F(BuilderTest_Type, TEST_F(BuilderTest_Type, StorageTexture_Generate_SampledTypeSint_Format_r32sint) { auto* s = ty.storage_texture(ast::TextureDimension::k2d, - ast::ImageFormat::kR32Sint, ast::Access::kWrite); + ast::TexelFormat::kR32Sint, ast::Access::kWrite); Global("test_var", s, ast::DecorationList{ @@ -912,7 +912,7 @@ TEST_F(BuilderTest_Type, TEST_F(BuilderTest_Type, StorageTexture_Generate_SampledTypeUint_Format_r32uint) { auto* s = ty.storage_texture(ast::TextureDimension::k2d, - ast::ImageFormat::kR32Uint, ast::Access::kWrite); + ast::TexelFormat::kR32Uint, ast::Access::kWrite); Global("test_var", s, ast::DecorationList{ diff --git a/src/writer/wgsl/generator_impl.cc b/src/writer/wgsl/generator_impl.cc index eef9aaaff9..a4c3ed9596 100644 --- a/src/writer/wgsl/generator_impl.cc +++ b/src/writer/wgsl/generator_impl.cc @@ -336,9 +336,9 @@ bool GeneratorImpl::EmitFunction(const ast::Function* func) { } bool GeneratorImpl::EmitImageFormat(std::ostream& out, - const ast::ImageFormat fmt) { + const ast::TexelFormat fmt) { switch (fmt) { - case ast::ImageFormat::kNone: + case ast::TexelFormat::kNone: diagnostics_.add_error(diag::System::Writer, "unknown image format"); return false; default: diff --git a/src/writer/wgsl/generator_impl.h b/src/writer/wgsl/generator_impl.h index a88f2633d0..80c8d9fc0b 100644 --- a/src/writer/wgsl/generator_impl.h +++ b/src/writer/wgsl/generator_impl.h @@ -176,7 +176,7 @@ class GeneratorImpl : public TextGenerator { /// @param out the output of the expression stream /// @param fmt the format to generate /// @returns true if the format is emitted - bool EmitImageFormat(std::ostream& out, const ast::ImageFormat fmt); + bool EmitImageFormat(std::ostream& out, const ast::TexelFormat fmt); /// Handles emitting an access control /// @param out the output of the expression stream /// @param access the access to generate diff --git a/src/writer/wgsl/generator_impl_type_test.cc b/src/writer/wgsl/generator_impl_type_test.cc index 0a075ec6f8..2b8482606a 100644 --- a/src/writer/wgsl/generator_impl_type_test.cc +++ b/src/writer/wgsl/generator_impl_type_test.cc @@ -423,7 +423,7 @@ INSTANTIATE_TEST_SUITE_P(WgslGeneratorImplTest, "texture_multisampled_2d"})); struct StorageTextureData { - ast::ImageFormat fmt; + ast::TexelFormat fmt; ast::TextureDimension dim; ast::Access access; const char* name; @@ -453,21 +453,21 @@ INSTANTIATE_TEST_SUITE_P( WgslGeneratorImplTest, WgslGenerator_StorageTextureTest, testing::Values( - StorageTextureData{ast::ImageFormat::kRgba8Sint, + StorageTextureData{ast::TexelFormat::kRgba8Sint, ast::TextureDimension::k1d, ast::Access::kWrite, "texture_storage_1d"}, - StorageTextureData{ast::ImageFormat::kRgba8Sint, + StorageTextureData{ast::TexelFormat::kRgba8Sint, ast::TextureDimension::k2d, ast::Access::kWrite, "texture_storage_2d"}, - StorageTextureData{ast::ImageFormat::kRgba8Sint, + StorageTextureData{ast::TexelFormat::kRgba8Sint, ast::TextureDimension::k2dArray, ast::Access::kWrite, "texture_storage_2d_array"}, - StorageTextureData{ast::ImageFormat::kRgba8Sint, + StorageTextureData{ast::TexelFormat::kRgba8Sint, ast::TextureDimension::k3d, ast::Access::kWrite, "texture_storage_3d"})); struct ImageFormatData { - ast::ImageFormat fmt; + ast::TexelFormat fmt; const char* name; }; inline std::ostream& operator<<(std::ostream& out, ImageFormatData data) { @@ -489,41 +489,41 @@ INSTANTIATE_TEST_SUITE_P( WgslGeneratorImplTest, WgslGenerator_ImageFormatTest, testing::Values( - ImageFormatData{ast::ImageFormat::kR8Unorm, "r8unorm"}, - ImageFormatData{ast::ImageFormat::kR8Snorm, "r8snorm"}, - ImageFormatData{ast::ImageFormat::kR8Uint, "r8uint"}, - ImageFormatData{ast::ImageFormat::kR8Sint, "r8sint"}, - ImageFormatData{ast::ImageFormat::kR16Uint, "r16uint"}, - ImageFormatData{ast::ImageFormat::kR16Sint, "r16sint"}, - ImageFormatData{ast::ImageFormat::kR16Float, "r16float"}, - ImageFormatData{ast::ImageFormat::kRg8Unorm, "rg8unorm"}, - ImageFormatData{ast::ImageFormat::kRg8Snorm, "rg8snorm"}, - ImageFormatData{ast::ImageFormat::kRg8Uint, "rg8uint"}, - ImageFormatData{ast::ImageFormat::kRg8Sint, "rg8sint"}, - ImageFormatData{ast::ImageFormat::kR32Uint, "r32uint"}, - ImageFormatData{ast::ImageFormat::kR32Sint, "r32sint"}, - ImageFormatData{ast::ImageFormat::kR32Float, "r32float"}, - ImageFormatData{ast::ImageFormat::kRg16Uint, "rg16uint"}, - ImageFormatData{ast::ImageFormat::kRg16Sint, "rg16sint"}, - ImageFormatData{ast::ImageFormat::kRg16Float, "rg16float"}, - ImageFormatData{ast::ImageFormat::kRgba8Unorm, "rgba8unorm"}, - ImageFormatData{ast::ImageFormat::kRgba8UnormSrgb, "rgba8unorm_srgb"}, - ImageFormatData{ast::ImageFormat::kRgba8Snorm, "rgba8snorm"}, - ImageFormatData{ast::ImageFormat::kRgba8Uint, "rgba8uint"}, - ImageFormatData{ast::ImageFormat::kRgba8Sint, "rgba8sint"}, - ImageFormatData{ast::ImageFormat::kBgra8Unorm, "bgra8unorm"}, - ImageFormatData{ast::ImageFormat::kBgra8UnormSrgb, "bgra8unorm_srgb"}, - ImageFormatData{ast::ImageFormat::kRgb10A2Unorm, "rgb10a2unorm"}, - ImageFormatData{ast::ImageFormat::kRg11B10Float, "rg11b10float"}, - ImageFormatData{ast::ImageFormat::kRg32Uint, "rg32uint"}, - ImageFormatData{ast::ImageFormat::kRg32Sint, "rg32sint"}, - ImageFormatData{ast::ImageFormat::kRg32Float, "rg32float"}, - ImageFormatData{ast::ImageFormat::kRgba16Uint, "rgba16uint"}, - ImageFormatData{ast::ImageFormat::kRgba16Sint, "rgba16sint"}, - ImageFormatData{ast::ImageFormat::kRgba16Float, "rgba16float"}, - ImageFormatData{ast::ImageFormat::kRgba32Uint, "rgba32uint"}, - ImageFormatData{ast::ImageFormat::kRgba32Sint, "rgba32sint"}, - ImageFormatData{ast::ImageFormat::kRgba32Float, "rgba32float"})); + ImageFormatData{ast::TexelFormat::kR8Unorm, "r8unorm"}, + ImageFormatData{ast::TexelFormat::kR8Snorm, "r8snorm"}, + ImageFormatData{ast::TexelFormat::kR8Uint, "r8uint"}, + ImageFormatData{ast::TexelFormat::kR8Sint, "r8sint"}, + ImageFormatData{ast::TexelFormat::kR16Uint, "r16uint"}, + ImageFormatData{ast::TexelFormat::kR16Sint, "r16sint"}, + ImageFormatData{ast::TexelFormat::kR16Float, "r16float"}, + ImageFormatData{ast::TexelFormat::kRg8Unorm, "rg8unorm"}, + ImageFormatData{ast::TexelFormat::kRg8Snorm, "rg8snorm"}, + ImageFormatData{ast::TexelFormat::kRg8Uint, "rg8uint"}, + ImageFormatData{ast::TexelFormat::kRg8Sint, "rg8sint"}, + ImageFormatData{ast::TexelFormat::kR32Uint, "r32uint"}, + ImageFormatData{ast::TexelFormat::kR32Sint, "r32sint"}, + ImageFormatData{ast::TexelFormat::kR32Float, "r32float"}, + ImageFormatData{ast::TexelFormat::kRg16Uint, "rg16uint"}, + ImageFormatData{ast::TexelFormat::kRg16Sint, "rg16sint"}, + ImageFormatData{ast::TexelFormat::kRg16Float, "rg16float"}, + ImageFormatData{ast::TexelFormat::kRgba8Unorm, "rgba8unorm"}, + ImageFormatData{ast::TexelFormat::kRgba8UnormSrgb, "rgba8unorm_srgb"}, + ImageFormatData{ast::TexelFormat::kRgba8Snorm, "rgba8snorm"}, + ImageFormatData{ast::TexelFormat::kRgba8Uint, "rgba8uint"}, + ImageFormatData{ast::TexelFormat::kRgba8Sint, "rgba8sint"}, + ImageFormatData{ast::TexelFormat::kBgra8Unorm, "bgra8unorm"}, + ImageFormatData{ast::TexelFormat::kBgra8UnormSrgb, "bgra8unorm_srgb"}, + ImageFormatData{ast::TexelFormat::kRgb10A2Unorm, "rgb10a2unorm"}, + ImageFormatData{ast::TexelFormat::kRg11B10Float, "rg11b10float"}, + ImageFormatData{ast::TexelFormat::kRg32Uint, "rg32uint"}, + ImageFormatData{ast::TexelFormat::kRg32Sint, "rg32sint"}, + ImageFormatData{ast::TexelFormat::kRg32Float, "rg32float"}, + ImageFormatData{ast::TexelFormat::kRgba16Uint, "rgba16uint"}, + ImageFormatData{ast::TexelFormat::kRgba16Sint, "rgba16sint"}, + ImageFormatData{ast::TexelFormat::kRgba16Float, "rgba16float"}, + ImageFormatData{ast::TexelFormat::kRgba32Uint, "rgba32uint"}, + ImageFormatData{ast::TexelFormat::kRgba32Sint, "rgba32sint"}, + ImageFormatData{ast::TexelFormat::kRgba32Float, "rgba32float"})); TEST_F(WgslGeneratorImplTest, EmitType_Sampler) { auto* sampler = ty.sampler(ast::SamplerKind::kSampler); diff --git a/test/BUILD.gn b/test/BUILD.gn index e85e787355..9b72af64b4 100644 --- a/test/BUILD.gn +++ b/test/BUILD.gn @@ -477,7 +477,6 @@ tint_unittests_source_set("tint_unittests_wgsl_reader_src") { "../src/reader/wgsl/parser_impl_global_decl_test.cc", "../src/reader/wgsl/parser_impl_global_variable_decl_test.cc", "../src/reader/wgsl/parser_impl_if_stmt_test.cc", - "../src/reader/wgsl/parser_impl_image_storage_type_test.cc", "../src/reader/wgsl/parser_impl_inclusive_or_expression_test.cc", "../src/reader/wgsl/parser_impl_logical_and_expression_test.cc", "../src/reader/wgsl/parser_impl_logical_or_expression_test.cc", @@ -509,6 +508,7 @@ tint_unittests_source_set("tint_unittests_wgsl_reader_src") { "../src/reader/wgsl/parser_impl_test.cc", "../src/reader/wgsl/parser_impl_test_helper.cc", "../src/reader/wgsl/parser_impl_test_helper.h", + "../src/reader/wgsl/parser_impl_texel_format_test.cc", "../src/reader/wgsl/parser_impl_texture_sampler_types_test.cc", "../src/reader/wgsl/parser_impl_type_alias_test.cc", "../src/reader/wgsl/parser_impl_type_decl_test.cc",