encounter
/
dawn-cmake
mirror of https://github.com/encounter/dawn-cmake.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Move ast/texel_format to type/texel_format. 

This CL moves the texel_format code from ast to type to remove the
dependency on ast from type.

Change-Id: Ie075b2315360dc782284a7b4b55a817a9de31d78
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/117606
Reviewed-by: Ben Clayton <bclayton@google.com>
Kokoro: Kokoro <noreply+kokoro@google.com>
Commit-Queue: Dan Sinclair <dsinclair@chromium.org>
This commit is contained in:
dan sinclair 2023-01-21 23:51:25 +00:00 committed by Dawn LUCI CQ
parent 61c16eb448
commit 57c0bbc2a5
59 changed files with 529 additions and 527 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/tint/BUILD.gn
View File

@ -331,8 +331,6 @@ libtint_source_set("libtint_core_all_src") {
"ast/struct_member_size_attribute.h",
"ast/switch_statement.cc",
"ast/switch_statement.h",
"ast/texel_format.cc",
"ast/texel_format.h",
"ast/texture.cc",
"ast/texture.h",
"ast/traverse_expressions.h",
@ -481,6 +479,7 @@ libtint_source_set("libtint_core_all_src") {
"type/short_name.h",
"type/storage_texture.h",
"type/struct.h",
"type/texel_format.h",
"type/texture.h",
"type/texture_dimension.h",
"type/type.h",
@ -746,6 +745,8 @@ libtint_source_set("libtint_type_src") {
"type/storage_texture.h",
"type/struct.cc",
"type/struct.h",
"type/texel_format.cc",
"type/texel_format.h",
"type/texture.cc",
"type/texture.h",
"type/texture_dimension.cc",
@ -1204,7 +1205,6 @@ if (tint_build_unittests) {
"ast/struct_test.cc",
"ast/switch_statement_test.cc",
"ast/test_helper.h",
"ast/texel_format_test.cc",
"ast/texture_test.cc",
"ast/traverse_expressions_test.cc",
"ast/u32_test.cc",
@ -1343,6 +1343,7 @@ if (tint_build_unittests) {
"type/short_name_test.cc",
"type/storage_texture_test.cc",
"type/struct_test.cc",
"type/texel_format_test.cc",
"type/texture_test.cc",
"type/type_test.cc",
"type/u32_test.cc",

2
src/tint/CMakeLists.txt
View File

@ -569,13 +569,13 @@ list(APPEND TINT_LIB_SRCS
tint_generated(ast/builtin_value BENCH TEST)
tint_generated(ast/extension BENCH TEST)
tint_generated(ast/interpolate_attribute BENCH TEST)
tint_generated(ast/texel_format BENCH TEST)
tint_generated(resolver/init_conv_intrinsic)
tint_generated(sem/builtin_type)
tint_generated(sem/parameter_usage)
tint_generated(type/access BENCH TEST)
tint_generated(type/address_space BENCH TEST)
tint_generated(type/short_name BENCH TEST)
tint_generated(type/texel_format BENCH TEST)
if(UNIX)
list(APPEND TINT_LIB_SRCS diagnostic/printer_posix.cc)

20
src/tint/ast/builtin_texture_helper_test.cc
View File

@ -56,7 +56,7 @@ TextureOverloadCase::TextureOverloadCase(ValidTextureOverload o,
TextureOverloadCase::TextureOverloadCase(ValidTextureOverload o,
const char* d,
type::Access acc,
ast::TexelFormat fmt,
type::TexelFormat fmt,
type::TextureDimension dims,
TextureDataType datatype,
const char* f,
@ -405,7 +405,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
ValidTextureOverload::kDimensionsStorageWO1d,
"textureDimensions(t : texture_storage_1d<rgba32float>) -> u32",
type::Access::kWrite,
ast::TexelFormat::kRgba32Float,
type::TexelFormat::kRgba32Float,
type::TextureDimension::k1d,
TextureDataType::kF32,
"textureDimensions",
@ -415,7 +415,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
ValidTextureOverload::kDimensionsStorageWO2d,
"textureDimensions(t : texture_storage_2d<rgba32float>) -> vec2<u32>",
type::Access::kWrite,
ast::TexelFormat::kRgba32Float,
type::TexelFormat::kRgba32Float,
type::TextureDimension::k2d,
TextureDataType::kF32,
"textureDimensions",
@ -425,7 +425,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
ValidTextureOverload::kDimensionsStorageWO2dArray,
"textureDimensions(t : texture_storage_2d_array<rgba32float>) -> vec2<u32>",
type::Access::kWrite,
ast::TexelFormat::kRgba32Float,
type::TexelFormat::kRgba32Float,
type::TextureDimension::k2dArray,
TextureDataType::kF32,
"textureDimensions",
@ -435,7 +435,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
ValidTextureOverload::kDimensionsStorageWO3d,
"textureDimensions(t : texture_storage_3d<rgba32float>) -> vec3<u32>",
type::Access::kWrite,
ast::TexelFormat::kRgba32Float,
type::TexelFormat::kRgba32Float,
type::TextureDimension::k3d,
TextureDataType::kF32,
"textureDimensions",
@ -828,7 +828,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
ValidTextureOverload::kNumLayersStorageWO2dArray,
"textureNumLayers(t : texture_storage_2d_array<rgba32float>) -> u32",
type::Access::kWrite,
ast::TexelFormat::kRgba32Float,
type::TexelFormat::kRgba32Float,
type::TextureDimension::k2dArray,
TextureDataType::kF32,
"textureNumLayers",
@ -2328,7 +2328,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
" coords : i32,\n"
" value : vec4<T>)",
type::Access::kWrite,
ast::TexelFormat::kRgba32Float,
type::TexelFormat::kRgba32Float,
type::TextureDimension::k1d,
TextureDataType::kF32,
"textureStore",
@ -2344,7 +2344,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
" coords : vec2<i32>,\n"
" value : vec4<T>)",
type::Access::kWrite,
ast::TexelFormat::kRgba32Float,
type::TexelFormat::kRgba32Float,
type::TextureDimension::k2d,
TextureDataType::kF32,
"textureStore",
@ -2361,7 +2361,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
" array_index : u32,\n"
" value : vec4<T>)",
type::Access::kWrite,
ast::TexelFormat::kRgba32Float,
type::TexelFormat::kRgba32Float,
type::TextureDimension::k2dArray,
TextureDataType::kF32,
"textureStore",
@ -2378,7 +2378,7 @@ std::vector<TextureOverloadCase> TextureOverloadCase::ValidCases() {
" coords : vec3<u32>,\n"
" value : vec4<T>)",
type::Access::kWrite,
ast::TexelFormat::kRgba32Float,
type::TexelFormat::kRgba32Float,
type::TextureDimension::k3d,
TextureDataType::kF32,
"textureStore",

4
src/tint/ast/builtin_texture_helper_test.h
View File

@ -202,7 +202,7 @@ struct TextureOverloadCase {
TextureOverloadCase(ValidTextureOverload,
const char*,
type::Access,
ast::TexelFormat,
type::TexelFormat,
type::TextureDimension,
TextureDataType,
const char*,
@ -242,7 +242,7 @@ struct TextureOverloadCase {
type::Access const access = type::Access::kReadWrite;
/// The image format for the storage texture
/// Used only when texture_kind is kStorage
ast::TexelFormat const texel_format = ast::TexelFormat::kUndefined;
type::TexelFormat const texel_format = type::TexelFormat::kUndefined;
/// The dimensions of the texture parameter
type::TextureDimension const texture_dimension;
/// The data type of the texture parameter

40
src/tint/ast/storage_texture.cc
View File

@ -27,7 +27,7 @@ StorageTexture::StorageTexture(ProgramID pid,
NodeID nid,
const Source& src,
type::TextureDimension d,
TexelFormat fmt,
type::TexelFormat fmt,
const Type* subtype,
type::Access ac)
: Base(pid, nid, src, d), format(fmt), type(subtype), access(ac) {}
@ -49,35 +49,35 @@ const StorageTexture* StorageTexture::Clone(CloneContext* ctx) const {
return ctx->dst->create<StorageTexture>(src, dim, format, ty, access);
}
Type* StorageTexture::SubtypeFor(TexelFormat format, ProgramBuilder& builder) {
Type* StorageTexture::SubtypeFor(type::TexelFormat format, ProgramBuilder& builder) {
switch (format) {
case TexelFormat::kR32Uint:
case TexelFormat::kRgba8Uint:
case TexelFormat::kRg32Uint:
case TexelFormat::kRgba16Uint:
case TexelFormat::kRgba32Uint: {
case type::TexelFormat::kR32Uint:
case type::TexelFormat::kRgba8Uint:
case type::TexelFormat::kRg32Uint:
case type::TexelFormat::kRgba16Uint:
case type::TexelFormat::kRgba32Uint: {
return builder.create<U32>();
}
case TexelFormat::kR32Sint:
case TexelFormat::kRgba8Sint:
case TexelFormat::kRg32Sint:
case TexelFormat::kRgba16Sint:
case TexelFormat::kRgba32Sint: {
case type::TexelFormat::kR32Sint:
case type::TexelFormat::kRgba8Sint:
case type::TexelFormat::kRg32Sint:
case type::TexelFormat::kRgba16Sint:
case type::TexelFormat::kRgba32Sint: {
return builder.create<I32>();
}
case TexelFormat::kBgra8Unorm:
case TexelFormat::kRgba8Unorm:
case TexelFormat::kRgba8Snorm:
case TexelFormat::kR32Float:
case TexelFormat::kRg32Float:
case TexelFormat::kRgba16Float:
case TexelFormat::kRgba32Float: {
case type::TexelFormat::kBgra8Unorm:
case type::TexelFormat::kRgba8Unorm:
case type::TexelFormat::kRgba8Snorm:
case type::TexelFormat::kR32Float:
case type::TexelFormat::kRg32Float:
case type::TexelFormat::kRgba16Float:
case type::TexelFormat::kRgba32Float: {
return builder.create<F32>();
}
case TexelFormat::kUndefined:
case type::TexelFormat::kUndefined:
break;
}

10
src/tint/ast/storage_texture.h
View File

@ -17,9 +17,9 @@
#include <string>
#include "src/tint/ast/texel_format.h"
#include "src/tint/ast/texture.h"
#include "src/tint/type/access.h"
#include "src/tint/type/texel_format.h"
#include "src/tint/type/texture_dimension.h"
namespace tint::ast {
@ -39,7 +39,7 @@ class StorageTexture final : public Castable<StorageTexture, Texture> {
NodeID nid,
const Source& src,
type::TextureDimension dim,
TexelFormat format,
type::TexelFormat format,
const Type* subtype,
type::Access access_control);
@ -59,11 +59,11 @@ class StorageTexture final : public Castable<StorageTexture, Texture> {
/// @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 TexelFormat
static Type* SubtypeFor(TexelFormat format, ProgramBuilder& builder);
/// @returns the storage texture subtype for the given type::TexelFormat
static Type* SubtypeFor(type::TexelFormat format, ProgramBuilder& builder);
/// The image format
const TexelFormat format;
const type::TexelFormat format;
/// The storage subtype
const Type* const type;

43
src/tint/ast/storage_texture_test.cc
View File

@ -22,39 +22,40 @@ namespace {
using AstStorageTextureTest = TestHelper;
TEST_F(AstStorageTextureTest, IsTexture) {
auto* subtype = StorageTexture::SubtypeFor(TexelFormat::kRgba32Float, *this);
Texture* ty = create<StorageTexture>(type::TextureDimension::k2dArray,
TexelFormat::kRgba32Float, subtype, type::Access::kRead);
auto* subtype = StorageTexture::SubtypeFor(type::TexelFormat::kRgba32Float, *this);
Texture* ty =
create<StorageTexture>(type::TextureDimension::k2dArray, type::TexelFormat::kRgba32Float,
subtype, type::Access::kRead);
EXPECT_FALSE(ty->Is<DepthTexture>());
EXPECT_FALSE(ty->Is<SampledTexture>());
EXPECT_TRUE(ty->Is<StorageTexture>());
}
TEST_F(AstStorageTextureTest, Dim) {
auto* subtype = StorageTexture::SubtypeFor(TexelFormat::kRgba32Float, *this);
auto* s = create<StorageTexture>(type::TextureDimension::k2dArray, TexelFormat::kRgba32Float,
subtype, type::Access::kRead);
auto* subtype = StorageTexture::SubtypeFor(type::TexelFormat::kRgba32Float, *this);
auto* s = create<StorageTexture>(type::TextureDimension::k2dArray,
type::TexelFormat::kRgba32Float, subtype, type::Access::kRead);
EXPECT_EQ(s->dim, type::TextureDimension::k2dArray);
}
TEST_F(AstStorageTextureTest, Format) {
auto* subtype = StorageTexture::SubtypeFor(TexelFormat::kRgba32Float, *this);
auto* s = create<StorageTexture>(type::TextureDimension::k2dArray, TexelFormat::kRgba32Float,
subtype, type::Access::kRead);
EXPECT_EQ(s->format, TexelFormat::kRgba32Float);
auto* subtype = StorageTexture::SubtypeFor(type::TexelFormat::kRgba32Float, *this);
auto* s = create<StorageTexture>(type::TextureDimension::k2dArray,
type::TexelFormat::kRgba32Float, subtype, type::Access::kRead);
EXPECT_EQ(s->format, type::TexelFormat::kRgba32Float);
}
TEST_F(AstStorageTextureTest, FriendlyName) {
auto* subtype = StorageTexture::SubtypeFor(TexelFormat::kRgba32Float, *this);
auto* s = create<StorageTexture>(type::TextureDimension::k2dArray, TexelFormat::kRgba32Float,
subtype, type::Access::kRead);
auto* subtype = StorageTexture::SubtypeFor(type::TexelFormat::kRgba32Float, *this);
auto* s = create<StorageTexture>(type::TextureDimension::k2dArray,
type::TexelFormat::kRgba32Float, subtype, type::Access::kRead);
EXPECT_EQ(s->FriendlyName(Symbols()), "texture_storage_2d_array<rgba32float, read>");
}
TEST_F(AstStorageTextureTest, F32) {
auto* subtype = StorageTexture::SubtypeFor(TexelFormat::kRgba32Float, *this);
Type* s = create<StorageTexture>(type::TextureDimension::k2dArray, TexelFormat::kRgba32Float,
subtype, type::Access::kRead);
auto* subtype = StorageTexture::SubtypeFor(type::TexelFormat::kRgba32Float, *this);
Type* s = create<StorageTexture>(type::TextureDimension::k2dArray,
type::TexelFormat::kRgba32Float, subtype, type::Access::kRead);
ASSERT_TRUE(s->Is<Texture>());
ASSERT_TRUE(s->Is<StorageTexture>());
@ -62,8 +63,8 @@ TEST_F(AstStorageTextureTest, F32) {
}
TEST_F(AstStorageTextureTest, U32) {
auto* subtype = StorageTexture::SubtypeFor(TexelFormat::kRg32Uint, *this);
Type* s = create<StorageTexture>(type::TextureDimension::k2dArray, TexelFormat::kRg32Uint,
auto* subtype = StorageTexture::SubtypeFor(type::TexelFormat::kRg32Uint, *this);
Type* s = create<StorageTexture>(type::TextureDimension::k2dArray, type::TexelFormat::kRg32Uint,
subtype, type::Access::kRead);
ASSERT_TRUE(s->Is<Texture>());
@ -72,9 +73,9 @@ TEST_F(AstStorageTextureTest, U32) {
}
TEST_F(AstStorageTextureTest, I32) {
auto* subtype = StorageTexture::SubtypeFor(TexelFormat::kRgba32Sint, *this);
Type* s = create<StorageTexture>(type::TextureDimension::k2dArray, TexelFormat::kRgba32Sint,
subtype, type::Access::kRead);
auto* subtype = StorageTexture::SubtypeFor(type::TexelFormat::kRgba32Sint, *this);
Type* s = create<StorageTexture>(type::TextureDimension::k2dArray,
type::TexelFormat::kRgba32Sint, subtype, type::Access::kRead);
ASSERT_TRUE(s->Is<Texture>());
ASSERT_TRUE(s->Is<StorageTexture>());

38
src/tint/inspector/inspector_test.cc
View File

@ -112,7 +112,7 @@ class InspectorGetDepthMultisampledTextureResourceBindingsTest : public Inspecto
public testing::Test {};
typedef std::tuple<type::TextureDimension, ResourceBinding::TextureDimension> DimensionParams;
typedef std::tuple<ast::TexelFormat, ResourceBinding::TexelFormat, ResourceBinding::SampledKind>
typedef std::tuple<type::TexelFormat, ResourceBinding::TexelFormat, ResourceBinding::SampledKind>
TexelFormatParams;
typedef std::tuple<DimensionParams, TexelFormatParams> GetStorageTextureTestParams;
class InspectorGetStorageTextureResourceBindingsTestWithParam
@ -1808,7 +1808,7 @@ TEST_F(InspectorGetResourceBindingsTest, Simple) {
});
auto* st_type =
MakeStorageTextureTypes(type::TextureDimension::k2d, ast::TexelFormat::kR32Uint);
MakeStorageTextureTypes(type::TextureDimension::k2d, type::TexelFormat::kR32Uint);
AddStorageTexture("st_var", st_type, 4, 0);
MakeStorageTextureBodyFunction("st_func", "st_var", ty.vec2<u32>(), utils::Empty);
@ -2970,7 +2970,7 @@ TEST_P(InspectorGetStorageTextureResourceBindingsTestWithParam, Simple) {
ResourceBinding::TextureDimension expected_dim;
std::tie(dim, expected_dim) = dim_params;
ast::TexelFormat format;
type::TexelFormat format;
ResourceBinding::TexelFormat expected_format;
ResourceBinding::SampledKind expected_kind;
std::tie(format, expected_format, expected_kind) = format_params;
@ -3026,52 +3026,52 @@ INSTANTIATE_TEST_SUITE_P(
ResourceBinding::TextureDimension::k2dArray),
std::make_tuple(type::TextureDimension::k3d,
ResourceBinding::TextureDimension::k3d)),
testing::Values(std::make_tuple(ast::TexelFormat::kR32Float,
testing::Values(std::make_tuple(type::TexelFormat::kR32Float,
ResourceBinding::TexelFormat::kR32Float,
ResourceBinding::SampledKind::kFloat),
std::make_tuple(ast::TexelFormat::kR32Sint,
std::make_tuple(type::TexelFormat::kR32Sint,
ResourceBinding::TexelFormat::kR32Sint,
ResourceBinding::SampledKind::kSInt),
std::make_tuple(ast::TexelFormat::kR32Uint,
std::make_tuple(type::TexelFormat::kR32Uint,
ResourceBinding::TexelFormat::kR32Uint,
ResourceBinding::SampledKind::kUInt),
std::make_tuple(ast::TexelFormat::kRg32Float,
std::make_tuple(type::TexelFormat::kRg32Float,
ResourceBinding::TexelFormat::kRg32Float,
ResourceBinding::SampledKind::kFloat),
std::make_tuple(ast::TexelFormat::kRg32Sint,
std::make_tuple(type::TexelFormat::kRg32Sint,
ResourceBinding::TexelFormat::kRg32Sint,
ResourceBinding::SampledKind::kSInt),
std::make_tuple(ast::TexelFormat::kRg32Uint,
std::make_tuple(type::TexelFormat::kRg32Uint,
ResourceBinding::TexelFormat::kRg32Uint,
ResourceBinding::SampledKind::kUInt),
std::make_tuple(ast::TexelFormat::kRgba16Float,
std::make_tuple(type::TexelFormat::kRgba16Float,
ResourceBinding::TexelFormat::kRgba16Float,
ResourceBinding::SampledKind::kFloat),
std::make_tuple(ast::TexelFormat::kRgba16Sint,
std::make_tuple(type::TexelFormat::kRgba16Sint,
ResourceBinding::TexelFormat::kRgba16Sint,
ResourceBinding::SampledKind::kSInt),
std::make_tuple(ast::TexelFormat::kRgba16Uint,
std::make_tuple(type::TexelFormat::kRgba16Uint,
ResourceBinding::TexelFormat::kRgba16Uint,
ResourceBinding::SampledKind::kUInt),
std::make_tuple(ast::TexelFormat::kRgba32Float,
std::make_tuple(type::TexelFormat::kRgba32Float,
ResourceBinding::TexelFormat::kRgba32Float,
ResourceBinding::SampledKind::kFloat),
std::make_tuple(ast::TexelFormat::kRgba32Sint,
std::make_tuple(type::TexelFormat::kRgba32Sint,
ResourceBinding::TexelFormat::kRgba32Sint,
ResourceBinding::SampledKind::kSInt),
std::make_tuple(ast::TexelFormat::kRgba32Uint,
std::make_tuple(type::TexelFormat::kRgba32Uint,
ResourceBinding::TexelFormat::kRgba32Uint,
ResourceBinding::SampledKind::kUInt),
std::make_tuple(ast::TexelFormat::kRgba8Sint,
std::make_tuple(type::TexelFormat::kRgba8Sint,
ResourceBinding::TexelFormat::kRgba8Sint,
ResourceBinding::SampledKind::kSInt),
std::make_tuple(ast::TexelFormat::kRgba8Snorm,
std::make_tuple(type::TexelFormat::kRgba8Snorm,
ResourceBinding::TexelFormat::kRgba8Snorm,
ResourceBinding::SampledKind::kFloat),
std::make_tuple(ast::TexelFormat::kRgba8Uint,
std::make_tuple(type::TexelFormat::kRgba8Uint,
ResourceBinding::TexelFormat::kRgba8Uint,
ResourceBinding::SampledKind::kUInt),
std::make_tuple(ast::TexelFormat::kRgba8Unorm,
std::make_tuple(type::TexelFormat::kRgba8Unorm,
ResourceBinding::TexelFormat::kRgba8Unorm,
ResourceBinding::SampledKind::kFloat))));

38
src/tint/inspector/resource_binding.cc
View File

@ -71,43 +71,43 @@ ResourceBinding::SampledKind BaseTypeToSampledKind(const type::Type* base_type)
}
ResourceBinding::TexelFormat TypeTexelFormatToResourceBindingTexelFormat(
const ast::TexelFormat& image_format) {
const type::TexelFormat& image_format) {
switch (image_format) {
case ast::TexelFormat::kBgra8Unorm:
case type::TexelFormat::kBgra8Unorm:
return ResourceBinding::TexelFormat::kBgra8Unorm;
case ast::TexelFormat::kR32Uint:
case type::TexelFormat::kR32Uint:
return ResourceBinding::TexelFormat::kR32Uint;
case ast::TexelFormat::kR32Sint:
case type::TexelFormat::kR32Sint:
return ResourceBinding::TexelFormat::kR32Sint;
case ast::TexelFormat::kR32Float:
case type::TexelFormat::kR32Float:
return ResourceBinding::TexelFormat::kR32Float;
case ast::TexelFormat::kRgba8Unorm:
case type::TexelFormat::kRgba8Unorm:
return ResourceBinding::TexelFormat::kRgba8Unorm;
case ast::TexelFormat::kRgba8Snorm:
case type::TexelFormat::kRgba8Snorm:
return ResourceBinding::TexelFormat::kRgba8Snorm;
case ast::TexelFormat::kRgba8Uint:
case type::TexelFormat::kRgba8Uint:
return ResourceBinding::TexelFormat::kRgba8Uint;
case ast::TexelFormat::kRgba8Sint:
case type::TexelFormat::kRgba8Sint:
return ResourceBinding::TexelFormat::kRgba8Sint;
case ast::TexelFormat::kRg32Uint:
case type::TexelFormat::kRg32Uint:
return ResourceBinding::TexelFormat::kRg32Uint;
case ast::TexelFormat::kRg32Sint:
case type::TexelFormat::kRg32Sint:
return ResourceBinding::TexelFormat::kRg32Sint;
case ast::TexelFormat::kRg32Float:
case type::TexelFormat::kRg32Float:
return ResourceBinding::TexelFormat::kRg32Float;
case ast::TexelFormat::kRgba16Uint:
case type::TexelFormat::kRgba16Uint:
return ResourceBinding::TexelFormat::kRgba16Uint;
case ast::TexelFormat::kRgba16Sint:
case type::TexelFormat::kRgba16Sint:
return ResourceBinding::TexelFormat::kRgba16Sint;
case ast::TexelFormat::kRgba16Float:
case type::TexelFormat::kRgba16Float:
return ResourceBinding::TexelFormat::kRgba16Float;
case ast::TexelFormat::kRgba32Uint:
case type::TexelFormat::kRgba32Uint:
return ResourceBinding::TexelFormat::kRgba32Uint;
case ast::TexelFormat::kRgba32Sint:
case type::TexelFormat::kRgba32Sint:
return ResourceBinding::TexelFormat::kRgba32Sint;
case ast::TexelFormat::kRgba32Float:
case type::TexelFormat::kRgba32Float:
return ResourceBinding::TexelFormat::kRgba32Float;
case ast::TexelFormat::kUndefined:
case type::TexelFormat::kUndefined:
return ResourceBinding::TexelFormat::kNone;
}
return ResourceBinding::TexelFormat::kNone;

4
src/tint/inspector/resource_binding.h
View File

@ -116,12 +116,12 @@ ResourceBinding::TextureDimension TypeTextureDimensionToResourceBindingTextureDi
/// @returns the publicly visible equivalent
ResourceBinding::SampledKind BaseTypeToSampledKind(const type::Type* base_type);
/// Convert from internal ast::TexelFormat to public
/// Convert from internal type::TexelFormat to public
/// ResourceBinding::TexelFormat
/// @param image_format internal value to convert from
/// @returns the publicly visible equivalent
ResourceBinding::TexelFormat TypeTexelFormatToResourceBindingTexelFormat(
const ast::TexelFormat& image_format);
const type::TexelFormat& image_format);
} // namespace tint::inspector

2
src/tint/inspector/test_inspector_builder.cc
View File

@ -278,7 +278,7 @@ const ast::Type* InspectorBuilder::GetCoordsType(type::TextureDimension dim,
}
const ast::Type* InspectorBuilder::MakeStorageTextureTypes(type::TextureDimension dim,
ast::TexelFormat format) {
type::TexelFormat format) {
return ty.storage_texture(dim, format, type::Access::kWrite);
}

2
src/tint/inspector/test_inspector_builder.h
View File

@ -294,7 +294,7 @@ class InspectorBuilder : public ProgramBuilder {
/// @param dim the texture dimension of the storage texture
/// @param format the texel format of the storage texture
/// @returns the storage texture type
const ast::Type* MakeStorageTextureTypes(type::TextureDimension dim, ast::TexelFormat format);
const ast::Type* MakeStorageTextureTypes(type::TextureDimension dim, type::TexelFormat format);
/// Adds a storage texture variable to the program
/// @param name the name of the variable

4
src/tint/program_builder.h
View File

@ -1082,7 +1082,7 @@ class ProgramBuilder {
/// @param access the access control of the texture
/// @returns the storage texture
const ast::StorageTexture* storage_texture(type::TextureDimension dims,
ast::TexelFormat format,
type::TexelFormat format,
type::Access access) const {
auto* subtype = ast::StorageTexture::SubtypeFor(format, *builder);
return builder->create<ast::StorageTexture>(dims, format, subtype, access);
@ -1095,7 +1095,7 @@ class ProgramBuilder {
/// @returns the storage texture
const ast::StorageTexture* storage_texture(const Source& source,
type::TextureDimension dims,
ast::TexelFormat format,
type::TexelFormat format,
type::Access access) const {
auto* subtype = ast::StorageTexture::SubtypeFor(format, *builder);
return builder->create<ast::StorageTexture>(source, dims, format, subtype, access);

38
src/tint/reader/spirv/enum_converter.cc
View File

@ -130,53 +130,53 @@ type::TextureDimension EnumConverter::ToDim(spv::Dim dim, bool arrayed) {
return type::TextureDimension::kNone;
}
ast::TexelFormat EnumConverter::ToTexelFormat(spv::ImageFormat fmt) {
type::TexelFormat EnumConverter::ToTexelFormat(spv::ImageFormat fmt) {
switch (fmt) {
case spv::ImageFormat::Unknown:
return ast::TexelFormat::kUndefined;
return type::TexelFormat::kUndefined;
// 8 bit channels
case spv::ImageFormat::Rgba8:
return ast::TexelFormat::kRgba8Unorm;
return type::TexelFormat::kRgba8Unorm;
case spv::ImageFormat::Rgba8Snorm:
return ast::TexelFormat::kRgba8Snorm;
return type::TexelFormat::kRgba8Snorm;
case spv::ImageFormat::Rgba8ui:
return ast::TexelFormat::kRgba8Uint;
return type::TexelFormat::kRgba8Uint;
case spv::ImageFormat::Rgba8i:
return ast::TexelFormat::kRgba8Sint;
return type::TexelFormat::kRgba8Sint;
// 16 bit channels
case spv::ImageFormat::Rgba16ui:
return ast::TexelFormat::kRgba16Uint;
return type::TexelFormat::kRgba16Uint;
case spv::ImageFormat::Rgba16i:
return ast::TexelFormat::kRgba16Sint;
return type::TexelFormat::kRgba16Sint;
case spv::ImageFormat::Rgba16f:
return ast::TexelFormat::kRgba16Float;
return type::TexelFormat::kRgba16Float;
// 32 bit channels
case spv::ImageFormat::R32ui:
return ast::TexelFormat::kR32Uint;
return type::TexelFormat::kR32Uint;
case spv::ImageFormat::R32i:
return ast::TexelFormat::kR32Sint;
return type::TexelFormat::kR32Sint;
case spv::ImageFormat::R32f:
return ast::TexelFormat::kR32Float;
return type::TexelFormat::kR32Float;
case spv::ImageFormat::Rg32ui:
return ast::TexelFormat::kRg32Uint;
return type::TexelFormat::kRg32Uint;
case spv::ImageFormat::Rg32i:
return ast::TexelFormat::kRg32Sint;
return type::TexelFormat::kRg32Sint;
case spv::ImageFormat::Rg32f:
return ast::TexelFormat::kRg32Float;
return type::TexelFormat::kRg32Float;
case spv::ImageFormat::Rgba32ui:
return ast::TexelFormat::kRgba32Uint;
return type::TexelFormat::kRgba32Uint;
case spv::ImageFormat::Rgba32i:
return ast::TexelFormat::kRgba32Sint;
return type::TexelFormat::kRgba32Sint;
case spv::ImageFormat::Rgba32f:
return ast::TexelFormat::kRgba32Float;
return type::TexelFormat::kRgba32Float;
default:
break;
}
Fail() << "invalid image format: " << int(fmt);
return ast::TexelFormat::kUndefined;
return type::TexelFormat::kUndefined;
}
} // namespace tint::reader::spirv

4
src/tint/reader/spirv/enum_converter.h
View File

@ -73,13 +73,13 @@ class EnumConverter {
/// On failure, logs an error and returns kNone
/// @param fmt the SPIR-V format
/// @returns a Tint AST format
ast::TexelFormat ToTexelFormat(spv::ImageFormat fmt);
type::TexelFormat ToTexelFormat(spv::ImageFormat fmt);
/// 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::TexelFormat ToTexelFormat(SpvImageFormat fmt) {
type::TexelFormat ToTexelFormat(SpvImageFormat fmt) {
return ToTexelFormat(static_cast<spv::ImageFormat>(fmt));
}

70
src/tint/reader/spirv/enum_converter_test.cc
View File

@ -288,7 +288,7 @@ INSTANTIATE_TEST_SUITE_P(
struct TexelFormatCase {
spv::ImageFormat format;
bool expect_success;
ast::TexelFormat expected;
type::TexelFormat expected;
};
inline std::ostream& operator<<(std::ostream& out, TexelFormatCase ifc) {
out << "TexelFormatCase{ spv::ImageFormat:::" << int(ifc.format)
@ -330,52 +330,52 @@ INSTANTIATE_TEST_SUITE_P(
SpvImageFormatTest,
testing::Values(
// Unknown. This is used for sampled images.
TexelFormatCase{spv::ImageFormat::Unknown, true, ast::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::Unknown, true, type::TexelFormat::kUndefined},
// 8 bit channels
TexelFormatCase{spv::ImageFormat::Rgba8, true, ast::TexelFormat::kRgba8Unorm},
TexelFormatCase{spv::ImageFormat::Rgba8Snorm, true, ast::TexelFormat::kRgba8Snorm},
TexelFormatCase{spv::ImageFormat::Rgba8ui, true, ast::TexelFormat::kRgba8Uint},
TexelFormatCase{spv::ImageFormat::Rgba8i, true, ast::TexelFormat::kRgba8Sint},
TexelFormatCase{spv::ImageFormat::Rgba8, true, type::TexelFormat::kRgba8Unorm},
TexelFormatCase{spv::ImageFormat::Rgba8Snorm, true, type::TexelFormat::kRgba8Snorm},
TexelFormatCase{spv::ImageFormat::Rgba8ui, true, type::TexelFormat::kRgba8Uint},
TexelFormatCase{spv::ImageFormat::Rgba8i, true, type::TexelFormat::kRgba8Sint},
// 16 bit channels
TexelFormatCase{spv::ImageFormat::Rgba16ui, true, ast::TexelFormat::kRgba16Uint},
TexelFormatCase{spv::ImageFormat::Rgba16i, true, ast::TexelFormat::kRgba16Sint},
TexelFormatCase{spv::ImageFormat::Rgba16f, true, ast::TexelFormat::kRgba16Float},
TexelFormatCase{spv::ImageFormat::Rgba16ui, true, type::TexelFormat::kRgba16Uint},
TexelFormatCase{spv::ImageFormat::Rgba16i, true, type::TexelFormat::kRgba16Sint},
TexelFormatCase{spv::ImageFormat::Rgba16f, true, type::TexelFormat::kRgba16Float},
// 32 bit channels
// ... 1 channel
TexelFormatCase{spv::ImageFormat::R32ui, true, ast::TexelFormat::kR32Uint},
TexelFormatCase{spv::ImageFormat::R32i, true, ast::TexelFormat::kR32Sint},
TexelFormatCase{spv::ImageFormat::R32f, true, ast::TexelFormat::kR32Float},
TexelFormatCase{spv::ImageFormat::R32ui, true, type::TexelFormat::kR32Uint},
TexelFormatCase{spv::ImageFormat::R32i, true, type::TexelFormat::kR32Sint},
TexelFormatCase{spv::ImageFormat::R32f, true, type::TexelFormat::kR32Float},
// ... 2 channels
TexelFormatCase{spv::ImageFormat::Rg32ui, true, ast::TexelFormat::kRg32Uint},
TexelFormatCase{spv::ImageFormat::Rg32i, true, ast::TexelFormat::kRg32Sint},
TexelFormatCase{spv::ImageFormat::Rg32f, true, ast::TexelFormat::kRg32Float},
TexelFormatCase{spv::ImageFormat::Rg32ui, true, type::TexelFormat::kRg32Uint},
TexelFormatCase{spv::ImageFormat::Rg32i, true, type::TexelFormat::kRg32Sint},
TexelFormatCase{spv::ImageFormat::Rg32f, true, type::TexelFormat::kRg32Float},
// ... 4 channels
TexelFormatCase{spv::ImageFormat::Rgba32ui, true, ast::TexelFormat::kRgba32Uint},
TexelFormatCase{spv::ImageFormat::Rgba32i, true, ast::TexelFormat::kRgba32Sint},
TexelFormatCase{spv::ImageFormat::Rgba32f, true, ast::TexelFormat::kRgba32Float}));
TexelFormatCase{spv::ImageFormat::Rgba32ui, true, type::TexelFormat::kRgba32Uint},
TexelFormatCase{spv::ImageFormat::Rgba32i, true, type::TexelFormat::kRgba32Sint},
TexelFormatCase{spv::ImageFormat::Rgba32f, true, type::TexelFormat::kRgba32Float}));
INSTANTIATE_TEST_SUITE_P(
EnumConverterBad,
SpvImageFormatTest,
testing::Values(
// Scanning in order from the SPIR-V spec.
TexelFormatCase{spv::ImageFormat::Rg16f, false, ast::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::R11fG11fB10f, false, ast::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::R16f, false, ast::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::Rgb10A2, false, ast::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::Rg16, false, ast::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::Rg8, false, ast::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::R16, false, ast::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::R8, false, ast::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::Rgba16Snorm, false, ast::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::Rg16Snorm, false, ast::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::Rg8Snorm, false, ast::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::Rg16i, false, ast::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::Rg8i, false, ast::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::R8i, false, ast::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::Rgb10a2ui, false, ast::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::Rg16ui, false, ast::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::Rg8ui, false, ast::TexelFormat::kUndefined}));
TexelFormatCase{spv::ImageFormat::Rg16f, false, type::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::R11fG11fB10f, false, type::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::R16f, false, type::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::Rgb10A2, false, type::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::Rg16, false, type::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::Rg8, false, type::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::R16, false, type::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::R8, false, type::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::Rgba16Snorm, false, type::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::Rg16Snorm, false, type::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::Rg8Snorm, false, type::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::Rg16i, false, type::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::Rg8i, false, type::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::R8i, false, type::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::Rgb10a2ui, false, type::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::Rg16ui, false, type::TexelFormat::kUndefined},
TexelFormatCase{spv::ImageFormat::Rg8ui, false, type::TexelFormat::kUndefined}));
} // namespace
} // namespace tint::reader::spirv

72
src/tint/reader/spirv/parser_impl.cc
View File

@ -2520,7 +2520,7 @@ const Type* ParserImpl::GetHandleTypeForSpirvHandle(const spvtools::opt::Instruc
} else {
const auto access = type::Access::kWrite;
const auto format = enum_converter_.ToTexelFormat(image_type->format());
if (format == ast::TexelFormat::kUndefined) {
if (format == type::TexelFormat::kUndefined) {
return nullptr;
}
ast_handle_type = ty_.StorageTexture(dim, format, access);
@ -2537,28 +2537,28 @@ const Type* ParserImpl::GetHandleTypeForSpirvHandle(const spvtools::opt::Instruc
return ast_handle_type;
}
const Type* ParserImpl::GetComponentTypeForFormat(ast::TexelFormat format) {
const Type* ParserImpl::GetComponentTypeForFormat(type::TexelFormat format) {
switch (format) {
case ast::TexelFormat::kR32Uint:
case ast::TexelFormat::kRgba8Uint:
case ast::TexelFormat::kRg32Uint:
case ast::TexelFormat::kRgba16Uint:
case ast::TexelFormat::kRgba32Uint:
case type::TexelFormat::kR32Uint:
case type::TexelFormat::kRgba8Uint:
case type::TexelFormat::kRg32Uint:
case type::TexelFormat::kRgba16Uint:
case type::TexelFormat::kRgba32Uint:
return ty_.U32();
case ast::TexelFormat::kR32Sint:
case ast::TexelFormat::kRgba8Sint:
case ast::TexelFormat::kRg32Sint:
case ast::TexelFormat::kRgba16Sint:
case ast::TexelFormat::kRgba32Sint:
case type::TexelFormat::kR32Sint:
case type::TexelFormat::kRgba8Sint:
case type::TexelFormat::kRg32Sint:
case type::TexelFormat::kRgba16Sint:
case type::TexelFormat::kRgba32Sint:
return ty_.I32();
case ast::TexelFormat::kRgba8Unorm:
case ast::TexelFormat::kRgba8Snorm:
case ast::TexelFormat::kR32Float:
case ast::TexelFormat::kRg32Float:
case ast::TexelFormat::kRgba16Float:
case ast::TexelFormat::kRgba32Float:
case type::TexelFormat::kRgba8Unorm:
case type::TexelFormat::kRgba8Snorm:
case type::TexelFormat::kR32Float:
case type::TexelFormat::kRg32Float:
case type::TexelFormat::kRgba16Float:
case type::TexelFormat::kRgba32Float:
return ty_.F32();
default:
break;
@ -2567,30 +2567,30 @@ const Type* ParserImpl::GetComponentTypeForFormat(ast::TexelFormat format) {
return nullptr;
}
unsigned ParserImpl::GetChannelCountForFormat(ast::TexelFormat format) {
unsigned ParserImpl::GetChannelCountForFormat(type::TexelFormat format) {
switch (format) {
case ast::TexelFormat::kR32Float:
case ast::TexelFormat::kR32Sint:
case ast::TexelFormat::kR32Uint:
case type::TexelFormat::kR32Float:
case type::TexelFormat::kR32Sint:
case type::TexelFormat::kR32Uint:
// One channel
return 1;
case ast::TexelFormat::kRg32Float:
case ast::TexelFormat::kRg32Sint:
case ast::TexelFormat::kRg32Uint:
case type::TexelFormat::kRg32Float:
case type::TexelFormat::kRg32Sint:
case type::TexelFormat::kRg32Uint:
// Two channels
return 2;
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 type::TexelFormat::kRgba16Float:
case type::TexelFormat::kRgba16Sint:
case type::TexelFormat::kRgba16Uint:
case type::TexelFormat::kRgba32Float:
case type::TexelFormat::kRgba32Sint:
case type::TexelFormat::kRgba32Uint:
case type::TexelFormat::kRgba8Sint:
case type::TexelFormat::kRgba8Snorm:
case type::TexelFormat::kRgba8Uint:
case type::TexelFormat::kRgba8Unorm:
// Four channels
return 4;
@ -2601,7 +2601,7 @@ unsigned ParserImpl::GetChannelCountForFormat(ast::TexelFormat format) {
return 0;
}
const Type* ParserImpl::GetTexelTypeForFormat(ast::TexelFormat format) {
const Type* ParserImpl::GetTexelTypeForFormat(type::TexelFormat format) {
const auto* component_type = GetComponentTypeForFormat(format);
if (!component_type) {
return nullptr;

6
src/tint/reader/spirv/parser_impl.h
View File

@ -672,19 +672,19 @@ class ParserImpl : Reader {
/// format.
/// @param format image texel format
/// @returns the component type, one of f32, i32, u32
const Type* GetComponentTypeForFormat(ast::TexelFormat format);
const Type* GetComponentTypeForFormat(type::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::TexelFormat format);
unsigned GetChannelCountForFormat(type::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::TexelFormat format);
const Type* GetTexelTypeForFormat(type::TexelFormat format);
/// Returns the SPIR-V instruction with the given ID, or nullptr.
/// @param id the SPIR-V result ID

4
src/tint/reader/spirv/parser_type.cc
View File

@ -255,7 +255,7 @@ const ast::Type* SampledTexture::Build(ProgramBuilder& b) const {
return b.ty.sampled_texture(dims, type->Build(b));
}
StorageTexture::StorageTexture(type::TextureDimension d, ast::TexelFormat f, type::Access a)
StorageTexture::StorageTexture(type::TextureDimension d, type::TexelFormat f, type::Access a)
: Base(d), format(f), access(a) {}
StorageTexture::StorageTexture(const StorageTexture&) = default;
@ -515,7 +515,7 @@ const spirv::SampledTexture* TypeManager::SampledTexture(type::TextureDimension
}
const spirv::StorageTexture* TypeManager::StorageTexture(type::TextureDimension dims,
ast::TexelFormat fmt,
type::TexelFormat fmt,
type::Access access) {
return state->storage_textures_.Get(dims, fmt, access);
}

6
src/tint/reader/spirv/parser_type.h
View File

@ -435,7 +435,7 @@ struct StorageTexture final : public Castable<StorageTexture, Texture> {
/// @param d the texture dimensions
/// @param f the storage image format
/// @param a the access control
StorageTexture(type::TextureDimension d, ast::TexelFormat f, type::Access a);
StorageTexture(type::TextureDimension d, type::TexelFormat f, type::Access a);
/// Copy constructor
/// @param other the other type to copy
@ -451,7 +451,7 @@ struct StorageTexture final : public Castable<StorageTexture, Texture> {
#endif // NDEBUG
/// the storage image format
ast::TexelFormat const format;
type::TexelFormat const format;
/// the access control
type::Access const access;
@ -616,7 +616,7 @@ class TypeManager {
/// @return a StorageTexture type. Repeated calls with the same arguments will
/// return the same pointer.
const spirv::StorageTexture* StorageTexture(type::TextureDimension d,
ast::TexelFormat f,
type::TexelFormat f,
type::Access a);
private:

16
src/tint/reader/spirv/parser_type_test.cc
View File

@ -43,9 +43,9 @@ TEST(SpvParserTypeTest, SameArgumentsGivesSamePointer) {
ty.MultisampledTexture(type::TextureDimension::k2d, ty.I32()));
EXPECT_EQ(ty.SampledTexture(type::TextureDimension::k2d, ty.I32()),
ty.SampledTexture(type::TextureDimension::k2d, ty.I32()));
EXPECT_EQ(ty.StorageTexture(type::TextureDimension::k2d, ast::TexelFormat::kR32Uint,
EXPECT_EQ(ty.StorageTexture(type::TextureDimension::k2d, type::TexelFormat::kR32Uint,
type::Access::kRead),
ty.StorageTexture(type::TextureDimension::k2d, ast::TexelFormat::kR32Uint,
ty.StorageTexture(type::TextureDimension::k2d, type::TexelFormat::kR32Uint,
type::Access::kRead));
}
@ -80,17 +80,17 @@ TEST(SpvParserTypeTest, DifferentArgumentsGivesDifferentPointer) {
ty.SampledTexture(type::TextureDimension::k3d, ty.I32()));
EXPECT_NE(ty.SampledTexture(type::TextureDimension::k2d, ty.I32()),
ty.SampledTexture(type::TextureDimension::k2d, ty.U32()));
EXPECT_NE(ty.StorageTexture(type::TextureDimension::k2d, ast::TexelFormat::kR32Uint,
EXPECT_NE(ty.StorageTexture(type::TextureDimension::k2d, type::TexelFormat::kR32Uint,
type::Access::kRead),
ty.StorageTexture(type::TextureDimension::k3d, ast::TexelFormat::kR32Uint,
ty.StorageTexture(type::TextureDimension::k3d, type::TexelFormat::kR32Uint,
type::Access::kRead));
EXPECT_NE(ty.StorageTexture(type::TextureDimension::k2d, ast::TexelFormat::kR32Uint,
EXPECT_NE(ty.StorageTexture(type::TextureDimension::k2d, type::TexelFormat::kR32Uint,
type::Access::kRead),
ty.StorageTexture(type::TextureDimension::k2d, ast::TexelFormat::kR32Sint,
ty.StorageTexture(type::TextureDimension::k2d, type::TexelFormat::kR32Sint,
type::Access::kRead));
EXPECT_NE(ty.StorageTexture(type::TextureDimension::k2d, ast::TexelFormat::kR32Uint,
EXPECT_NE(ty.StorageTexture(type::TextureDimension::k2d, type::TexelFormat::kR32Uint,
type::Access::kRead),
ty.StorageTexture(type::TextureDimension::k2d, ast::TexelFormat::kR32Uint,
ty.StorageTexture(type::TextureDimension::k2d, type::TexelFormat::kR32Uint,
type::Access::kWrite));
}

6
src/tint/reader/wgsl/parser_impl.cc
View File

@ -754,7 +754,7 @@ Maybe<const ast::Type*> ParserImpl::texture_and_sampler_types() {
auto storage = storage_texture_type();
if (storage.matched) {
const char* use = "storage texture type";
using StorageTextureInfo = std::pair<tint::ast::TexelFormat, tint::type::Access>;
using StorageTextureInfo = std::pair<tint::type::TexelFormat, tint::type::Access>;
auto params = expect_lt_gt_block(use, [&]() -> Expect<StorageTextureInfo> {
auto format = expect_texel_format(use);
if (format.errored) {
@ -921,8 +921,8 @@ Maybe<const ast::Type*> ParserImpl::depth_texture_type() {
// | 'rgba32uint'
// | 'rgba32sint'
// | 'rgba32float'
Expect<ast::TexelFormat> ParserImpl::expect_texel_format(std::string_view use) {
return expect_enum("texel format", ast::ParseTexelFormat, ast::kTexelFormatStrings, use);
Expect<type::TexelFormat> ParserImpl::expect_texel_format(std::string_view use) {
return expect_enum("texel format", type::ParseTexelFormat, type::kTexelFormatStrings, use);
}
Expect<ParserImpl::TypedIdentifier> ParserImpl::expect_ident_with_optional_type_specifier(

2
src/tint/reader/wgsl/parser_impl.h
View File

@ -504,7 +504,7 @@ class ParserImpl {
/// Parses a `texel_format` grammar element
/// @param use a description of what was being parsed if an error was raised
/// @returns returns the texel format or kNone if none matched.
Expect<ast::TexelFormat> expect_texel_format(std::string_view use);
Expect<type::TexelFormat> expect_texel_format(std::string_view use);
/// Parses a `static_assert_statement` grammar element
/// @returns returns the static assert, if it matched.
Maybe<const ast::StaticAssert*> static_assert_statement();

32
src/tint/reader/wgsl/parser_impl_texel_format_test.cc
View File

@ -30,7 +30,7 @@ TEST_F(ParserImplTest, TexelFormat_R32Uint) {
auto p = parser("r32uint");
auto t = p->expect_texel_format("test");
EXPECT_FALSE(t.errored);
EXPECT_EQ(t.value, ast::TexelFormat::kR32Uint);
EXPECT_EQ(t.value, type::TexelFormat::kR32Uint);
EXPECT_FALSE(p->has_error());
}
@ -38,7 +38,7 @@ TEST_F(ParserImplTest, TexelFormat_R32Sint) {
auto p = parser("r32sint");
auto t = p->expect_texel_format("test");
EXPECT_FALSE(t.errored);
EXPECT_EQ(t.value, ast::TexelFormat::kR32Sint);
EXPECT_EQ(t.value, type::TexelFormat::kR32Sint);
EXPECT_FALSE(p->has_error());
}
@ -46,7 +46,7 @@ TEST_F(ParserImplTest, TexelFormat_R32Float) {
auto p = parser("r32float");
auto t = p->expect_texel_format("test");
EXPECT_FALSE(t.errored);
EXPECT_EQ(t.value, ast::TexelFormat::kR32Float);
EXPECT_EQ(t.value, type::TexelFormat::kR32Float);
EXPECT_FALSE(p->has_error());
}
@ -54,7 +54,7 @@ TEST_F(ParserImplTest, TexelFormat_Rgba8Unorm) {
auto p = parser("rgba8unorm");
auto t = p->expect_texel_format("test");
EXPECT_FALSE(t.errored);
EXPECT_EQ(t.value, ast::TexelFormat::kRgba8Unorm);
EXPECT_EQ(t.value, type::TexelFormat::kRgba8Unorm);
EXPECT_FALSE(p->has_error());
}
@ -62,7 +62,7 @@ TEST_F(ParserImplTest, TexelFormat_Rgba8Snorm) {
auto p = parser("rgba8snorm");
auto t = p->expect_texel_format("test");
EXPECT_FALSE(t.errored);
EXPECT_EQ(t.value, ast::TexelFormat::kRgba8Snorm);
EXPECT_EQ(t.value, type::TexelFormat::kRgba8Snorm);
EXPECT_FALSE(p->has_error());
}
@ -70,7 +70,7 @@ TEST_F(ParserImplTest, TexelFormat_Rgba8Uint) {
auto p = parser("rgba8uint");
auto t = p->expect_texel_format("test");
EXPECT_FALSE(t.errored);
EXPECT_EQ(t.value, ast::TexelFormat::kRgba8Uint);
EXPECT_EQ(t.value, type::TexelFormat::kRgba8Uint);
EXPECT_FALSE(p->has_error());
}
@ -78,7 +78,7 @@ TEST_F(ParserImplTest, TexelFormat_Rgba8Sint) {
auto p = parser("rgba8sint");
auto t = p->expect_texel_format("test");
EXPECT_FALSE(t.errored);
EXPECT_EQ(t.value, ast::TexelFormat::kRgba8Sint);
EXPECT_EQ(t.value, type::TexelFormat::kRgba8Sint);
EXPECT_FALSE(p->has_error());
}
@ -86,7 +86,7 @@ TEST_F(ParserImplTest, TexelFormat_Rg32Uint) {
auto p = parser("rg32uint");
auto t = p->expect_texel_format("test");
EXPECT_FALSE(t.errored);
EXPECT_EQ(t.value, ast::TexelFormat::kRg32Uint);
EXPECT_EQ(t.value, type::TexelFormat::kRg32Uint);
EXPECT_FALSE(p->has_error());
}
@ -94,7 +94,7 @@ TEST_F(ParserImplTest, TexelFormat_Rg32Sint) {
auto p = parser("rg32sint");
auto t = p->expect_texel_format("test");
EXPECT_FALSE(t.errored);
EXPECT_EQ(t.value, ast::TexelFormat::kRg32Sint);
EXPECT_EQ(t.value, type::TexelFormat::kRg32Sint);
EXPECT_FALSE(p->has_error());
}
@ -102,7 +102,7 @@ TEST_F(ParserImplTest, TexelFormat_Rg32Float) {
auto p = parser("rg32float");
auto t = p->expect_texel_format("test");
EXPECT_FALSE(t.errored);
EXPECT_EQ(t.value, ast::TexelFormat::kRg32Float);
EXPECT_EQ(t.value, type::TexelFormat::kRg32Float);
EXPECT_FALSE(p->has_error());
}
@ -110,7 +110,7 @@ TEST_F(ParserImplTest, TexelFormat_Rgba16Uint) {
auto p = parser("rgba16uint");
auto t = p->expect_texel_format("test");
EXPECT_FALSE(t.errored);
EXPECT_EQ(t.value, ast::TexelFormat::kRgba16Uint);
EXPECT_EQ(t.value, type::TexelFormat::kRgba16Uint);
EXPECT_FALSE(p->has_error());
}
@ -118,7 +118,7 @@ TEST_F(ParserImplTest, TexelFormat_Rgba16Sint) {
auto p = parser("rgba16sint");
auto t = p->expect_texel_format("test");
EXPECT_FALSE(t.errored);
EXPECT_EQ(t.value, ast::TexelFormat::kRgba16Sint);
EXPECT_EQ(t.value, type::TexelFormat::kRgba16Sint);
EXPECT_FALSE(p->has_error());
}
@ -126,7 +126,7 @@ TEST_F(ParserImplTest, TexelFormat_Rgba16Float) {
auto p = parser("rgba16float");
auto t = p->expect_texel_format("test");
EXPECT_FALSE(t.errored);
EXPECT_EQ(t.value, ast::TexelFormat::kRgba16Float);
EXPECT_EQ(t.value, type::TexelFormat::kRgba16Float);
EXPECT_FALSE(p->has_error());
}
@ -134,7 +134,7 @@ TEST_F(ParserImplTest, TexelFormat_Rgba32Uint) {
auto p = parser("rgba32uint");
auto t = p->expect_texel_format("test");
EXPECT_FALSE(t.errored);
EXPECT_EQ(t.value, ast::TexelFormat::kRgba32Uint);
EXPECT_EQ(t.value, type::TexelFormat::kRgba32Uint);
EXPECT_FALSE(p->has_error());
}
@ -142,7 +142,7 @@ TEST_F(ParserImplTest, TexelFormat_Rgba32Sint) {
auto p = parser("rgba32sint");
auto t = p->expect_texel_format("test");
EXPECT_FALSE(t.errored);
EXPECT_EQ(t.value, ast::TexelFormat::kRgba32Sint);
EXPECT_EQ(t.value, type::TexelFormat::kRgba32Sint);
EXPECT_FALSE(p->has_error());
}
@ -150,7 +150,7 @@ TEST_F(ParserImplTest, TexelFormat_Rgba32Float) {
auto p = parser("rgba32float");
auto t = p->expect_texel_format("test");
EXPECT_FALSE(t.errored);
EXPECT_EQ(t.value, ast::TexelFormat::kRgba32Float);
EXPECT_EQ(t.value, type::TexelFormat::kRgba32Float);
EXPECT_FALSE(p->has_error());
}

4
src/tint/reader/wgsl/parser_impl_texture_sampler_test.cc
View File

@ -191,7 +191,7 @@ TEST_F(ParserImplTest, TextureSamplerTypes_StorageTexture_Readonly1dRg32Float) {
ASSERT_TRUE(t->Is<ast::Texture>());
ASSERT_TRUE(t->Is<ast::StorageTexture>());
EXPECT_EQ(t->As<ast::StorageTexture>()->format, ast::TexelFormat::kRg32Float);
EXPECT_EQ(t->As<ast::StorageTexture>()->format, type::TexelFormat::kRg32Float);
EXPECT_EQ(t->As<ast::StorageTexture>()->access, type::Access::kRead);
EXPECT_EQ(t->As<ast::Texture>()->dim, type::TextureDimension::k1d);
EXPECT_EQ(t->source.range, (Source::Range{{1u, 1u}, {1u, 36u}}));
@ -207,7 +207,7 @@ TEST_F(ParserImplTest, TextureSamplerTypes_StorageTexture_Writeonly2dR32Uint) {
ASSERT_TRUE(t->Is<ast::Texture>());
ASSERT_TRUE(t->Is<ast::StorageTexture>());
EXPECT_EQ(t->As<ast::StorageTexture>()->format, ast::TexelFormat::kR32Uint);
EXPECT_EQ(t->As<ast::StorageTexture>()->format, type::TexelFormat::kR32Uint);
EXPECT_EQ(t->As<ast::StorageTexture>()->access, type::Access::kWrite);
EXPECT_EQ(t->As<ast::Texture>()->dim, type::TextureDimension::k2d);
EXPECT_EQ(t->source.range, (Source::Range{{1u, 1u}, {1u, 35u}}));

2
src/tint/resolver/assignment_validation_test.cc
View File

@ -231,7 +231,7 @@ TEST_F(ResolverAssignmentValidationTest, AssignNonConstructible_Handle) {
// a = b;
auto make_type = [&] {
return ty.storage_texture(type::TextureDimension::k1d, ast::TexelFormat::kRgba8Unorm,
return ty.storage_texture(type::TextureDimension::k1d, type::TexelFormat::kRgba8Unorm,
type::Access::kWrite);
};

2
src/tint/resolver/builtin_test.cc
View File

@ -2105,7 +2105,7 @@ inline std::ostream& operator<<(std::ostream& out, Texture data) {
struct TextureTestParams {
type::TextureDimension dim;
Texture type = Texture::kF32;
ast::TexelFormat format = ast::TexelFormat::kR32Float;
type::TexelFormat format = type::TexelFormat::kR32Float;
};
inline std::ostream& operator<<(std::ostream& out, TextureTestParams data) {
out << data.dim << "_" << data.type;

2
src/tint/resolver/dependency_graph_test.cc
View File

@ -1296,7 +1296,7 @@ TEST_F(ResolverDependencyGraphTraversalTest, SymbolsReached) {
GlobalVar(Sym(), ty.depth_multisampled_texture(type::TextureDimension::k2d));
GlobalVar(Sym(), ty.external_texture());
GlobalVar(Sym(), ty.multisampled_texture(type::TextureDimension::k2d, T));
GlobalVar(Sym(), ty.storage_texture(type::TextureDimension::k2d, ast::TexelFormat::kR32Float,
GlobalVar(Sym(), ty.storage_texture(type::TextureDimension::k2d, type::TexelFormat::kR32Float,
type::Access::kRead)); //
GlobalVar(Sym(), ty.sampler(ast::SamplerKind::kSampler));

2
src/tint/resolver/intrinsic_table.cc
View File

@ -328,7 +328,7 @@ class TemplateNumberMatcher : public NumberMatcher {
// TODO(bclayton): See if we can move more of this hand-rolled code to the
// template
////////////////////////////////////////////////////////////////////////////////
using TexelFormat = ast::TexelFormat;
using TexelFormat = type::TexelFormat;
using Access = type::Access;
using AddressSpace = type::AddressSpace;
using ParameterUsage = sem::ParameterUsage;

4
src/tint/resolver/intrinsic_table_test.cc
View File

@ -414,9 +414,9 @@ TEST_F(IntrinsicTableTest, MatchWOStorageTexture) {
auto* i32 = create<type::I32>();
auto* vec2_i32 = create<type::Vector>(i32, 2u);
auto* vec4_f32 = create<type::Vector>(f32, 4u);
auto* subtype = type::StorageTexture::SubtypeFor(ast::TexelFormat::kR32Float, Types());
auto* subtype = type::StorageTexture::SubtypeFor(type::TexelFormat::kR32Float, Types());
auto* tex = create<type::StorageTexture>(
type::TextureDimension::k2d, ast::TexelFormat::kR32Float, type::Access::kWrite, subtype);
type::TextureDimension::k2d, type::TexelFormat::kR32Float, type::Access::kWrite, subtype);
auto result = table->Lookup(BuiltinType::kTextureStore, utils::Vector{tex, vec2_i32, vec4_f32},
sem::EvaluationStage::kConstant, Source{});

2
src/tint/resolver/side_effects_test.cc
View File

@ -190,7 +190,7 @@ TEST_P(SideEffectsBuiltinTest, Test) {
GlobalVar("t2d_multi", ty.multisampled_texture(type::TextureDimension::k2d, ty.f32()),
Group(0_a), Binding(AInt(next_binding++)));
GlobalVar("tstorage2d",
ty.storage_texture(type::TextureDimension::k2d, ast::TexelFormat::kR32Float,
ty.storage_texture(type::TextureDimension::k2d, type::TexelFormat::kR32Float,
type::Access::kWrite),
Group(0_a), Binding(AInt(next_binding++)));
GlobalVar("s2d", ty.sampler(ast::SamplerKind::kSampler), Group(0_a),

46
src/tint/resolver/type_validation_test.cc
View File

@ -1113,7 +1113,7 @@ TEST_P(StorageTextureDimensionTest, All) {
// var a : texture_storage_*<ru32int, write>;
auto& params = GetParam();
auto* st = ty.storage_texture(Source{{12, 34}}, params.dim, ast::TexelFormat::kR32Uint,
auto* st = ty.storage_texture(Source{{12, 34}}, params.dim, type::TexelFormat::kR32Uint,
type::Access::kWrite);
GlobalVar("a", st, Group(0_a), Binding(0_a));
@ -1131,27 +1131,27 @@ INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest,
testing::ValuesIn(Dimension_cases));
struct FormatParams {
ast::TexelFormat format;
type::TexelFormat format;
bool is_valid;
};
static constexpr FormatParams format_cases[] = {FormatParams{ast::TexelFormat::kBgra8Unorm, true},
FormatParams{ast::TexelFormat::kR32Float, true},
FormatParams{ast::TexelFormat::kR32Sint, true},
FormatParams{ast::TexelFormat::kR32Uint, true},
FormatParams{ast::TexelFormat::kRg32Float, true},
FormatParams{ast::TexelFormat::kRg32Sint, true},
FormatParams{ast::TexelFormat::kRg32Uint, true},
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}};
static constexpr FormatParams format_cases[] = {FormatParams{type::TexelFormat::kBgra8Unorm, true},
FormatParams{type::TexelFormat::kR32Float, true},
FormatParams{type::TexelFormat::kR32Sint, true},
FormatParams{type::TexelFormat::kR32Uint, true},
FormatParams{type::TexelFormat::kRg32Float, true},
FormatParams{type::TexelFormat::kRg32Sint, true},
FormatParams{type::TexelFormat::kRg32Uint, true},
FormatParams{type::TexelFormat::kRgba16Float, true},
FormatParams{type::TexelFormat::kRgba16Sint, true},
FormatParams{type::TexelFormat::kRgba16Uint, true},
FormatParams{type::TexelFormat::kRgba32Float, true},
FormatParams{type::TexelFormat::kRgba32Sint, true},
FormatParams{type::TexelFormat::kRgba32Uint, true},
FormatParams{type::TexelFormat::kRgba8Sint, true},
FormatParams{type::TexelFormat::kRgba8Snorm, true},
FormatParams{type::TexelFormat::kRgba8Uint, true},
FormatParams{type::TexelFormat::kRgba8Unorm, true}};
using StorageTextureFormatTest = ResolverTestWithParam<FormatParams>;
TEST_P(StorageTextureFormatTest, All) {
@ -1201,7 +1201,7 @@ TEST_F(StorageTextureAccessTest, MissingAccess_Fail) {
// var a : texture_storage_1d<ru32int>;
auto* st = ty.storage_texture(Source{{12, 34}}, type::TextureDimension::k1d,
ast::TexelFormat::kR32Uint, type::Access::kUndefined);
type::TexelFormat::kR32Uint, type::Access::kUndefined);
GlobalVar("a", st, Group(0_a), Binding(0_a));
@ -1214,7 +1214,7 @@ TEST_F(StorageTextureAccessTest, RWAccess_Fail) {
// var a : texture_storage_1d<ru32int, read_write>;
auto* st = ty.storage_texture(Source{{12, 34}}, type::TextureDimension::k1d,
ast::TexelFormat::kR32Uint, type::Access::kReadWrite);
type::TexelFormat::kR32Uint, type::Access::kReadWrite);
GlobalVar("a", st, Group(0_a), Binding(0_a));
@ -1228,7 +1228,7 @@ TEST_F(StorageTextureAccessTest, ReadOnlyAccess_Fail) {
// var a : texture_storage_1d<ru32int, read>;
auto* st = ty.storage_texture(Source{{12, 34}}, type::TextureDimension::k1d,
ast::TexelFormat::kR32Uint, type::Access::kRead);
type::TexelFormat::kR32Uint, type::Access::kRead);
GlobalVar("a", st, Group(0_a), Binding(0_a));
@ -1241,7 +1241,7 @@ TEST_F(StorageTextureAccessTest, WriteOnlyAccess_Pass) {
// @group(0) @binding(0)
// var a : texture_storage_1d<ru32int, write>;
auto* st = ty.storage_texture(type::TextureDimension::k1d, ast::TexelFormat::kR32Uint,
auto* st = ty.storage_texture(type::TextureDimension::k1d, type::TexelFormat::kR32Uint,
type::Access::kWrite);
GlobalVar("a", st, Group(0_a), Binding(0_a));

36
src/tint/resolver/validator.cc
View File

@ -97,25 +97,25 @@ bool IsValidStorageTextureDimension(type::TextureDimension dim) {
}
}
bool IsValidStorageTextureTexelFormat(ast::TexelFormat format) {
bool IsValidStorageTextureTexelFormat(type::TexelFormat format) {
switch (format) {
case ast::TexelFormat::kBgra8Unorm:
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:
case type::TexelFormat::kBgra8Unorm:
case type::TexelFormat::kR32Uint:
case type::TexelFormat::kR32Sint:
case type::TexelFormat::kR32Float:
case type::TexelFormat::kRg32Uint:
case type::TexelFormat::kRg32Sint:
case type::TexelFormat::kRg32Float:
case type::TexelFormat::kRgba8Unorm:
case type::TexelFormat::kRgba8Snorm:
case type::TexelFormat::kRgba8Uint:
case type::TexelFormat::kRgba8Sint:
case type::TexelFormat::kRgba16Uint:
case type::TexelFormat::kRgba16Sint:
case type::TexelFormat::kRgba16Float:
case type::TexelFormat::kRgba32Uint:
case type::TexelFormat::kRgba32Sint:
case type::TexelFormat::kRgba32Float:
return true;
default:
return false;

6
src/tint/transform/builtin_polyfill.cc
View File

@ -946,7 +946,7 @@ Transform::ApplyResult BuiltinPolyfill::Apply(const Program* src,
auto& sig = builtin->Signature();
auto* tex = sig.Parameter(sem::ParameterUsage::kTexture);
if (auto* stex = tex->Type()->As<type::StorageTexture>()) {
if (stex->texel_format() == ast::TexelFormat::kBgra8Unorm) {
if (stex->texel_format() == type::TexelFormat::kBgra8Unorm) {
size_t value_idx = static_cast<size_t>(
sig.IndexOf(sem::ParameterUsage::kValue));
ctx.Replace(expr, [&ctx, expr, value_idx] {
@ -1026,9 +1026,9 @@ Transform::ApplyResult BuiltinPolyfill::Apply(const Program* src,
}
},
[&](const ast::StorageTexture* tex) {
if (polyfill.bgra8unorm && tex->format == ast::TexelFormat::kBgra8Unorm) {
if (polyfill.bgra8unorm && tex->format == type::TexelFormat::kBgra8Unorm) {
ctx.Replace(tex, [&ctx, tex] {
return ctx.dst->ty.storage_texture(tex->dim, ast::TexelFormat::kRgba8Unorm,
return ctx.dst->ty.storage_texture(tex->dim, type::TexelFormat::kRgba8Unorm,
tex->access);
});
made_changes = true;

40
src/tint/type/storage_texture.cc
View File

@ -22,7 +22,7 @@ TINT_INSTANTIATE_TYPEINFO(tint::type::StorageTexture);
namespace tint::type {
StorageTexture::StorageTexture(TextureDimension dim,
ast::TexelFormat format,
type::TexelFormat format,
type::Access access,
Type* subtype)
: Base(utils::Hash(TypeInfo::Of<StorageTexture>().full_hashcode, dim, format, access), dim),
@ -45,35 +45,35 @@ std::string StorageTexture::FriendlyName(const SymbolTable&) const {
return out.str();
}
Type* StorageTexture::SubtypeFor(ast::TexelFormat format, Manager& type_mgr) {
Type* StorageTexture::SubtypeFor(type::TexelFormat format, Manager& type_mgr) {
switch (format) {
case ast::TexelFormat::kR32Uint:
case ast::TexelFormat::kRgba8Uint:
case ast::TexelFormat::kRg32Uint:
case ast::TexelFormat::kRgba16Uint:
case ast::TexelFormat::kRgba32Uint: {
case type::TexelFormat::kR32Uint:
case type::TexelFormat::kRgba8Uint:
case type::TexelFormat::kRg32Uint:
case type::TexelFormat::kRgba16Uint:
case type::TexelFormat::kRgba32Uint: {
return type_mgr.Get<U32>();
}
case ast::TexelFormat::kR32Sint:
case ast::TexelFormat::kRgba8Sint:
case ast::TexelFormat::kRg32Sint:
case ast::TexelFormat::kRgba16Sint:
case ast::TexelFormat::kRgba32Sint: {
case type::TexelFormat::kR32Sint:
case type::TexelFormat::kRgba8Sint:
case type::TexelFormat::kRg32Sint:
case type::TexelFormat::kRgba16Sint:
case type::TexelFormat::kRgba32Sint: {
return type_mgr.Get<I32>();
}
case ast::TexelFormat::kBgra8Unorm:
case ast::TexelFormat::kRgba8Unorm:
case ast::TexelFormat::kRgba8Snorm:
case ast::TexelFormat::kR32Float:
case ast::TexelFormat::kRg32Float:
case ast::TexelFormat::kRgba16Float:
case ast::TexelFormat::kRgba32Float: {
case type::TexelFormat::kBgra8Unorm:
case type::TexelFormat::kRgba8Unorm:
case type::TexelFormat::kRgba8Snorm:
case type::TexelFormat::kR32Float:
case type::TexelFormat::kRg32Float:
case type::TexelFormat::kRgba16Float:
case type::TexelFormat::kRgba32Float: {
return type_mgr.Get<F32>();
}
case ast::TexelFormat::kUndefined:
case type::TexelFormat::kUndefined:
break;
}

10
src/tint/type/storage_texture.h
View File

@ -17,8 +17,8 @@
#include <string>
#include "src/tint/ast/storage_texture.h"
#include "src/tint/type/access.h"
#include "src/tint/type/texel_format.h"
#include "src/tint/type/texture.h"
#include "src/tint/type/texture_dimension.h"
@ -38,7 +38,7 @@ class StorageTexture final : public Castable<StorageTexture, Texture> {
/// @param access the access control type of the texture
/// @param subtype the storage subtype. Use SubtypeFor() to calculate this.
StorageTexture(TextureDimension dim,
ast::TexelFormat format,
type::TexelFormat format,
type::Access access,
Type* subtype);
@ -53,7 +53,7 @@ class StorageTexture final : public Castable<StorageTexture, Texture> {
Type* type() const { return subtype_; }
/// @returns the texel format
ast::TexelFormat texel_format() const { return texel_format_; }
type::TexelFormat texel_format() const { return texel_format_; }
/// @returns the access control
type::Access access() const { return access_; }
@ -66,14 +66,14 @@ class StorageTexture final : public Castable<StorageTexture, Texture> {
/// @param format the storage texture image format
/// @param type_mgr the Manager used to build the returned type
/// @returns the storage texture subtype for the given TexelFormat
static Type* SubtypeFor(ast::TexelFormat format, Manager& type_mgr);
static Type* SubtypeFor(type::TexelFormat format, Manager& type_mgr);
/// @param ctx the clone context
/// @returns a clone of this type
StorageTexture* Clone(CloneContext& ctx) const override;
private:
ast::TexelFormat const texel_format_;
type::TexelFormat const texel_format_;
type::Access const access_;
Type* const subtype_;
};

48
src/tint/type/storage_texture_test.cc
View File

@ -24,7 +24,7 @@ namespace tint::type {
namespace {
struct StorageTextureTest : public TestHelper {
StorageTexture* Create(TextureDimension dims, ast::TexelFormat fmt, type::Access access) {
StorageTexture* Create(TextureDimension dims, type::TexelFormat fmt, type::Access access) {
auto* subtype = StorageTexture::SubtypeFor(fmt, Types());
return create<StorageTexture>(dims, fmt, access, subtype);
}
@ -32,14 +32,14 @@ struct StorageTextureTest : public TestHelper {
TEST_F(StorageTextureTest, Creation) {
auto* a =
Create(TextureDimension::kCube, ast::TexelFormat::kRgba32Float, type::Access::kReadWrite);
Create(TextureDimension::kCube, type::TexelFormat::kRgba32Float, type::Access::kReadWrite);
auto* b =
Create(TextureDimension::kCube, ast::TexelFormat::kRgba32Float, type::Access::kReadWrite);
Create(TextureDimension::kCube, type::TexelFormat::kRgba32Float, type::Access::kReadWrite);
auto* c =
Create(TextureDimension::k2d, ast::TexelFormat::kRgba32Float, type::Access::kReadWrite);
Create(TextureDimension::k2d, type::TexelFormat::kRgba32Float, type::Access::kReadWrite);
auto* d =
Create(TextureDimension::kCube, ast::TexelFormat::kR32Float, type::Access::kReadWrite);
auto* e = Create(TextureDimension::kCube, ast::TexelFormat::kRgba32Float, type::Access::kRead);
Create(TextureDimension::kCube, type::TexelFormat::kR32Float, type::Access::kReadWrite);
auto* e = Create(TextureDimension::kCube, type::TexelFormat::kRgba32Float, type::Access::kRead);
EXPECT_TRUE(a->type()->Is<F32>());
EXPECT_EQ(a->dim(), TextureDimension::kCube);
@ -52,23 +52,23 @@ TEST_F(StorageTextureTest, Creation) {
TEST_F(StorageTextureTest, Hash) {
auto* a =
Create(TextureDimension::kCube, ast::TexelFormat::kRgba32Float, type::Access::kReadWrite);
Create(TextureDimension::kCube, type::TexelFormat::kRgba32Float, type::Access::kReadWrite);
auto* b =
Create(TextureDimension::kCube, ast::TexelFormat::kRgba32Float, type::Access::kReadWrite);
Create(TextureDimension::kCube, type::TexelFormat::kRgba32Float, type::Access::kReadWrite);
EXPECT_EQ(a->unique_hash, b->unique_hash);
}
TEST_F(StorageTextureTest, Equals) {
auto* a =
Create(TextureDimension::kCube, ast::TexelFormat::kRgba32Float, type::Access::kReadWrite);
Create(TextureDimension::kCube, type::TexelFormat::kRgba32Float, type::Access::kReadWrite);
auto* b =
Create(TextureDimension::kCube, ast::TexelFormat::kRgba32Float, type::Access::kReadWrite);
Create(TextureDimension::kCube, type::TexelFormat::kRgba32Float, type::Access::kReadWrite);
auto* c =
Create(TextureDimension::k2d, ast::TexelFormat::kRgba32Float, type::Access::kReadWrite);
Create(TextureDimension::k2d, type::TexelFormat::kRgba32Float, type::Access::kReadWrite);
auto* d =
Create(TextureDimension::kCube, ast::TexelFormat::kR32Float, type::Access::kReadWrite);
auto* e = Create(TextureDimension::kCube, ast::TexelFormat::kRgba32Float, type::Access::kRead);
Create(TextureDimension::kCube, type::TexelFormat::kR32Float, type::Access::kReadWrite);
auto* e = Create(TextureDimension::kCube, type::TexelFormat::kRgba32Float, type::Access::kRead);
EXPECT_TRUE(a->Equals(*b));
EXPECT_FALSE(a->Equals(*c));
@ -78,25 +78,25 @@ TEST_F(StorageTextureTest, Equals) {
}
TEST_F(StorageTextureTest, Dim) {
auto* s = Create(TextureDimension::k2dArray, ast::TexelFormat::kRgba32Float,
auto* s = Create(TextureDimension::k2dArray, type::TexelFormat::kRgba32Float,
type::Access::kReadWrite);
EXPECT_EQ(s->dim(), TextureDimension::k2dArray);
}
TEST_F(StorageTextureTest, Format) {
auto* s = Create(TextureDimension::k2dArray, ast::TexelFormat::kRgba32Float,
auto* s = Create(TextureDimension::k2dArray, type::TexelFormat::kRgba32Float,
type::Access::kReadWrite);
EXPECT_EQ(s->texel_format(), ast::TexelFormat::kRgba32Float);
EXPECT_EQ(s->texel_format(), type::TexelFormat::kRgba32Float);
}
TEST_F(StorageTextureTest, FriendlyName) {
auto* s = Create(TextureDimension::k2dArray, ast::TexelFormat::kRgba32Float,
auto* s = Create(TextureDimension::k2dArray, type::TexelFormat::kRgba32Float,
type::Access::kReadWrite);
EXPECT_EQ(s->FriendlyName(Symbols()), "texture_storage_2d_array<rgba32float, read_write>");
}
TEST_F(StorageTextureTest, F32) {
Type* s = Create(TextureDimension::k2dArray, ast::TexelFormat::kRgba32Float,
Type* s = Create(TextureDimension::k2dArray, type::TexelFormat::kRgba32Float,
type::Access::kReadWrite);
auto program = Build();
@ -108,8 +108,8 @@ TEST_F(StorageTextureTest, F32) {
}
TEST_F(StorageTextureTest, U32) {
auto* subtype = StorageTexture::SubtypeFor(ast::TexelFormat::kRg32Uint, Types());
Type* s = create<StorageTexture>(TextureDimension::k2dArray, ast::TexelFormat::kRg32Uint,
auto* subtype = StorageTexture::SubtypeFor(type::TexelFormat::kRg32Uint, Types());
Type* s = create<StorageTexture>(TextureDimension::k2dArray, type::TexelFormat::kRg32Uint,
type::Access::kReadWrite, subtype);
auto program = Build();
@ -121,8 +121,8 @@ TEST_F(StorageTextureTest, U32) {
}
TEST_F(StorageTextureTest, I32) {
auto* subtype = StorageTexture::SubtypeFor(ast::TexelFormat::kRgba32Sint, Types());
Type* s = create<StorageTexture>(TextureDimension::k2dArray, ast::TexelFormat::kRgba32Sint,
auto* subtype = StorageTexture::SubtypeFor(type::TexelFormat::kRgba32Sint, Types());
Type* s = create<StorageTexture>(TextureDimension::k2dArray, type::TexelFormat::kRgba32Sint,
type::Access::kReadWrite, subtype);
auto program = Build();
@ -135,14 +135,14 @@ TEST_F(StorageTextureTest, I32) {
TEST_F(StorageTextureTest, Clone) {
auto* a =
Create(TextureDimension::kCube, ast::TexelFormat::kRgba32Float, type::Access::kReadWrite);
Create(TextureDimension::kCube, type::TexelFormat::kRgba32Float, type::Access::kReadWrite);
type::Manager mgr;
type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
auto* mt = a->Clone(ctx);
EXPECT_EQ(mt->dim(), TextureDimension::kCube);
EXPECT_EQ(mt->texel_format(), ast::TexelFormat::kRgba32Float);
EXPECT_EQ(mt->texel_format(), type::TexelFormat::kRgba32Float);
EXPECT_TRUE(mt->type()->Is<F32>());
}

8
src/tint/ast/texel_format.cc → src/tint/type/texel_format.cc
View File

@ -15,14 +15,14 @@
////////////////////////////////////////////////////////////////////////////////
// File generated by tools/src/cmd/gen
// using the template:
// src/tint/ast/texel_format.cc.tmpl
// src/tint/type/texel_format.cc.tmpl
//
// Do not modify this file directly
////////////////////////////////////////////////////////////////////////////////
#include "src/tint/ast/texel_format.h"
#include "src/tint/type/texel_format.h"
namespace tint::ast {
namespace tint::type {
/// ParseTexelFormat parses a TexelFormat from a string.
/// @param str the string to parse
@ -124,4 +124,4 @@ std::ostream& operator<<(std::ostream& out, TexelFormat value) {
return out << "<unknown>";
}
} // namespace tint::ast
} // namespace tint::type

6
src/tint/ast/texel_format.cc.tmpl → src/tint/type/texel_format.cc.tmpl
View File

@ -11,12 +11,12 @@ See:
{{- Import "src/tint/templates/enums.tmpl.inc" -}}
{{- $enum := (Sem.Enum "texel_format") -}}
#include "src/tint/ast/texel_format.h"
#include "src/tint/type/texel_format.h"
namespace tint::ast {
namespace tint::type {
{{ Eval "ParseEnum" $enum}}
{{ Eval "EnumOStream" $enum}}
} // namespace tint::ast
} // namespace tint::type

12
src/tint/ast/texel_format.h → src/tint/type/texel_format.h
View File

@ -15,17 +15,17 @@
////////////////////////////////////////////////////////////////////////////////
// File generated by tools/src/cmd/gen
// using the template:
// src/tint/ast/texel_format.h.tmpl
// src/tint/type/texel_format.h.tmpl
//
// Do not modify this file directly
////////////////////////////////////////////////////////////////////////////////
#ifndef SRC_TINT_AST_TEXEL_FORMAT_H_
#define SRC_TINT_AST_TEXEL_FORMAT_H_
#ifndef SRC_TINT_TYPE_TEXEL_FORMAT_H_
#define SRC_TINT_TYPE_TEXEL_FORMAT_H_
#include <ostream>
namespace tint::ast {
namespace tint::type {
/// Enumerator of texel formats
enum class TexelFormat {
@ -65,6 +65,6 @@ constexpr const char* kTexelFormatStrings[] = {
"rgba32uint", "rgba8sint", "rgba8snorm", "rgba8uint", "rgba8unorm",
};
} // namespace tint::ast
} // namespace tint::type
#endif // SRC_TINT_AST_TEXEL_FORMAT_H_
#endif // SRC_TINT_TYPE_TEXEL_FORMAT_H_

10
src/tint/ast/texel_format.h.tmpl → src/tint/type/texel_format.h.tmpl
View File

@ -11,16 +11,16 @@ See:
{{- Import "src/tint/templates/enums.tmpl.inc" -}}
{{- $enum := (Sem.Enum "texel_format") -}}
#ifndef SRC_TINT_AST_TEXEL_FORMAT_H_
#define SRC_TINT_AST_TEXEL_FORMAT_H_
#ifndef SRC_TINT_TYPE_TEXEL_FORMAT_H_
#define SRC_TINT_TYPE_TEXEL_FORMAT_H_
#include <ostream>
namespace tint::ast {
namespace tint::type {
/// Enumerator of texel formats
{{ Eval "DeclareEnum" $enum}}
} // namespace tint::ast
} // namespace tint::type
#endif // SRC_TINT_AST_TEXEL_FORMAT_H_
#endif // SRC_TINT_TYPE_TEXEL_FORMAT_H_

8
src/tint/ast/texel_format_bench.cc → src/tint/type/texel_format_bench.cc
View File

@ -15,18 +15,18 @@
////////////////////////////////////////////////////////////////////////////////
// File generated by tools/src/cmd/gen
// using the template:
// src/tint/ast/texel_format_bench.cc.tmpl
// src/tint/type/texel_format_bench.cc.tmpl
//
// Do not modify this file directly
////////////////////////////////////////////////////////////////////////////////
#include "src/tint/ast/texel_format.h"
#include "src/tint/type/texel_format.h"
#include <array>
#include "benchmark/benchmark.h"
namespace tint::ast {
namespace tint::type {
namespace {
void TexelFormatParser(::benchmark::State& state) {
@ -67,4 +67,4 @@ void TexelFormatParser(::benchmark::State& state) {
BENCHMARK(TexelFormatParser);
} // namespace
} // namespace tint::ast
} // namespace tint::type

6
src/tint/ast/texel_format_bench.cc.tmpl → src/tint/type/texel_format_bench.cc.tmpl
View File

@ -11,16 +11,16 @@ See:
{{- Import "src/tint/templates/enums.tmpl.inc" -}}
{{- $enum := (Sem.Enum "texel_format") -}}
#include "src/tint/ast/texel_format.h"
#include "src/tint/type/texel_format.h"
#include <array>
#include "benchmark/benchmark.h"
namespace tint::ast {
namespace tint::type {
namespace {
{{ Eval "BenchmarkParseEnum" $enum }}
} // namespace
} // namespace tint::ast
} // namespace tint::type

10
src/tint/ast/texel_format_test.cc → src/tint/type/texel_format_test.cc
View File

@ -15,19 +15,19 @@
////////////////////////////////////////////////////////////////////////////////
// File generated by tools/src/cmd/gen
// using the template:
// src/tint/ast/texel_format_test.cc.tmpl
// src/tint/type/texel_format_test.cc.tmpl
//
// Do not modify this file directly
////////////////////////////////////////////////////////////////////////////////
#include "src/tint/ast/texel_format.h"
#include "src/tint/type/texel_format.h"
#include <string>
#include "src/tint/ast/test_helper.h"
#include "src/tint/type/test_helper.h"
#include "src/tint/utils/string.h"
namespace tint::ast {
namespace tint::type {
namespace {
namespace parse_print_tests {
@ -106,4 +106,4 @@ INSTANTIATE_TEST_SUITE_P(ValidCases, TexelFormatPrintTest, testing::ValuesIn(kVa
} // namespace parse_print_tests
} // namespace
} // namespace tint::ast
} // namespace tint::type

8
src/tint/ast/texel_format_test.cc.tmpl → src/tint/type/texel_format_test.cc.tmpl
View File

@ -11,17 +11,17 @@ See:
{{- Import "src/tint/templates/enums.tmpl.inc" -}}
{{- $enum := (Sem.Enum "texel_format") -}}
#include "src/tint/ast/texel_format.h"
#include "src/tint/type/texel_format.h"
#include <string>
#include "src/tint/ast/test_helper.h"
#include "src/tint/type/test_helper.h"
#include "src/tint/utils/string.h"
namespace tint::ast {
namespace tint::type {
namespace {
{{ Eval "TestParsePrintEnum" $enum}}
} // namespace
} // namespace tint::ast
} // namespace tint::type

2
src/tint/writer/flatten_bindings_test.cc
View File

@ -101,7 +101,7 @@ TEST_F(FlattenBindingsTest, NotFlat_MultipleNamespaces) {
b.GlobalVar("texture2", b.ty.multisampled_texture(type::TextureDimension::k2d, b.ty.f32()),
b.Group(6_a), b.Binding(6_a));
b.GlobalVar("texture3",
b.ty.storage_texture(type::TextureDimension::k2d, ast::TexelFormat::kR32Float,
b.ty.storage_texture(type::TextureDimension::k2d, type::TexelFormat::kR32Float,
type::Access::kWrite),
b.Group(7_a), b.Binding(7_a));
b.GlobalVar("texture4", b.ty.depth_texture(type::TextureDimension::k2d), b.Group(8_a),

36
src/tint/writer/glsl/generator_impl.cc
View File

@ -2033,59 +2033,59 @@ bool GeneratorImpl::EmitHandleVariable(const ast::Var* var, const sem::Variable*
if (auto* storage = type->As<type::StorageTexture>()) {
out << "layout(";
switch (storage->texel_format()) {
case ast::TexelFormat::kBgra8Unorm:
case type::TexelFormat::kBgra8Unorm:
TINT_ICE(Writer, diagnostics_)
<< "bgra8unorm should have been polyfilled to rgba8unorm";
break;
case ast::TexelFormat::kR32Uint:
case type::TexelFormat::kR32Uint:
out << "r32ui";
break;
case ast::TexelFormat::kR32Sint:
case type::TexelFormat::kR32Sint:
out << "r32i";
break;
case ast::TexelFormat::kR32Float:
case type::TexelFormat::kR32Float:
out << "r32f";
break;
case ast::TexelFormat::kRgba8Unorm:
case type::TexelFormat::kRgba8Unorm:
out << "rgba8";
break;
case ast::TexelFormat::kRgba8Snorm:
case type::TexelFormat::kRgba8Snorm:
out << "rgba8_snorm";
break;
case ast::TexelFormat::kRgba8Uint:
case type::TexelFormat::kRgba8Uint:
out << "rgba8ui";
break;
case ast::TexelFormat::kRgba8Sint:
case type::TexelFormat::kRgba8Sint:
out << "rgba8i";
break;
case ast::TexelFormat::kRg32Uint:
case type::TexelFormat::kRg32Uint:
out << "rg32ui";
break;
case ast::TexelFormat::kRg32Sint:
case type::TexelFormat::kRg32Sint:
out << "rg32i";
break;
case ast::TexelFormat::kRg32Float:
case type::TexelFormat::kRg32Float:
out << "rg32f";
break;
case ast::TexelFormat::kRgba16Uint:
case type::TexelFormat::kRgba16Uint:
out << "rgba16ui";
break;
case ast::TexelFormat::kRgba16Sint:
case type::TexelFormat::kRgba16Sint:
out << "rgba16i";
break;
case ast::TexelFormat::kRgba16Float:
case type::TexelFormat::kRgba16Float:
out << "rgba16f";
break;
case ast::TexelFormat::kRgba32Uint:
case type::TexelFormat::kRgba32Uint:
out << "rgba32ui";
break;
case ast::TexelFormat::kRgba32Sint:
case type::TexelFormat::kRgba32Sint:
out << "rgba32i";
break;
case ast::TexelFormat::kRgba32Float:
case type::TexelFormat::kRgba32Float:
out << "rgba32f";
break;
case ast::TexelFormat::kUndefined:
case type::TexelFormat::kUndefined:
TINT_ICE(Writer, diagnostics_) << "invalid texel format";
return false;
}

32
src/tint/writer/glsl/generator_impl_type_test.cc
View File

@ -510,7 +510,7 @@ TEST_F(GlslGeneratorImplTest_Type, EmitMultisampledTexture) {
struct GlslStorageTextureData {
type::TextureDimension dim;
ast::TexelFormat imgfmt;
type::TexelFormat imgfmt;
std::string result;
};
inline std::ostream& operator<<(std::ostream& out, GlslStorageTextureData data) {
@ -541,31 +541,31 @@ INSTANTIATE_TEST_SUITE_P(
GlslGeneratorImplTest_Type,
GlslStorageTexturesTest,
testing::Values(GlslStorageTextureData{type::TextureDimension::k1d,
ast::TexelFormat::kRgba8Unorm, "image1D tex;"},
type::TexelFormat::kRgba8Unorm, "image1D tex;"},
GlslStorageTextureData{type::TextureDimension::k2d,
ast::TexelFormat::kRgba16Float, "image2D tex;"},
type::TexelFormat::kRgba16Float, "image2D tex;"},
GlslStorageTextureData{type::TextureDimension::k2dArray,
ast::TexelFormat::kR32Float, "image2DArray tex;"},
type::TexelFormat::kR32Float, "image2DArray tex;"},
GlslStorageTextureData{type::TextureDimension::k3d,
ast::TexelFormat::kRg32Float, "image3D tex;"},
type::TexelFormat::kRg32Float, "image3D tex;"},
GlslStorageTextureData{type::TextureDimension::k1d,
ast::TexelFormat::kRgba32Float, "image1D tex;"},
type::TexelFormat::kRgba32Float, "image1D tex;"},
GlslStorageTextureData{type::TextureDimension::k2d,
ast::TexelFormat::kRgba16Uint, "image2D tex;"},
type::TexelFormat::kRgba16Uint, "image2D tex;"},
GlslStorageTextureData{type::TextureDimension::k2dArray,
ast::TexelFormat::kR32Uint, "image2DArray tex;"},
GlslStorageTextureData{type::TextureDimension::k3d, ast::TexelFormat::kRg32Uint,
"image3D tex;"},
type::TexelFormat::kR32Uint, "image2DArray tex;"},
GlslStorageTextureData{type::TextureDimension::k3d,
type::TexelFormat::kRg32Uint, "image3D tex;"},
GlslStorageTextureData{type::TextureDimension::k1d,
ast::TexelFormat::kRgba32Uint, "image1D tex;"},
type::TexelFormat::kRgba32Uint, "image1D tex;"},
GlslStorageTextureData{type::TextureDimension::k2d,
ast::TexelFormat::kRgba16Sint, "image2D tex;"},
type::TexelFormat::kRgba16Sint, "image2D tex;"},
GlslStorageTextureData{type::TextureDimension::k2dArray,
ast::TexelFormat::kR32Sint, "image2DArray tex;"},
GlslStorageTextureData{type::TextureDimension::k3d, ast::TexelFormat::kRg32Sint,
"image3D tex;"},
type::TexelFormat::kR32Sint, "image2DArray tex;"},
GlslStorageTextureData{type::TextureDimension::k3d,
type::TexelFormat::kRg32Sint, "image3D tex;"},
GlslStorageTextureData{type::TextureDimension::k1d,
ast::TexelFormat::kRgba32Sint, "image1D tex;"}));
type::TexelFormat::kRgba32Sint, "image1D tex;"}));
} // namespace
} // namespace tint::writer::glsl

36
src/tint/writer/hlsl/generator_impl.cc
View File

@ -87,27 +87,27 @@ namespace {
const char kTempNamePrefix[] = "tint_tmp";
const char* image_format_to_rwtexture_type(ast::TexelFormat image_format) {
const char* image_format_to_rwtexture_type(type::TexelFormat image_format) {
switch (image_format) {
case ast::TexelFormat::kBgra8Unorm:
case ast::TexelFormat::kRgba8Unorm:
case ast::TexelFormat::kRgba8Snorm:
case ast::TexelFormat::kRgba16Float:
case ast::TexelFormat::kR32Float:
case ast::TexelFormat::kRg32Float:
case ast::TexelFormat::kRgba32Float:
case type::TexelFormat::kBgra8Unorm:
case type::TexelFormat::kRgba8Unorm:
case type::TexelFormat::kRgba8Snorm:
case type::TexelFormat::kRgba16Float:
case type::TexelFormat::kR32Float:
case type::TexelFormat::kRg32Float:
case type::TexelFormat::kRgba32Float:
return "float4";
case ast::TexelFormat::kRgba8Uint:
case ast::TexelFormat::kRgba16Uint:
case ast::TexelFormat::kR32Uint:
case ast::TexelFormat::kRg32Uint:
case ast::TexelFormat::kRgba32Uint:
case type::TexelFormat::kRgba8Uint:
case type::TexelFormat::kRgba16Uint:
case type::TexelFormat::kR32Uint:
case type::TexelFormat::kRg32Uint:
case type::TexelFormat::kRgba32Uint:
return "uint4";
case ast::TexelFormat::kRgba8Sint:
case ast::TexelFormat::kRgba16Sint:
case ast::TexelFormat::kR32Sint:
case ast::TexelFormat::kRg32Sint:
case ast::TexelFormat::kRgba32Sint:
case type::TexelFormat::kRgba8Sint:
case type::TexelFormat::kRgba16Sint:
case type::TexelFormat::kR32Sint:
case type::TexelFormat::kRg32Sint:
case type::TexelFormat::kRgba32Sint:
return "int4";
default:
return nullptr;

28
src/tint/writer/hlsl/generator_impl_type_test.cc
View File

@ -507,7 +507,7 @@ TEST_F(HlslGeneratorImplTest_Type, EmitMultisampledTexture) {
struct HlslStorageTextureData {
type::TextureDimension dim;
ast::TexelFormat imgfmt;
type::TexelFormat imgfmt;
std::string result;
};
inline std::ostream& operator<<(std::ostream& out, HlslStorageTextureData data) {
@ -543,31 +543,31 @@ INSTANTIATE_TEST_SUITE_P(
HlslGeneratorImplTest_Type,
HlslStorageTexturesTest,
testing::Values(
HlslStorageTextureData{type::TextureDimension::k1d, ast::TexelFormat::kRgba8Unorm,
HlslStorageTextureData{type::TextureDimension::k1d, type::TexelFormat::kRgba8Unorm,
"RWTexture1D<float4> tex : register(u1, space2);"},
HlslStorageTextureData{type::TextureDimension::k2d, ast::TexelFormat::kRgba16Float,
HlslStorageTextureData{type::TextureDimension::k2d, type::TexelFormat::kRgba16Float,
"RWTexture2D<float4> tex : register(u1, space2);"},
HlslStorageTextureData{type::TextureDimension::k2dArray, ast::TexelFormat::kR32Float,
HlslStorageTextureData{type::TextureDimension::k2dArray, type::TexelFormat::kR32Float,
"RWTexture2DArray<float4> tex : register(u1, space2);"},
HlslStorageTextureData{type::TextureDimension::k3d, ast::TexelFormat::kRg32Float,
HlslStorageTextureData{type::TextureDimension::k3d, type::TexelFormat::kRg32Float,
"RWTexture3D<float4> tex : register(u1, space2);"},
HlslStorageTextureData{type::TextureDimension::k1d, ast::TexelFormat::kRgba32Float,
HlslStorageTextureData{type::TextureDimension::k1d, type::TexelFormat::kRgba32Float,
"RWTexture1D<float4> tex : register(u1, space2);"},
HlslStorageTextureData{type::TextureDimension::k2d, ast::TexelFormat::kRgba16Uint,
HlslStorageTextureData{type::TextureDimension::k2d, type::TexelFormat::kRgba16Uint,
"RWTexture2D<uint4> tex : register(u1, space2);"},
HlslStorageTextureData{type::TextureDimension::k2dArray, ast::TexelFormat::kR32Uint,
HlslStorageTextureData{type::TextureDimension::k2dArray, type::TexelFormat::kR32Uint,
"RWTexture2DArray<uint4> tex : register(u1, space2);"},
HlslStorageTextureData{type::TextureDimension::k3d, ast::TexelFormat::kRg32Uint,
HlslStorageTextureData{type::TextureDimension::k3d, type::TexelFormat::kRg32Uint,
"RWTexture3D<uint4> tex : register(u1, space2);"},
HlslStorageTextureData{type::TextureDimension::k1d, ast::TexelFormat::kRgba32Uint,
HlslStorageTextureData{type::TextureDimension::k1d, type::TexelFormat::kRgba32Uint,
"RWTexture1D<uint4> tex : register(u1, space2);"},
HlslStorageTextureData{type::TextureDimension::k2d, ast::TexelFormat::kRgba16Sint,
HlslStorageTextureData{type::TextureDimension::k2d, type::TexelFormat::kRgba16Sint,
"RWTexture2D<int4> tex : register(u1, space2);"},
HlslStorageTextureData{type::TextureDimension::k2dArray, ast::TexelFormat::kR32Sint,
HlslStorageTextureData{type::TextureDimension::k2dArray, type::TexelFormat::kR32Sint,
"RWTexture2DArray<int4> tex : register(u1, space2);"},
HlslStorageTextureData{type::TextureDimension::k3d, ast::TexelFormat::kRg32Sint,
HlslStorageTextureData{type::TextureDimension::k3d, type::TexelFormat::kRg32Sint,
"RWTexture3D<int4> tex : register(u1, space2);"},
HlslStorageTextureData{type::TextureDimension::k1d, ast::TexelFormat::kRgba32Sint,
HlslStorageTextureData{type::TextureDimension::k1d, type::TexelFormat::kRgba32Sint,
"RWTexture1D<int4> tex : register(u1, space2);"}));
} // namespace

2
src/tint/writer/msl/generator_impl_type_test.cc
View File

@ -847,7 +847,7 @@ using MslStorageTexturesTest = TestParamHelper<MslStorageTextureData>;
TEST_P(MslStorageTexturesTest, Emit) {
auto params = GetParam();
auto* s = ty.storage_texture(params.dim, ast::TexelFormat::kR32Float, type::Access::kWrite);
auto* s = ty.storage_texture(params.dim, type::TexelFormat::kR32Float, type::Access::kWrite);
GlobalVar("test_var", s, Binding(0_a), Group(0_a));
GeneratorImpl& gen = Build();

38
src/tint/writer/spirv/builder.cc
View File

@ -4078,48 +4078,48 @@ void Builder::AddInterpolationDecorations(uint32_t id,
}
}
SpvImageFormat Builder::convert_texel_format_to_spv(const ast::TexelFormat format) {
SpvImageFormat Builder::convert_texel_format_to_spv(const type::TexelFormat format) {
switch (format) {
case ast::TexelFormat::kBgra8Unorm:
case type::TexelFormat::kBgra8Unorm:
TINT_ICE(Writer, builder_.Diagnostics())
<< "bgra8unorm should have been polyfilled to rgba8unorm";
return SpvImageFormatUnknown;
case ast::TexelFormat::kR32Uint:
case type::TexelFormat::kR32Uint:
return SpvImageFormatR32ui;
case ast::TexelFormat::kR32Sint:
case type::TexelFormat::kR32Sint:
return SpvImageFormatR32i;
case ast::TexelFormat::kR32Float:
case type::TexelFormat::kR32Float:
return SpvImageFormatR32f;
case ast::TexelFormat::kRgba8Unorm:
case type::TexelFormat::kRgba8Unorm:
return SpvImageFormatRgba8;
case ast::TexelFormat::kRgba8Snorm:
case type::TexelFormat::kRgba8Snorm:
return SpvImageFormatRgba8Snorm;
case ast::TexelFormat::kRgba8Uint:
case type::TexelFormat::kRgba8Uint:
return SpvImageFormatRgba8ui;
case ast::TexelFormat::kRgba8Sint:
case type::TexelFormat::kRgba8Sint:
return SpvImageFormatRgba8i;
case ast::TexelFormat::kRg32Uint:
case type::TexelFormat::kRg32Uint:
push_capability(SpvCapabilityStorageImageExtendedFormats);
return SpvImageFormatRg32ui;
case ast::TexelFormat::kRg32Sint:
case type::TexelFormat::kRg32Sint:
push_capability(SpvCapabilityStorageImageExtendedFormats);
return SpvImageFormatRg32i;
case ast::TexelFormat::kRg32Float:
case type::TexelFormat::kRg32Float:
push_capability(SpvCapabilityStorageImageExtendedFormats);
return SpvImageFormatRg32f;
case ast::TexelFormat::kRgba16Uint:
case type::TexelFormat::kRgba16Uint:
return SpvImageFormatRgba16ui;
case ast::TexelFormat::kRgba16Sint:
case type::TexelFormat::kRgba16Sint:
return SpvImageFormatRgba16i;
case ast::TexelFormat::kRgba16Float:
case type::TexelFormat::kRgba16Float:
return SpvImageFormatRgba16f;
case ast::TexelFormat::kRgba32Uint:
case type::TexelFormat::kRgba32Uint:
return SpvImageFormatRgba32ui;
case ast::TexelFormat::kRgba32Sint:
case type::TexelFormat::kRgba32Sint:
return SpvImageFormatRgba32i;
case ast::TexelFormat::kRgba32Float:
case type::TexelFormat::kRgba32Float:
return SpvImageFormatRgba32f;
case ast::TexelFormat::kUndefined:
case type::TexelFormat::kUndefined:
return SpvImageFormatUnknown;
}
return SpvImageFormatUnknown;

2
src/tint/writer/spirv/builder.h
View File

@ -535,7 +535,7 @@ class Builder {
/// Converts TexelFormat to SPIR-V and pushes an appropriate capability.
/// @param format AST image format type
/// @returns SPIR-V image format type
SpvImageFormat convert_texel_format_to_spv(const ast::TexelFormat format);
SpvImageFormat convert_texel_format_to_spv(const type::TexelFormat format);
/// Determines if the given type initializer is created from constant values
/// @param expr the expression to check

72
src/tint/writer/spirv/builder_format_conversion_test.cc
View File

@ -19,7 +19,7 @@ namespace tint::writer::spirv {
namespace {
struct TestData {
ast::TexelFormat ast_format;
type::TexelFormat ast_format;
SpvImageFormat_ spv_format;
bool extended_format = false;
};
@ -49,42 +49,42 @@ INSTANTIATE_TEST_SUITE_P(BuilderTest,
ImageFormatConversionTest,
testing::Values(
/* WGSL unsupported formats
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::kRg16Uint, SpvImageFormatRg16ui, true},
TestData{ast::TexelFormat::kRg16Sint, SpvImageFormatRg16i, true},
TestData{ast::TexelFormat::kRg16Float, SpvImageFormatRg16f, true},
TestData{ast::TexelFormat::kRgba8UnormSrgb, SpvImageFormatUnknown},
TestData{ast::TexelFormat::kBgra8Unorm, SpvImageFormatUnknown},
TestData{ast::TexelFormat::kBgra8UnormSrgb, SpvImageFormatUnknown},
TestData{ast::TexelFormat::kRgb10A2Unorm, SpvImageFormatRgb10A2, true},
TestData{ast::TexelFormat::kRg11B10Float, SpvImageFormatR11fG11fB10f, true},
TestData{type::TexelFormat::kR8Unorm, SpvImageFormatR8, true},
TestData{type::TexelFormat::kR8Snorm, SpvImageFormatR8Snorm, true},
TestData{type::TexelFormat::kR8Uint, SpvImageFormatR8ui, true},
TestData{type::TexelFormat::kR8Sint, SpvImageFormatR8i, true},
TestData{type::TexelFormat::kR16Uint, SpvImageFormatR16ui, true},
TestData{type::TexelFormat::kR16Sint, SpvImageFormatR16i, true},
TestData{type::TexelFormat::kR16Float, SpvImageFormatR16f, true},
TestData{type::TexelFormat::kRg8Unorm, SpvImageFormatRg8, true},
TestData{type::TexelFormat::kRg8Snorm, SpvImageFormatRg8Snorm, true},
TestData{type::TexelFormat::kRg8Uint, SpvImageFormatRg8ui, true},
TestData{type::TexelFormat::kRg8Sint, SpvImageFormatRg8i, true},
TestData{type::TexelFormat::kRg16Uint, SpvImageFormatRg16ui, true},
TestData{type::TexelFormat::kRg16Sint, SpvImageFormatRg16i, true},
TestData{type::TexelFormat::kRg16Float, SpvImageFormatRg16f, true},
TestData{type::TexelFormat::kRgba8UnormSrgb, SpvImageFormatUnknown},
TestData{type::TexelFormat::kBgra8Unorm, SpvImageFormatUnknown},
TestData{type::TexelFormat::kBgra8UnormSrgb, SpvImageFormatUnknown},
TestData{type::TexelFormat::kRgb10A2Unorm, SpvImageFormatRgb10A2, true},
TestData{type::TexelFormat::kRg11B10Float, SpvImageFormatR11fG11fB10f, true},
*/
TestData{ast::TexelFormat::kR32Uint, SpvImageFormatR32ui},
TestData{ast::TexelFormat::kR32Sint, SpvImageFormatR32i},
TestData{ast::TexelFormat::kR32Float, SpvImageFormatR32f},
TestData{ast::TexelFormat::kRgba8Unorm, SpvImageFormatRgba8},
TestData{ast::TexelFormat::kRgba8Snorm, SpvImageFormatRgba8Snorm},
TestData{ast::TexelFormat::kRgba8Uint, SpvImageFormatRgba8ui},
TestData{ast::TexelFormat::kRgba8Sint, SpvImageFormatRgba8i},
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}));
TestData{type::TexelFormat::kR32Uint, SpvImageFormatR32ui},
TestData{type::TexelFormat::kR32Sint, SpvImageFormatR32i},
TestData{type::TexelFormat::kR32Float, SpvImageFormatR32f},
TestData{type::TexelFormat::kRgba8Unorm, SpvImageFormatRgba8},
TestData{type::TexelFormat::kRgba8Snorm, SpvImageFormatRgba8Snorm},
TestData{type::TexelFormat::kRgba8Uint, SpvImageFormatRgba8ui},
TestData{type::TexelFormat::kRgba8Sint, SpvImageFormatRgba8i},
TestData{type::TexelFormat::kRg32Uint, SpvImageFormatRg32ui, true},
TestData{type::TexelFormat::kRg32Sint, SpvImageFormatRg32i, true},
TestData{type::TexelFormat::kRg32Float, SpvImageFormatRg32f, true},
TestData{type::TexelFormat::kRgba16Uint, SpvImageFormatRgba16ui},
TestData{type::TexelFormat::kRgba16Sint, SpvImageFormatRgba16i},
TestData{type::TexelFormat::kRgba16Float, SpvImageFormatRgba16f},
TestData{type::TexelFormat::kRgba32Uint, SpvImageFormatRgba32ui},
TestData{type::TexelFormat::kRgba32Sint, SpvImageFormatRgba32i},
TestData{type::TexelFormat::kRgba32Float, SpvImageFormatRgba32f}));
} // namespace
} // namespace tint::writer::spirv

2
src/tint/writer/spirv/builder_global_variable_test.cc
View File

@ -472,7 +472,7 @@ OpName %9 "unused_entry_point"
TEST_F(BuilderTest, GlobalVar_TextureStorageWriteOnly) {
// var<uniform_constant> a : texture_storage_2d<r32uint, write>;
auto* type = ty.storage_texture(type::TextureDimension::k2d, ast::TexelFormat::kR32Uint,
auto* type = ty.storage_texture(type::TextureDimension::k2d, type::TexelFormat::kR32Uint,
type::Access::kWrite);
auto* var_a = GlobalVar("a", type, Binding(0_a), Group(0_a));

14
src/tint/writer/spirv/builder_type_test.cc
View File

@ -860,7 +860,7 @@ TEST_F(BuilderTest_Type, SampledTexture_Generate_CubeArray) {
}
TEST_F(BuilderTest_Type, StorageTexture_Generate_1d) {
auto* s = ty.storage_texture(type::TextureDimension::k1d, ast::TexelFormat::kR32Float,
auto* s = ty.storage_texture(type::TextureDimension::k1d, type::TexelFormat::kR32Float,
type::Access::kWrite);
GlobalVar("test_var", s, Binding(0_a), Group(0_a));
@ -875,7 +875,7 @@ TEST_F(BuilderTest_Type, StorageTexture_Generate_1d) {
}
TEST_F(BuilderTest_Type, StorageTexture_Generate_2d) {
auto* s = ty.storage_texture(type::TextureDimension::k2d, ast::TexelFormat::kR32Float,
auto* s = ty.storage_texture(type::TextureDimension::k2d, type::TexelFormat::kR32Float,
type::Access::kWrite);
GlobalVar("test_var", s, Binding(0_a), Group(0_a));
@ -890,7 +890,7 @@ TEST_F(BuilderTest_Type, StorageTexture_Generate_2d) {
}
TEST_F(BuilderTest_Type, StorageTexture_Generate_2dArray) {
auto* s = ty.storage_texture(type::TextureDimension::k2dArray, ast::TexelFormat::kR32Float,
auto* s = ty.storage_texture(type::TextureDimension::k2dArray, type::TexelFormat::kR32Float,
type::Access::kWrite);
GlobalVar("test_var", s, Binding(0_a), Group(0_a));
@ -905,7 +905,7 @@ TEST_F(BuilderTest_Type, StorageTexture_Generate_2dArray) {
}
TEST_F(BuilderTest_Type, StorageTexture_Generate_3d) {
auto* s = ty.storage_texture(type::TextureDimension::k3d, ast::TexelFormat::kR32Float,
auto* s = ty.storage_texture(type::TextureDimension::k3d, type::TexelFormat::kR32Float,
type::Access::kWrite);
GlobalVar("test_var", s, Binding(0_a), Group(0_a));
@ -920,7 +920,7 @@ TEST_F(BuilderTest_Type, StorageTexture_Generate_3d) {
}
TEST_F(BuilderTest_Type, StorageTexture_Generate_SampledTypeFloat_Format_r32float) {
auto* s = ty.storage_texture(type::TextureDimension::k2d, ast::TexelFormat::kR32Float,
auto* s = ty.storage_texture(type::TextureDimension::k2d, type::TexelFormat::kR32Float,
type::Access::kWrite);
GlobalVar("test_var", s, Binding(0_a), Group(0_a));
@ -935,7 +935,7 @@ TEST_F(BuilderTest_Type, StorageTexture_Generate_SampledTypeFloat_Format_r32floa
}
TEST_F(BuilderTest_Type, StorageTexture_Generate_SampledTypeSint_Format_r32sint) {
auto* s = ty.storage_texture(type::TextureDimension::k2d, ast::TexelFormat::kR32Sint,
auto* s = ty.storage_texture(type::TextureDimension::k2d, type::TexelFormat::kR32Sint,
type::Access::kWrite);
GlobalVar("test_var", s, Binding(0_a), Group(0_a));
@ -950,7 +950,7 @@ TEST_F(BuilderTest_Type, StorageTexture_Generate_SampledTypeSint_Format_r32sint)
}
TEST_F(BuilderTest_Type, StorageTexture_Generate_SampledTypeUint_Format_r32uint) {
auto* s = ty.storage_texture(type::TextureDimension::k2d, ast::TexelFormat::kR32Uint,
auto* s = ty.storage_texture(type::TextureDimension::k2d, type::TexelFormat::kR32Uint,
type::Access::kWrite);
GlobalVar("test_var", s, Binding(0_a), Group(0_a));

4
src/tint/writer/wgsl/generator_impl.cc
View File

@ -350,9 +350,9 @@ bool GeneratorImpl::EmitFunction(const ast::Function* func) {
return true;
}
bool GeneratorImpl::EmitImageFormat(std::ostream& out, const ast::TexelFormat fmt) {
bool GeneratorImpl::EmitImageFormat(std::ostream& out, const type::TexelFormat fmt) {
switch (fmt) {
case ast::TexelFormat::kUndefined:
case type::TexelFormat::kUndefined:
diagnostics_.add_error(diag::System::Writer, "unknown image format");
return false;
default:

2
src/tint/writer/wgsl/generator_impl.h
View File

@ -198,7 +198,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::TexelFormat fmt);
bool EmitImageFormat(std::ostream& out, const type::TexelFormat fmt);
/// Handles emitting an access control
/// @param out the output of the expression stream
/// @param access the access to generate

44
src/tint/writer/wgsl/generator_impl_type_test.cc
View File

@ -453,7 +453,7 @@ INSTANTIATE_TEST_SUITE_P(WgslGeneratorImplTest,
"texture_multisampled_2d"}));
struct StorageTextureData {
ast::TexelFormat fmt;
type::TexelFormat fmt;
type::TextureDimension dim;
type::Access access;
const char* name;
@ -479,17 +479,17 @@ INSTANTIATE_TEST_SUITE_P(
WgslGeneratorImplTest,
WgslGenerator_StorageTextureTest,
testing::Values(
StorageTextureData{ast::TexelFormat::kRgba8Sint, type::TextureDimension::k1d,
StorageTextureData{type::TexelFormat::kRgba8Sint, type::TextureDimension::k1d,
type::Access::kWrite, "texture_storage_1d<rgba8sint, write>"},
StorageTextureData{ast::TexelFormat::kRgba8Sint, type::TextureDimension::k2d,
StorageTextureData{type::TexelFormat::kRgba8Sint, type::TextureDimension::k2d,
type::Access::kWrite, "texture_storage_2d<rgba8sint, write>"},
StorageTextureData{ast::TexelFormat::kRgba8Sint, type::TextureDimension::k2dArray,
StorageTextureData{type::TexelFormat::kRgba8Sint, type::TextureDimension::k2dArray,
type::Access::kWrite, "texture_storage_2d_array<rgba8sint, write>"},
StorageTextureData{ast::TexelFormat::kRgba8Sint, type::TextureDimension::k3d,
StorageTextureData{type::TexelFormat::kRgba8Sint, type::TextureDimension::k3d,
type::Access::kWrite, "texture_storage_3d<rgba8sint, write>"}));
struct ImageFormatData {
ast::TexelFormat fmt;
type::TexelFormat fmt;
const char* name;
};
inline std::ostream& operator<<(std::ostream& out, ImageFormatData data) {
@ -510,22 +510,22 @@ TEST_P(WgslGenerator_ImageFormatTest, EmitType_StorageTexture_ImageFormat) {
INSTANTIATE_TEST_SUITE_P(
WgslGeneratorImplTest,
WgslGenerator_ImageFormatTest,
testing::Values(ImageFormatData{ast::TexelFormat::kR32Uint, "r32uint"},
ImageFormatData{ast::TexelFormat::kR32Sint, "r32sint"},
ImageFormatData{ast::TexelFormat::kR32Float, "r32float"},
ImageFormatData{ast::TexelFormat::kRgba8Unorm, "rgba8unorm"},
ImageFormatData{ast::TexelFormat::kRgba8Snorm, "rgba8snorm"},
ImageFormatData{ast::TexelFormat::kRgba8Uint, "rgba8uint"},
ImageFormatData{ast::TexelFormat::kRgba8Sint, "rgba8sint"},
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"}));
testing::Values(ImageFormatData{type::TexelFormat::kR32Uint, "r32uint"},
ImageFormatData{type::TexelFormat::kR32Sint, "r32sint"},
ImageFormatData{type::TexelFormat::kR32Float, "r32float"},
ImageFormatData{type::TexelFormat::kRgba8Unorm, "rgba8unorm"},
ImageFormatData{type::TexelFormat::kRgba8Snorm, "rgba8snorm"},
ImageFormatData{type::TexelFormat::kRgba8Uint, "rgba8uint"},
ImageFormatData{type::TexelFormat::kRgba8Sint, "rgba8sint"},
ImageFormatData{type::TexelFormat::kRg32Uint, "rg32uint"},
ImageFormatData{type::TexelFormat::kRg32Sint, "rg32sint"},
ImageFormatData{type::TexelFormat::kRg32Float, "rg32float"},
ImageFormatData{type::TexelFormat::kRgba16Uint, "rgba16uint"},
ImageFormatData{type::TexelFormat::kRgba16Sint, "rgba16sint"},
ImageFormatData{type::TexelFormat::kRgba16Float, "rgba16float"},
ImageFormatData{type::TexelFormat::kRgba32Uint, "rgba32uint"},
ImageFormatData{type::TexelFormat::kRgba32Sint, "rgba32sint"},
ImageFormatData{type::TexelFormat::kRgba32Float, "rgba32float"}));
TEST_F(WgslGeneratorImplTest, EmitType_Sampler) {
auto* sampler = ty.sampler(ast::SamplerKind::kSampler);