Flutter Engine
The Flutter Engine
Functions
SkSLMemoryLayoutTest.cpp File Reference
#include "include/private/base/SkTArray.h"
#include "src/sksl/SkSLBuiltinTypes.h"
#include "src/sksl/SkSLContext.h"
#include "src/sksl/SkSLErrorReporter.h"
#include "src/sksl/SkSLMemoryLayout.h"
#include "src/sksl/SkSLPosition.h"
#include "src/sksl/SkSLProgramSettings.h"
#include "src/sksl/SkSLUtil.h"
#include "src/sksl/ir/SkSLLayout.h"
#include "src/sksl/ir/SkSLModifierFlags.h"
#include "src/sksl/ir/SkSLType.h"
#include "tests/Test.h"
#include <memory>
#include <string>
#include <string_view>
#include <utility>

Go to the source code of this file.

Functions

 DEF_TEST (SkSLMemoryLayoutTest_std140, r)
 
 DEF_TEST (SkSLMemoryLayoutTest_std430, r)
 
 DEF_TEST (SkSLMemoryLayoutTest_WGSLUniform_Base, r)
 
 DEF_TEST (SkSLMemoryLayoutTest_WGSLUniform_EnableF16, r)
 
 DEF_TEST (SkSLMemoryLayoutTest_WGSLStorage_Base, r)
 
 DEF_TEST (SkSLMemoryLayoutTest_WGSLStorage_EnableF16, r)
 
 DEF_TEST (SkSLMemoryLayoutTest_WGSLUnsupportedTypes, r)
 
 DEF_TEST (SkSLMemoryLayoutTest_WGSLSupportedTypes, r)
 

Function Documentation

◆ DEF_TEST() [1/8]

DEF_TEST ( SkSLMemoryLayoutTest_std140  ,
r   
)

Definition at line 28 of file SkSLMemoryLayoutTest.cpp.

28 {
29 SkSL::TestingOnly_AbortErrorReporter errors;
30 SkSL::BuiltinTypes types;
31 SkSL::Context context(types, errors);
32 SkSL::MemoryLayout layout(SkSL::MemoryLayout::Standard::k140);
33 SkSL::ProgramConfig config = {};
34 context.fConfig = &config;
35
36 // basic types
37 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fFloat));
38 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fFloat2));
39 REPORTER_ASSERT(r, 12 == layout.size(*context.fTypes.fFloat3));
40 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fFloat4));
41 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fInt));
42 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fInt2));
43 REPORTER_ASSERT(r, 12 == layout.size(*context.fTypes.fInt3));
44 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fInt4));
45 REPORTER_ASSERT(r, 1 == layout.size(*context.fTypes.fBool));
46 REPORTER_ASSERT(r, 2 == layout.size(*context.fTypes.fBool2));
47 REPORTER_ASSERT(r, 3 == layout.size(*context.fTypes.fBool3));
48 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fBool4));
49 REPORTER_ASSERT(r, 32 == layout.size(*context.fTypes.fFloat2x2));
50 REPORTER_ASSERT(r, 32 == layout.size(*context.fTypes.fFloat2x4));
51 REPORTER_ASSERT(r, 48 == layout.size(*context.fTypes.fFloat3x3));
52 REPORTER_ASSERT(r, 64 == layout.size(*context.fTypes.fFloat4x2));
53 REPORTER_ASSERT(r, 64 == layout.size(*context.fTypes.fFloat4x4));
54 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fAtomicUInt));
55 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fFloat));
56 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fFloat2));
57 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat3));
58 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat4));
59 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fInt));
60 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fInt2));
61 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fInt3));
62 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fInt4));
63 REPORTER_ASSERT(r, 1 == layout.alignment(*context.fTypes.fBool));
64 REPORTER_ASSERT(r, 2 == layout.alignment(*context.fTypes.fBool2));
65 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fBool3));
66 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fBool4));
67 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat2x2));
68 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat2x4));
69 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat3x3));
70 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat4x2));
71 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat4x4));
72 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fAtomicUInt));
73
74 // struct 1
75 TArray<SkSL::Field> fields1;
76 fields1.emplace_back(SkSL::Position(), SkSL::Layout(), SkSL::ModifierFlag::kNone,
77 std::string_view("a"), context.fTypes.fFloat3.get());
78 std::unique_ptr<SkSL::Type> s1 =
79 SkSL::Type::MakeStructType(context, SkSL::Position(), std::string("s1"), fields1);
80 REPORTER_ASSERT(r, 16 == layout.size(*s1));
81 REPORTER_ASSERT(r, 16 == layout.alignment(*s1));
82
83 fields1.emplace_back(SkSL::Position(), SkSL::Layout(), SkSL::ModifierFlag::kNone,
84 std::string_view("b"), context.fTypes.fFloat.get());
85 std::unique_ptr<SkSL::Type> s2 =
86 SkSL::Type::MakeStructType(context, SkSL::Position(), std::string("s2"), fields1);
87 REPORTER_ASSERT(r, 16 == layout.size(*s2));
88 REPORTER_ASSERT(r, 16 == layout.alignment(*s2));
89
90 fields1.emplace_back(SkSL::Position(), SkSL::Layout(), SkSL::ModifierFlag::kNone,
91 std::string_view("c"), context.fTypes.fBool.get());
92 std::unique_ptr<SkSL::Type> s3 =
93 SkSL::Type::MakeStructType(context, SkSL::Position(), std::string("s3"), fields1);
94 REPORTER_ASSERT(r, 32 == layout.size(*s3));
95 REPORTER_ASSERT(r, 16 == layout.alignment(*s3));
96
97 // struct 2
98 TArray<SkSL::Field> fields2;
99 fields2.emplace_back(SkSL::Position(), SkSL::Layout(), SkSL::ModifierFlag::kNone,
100 std::string_view("a"), context.fTypes.fInt.get());
101 std::unique_ptr<SkSL::Type> s4 =
102 SkSL::Type::MakeStructType(context, SkSL::Position(), std::string("s4"), fields2);
103 REPORTER_ASSERT(r, 16 == layout.size(*s4));
104 REPORTER_ASSERT(r, 16 == layout.alignment(*s4));
105
106 fields2.emplace_back(SkSL::Position(), SkSL::Layout(), SkSL::ModifierFlag::kNone,
107 std::string_view("b"), context.fTypes.fFloat3.get());
108 std::unique_ptr<SkSL::Type> s5 =
109 SkSL::Type::MakeStructType(context, SkSL::Position(), std::string("s5"), fields2);
110 REPORTER_ASSERT(r, 32 == layout.size(*s5));
111 REPORTER_ASSERT(r, 16 == layout.alignment(*s5));
112
113 // arrays
114 std::unique_ptr<SkSL::Type> array1 =
115 SkSL::Type::MakeArrayType(context, std::string("float[4]"), *context.fTypes.fFloat, 4);
116 REPORTER_ASSERT(r, 64 == layout.size(*array1));
117 REPORTER_ASSERT(r, 16 == layout.alignment(*array1));
118 REPORTER_ASSERT(r, 16 == layout.stride(*array1));
119
120 std::unique_ptr<SkSL::Type> array2 =
121 SkSL::Type::MakeArrayType(context, std::string("float4[4]"), *context.fTypes.fFloat4, 4);
122 REPORTER_ASSERT(r, 64 == layout.size(*array2));
123 REPORTER_ASSERT(r, 16 == layout.alignment(*array2));
124 REPORTER_ASSERT(r, 16 == layout.stride(*array2));
125}
REPORTER_ASSERT
#define REPORTER_ASSERT(r, cond,...)
Definition: Test.h:286
SkSL::TestingOnly_AbortErrorReporter
Definition: SkSLErrorReporter.h:58
SkSL::Type::MakeArrayType
static std::unique_ptr< Type > MakeArrayType(const Context &context, std::string_view name, const Type &componentType, int columns)
SkSL::Type::MakeStructType
static std::unique_ptr< Type > MakeStructType(const Context &context, Position pos, std::string_view name, skia_private::TArray< Field > fields, bool interfaceBlock=false)
skia_private::TArray< SkSL::Field >
skia_private::TArray::emplace_back
T & emplace_back(Args &&... args)
Definition: SkTArray.h:248
compiler_layering_check.errors
def errors
Definition: compiler_layering_check.py:128

◆ DEF_TEST() [2/8]

DEF_TEST ( SkSLMemoryLayoutTest_std430  ,
r   
)

Definition at line 127 of file SkSLMemoryLayoutTest.cpp.

127 {
128 SkSL::TestingOnly_AbortErrorReporter errors;
129 SkSL::BuiltinTypes types;
130 SkSL::Context context(types, errors);
131 SkSL::MemoryLayout layout(SkSL::MemoryLayout::Standard::k430);
132 SkSL::ProgramConfig config = {};
133 context.fConfig = &config;
134
135 // basic types
136 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fFloat));
137 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fFloat2));
138 REPORTER_ASSERT(r, 12 == layout.size(*context.fTypes.fFloat3));
139 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fFloat4));
140 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fInt));
141 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fInt2));
142 REPORTER_ASSERT(r, 12 == layout.size(*context.fTypes.fInt3));
143 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fInt4));
144 REPORTER_ASSERT(r, 1 == layout.size(*context.fTypes.fBool));
145 REPORTER_ASSERT(r, 2 == layout.size(*context.fTypes.fBool2));
146 REPORTER_ASSERT(r, 3 == layout.size(*context.fTypes.fBool3));
147 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fBool4));
148 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fFloat2x2));
149 REPORTER_ASSERT(r, 32 == layout.size(*context.fTypes.fFloat2x4));
150 REPORTER_ASSERT(r, 48 == layout.size(*context.fTypes.fFloat3x3));
151 REPORTER_ASSERT(r, 32 == layout.size(*context.fTypes.fFloat4x2));
152 REPORTER_ASSERT(r, 64 == layout.size(*context.fTypes.fFloat4x4));
153 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fAtomicUInt));
154 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fFloat));
155 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fFloat2));
156 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat3));
157 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat4));
158 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fInt));
159 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fInt2));
160 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fInt3));
161 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fInt4));
162 REPORTER_ASSERT(r, 1 == layout.alignment(*context.fTypes.fBool));
163 REPORTER_ASSERT(r, 2 == layout.alignment(*context.fTypes.fBool2));
164 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fBool3));
165 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fBool4));
166 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fFloat2x2));
167 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat2x4));
168 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat3x3));
169 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fFloat4x2));
170 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat4x4));
171 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fAtomicUInt));
172
173 // struct 1
174 TArray<SkSL::Field> fields1;
175 fields1.emplace_back(SkSL::Position(), SkSL::Layout(), SkSL::ModifierFlag::kNone,
176 std::string_view("a"), context.fTypes.fFloat3.get());
177 std::unique_ptr<SkSL::Type> s1 =
178 SkSL::Type::MakeStructType(context, SkSL::Position(), std::string("s1"), fields1);
179 REPORTER_ASSERT(r, 16 == layout.size(*s1));
180 REPORTER_ASSERT(r, 16 == layout.alignment(*s1));
181
182 fields1.emplace_back(SkSL::Position(), SkSL::Layout(), SkSL::ModifierFlag::kNone,
183 std::string_view("b"), context.fTypes.fFloat.get());
184 std::unique_ptr<SkSL::Type> s2 =
185 SkSL::Type::MakeStructType(context, SkSL::Position(), std::string("s2"), fields1);
186 REPORTER_ASSERT(r, 16 == layout.size(*s2));
187 REPORTER_ASSERT(r, 16 == layout.alignment(*s2));
188
189 fields1.emplace_back(SkSL::Position(), SkSL::Layout(), SkSL::ModifierFlag::kNone,
190 std::string_view("c"), context.fTypes.fBool.get());
191 std::unique_ptr<SkSL::Type> s3 =
192 SkSL::Type::MakeStructType(context, SkSL::Position(), std::string("s3"), fields1);
193 REPORTER_ASSERT(r, 32 == layout.size(*s3));
194 REPORTER_ASSERT(r, 16 == layout.alignment(*s3));
195
196 // struct 2
197 TArray<SkSL::Field> fields2;
198 fields2.emplace_back(SkSL::Position(), SkSL::Layout(), SkSL::ModifierFlag::kNone,
199 std::string_view("a"), context.fTypes.fInt.get());
200 std::unique_ptr<SkSL::Type> s4 =
201 SkSL::Type::MakeStructType(context, SkSL::Position(), std::string("s4"), fields2);
202 REPORTER_ASSERT(r, 4 == layout.size(*s4));
203 REPORTER_ASSERT(r, 4 == layout.alignment(*s4));
204
205 fields2.emplace_back(SkSL::Position(), SkSL::Layout(), SkSL::ModifierFlag::kNone,
206 std::string_view("b"), context.fTypes.fFloat3.get());
207 std::unique_ptr<SkSL::Type> s5 =
208 SkSL::Type::MakeStructType(context, SkSL::Position(), std::string("s5"), fields2);
209 REPORTER_ASSERT(r, 32 == layout.size(*s5));
210 REPORTER_ASSERT(r, 16 == layout.alignment(*s5));
211
212 // arrays
213 std::unique_ptr<SkSL::Type> array1 =
214 SkSL::Type::MakeArrayType(context, std::string("float[4]"), *context.fTypes.fFloat, 4);
215 REPORTER_ASSERT(r, 16 == layout.size(*array1));
216 REPORTER_ASSERT(r, 4 == layout.alignment(*array1));
217 REPORTER_ASSERT(r, 4 == layout.stride(*array1));
218
219 std::unique_ptr<SkSL::Type> array2 =
220 SkSL::Type::MakeArrayType(context, std::string("float4[4]"), *context.fTypes.fFloat4, 4);
221 REPORTER_ASSERT(r, 64 == layout.size(*array2));
222 REPORTER_ASSERT(r, 16 == layout.alignment(*array2));
223 REPORTER_ASSERT(r, 16 == layout.stride(*array2));
224}

◆ DEF_TEST() [3/8]

DEF_TEST ( SkSLMemoryLayoutTest_WGSLStorage_Base  ,
r   
)

Definition at line 810 of file SkSLMemoryLayoutTest.cpp.

810 {
811 SkSL::TestingOnly_AbortErrorReporter errors;
812 SkSL::BuiltinTypes types;
813 SkSL::Context context(types, errors);
814 SkSL::MemoryLayout layout(SkSL::MemoryLayout::Standard::kWGSLStorage_Base);
815 SkSL::ProgramConfig config = {};
816 context.fConfig = &config;
817
818 // The values here are taken from https://www.w3.org/TR/WGSL/#alignment-and-size, table titled
819 // "Alignment and size for host-shareable types".
820
821 // scalars (i32, u32, f32, f16)
822 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fInt));
823 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fUInt));
824 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fShort));
825 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fUShort));
826 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fFloat));
827 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fHalf));
828 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fInt));
829 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fUInt));
830 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fShort));
831 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fUShort));
832 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fFloat));
833 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fHalf));
834
835 // vec2<T>, T: i32, u32, f32, f16
836 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fInt2));
837 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fUInt2));
838 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fShort2));
839 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fUShort2));
840 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fFloat2));
841 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fHalf2));
842 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fInt2));
843 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fUInt2));
844 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fShort2));
845 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fUShort2));
846 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fFloat2));
847 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fHalf2));
848
849 // vec3<T>, T: i32, u32, f32, f16
850 REPORTER_ASSERT(r, 12 == layout.size(*context.fTypes.fInt3));
851 REPORTER_ASSERT(r, 12 == layout.size(*context.fTypes.fUInt3));
852 REPORTER_ASSERT(r, 12 == layout.size(*context.fTypes.fShort3));
853 REPORTER_ASSERT(r, 12 == layout.size(*context.fTypes.fUShort3));
854 REPORTER_ASSERT(r, 12 == layout.size(*context.fTypes.fFloat3));
855 REPORTER_ASSERT(r, 12 == layout.size(*context.fTypes.fHalf3));
856 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fInt3));
857 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fUInt3));
858 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fShort3));
859 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fUShort3));
860 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat3));
861 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fHalf3));
862
863 // vec4<T>, T: i32, u32, f32, f16
864 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fInt4));
865 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fUInt4));
866 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fShort4));
867 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fUShort4));
868 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fFloat4));
869 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fHalf4));
870 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fInt4));
871 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fUInt4));
872 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fShort4));
873 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fUShort4));
874 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat4));
875 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fHalf4));
876
877 // mat2x2<f32>, mat2x2<f16>
878 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fFloat2x2));
879 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fHalf2x2));
880 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fFloat2x2));
881 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fHalf2x2));
882 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fFloat2x2));
883 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fHalf2x2));
884
885 // mat3x2<f32>, mat3x2<f16>
886 REPORTER_ASSERT(r, 24 == layout.size(*context.fTypes.fFloat3x2));
887 REPORTER_ASSERT(r, 24 == layout.size(*context.fTypes.fHalf3x2));
888 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fFloat3x2));
889 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fHalf3x2));
890 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fFloat3x2));
891 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fHalf3x2));
892
893 // mat4x2<f32>, mat4x2<f16>
894 REPORTER_ASSERT(r, 32 == layout.size(*context.fTypes.fFloat4x2));
895 REPORTER_ASSERT(r, 32 == layout.size(*context.fTypes.fHalf4x2));
896 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fFloat4x2));
897 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fHalf4x2));
898 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fFloat4x2));
899 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fHalf4x2));
900
901 // mat2x3<f32>, mat2x3<f16>
902 REPORTER_ASSERT(r, 32 == layout.size(*context.fTypes.fFloat2x3));
903 REPORTER_ASSERT(r, 32 == layout.size(*context.fTypes.fHalf2x3));
904 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat2x3));
905 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fHalf2x3));
906 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fFloat2x3));
907 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fHalf2x3));
908
909 // mat3x3<f32>, mat3x3<f16>
910 REPORTER_ASSERT(r, 48 == layout.size(*context.fTypes.fFloat3x3));
911 REPORTER_ASSERT(r, 48 == layout.size(*context.fTypes.fHalf3x3));
912 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat3x3));
913 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fHalf3x3));
914 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fFloat3x3));
915 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fHalf3x3));
916
917 // mat4x3<f32>, mat4x3<f16>
918 REPORTER_ASSERT(r, 64 == layout.size(*context.fTypes.fFloat4x3));
919 REPORTER_ASSERT(r, 64 == layout.size(*context.fTypes.fHalf4x3));
920 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat4x3));
921 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fHalf4x3));
922 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fFloat4x3));
923 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fHalf4x3));
924
925 // mat2x4<f32>, mat2x4<f16>
926 REPORTER_ASSERT(r, 32 == layout.size(*context.fTypes.fFloat2x4));
927 REPORTER_ASSERT(r, 32 == layout.size(*context.fTypes.fHalf2x4));
928 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat2x4));
929 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fHalf2x4));
930 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fFloat2x4));
931 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fHalf2x4));
932
933 // mat3x4<f32>, mat3x4<f16>
934 REPORTER_ASSERT(r, 48 == layout.size(*context.fTypes.fFloat3x4));
935 REPORTER_ASSERT(r, 48 == layout.size(*context.fTypes.fHalf3x4));
936 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat3x4));
937 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fHalf3x4));
938 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fFloat3x4));
939 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fHalf3x4));
940
941 // mat4x4<f32>, mat4x4<f16>
942 REPORTER_ASSERT(r, 64 == layout.size(*context.fTypes.fFloat4x4));
943 REPORTER_ASSERT(r, 64 == layout.size(*context.fTypes.fHalf4x4));
944 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat4x4));
945 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fHalf4x4));
946 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fFloat4x4));
947 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fHalf4x4));
948
949 // atomic<u32>
950 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fAtomicUInt));
951 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fAtomicUInt));
952
953 // bool is not a host-shareable type and returns 0 for WGSL.
954 REPORTER_ASSERT(r, 0 == layout.size(*context.fTypes.fBool));
955 REPORTER_ASSERT(r, 0 == layout.size(*context.fTypes.fBool2));
956 REPORTER_ASSERT(r, 0 == layout.size(*context.fTypes.fBool3));
957 REPORTER_ASSERT(r, 0 == layout.size(*context.fTypes.fBool4));
958
959 // Arrays
960 // array<f32, 4>
961 {
962 auto array = SkSL::Type::MakeArrayType(context, "float[4]", *context.fTypes.fFloat, 4);
963 REPORTER_ASSERT(r, 16 == layout.size(*array));
964 REPORTER_ASSERT(r, 4 == layout.alignment(*array));
965 REPORTER_ASSERT(r, 4 == layout.stride(*array));
966 }
967 // array<f16, 4>
968 {
969 auto array = SkSL::Type::MakeArrayType(context, "half[4]", *context.fTypes.fHalf, 4);
970 REPORTER_ASSERT(r, 16 == layout.size(*array));
971 REPORTER_ASSERT(r, 4 == layout.alignment(*array));
972 REPORTER_ASSERT(r, 4 == layout.stride(*array));
973 }
974 // array<vec2<f32>, 4>
975 {
976 auto array = SkSL::Type::MakeArrayType(context, "float2[4]", *context.fTypes.fFloat2, 4);
977 REPORTER_ASSERT(r, 32 == layout.size(*array));
978 REPORTER_ASSERT(r, 8 == layout.alignment(*array));
979 REPORTER_ASSERT(r, 8 == layout.stride(*array));
980 }
981 // array<vec3<f32>, 4>
982 {
983 auto array = SkSL::Type::MakeArrayType(context, "float3[4]", *context.fTypes.fFloat3, 4);
984 REPORTER_ASSERT(r, 64 == layout.size(*array));
985 REPORTER_ASSERT(r, 16 == layout.alignment(*array));
986 REPORTER_ASSERT(r, 16 == layout.stride(*array));
987 }
988 // array<vec4<f32>, 4>
989 {
990 auto array = SkSL::Type::MakeArrayType(context, "float4[4]", *context.fTypes.fFloat4, 4);
991 REPORTER_ASSERT(r, 64 == layout.size(*array));
992 REPORTER_ASSERT(r, 16 == layout.alignment(*array));
993 REPORTER_ASSERT(r, 16 == layout.stride(*array));
994 }
995 // array<mat3x3<f32>, 4>
996 {
997 auto array = SkSL::Type::MakeArrayType(context, "mat3[4]", *context.fTypes.fFloat3x3, 4);
998 REPORTER_ASSERT(r, 192 == layout.size(*array));
999 REPORTER_ASSERT(r, 16 == layout.alignment(*array));
1000 REPORTER_ASSERT(r, 48 == layout.stride(*array));
1001 }
1002
1003 // Structs A and B from example in https://www.w3.org/TR/WGSL/#structure-member-layout
1004 //
1005 // struct A { // align(8) size(24)
1006 // u: f32, // offset(0) align(4) size(4)
1007 // v: f32, // offset(4) align(4) size(4)
1008 // w: vec2<f32>, // offset(8) align(8) size(8)
1009 // x: f32 // offset(16) align(4) size(4)
1010 // // padding // offset(20) size(4)
1011 // }
1012 TArray<SkSL::Field> fields;
1013 fields.emplace_back(SkSL::Position(),
1014 SkSL::Layout(),
1015 SkSL::ModifierFlag::kNone,
1016 std::string_view("u"),
1017 context.fTypes.fFloat.get());
1018 fields.emplace_back(SkSL::Position(),
1019 SkSL::Layout(),
1020 SkSL::ModifierFlag::kNone,
1021 std::string_view("v"),
1022 context.fTypes.fFloat.get());
1023 fields.emplace_back(SkSL::Position(),
1024 SkSL::Layout(),
1025 SkSL::ModifierFlag::kNone,
1026 std::string_view("w"),
1027 context.fTypes.fFloat2.get());
1028 fields.emplace_back(SkSL::Position(),
1029 SkSL::Layout(),
1030 SkSL::ModifierFlag::kNone,
1031 std::string_view("x"),
1032 context.fTypes.fFloat.get());
1033 std::unique_ptr<SkSL::Type> structA = SkSL::Type::MakeStructType(
1034 context, SkSL::Position(), std::string_view("A"), std::move(fields));
1035 REPORTER_ASSERT(r, 24 == layout.size(*structA));
1036 REPORTER_ASSERT(r, 8 == layout.alignment(*structA));
1037 fields = {};
1038
1039 // struct B { // align(16) size(160)
1040 // a: vec2<f32>, // offset(0) align(8) size(8)
1041 // // padding // offset(8) size(8)
1042 // b: vec3<f32>, // offset(16) align(16) size(12)
1043 // c: f32, // offset(28) align(4) size(4)
1044 // d: f32, // offset(32) align(4) size(4)
1045 // // padding // offset(36) size(4)
1046 // e: A, // offset(40) align(8) size(24)
1047 // f: vec3<f32>, // offset(64) align(16) size(12)
1048 // // padding // offset(76) size(4)
1049 // g: array<A, 3>, // offset(80) align(16) size(72)
1050 // h: i32 // offset(152) align(4) size(4)
1051 // // padding // offset(156) size(4)
1052 // }
1053 fields.emplace_back(SkSL::Position(),
1054 SkSL::Layout(),
1055 SkSL::ModifierFlag::kNone,
1056 std::string_view("a"),
1057 context.fTypes.fFloat2.get());
1058 fields.emplace_back(SkSL::Position(),
1059 SkSL::Layout(),
1060 SkSL::ModifierFlag::kNone,
1061 std::string_view("b"),
1062 context.fTypes.fFloat3.get());
1063 fields.emplace_back(SkSL::Position(),
1064 SkSL::Layout(),
1065 SkSL::ModifierFlag::kNone,
1066 std::string_view("c"),
1067 context.fTypes.fFloat.get());
1068 fields.emplace_back(SkSL::Position(),
1069 SkSL::Layout(),
1070 SkSL::ModifierFlag::kNone,
1071 std::string_view("d"),
1072 context.fTypes.fFloat.get());
1073 fields.emplace_back(SkSL::Position(),
1074 SkSL::Layout(),
1075 SkSL::ModifierFlag::kNone,
1076 std::string_view("e"),
1077 structA.get());
1078 fields.emplace_back(SkSL::Position(),
1079 SkSL::Layout(),
1080 SkSL::ModifierFlag::kNone,
1081 std::string_view("f"),
1082 context.fTypes.fFloat3.get());
1083 auto array = SkSL::Type::MakeArrayType(context, "A[3]", *structA, 3);
1084 fields.emplace_back(SkSL::Position(),
1085 SkSL::Layout(),
1086 SkSL::ModifierFlag::kNone,
1087 std::string_view("g"),
1088 array.get());
1089 fields.emplace_back(SkSL::Position(),
1090 SkSL::Layout(),
1091 SkSL::ModifierFlag::kNone,
1092 std::string_view("h"),
1093 context.fTypes.fInt.get());
1094 std::unique_ptr<SkSL::Type> structB = SkSL::Type::MakeStructType(
1095 context, SkSL::Position(), std::string_view("B"), std::move(fields));
1096 REPORTER_ASSERT(r, 160 == layout.size(*structB));
1097 REPORTER_ASSERT(r, 16 == layout.alignment(*structB));
1098}

◆ DEF_TEST() [4/8]

DEF_TEST ( SkSLMemoryLayoutTest_WGSLStorage_EnableF16  ,
r   
)

Definition at line 1100 of file SkSLMemoryLayoutTest.cpp.

1100 {
1101 SkSL::TestingOnly_AbortErrorReporter errors;
1102 SkSL::BuiltinTypes types;
1103 SkSL::Context context(types, errors);
1104 SkSL::MemoryLayout layout(SkSL::MemoryLayout::Standard::kWGSLStorage_EnableF16);
1105 SkSL::ProgramConfig config = {};
1106 context.fConfig = &config;
1107
1108 // The values here are taken from https://www.w3.org/TR/WGSL/#alignment-and-size, table titled
1109 // "Alignment and size for host-shareable types".
1110
1111 // scalars (i32, u32, f32, f16)
1112 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fInt));
1113 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fUInt));
1114 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fShort));
1115 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fUShort));
1116 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fFloat));
1117 REPORTER_ASSERT(r, 2 == layout.size(*context.fTypes.fHalf));
1118 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fInt));
1119 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fUInt));
1120 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fShort));
1121 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fUShort));
1122 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fFloat));
1123 REPORTER_ASSERT(r, 2 == layout.alignment(*context.fTypes.fHalf));
1124
1125 // vec2<T>, T: i32, u32, f32, f16
1126 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fInt2));
1127 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fUInt2));
1128 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fShort2));
1129 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fUShort2));
1130 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fFloat2));
1131 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fHalf2));
1132 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fInt2));
1133 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fUInt2));
1134 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fShort2));
1135 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fUShort2));
1136 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fFloat2));
1137 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fHalf2));
1138
1139 // vec3<T>, T: i32, u32, f32, f16
1140 REPORTER_ASSERT(r, 12 == layout.size(*context.fTypes.fInt3));
1141 REPORTER_ASSERT(r, 12 == layout.size(*context.fTypes.fUInt3));
1142 REPORTER_ASSERT(r, 12 == layout.size(*context.fTypes.fShort3));
1143 REPORTER_ASSERT(r, 12 == layout.size(*context.fTypes.fUShort3));
1144 REPORTER_ASSERT(r, 12 == layout.size(*context.fTypes.fFloat3));
1145 REPORTER_ASSERT(r, 6 == layout.size(*context.fTypes.fHalf3));
1146 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fInt3));
1147 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fUInt3));
1148 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fShort3));
1149 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fUShort3));
1150 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat3));
1151 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fHalf3));
1152
1153 // vec4<T>, T: i32, u32, f32, f16
1154 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fInt4));
1155 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fUInt4));
1156 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fShort4));
1157 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fUShort4));
1158 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fFloat4));
1159 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fHalf4));
1160 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fInt4));
1161 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fUInt4));
1162 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fShort4));
1163 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fUShort4));
1164 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat4));
1165 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fHalf4));
1166
1167 // mat2x2<f32>, mat2x2<f16>
1168 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fFloat2x2));
1169 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fHalf2x2));
1170 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fFloat2x2));
1171 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fHalf2x2));
1172 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fFloat2x2));
1173 REPORTER_ASSERT(r, 4 == layout.stride(*context.fTypes.fHalf2x2));
1174
1175 // mat3x2<f32>, mat3x2<f16>
1176 REPORTER_ASSERT(r, 24 == layout.size(*context.fTypes.fFloat3x2));
1177 REPORTER_ASSERT(r, 12 == layout.size(*context.fTypes.fHalf3x2));
1178 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fFloat3x2));
1179 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fHalf3x2));
1180 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fFloat3x2));
1181 REPORTER_ASSERT(r, 4 == layout.stride(*context.fTypes.fHalf3x2));
1182
1183 // mat4x2<f32>, mat4x2<f16>
1184 REPORTER_ASSERT(r, 32 == layout.size(*context.fTypes.fFloat4x2));
1185 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fHalf4x2));
1186 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fFloat4x2));
1187 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fHalf4x2));
1188 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fFloat4x2));
1189 REPORTER_ASSERT(r, 4 == layout.stride(*context.fTypes.fHalf4x2));
1190
1191 // mat2x3<f32>, mat2x3<f16>
1192 REPORTER_ASSERT(r, 32 == layout.size(*context.fTypes.fFloat2x3));
1193 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fHalf2x3));
1194 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat2x3));
1195 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fHalf2x3));
1196 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fFloat2x3));
1197 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fHalf2x3));
1198
1199 // mat3x3<f32>, mat3x3<f16>
1200 REPORTER_ASSERT(r, 48 == layout.size(*context.fTypes.fFloat3x3));
1201 REPORTER_ASSERT(r, 24 == layout.size(*context.fTypes.fHalf3x3));
1202 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat3x3));
1203 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fHalf3x3));
1204 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fFloat3x3));
1205 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fHalf3x3));
1206
1207 // mat4x3<f32>, mat4x3<f16>
1208 REPORTER_ASSERT(r, 64 == layout.size(*context.fTypes.fFloat4x3));
1209 REPORTER_ASSERT(r, 32 == layout.size(*context.fTypes.fHalf4x3));
1210 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat4x3));
1211 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fHalf4x3));
1212 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fFloat4x3));
1213 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fHalf4x3));
1214
1215 // mat2x4<f32>, mat2x4<f16>
1216 REPORTER_ASSERT(r, 32 == layout.size(*context.fTypes.fFloat2x4));
1217 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fHalf2x4));
1218 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat2x4));
1219 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fHalf2x4));
1220 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fFloat2x4));
1221 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fHalf2x4));
1222
1223 // mat3x4<f32>, mat3x4<f16>
1224 REPORTER_ASSERT(r, 48 == layout.size(*context.fTypes.fFloat3x4));
1225 REPORTER_ASSERT(r, 24 == layout.size(*context.fTypes.fHalf3x4));
1226 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat3x4));
1227 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fHalf3x4));
1228 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fFloat3x4));
1229 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fHalf3x4));
1230
1231 // mat4x4<f32>, mat4x4<f16>
1232 REPORTER_ASSERT(r, 64 == layout.size(*context.fTypes.fFloat4x4));
1233 REPORTER_ASSERT(r, 32 == layout.size(*context.fTypes.fHalf4x4));
1234 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat4x4));
1235 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fHalf4x4));
1236 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fFloat4x4));
1237 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fHalf4x4));
1238
1239 // atomic<u32>
1240 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fAtomicUInt));
1241 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fAtomicUInt));
1242
1243 // bool is not a host-shareable type and returns 0 for WGSL.
1244 REPORTER_ASSERT(r, 0 == layout.size(*context.fTypes.fBool));
1245 REPORTER_ASSERT(r, 0 == layout.size(*context.fTypes.fBool2));
1246 REPORTER_ASSERT(r, 0 == layout.size(*context.fTypes.fBool3));
1247 REPORTER_ASSERT(r, 0 == layout.size(*context.fTypes.fBool4));
1248
1249 // Arrays
1250 // array<f32, 4>
1251 {
1252 auto array = SkSL::Type::MakeArrayType(context, "float[4]", *context.fTypes.fFloat, 4);
1253 REPORTER_ASSERT(r, 16 == layout.size(*array));
1254 REPORTER_ASSERT(r, 4 == layout.alignment(*array));
1255 REPORTER_ASSERT(r, 4 == layout.stride(*array));
1256 }
1257 // array<f16, 4>
1258 {
1259 auto array = SkSL::Type::MakeArrayType(context, "half[4]", *context.fTypes.fHalf, 4);
1260 REPORTER_ASSERT(r, 8 == layout.size(*array));
1261 REPORTER_ASSERT(r, 2 == layout.alignment(*array));
1262 REPORTER_ASSERT(r, 2 == layout.stride(*array));
1263 }
1264 // array<vec2<f32>, 4>
1265 {
1266 auto array = SkSL::Type::MakeArrayType(context, "float2[4]", *context.fTypes.fFloat2, 4);
1267 REPORTER_ASSERT(r, 32 == layout.size(*array));
1268 REPORTER_ASSERT(r, 8 == layout.alignment(*array));
1269 REPORTER_ASSERT(r, 8 == layout.stride(*array));
1270 }
1271 // array<vec3<f32>, 4>
1272 {
1273 auto array = SkSL::Type::MakeArrayType(context, "float3[4]", *context.fTypes.fFloat3, 4);
1274 REPORTER_ASSERT(r, 64 == layout.size(*array));
1275 REPORTER_ASSERT(r, 16 == layout.alignment(*array));
1276 REPORTER_ASSERT(r, 16 == layout.stride(*array));
1277 }
1278 // array<vec4<f32>, 4>
1279 {
1280 auto array = SkSL::Type::MakeArrayType(context, "float4[4]", *context.fTypes.fFloat4, 4);
1281 REPORTER_ASSERT(r, 64 == layout.size(*array));
1282 REPORTER_ASSERT(r, 16 == layout.alignment(*array));
1283 REPORTER_ASSERT(r, 16 == layout.stride(*array));
1284 }
1285 // array<mat3x3<f32>, 4>
1286 {
1287 auto array = SkSL::Type::MakeArrayType(context, "mat3[4]", *context.fTypes.fFloat3x3, 4);
1288 REPORTER_ASSERT(r, 192 == layout.size(*array));
1289 REPORTER_ASSERT(r, 16 == layout.alignment(*array));
1290 REPORTER_ASSERT(r, 48 == layout.stride(*array));
1291 }
1292
1293 // Structs A and B from example in https://www.w3.org/TR/WGSL/#structure-member-layout
1294 //
1295 // struct A { // align(8) size(24)
1296 // u: f32, // offset(0) align(4) size(4)
1297 // v: f32, // offset(4) align(4) size(4)
1298 // w: vec2<f32>, // offset(8) align(8) size(8)
1299 // x: f32 // offset(16) align(4) size(4)
1300 // // padding // offset(20) size(4)
1301 // }
1302 TArray<SkSL::Field> fields;
1303 fields.emplace_back(SkSL::Position(),
1304 SkSL::Layout(),
1305 SkSL::ModifierFlag::kNone,
1306 std::string_view("u"),
1307 context.fTypes.fFloat.get());
1308 fields.emplace_back(SkSL::Position(),
1309 SkSL::Layout(),
1310 SkSL::ModifierFlag::kNone,
1311 std::string_view("v"),
1312 context.fTypes.fFloat.get());
1313 fields.emplace_back(SkSL::Position(),
1314 SkSL::Layout(),
1315 SkSL::ModifierFlag::kNone,
1316 std::string_view("w"),
1317 context.fTypes.fFloat2.get());
1318 fields.emplace_back(SkSL::Position(),
1319 SkSL::Layout(),
1320 SkSL::ModifierFlag::kNone,
1321 std::string_view("x"),
1322 context.fTypes.fFloat.get());
1323 std::unique_ptr<SkSL::Type> structA = SkSL::Type::MakeStructType(
1324 context, SkSL::Position(), std::string_view("A"), std::move(fields));
1325 REPORTER_ASSERT(r, 24 == layout.size(*structA));
1326 REPORTER_ASSERT(r, 8 == layout.alignment(*structA));
1327 fields = {};
1328
1329 // struct B { // align(16) size(160)
1330 // a: vec2<f32>, // offset(0) align(8) size(8)
1331 // // padding // offset(8) size(8)
1332 // b: vec3<f32>, // offset(16) align(16) size(12)
1333 // c: f32, // offset(28) align(4) size(4)
1334 // d: f32, // offset(32) align(4) size(4)
1335 // // padding // offset(36) size(4)
1336 // e: A, // offset(40) align(8) size(24)
1337 // f: vec3<f32>, // offset(64) align(16) size(12)
1338 // // padding // offset(76) size(4)
1339 // g: array<A, 3>, // offset(80) align(16) size(72)
1340 // h: i32 // offset(152) align(4) size(4)
1341 // // padding // offset(156) size(4)
1342 // }
1343 fields.emplace_back(SkSL::Position(),
1344 SkSL::Layout(),
1345 SkSL::ModifierFlag::kNone,
1346 std::string_view("a"),
1347 context.fTypes.fFloat2.get());
1348 fields.emplace_back(SkSL::Position(),
1349 SkSL::Layout(),
1350 SkSL::ModifierFlag::kNone,
1351 std::string_view("b"),
1352 context.fTypes.fFloat3.get());
1353 fields.emplace_back(SkSL::Position(),
1354 SkSL::Layout(),
1355 SkSL::ModifierFlag::kNone,
1356 std::string_view("c"),
1357 context.fTypes.fFloat.get());
1358 fields.emplace_back(SkSL::Position(),
1359 SkSL::Layout(),
1360 SkSL::ModifierFlag::kNone,
1361 std::string_view("d"),
1362 context.fTypes.fFloat.get());
1363 fields.emplace_back(SkSL::Position(),
1364 SkSL::Layout(),
1365 SkSL::ModifierFlag::kNone,
1366 std::string_view("e"),
1367 structA.get());
1368 fields.emplace_back(SkSL::Position(),
1369 SkSL::Layout(),
1370 SkSL::ModifierFlag::kNone,
1371 std::string_view("f"),
1372 context.fTypes.fFloat3.get());
1373 auto array = SkSL::Type::MakeArrayType(context, "A[3]", *structA, 3);
1374 fields.emplace_back(SkSL::Position(),
1375 SkSL::Layout(),
1376 SkSL::ModifierFlag::kNone,
1377 std::string_view("g"),
1378 array.get());
1379 fields.emplace_back(SkSL::Position(),
1380 SkSL::Layout(),
1381 SkSL::ModifierFlag::kNone,
1382 std::string_view("h"),
1383 context.fTypes.fInt.get());
1384 std::unique_ptr<SkSL::Type> structB = SkSL::Type::MakeStructType(
1385 context, SkSL::Position(), std::string_view("B"), std::move(fields));
1386 REPORTER_ASSERT(r, 160 == layout.size(*structB));
1387 REPORTER_ASSERT(r, 16 == layout.alignment(*structB));
1388}

◆ DEF_TEST() [5/8]

DEF_TEST ( SkSLMemoryLayoutTest_WGSLSupportedTypes  ,
r   
)

Definition at line 1417 of file SkSLMemoryLayoutTest.cpp.

1417 {
1418 SkSL::TestingOnly_AbortErrorReporter errors;
1419 SkSL::BuiltinTypes types;
1420 SkSL::Context context(types, errors);
1421 SkSL::ProgramConfig config = {};
1422 context.fConfig = &config;
1423
1424 auto testArray = SkSL::Type::MakeArrayType(context, "float[3]", *context.fTypes.fFloat, 3);
1425
1426 TArray<SkSL::Field> fields;
1427 fields.emplace_back(SkSL::Position(),
1428 SkSL::Layout(),
1429 SkSL::ModifierFlag::kNone,
1430 std::string_view("foo"),
1431 testArray.get());
1432 auto testStruct = SkSL::Type::MakeStructType(
1433 context, SkSL::Position(), std::string_view("Test"), std::move(fields));
1434
1435 SkSL::MemoryLayout layout(SkSL::MemoryLayout::Standard::kWGSLUniform_EnableF16);
1436
1437 // scalars (i32, u32, f32, f16)
1438 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fInt));
1439 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fUInt));
1440 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fShort));
1441 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fUShort));
1442 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fFloat));
1443 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fHalf));
1444
1445 // vec2<T>, T: i32, u32, f32, f16
1446 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fInt2));
1447 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fUInt2));
1448 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fShort2));
1449 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fUShort2));
1450 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fFloat2));
1451 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fHalf2));
1452
1453 // vec3<T>, T: i32, u32, f32, f16
1454 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fInt3));
1455 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fUInt3));
1456 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fShort3));
1457 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fUShort3));
1458 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fFloat3));
1459 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fHalf3));
1460
1461 // vec4<T>, T: i32, u32, f32, f16
1462 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fInt4));
1463 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fUInt4));
1464 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fFloat4));
1465 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fShort4));
1466 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fUShort4));
1467 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fHalf4));
1468
1469 // mat2x2<f32>, mat2x2<f16>
1470 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fFloat2x2));
1471 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fHalf2x2));
1472
1473 // mat3x2<f32>, mat3x2<f16>
1474 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fFloat3x2));
1475 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fHalf3x2));
1476
1477 // mat4x2<f32>, mat4x2<f16>
1478 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fFloat4x2));
1479 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fHalf4x2));
1480
1481 // mat2x3<f32>, mat2x3<f16>
1482 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fFloat2x3));
1483 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fHalf2x3));
1484
1485 // mat3x3<f32>, mat3x3<f16>
1486 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fFloat3x3));
1487 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fHalf3x3));
1488
1489 // mat4x3<f32>, mat4x3<f16>
1490 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fFloat4x3));
1491 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fHalf4x3));
1492
1493 // mat2x4<f32>, mat2x4<f16>
1494 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fFloat2x4));
1495 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fHalf2x4));
1496
1497 // mat3x4<f32>, mat3x4<f16>
1498 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fFloat3x4));
1499 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fHalf3x4));
1500
1501 // mat4x4<f32>, mat4x4<f16>
1502 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fFloat4x4));
1503 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fHalf4x4));
1504
1505 // atomic<u32>
1506 REPORTER_ASSERT(r, layout.isSupported(*context.fTypes.fAtomicUInt));
1507
1508 // arrays and structs
1509 REPORTER_ASSERT(r, layout.isSupported(*testArray));
1510 REPORTER_ASSERT(r, layout.isSupported(*testStruct));
1511}

◆ DEF_TEST() [6/8]

DEF_TEST ( SkSLMemoryLayoutTest_WGSLUniform_Base  ,
r   
)

Definition at line 226 of file SkSLMemoryLayoutTest.cpp.

226 {
227 SkSL::TestingOnly_AbortErrorReporter errors;
228 SkSL::BuiltinTypes types;
229 SkSL::Context context(types, errors);
230 SkSL::MemoryLayout layout(SkSL::MemoryLayout::Standard::kWGSLUniform_Base);
231 SkSL::ProgramConfig config = {};
232 context.fConfig = &config;
233
234 // The values here are taken from https://www.w3.org/TR/WGSL/#alignment-and-size, table titled
235 // "Alignment and size for host-shareable types". WGSL does not have an i16 type, so short and
236 // unsigned-short integer types are treated as full-size integers in WGSL.
237
238 // scalars (i32, u32, f32, f16)
239 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fInt));
240 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fUInt));
241 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fShort));
242 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fUShort));
243 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fFloat));
244 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fHalf));
245 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fInt));
246 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fUInt));
247 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fShort));
248 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fUShort));
249 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fFloat));
250 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fHalf));
251
252 // vec2<T>, T: i32, u32, f32, f16
253 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fInt2));
254 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fUInt2));
255 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fShort2));
256 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fUShort2));
257 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fFloat2));
258 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fHalf2));
259 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fInt2));
260 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fUInt2));
261 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fShort2));
262 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fUShort2));
263 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fFloat2));
264 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fHalf2));
265
266 // vec3<T>, T: i32, u32, f32, f16
267 REPORTER_ASSERT(r, 12 == layout.size(*context.fTypes.fInt3));
268 REPORTER_ASSERT(r, 12 == layout.size(*context.fTypes.fUInt3));
269 REPORTER_ASSERT(r, 12 == layout.size(*context.fTypes.fShort3));
270 REPORTER_ASSERT(r, 12 == layout.size(*context.fTypes.fUShort3));
271 REPORTER_ASSERT(r, 12 == layout.size(*context.fTypes.fFloat3));
272 REPORTER_ASSERT(r, 12 == layout.size(*context.fTypes.fHalf3));
273 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fInt3));
274 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fUInt3));
275 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fShort3));
276 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fUShort3));
277 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat3));
278 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fHalf3));
279
280 // vec4<T>, T: i32, u32, f32, f16
281 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fInt4));
282 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fUInt4));
283 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fShort4));
284 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fUShort4));
285 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fFloat4));
286 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fHalf4));
287 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fInt4));
288 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fUInt4));
289 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fShort4));
290 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fUShort4));
291 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat4));
292 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fHalf4));
293
294 // mat2x2<f32>, mat2x2<f16>
295 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fFloat2x2));
296 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fHalf2x2));
297 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fFloat2x2));
298 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fHalf2x2));
299 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fFloat2x2));
300 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fHalf2x2));
301
302 // mat3x2<f32>, mat3x2<f16>
303 REPORTER_ASSERT(r, 24 == layout.size(*context.fTypes.fFloat3x2));
304 REPORTER_ASSERT(r, 24 == layout.size(*context.fTypes.fHalf3x2));
305 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fFloat3x2));
306 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fHalf3x2));
307 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fFloat3x2));
308 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fHalf3x2));
309
310 // mat4x2<f32>, mat4x2<f16>
311 REPORTER_ASSERT(r, 32 == layout.size(*context.fTypes.fFloat4x2));
312 REPORTER_ASSERT(r, 32 == layout.size(*context.fTypes.fHalf4x2));
313 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fFloat4x2));
314 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fHalf4x2));
315 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fFloat4x2));
316 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fHalf4x2));
317
318 // mat2x3<f32>, mat2x3<f16>
319 REPORTER_ASSERT(r, 32 == layout.size(*context.fTypes.fFloat2x3));
320 REPORTER_ASSERT(r, 32 == layout.size(*context.fTypes.fHalf2x3));
321 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat2x3));
322 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fHalf2x3));
323 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fFloat2x3));
324 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fHalf2x3));
325
326 // mat3x3<f32>, mat3x3<f16>
327 REPORTER_ASSERT(r, 48 == layout.size(*context.fTypes.fFloat3x3));
328 REPORTER_ASSERT(r, 48 == layout.size(*context.fTypes.fHalf3x3));
329 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat3x3));
330 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fHalf3x3));
331 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fFloat3x3));
332 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fHalf3x3));
333
334 // mat4x3<f32>, mat4x3<f16>
335 REPORTER_ASSERT(r, 64 == layout.size(*context.fTypes.fFloat4x3));
336 REPORTER_ASSERT(r, 64 == layout.size(*context.fTypes.fHalf4x3));
337 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat4x3));
338 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fHalf4x3));
339 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fFloat4x3));
340 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fHalf4x3));
341
342 // mat2x4<f32>, mat2x4<f16>
343 REPORTER_ASSERT(r, 32 == layout.size(*context.fTypes.fFloat2x4));
344 REPORTER_ASSERT(r, 32 == layout.size(*context.fTypes.fHalf2x4));
345 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat2x4));
346 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fHalf2x4));
347 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fFloat2x4));
348 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fHalf2x4));
349
350 // mat3x4<f32>, mat3x4<f16>
351 REPORTER_ASSERT(r, 48 == layout.size(*context.fTypes.fFloat3x4));
352 REPORTER_ASSERT(r, 48 == layout.size(*context.fTypes.fHalf3x4));
353 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat3x4));
354 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fHalf3x4));
355 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fFloat3x4));
356 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fHalf3x4));
357
358 // mat4x4<f32>, mat4x4<f16>
359 REPORTER_ASSERT(r, 64 == layout.size(*context.fTypes.fFloat4x4));
360 REPORTER_ASSERT(r, 64 == layout.size(*context.fTypes.fHalf4x4));
361 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat4x4));
362 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fHalf4x4));
363 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fFloat4x4));
364 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fHalf4x4));
365
366 // atomic<u32>
367 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fAtomicUInt));
368 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fAtomicUInt));
369
370 // bool is not a host-shareable type and returns 0 for WGSL.
371 REPORTER_ASSERT(r, 0 == layout.size(*context.fTypes.fBool));
372 REPORTER_ASSERT(r, 0 == layout.size(*context.fTypes.fBool2));
373 REPORTER_ASSERT(r, 0 == layout.size(*context.fTypes.fBool3));
374 REPORTER_ASSERT(r, 0 == layout.size(*context.fTypes.fBool4));
375
376 // Arrays
377 // array<f32, 4>
378 {
379 auto array = SkSL::Type::MakeArrayType(context, "float[4]", *context.fTypes.fFloat, 4);
380 REPORTER_ASSERT(r, 64 == layout.size(*array));
381 REPORTER_ASSERT(r, 16 == layout.alignment(*array));
382 REPORTER_ASSERT(r, 16 == layout.stride(*array));
383 }
384 // array<f16, 4>
385 {
386 auto array = SkSL::Type::MakeArrayType(context, "half[4]", *context.fTypes.fHalf, 4);
387 REPORTER_ASSERT(r, 64 == layout.size(*array));
388 REPORTER_ASSERT(r, 16 == layout.alignment(*array));
389 REPORTER_ASSERT(r, 16 == layout.stride(*array));
390 }
391 // array<vec2<f32>, 4>
392 {
393 auto array = SkSL::Type::MakeArrayType(context, "float2[4]", *context.fTypes.fFloat2, 4);
394 REPORTER_ASSERT(r, 64 == layout.size(*array));
395 REPORTER_ASSERT(r, 16 == layout.alignment(*array));
396 REPORTER_ASSERT(r, 16 == layout.stride(*array));
397 }
398 // array<vec3<f32>, 4>
399 {
400 auto array = SkSL::Type::MakeArrayType(context, "float3[4]", *context.fTypes.fFloat3, 4);
401 REPORTER_ASSERT(r, 64 == layout.size(*array));
402 REPORTER_ASSERT(r, 16 == layout.alignment(*array));
403 REPORTER_ASSERT(r, 16 == layout.stride(*array));
404 }
405 // array<vec4<f32>, 4>
406 {
407 auto array = SkSL::Type::MakeArrayType(context, "float4[4]", *context.fTypes.fFloat4, 4);
408 REPORTER_ASSERT(r, 64 == layout.size(*array));
409 REPORTER_ASSERT(r, 16 == layout.alignment(*array));
410 REPORTER_ASSERT(r, 16 == layout.stride(*array));
411 }
412 // array<mat3x3<f32>, 4>
413 {
414 auto array = SkSL::Type::MakeArrayType(context, "mat3[4]", *context.fTypes.fFloat3x3, 4);
415 REPORTER_ASSERT(r, 192 == layout.size(*array));
416 REPORTER_ASSERT(r, 16 == layout.alignment(*array));
417 REPORTER_ASSERT(r, 48 == layout.stride(*array));
418 }
419
420 // Structs A and B from example in https://www.w3.org/TR/WGSL/#structure-member-layout, with
421 // offsets adjusted for uniform address space constraints.
422 //
423 // struct A { // align(roundUp(16, 8)) size(roundUp(16, 24))
424 // u: f32, // offset(0) align(4) size(4)
425 // v: f32, // offset(4) align(4) size(4)
426 // w: vec2<f32>, // offset(8) align(8) size(8)
427 // x: f32 // offset(16) align(4) size(4)
428 // // padding // offset(20) size(12)
429 // }
430 TArray<SkSL::Field> fields;
431 fields.emplace_back(SkSL::Position(),
432 SkSL::Layout(),
433 SkSL::ModifierFlag::kNone,
434 std::string_view("u"),
435 context.fTypes.fFloat.get());
436 fields.emplace_back(SkSL::Position(),
437 SkSL::Layout(),
438 SkSL::ModifierFlag::kNone,
439 std::string_view("v"),
440 context.fTypes.fFloat.get());
441 fields.emplace_back(SkSL::Position(),
442 SkSL::Layout(),
443 SkSL::ModifierFlag::kNone,
444 std::string_view("w"),
445 context.fTypes.fFloat2.get());
446 fields.emplace_back(SkSL::Position(),
447 SkSL::Layout(),
448 SkSL::ModifierFlag::kNone,
449 std::string_view("x"),
450 context.fTypes.fFloat.get());
451 std::unique_ptr<SkSL::Type> structA = SkSL::Type::MakeStructType(
452 context, SkSL::Position(), std::string_view("A"), std::move(fields));
453 REPORTER_ASSERT(r, 32 == layout.size(*structA));
454 REPORTER_ASSERT(r, 16 == layout.alignment(*structA));
455 fields = {};
456
457 // struct B { // align(16) size(208)
458 // a: vec2<f32>, // offset(0) align(8) size(8)
459 // // padding // offset(8) size(8)
460 // b: vec3<f32>, // offset(16) align(16) size(12)
461 // c: f32, // offset(28) align(4) size(4)
462 // d: f32, // offset(32) align(4) size(4)
463 // // padding // offset(36) size(12)
464 // e: A, // offset(48) align(16) size(32)
465 // f: vec3<f32>, // offset(80) align(16) size(12)
466 // // padding // offset(92) size(4)
467 // g: array<A, 3>, // offset(96) align(16) size(96)
468 // h: i32 // offset(192) align(4) size(4)
469 // // padding // offset(196) size(12)
470 // }
471 fields.emplace_back(SkSL::Position(),
472 SkSL::Layout(),
473 SkSL::ModifierFlag::kNone,
474 std::string_view("a"),
475 context.fTypes.fFloat2.get());
476 fields.emplace_back(SkSL::Position(),
477 SkSL::Layout(),
478 SkSL::ModifierFlag::kNone,
479 std::string_view("b"),
480 context.fTypes.fFloat3.get());
481 fields.emplace_back(SkSL::Position(),
482 SkSL::Layout(),
483 SkSL::ModifierFlag::kNone,
484 std::string_view("c"),
485 context.fTypes.fFloat.get());
486 fields.emplace_back(SkSL::Position(),
487 SkSL::Layout(),
488 SkSL::ModifierFlag::kNone,
489 std::string_view("d"),
490 context.fTypes.fFloat.get());
491 fields.emplace_back(SkSL::Position(),
492 SkSL::Layout(),
493 SkSL::ModifierFlag::kNone,
494 std::string_view("e"),
495 structA.get());
496 fields.emplace_back(SkSL::Position(),
497 SkSL::Layout(),
498 SkSL::ModifierFlag::kNone,
499 std::string_view("f"),
500 context.fTypes.fFloat3.get());
501 auto array = SkSL::Type::MakeArrayType(context, "A[3]", *structA, 3);
502 fields.emplace_back(SkSL::Position(),
503 SkSL::Layout(),
504 SkSL::ModifierFlag::kNone,
505 std::string_view("g"),
506 array.get());
507 fields.emplace_back(SkSL::Position(),
508 SkSL::Layout(),
509 SkSL::ModifierFlag::kNone,
510 std::string_view("h"),
511 context.fTypes.fInt.get());
512 std::unique_ptr<SkSL::Type> structB = SkSL::Type::MakeStructType(
513 context, SkSL::Position(), std::string_view("B"), std::move(fields));
514 REPORTER_ASSERT(r, 208 == layout.size(*structB));
515 REPORTER_ASSERT(r, 16 == layout.alignment(*structB));
516}

◆ DEF_TEST() [7/8]

DEF_TEST ( SkSLMemoryLayoutTest_WGSLUniform_EnableF16  ,
r   
)

Definition at line 518 of file SkSLMemoryLayoutTest.cpp.

518 {
519 SkSL::TestingOnly_AbortErrorReporter errors;
520 SkSL::BuiltinTypes types;
521 SkSL::Context context(types, errors);
522 SkSL::MemoryLayout layout(SkSL::MemoryLayout::Standard::kWGSLUniform_EnableF16);
523 SkSL::ProgramConfig config = {};
524 context.fConfig = &config;
525
526 // The values here are taken from https://www.w3.org/TR/WGSL/#alignment-and-size, table titled
527 // "Alignment and size for host-shareable types". WGSL does not have an i16 type, so short and
528 // unsigned-short integer types are treated as full-size integers in WGSL.
529
530 // scalars (i32, u32, f32, f16)
531 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fInt));
532 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fUInt));
533 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fShort));
534 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fUShort));
535 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fFloat));
536 REPORTER_ASSERT(r, 2 == layout.size(*context.fTypes.fHalf));
537 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fInt));
538 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fUInt));
539 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fShort));
540 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fUShort));
541 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fFloat));
542 REPORTER_ASSERT(r, 2 == layout.alignment(*context.fTypes.fHalf));
543
544 // vec2<T>, T: i32, u32, f32, f16
545 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fInt2));
546 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fUInt2));
547 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fShort2));
548 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fUShort2));
549 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fFloat2));
550 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fHalf2));
551 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fInt2));
552 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fUInt2));
553 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fShort2));
554 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fUShort2));
555 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fFloat2));
556 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fHalf2));
557
558 // vec3<T>, T: i32, u32, f32, f16
559 REPORTER_ASSERT(r, 12 == layout.size(*context.fTypes.fInt3));
560 REPORTER_ASSERT(r, 12 == layout.size(*context.fTypes.fUInt3));
561 REPORTER_ASSERT(r, 12 == layout.size(*context.fTypes.fShort3));
562 REPORTER_ASSERT(r, 12 == layout.size(*context.fTypes.fUShort3));
563 REPORTER_ASSERT(r, 12 == layout.size(*context.fTypes.fFloat3));
564 REPORTER_ASSERT(r, 6 == layout.size(*context.fTypes.fHalf3));
565 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fInt3));
566 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fUInt3));
567 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fShort3));
568 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fUShort3));
569 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat3));
570 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fHalf3));
571
572 // vec4<T>, T: i32, u32, f32, f16
573 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fInt4));
574 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fUInt4));
575 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fShort4));
576 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fUShort4));
577 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fFloat4));
578 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fHalf4));
579 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fInt4));
580 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fUInt4));
581 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fShort4));
582 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fUShort4));
583 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat4));
584 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fHalf4));
585
586 // mat2x2<f32>, mat2x2<f16>
587 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fFloat2x2));
588 REPORTER_ASSERT(r, 8 == layout.size(*context.fTypes.fHalf2x2));
589 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fFloat2x2));
590 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fHalf2x2));
591 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fFloat2x2));
592 REPORTER_ASSERT(r, 4 == layout.stride(*context.fTypes.fHalf2x2));
593
594 // mat3x2<f32>, mat3x2<f16>
595 REPORTER_ASSERT(r, 24 == layout.size(*context.fTypes.fFloat3x2));
596 REPORTER_ASSERT(r, 12 == layout.size(*context.fTypes.fHalf3x2));
597 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fFloat3x2));
598 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fHalf3x2));
599 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fFloat3x2));
600 REPORTER_ASSERT(r, 4 == layout.stride(*context.fTypes.fHalf3x2));
601
602 // mat4x2<f32>, mat4x2<f16>
603 REPORTER_ASSERT(r, 32 == layout.size(*context.fTypes.fFloat4x2));
604 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fHalf4x2));
605 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fFloat4x2));
606 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fHalf4x2));
607 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fFloat4x2));
608 REPORTER_ASSERT(r, 4 == layout.stride(*context.fTypes.fHalf4x2));
609
610 // mat2x3<f32>, mat2x3<f16>
611 REPORTER_ASSERT(r, 32 == layout.size(*context.fTypes.fFloat2x3));
612 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fHalf2x3));
613 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat2x3));
614 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fHalf2x3));
615 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fFloat2x3));
616 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fHalf2x3));
617
618 // mat3x3<f32>, mat3x3<f16>
619 REPORTER_ASSERT(r, 48 == layout.size(*context.fTypes.fFloat3x3));
620 REPORTER_ASSERT(r, 24 == layout.size(*context.fTypes.fHalf3x3));
621 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat3x3));
622 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fHalf3x3));
623 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fFloat3x3));
624 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fHalf3x3));
625
626 // mat4x3<f32>, mat4x3<f16>
627 REPORTER_ASSERT(r, 64 == layout.size(*context.fTypes.fFloat4x3));
628 REPORTER_ASSERT(r, 32 == layout.size(*context.fTypes.fHalf4x3));
629 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat4x3));
630 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fHalf4x3));
631 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fFloat4x3));
632 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fHalf4x3));
633
634 // mat2x4<f32>, mat2x4<f16>
635 REPORTER_ASSERT(r, 32 == layout.size(*context.fTypes.fFloat2x4));
636 REPORTER_ASSERT(r, 16 == layout.size(*context.fTypes.fHalf2x4));
637 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat2x4));
638 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fHalf2x4));
639 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fFloat2x4));
640 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fHalf2x4));
641
642 // mat3x4<f32>, mat3x4<f16>
643 REPORTER_ASSERT(r, 48 == layout.size(*context.fTypes.fFloat3x4));
644 REPORTER_ASSERT(r, 24 == layout.size(*context.fTypes.fHalf3x4));
645 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat3x4));
646 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fHalf3x4));
647 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fFloat3x4));
648 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fHalf3x4));
649
650 // mat4x4<f32>, mat4x4<f16>
651 REPORTER_ASSERT(r, 64 == layout.size(*context.fTypes.fFloat4x4));
652 REPORTER_ASSERT(r, 32 == layout.size(*context.fTypes.fHalf4x4));
653 REPORTER_ASSERT(r, 16 == layout.alignment(*context.fTypes.fFloat4x4));
654 REPORTER_ASSERT(r, 8 == layout.alignment(*context.fTypes.fHalf4x4));
655 REPORTER_ASSERT(r, 16 == layout.stride(*context.fTypes.fFloat4x4));
656 REPORTER_ASSERT(r, 8 == layout.stride(*context.fTypes.fHalf4x4));
657
658 // atomic<u32>
659 REPORTER_ASSERT(r, 4 == layout.size(*context.fTypes.fAtomicUInt));
660 REPORTER_ASSERT(r, 4 == layout.alignment(*context.fTypes.fAtomicUInt));
661
662 // bool is not a host-shareable type and returns 0 for WGSL.
663 REPORTER_ASSERT(r, 0 == layout.size(*context.fTypes.fBool));
664 REPORTER_ASSERT(r, 0 == layout.size(*context.fTypes.fBool2));
665 REPORTER_ASSERT(r, 0 == layout.size(*context.fTypes.fBool3));
666 REPORTER_ASSERT(r, 0 == layout.size(*context.fTypes.fBool4));
667
668 // Arrays
669 // array<f32, 4>
670 {
671 auto array = SkSL::Type::MakeArrayType(context, "float[4]", *context.fTypes.fFloat, 4);
672 REPORTER_ASSERT(r, 64 == layout.size(*array));
673 REPORTER_ASSERT(r, 16 == layout.alignment(*array));
674 REPORTER_ASSERT(r, 16 == layout.stride(*array));
675 }
676 // array<f16, 4>
677 {
678 auto array = SkSL::Type::MakeArrayType(context, "half[4]", *context.fTypes.fHalf, 4);
679 REPORTER_ASSERT(r, 64 == layout.size(*array));
680 REPORTER_ASSERT(r, 16 == layout.alignment(*array));
681 REPORTER_ASSERT(r, 16 == layout.stride(*array));
682 }
683 // array<vec2<f32>, 4>
684 {
685 auto array = SkSL::Type::MakeArrayType(context, "float2[4]", *context.fTypes.fFloat2, 4);
686 REPORTER_ASSERT(r, 64 == layout.size(*array));
687 REPORTER_ASSERT(r, 16 == layout.alignment(*array));
688 REPORTER_ASSERT(r, 16 == layout.stride(*array));
689 }
690 // array<vec3<f32>, 4>
691 {
692 auto array = SkSL::Type::MakeArrayType(context, "float3[4]", *context.fTypes.fFloat3, 4);
693 REPORTER_ASSERT(r, 64 == layout.size(*array));
694 REPORTER_ASSERT(r, 16 == layout.alignment(*array));
695 REPORTER_ASSERT(r, 16 == layout.stride(*array));
696 }
697 // array<vec4<f32>, 4>
698 {
699 auto array = SkSL::Type::MakeArrayType(context, "float4[4]", *context.fTypes.fFloat4, 4);
700 REPORTER_ASSERT(r, 64 == layout.size(*array));
701 REPORTER_ASSERT(r, 16 == layout.alignment(*array));
702 REPORTER_ASSERT(r, 16 == layout.stride(*array));
703 }
704 // array<mat3x3<f32>, 4>
705 {
706 auto array = SkSL::Type::MakeArrayType(context, "mat3[4]", *context.fTypes.fFloat3x3, 4);
707 REPORTER_ASSERT(r, 192 == layout.size(*array));
708 REPORTER_ASSERT(r, 16 == layout.alignment(*array));
709 REPORTER_ASSERT(r, 48 == layout.stride(*array));
710 }
711
712 // Structs A and B from example in https://www.w3.org/TR/WGSL/#structure-member-layout, with
713 // offsets adjusted for uniform address space constraints.
714 //
715 // struct A { // align(roundUp(16, 8)) size(roundUp(16, 24))
716 // u: f32, // offset(0) align(4) size(4)
717 // v: f32, // offset(4) align(4) size(4)
718 // w: vec2<f32>, // offset(8) align(8) size(8)
719 // x: f32 // offset(16) align(4) size(4)
720 // // padding // offset(20) size(12)
721 // }
722 TArray<SkSL::Field> fields;
723 fields.emplace_back(SkSL::Position(),
724 SkSL::Layout(),
725 SkSL::ModifierFlag::kNone,
726 std::string_view("u"),
727 context.fTypes.fFloat.get());
728 fields.emplace_back(SkSL::Position(),
729 SkSL::Layout(),
730 SkSL::ModifierFlag::kNone,
731 std::string_view("v"),
732 context.fTypes.fFloat.get());
733 fields.emplace_back(SkSL::Position(),
734 SkSL::Layout(),
735 SkSL::ModifierFlag::kNone,
736 std::string_view("w"),
737 context.fTypes.fFloat2.get());
738 fields.emplace_back(SkSL::Position(),
739 SkSL::Layout(),
740 SkSL::ModifierFlag::kNone,
741 std::string_view("x"),
742 context.fTypes.fFloat.get());
743 std::unique_ptr<SkSL::Type> structA = SkSL::Type::MakeStructType(
744 context, SkSL::Position(), std::string_view("A"), std::move(fields));
745 REPORTER_ASSERT(r, 32 == layout.size(*structA));
746 REPORTER_ASSERT(r, 16 == layout.alignment(*structA));
747 fields = {};
748
749 // struct B { // align(16) size(208)
750 // a: vec2<f32>, // offset(0) align(8) size(8)
751 // // padding // offset(8) size(8)
752 // b: vec3<f32>, // offset(16) align(16) size(12)
753 // c: f32, // offset(28) align(4) size(4)
754 // d: f32, // offset(32) align(4) size(4)
755 // // padding // offset(36) size(12)
756 // e: A, // offset(48) align(16) size(32)
757 // f: vec3<f32>, // offset(80) align(16) size(12)
758 // // padding // offset(92) size(4)
759 // g: array<A, 3>, // offset(96) align(16) size(96)
760 // h: i32 // offset(192) align(4) size(4)
761 // // padding // offset(196) size(12)
762 // }
763 fields.emplace_back(SkSL::Position(),
764 SkSL::Layout(),
765 SkSL::ModifierFlag::kNone,
766 std::string_view("a"),
767 context.fTypes.fFloat2.get());
768 fields.emplace_back(SkSL::Position(),
769 SkSL::Layout(),
770 SkSL::ModifierFlag::kNone,
771 std::string_view("b"),
772 context.fTypes.fFloat3.get());
773 fields.emplace_back(SkSL::Position(),
774 SkSL::Layout(),
775 SkSL::ModifierFlag::kNone,
776 std::string_view("c"),
777 context.fTypes.fFloat.get());
778 fields.emplace_back(SkSL::Position(),
779 SkSL::Layout(),
780 SkSL::ModifierFlag::kNone,
781 std::string_view("d"),
782 context.fTypes.fFloat.get());
783 fields.emplace_back(SkSL::Position(),
784 SkSL::Layout(),
785 SkSL::ModifierFlag::kNone,
786 std::string_view("e"),
787 structA.get());
788 fields.emplace_back(SkSL::Position(),
789 SkSL::Layout(),
790 SkSL::ModifierFlag::kNone,
791 std::string_view("f"),
792 context.fTypes.fFloat3.get());
793 auto array = SkSL::Type::MakeArrayType(context, "A[3]", *structA, 3);
794 fields.emplace_back(SkSL::Position(),
795 SkSL::Layout(),
796 SkSL::ModifierFlag::kNone,
797 std::string_view("g"),
798 array.get());
799 fields.emplace_back(SkSL::Position(),
800 SkSL::Layout(),
801 SkSL::ModifierFlag::kNone,
802 std::string_view("h"),
803 context.fTypes.fInt.get());
804 std::unique_ptr<SkSL::Type> structB = SkSL::Type::MakeStructType(
805 context, SkSL::Position(), std::string_view("B"), std::move(fields));
806 REPORTER_ASSERT(r, 208 == layout.size(*structB));
807 REPORTER_ASSERT(r, 16 == layout.alignment(*structB));
808}

◆ DEF_TEST() [8/8]

DEF_TEST ( SkSLMemoryLayoutTest_WGSLUnsupportedTypes  ,
r   
)

Definition at line 1390 of file SkSLMemoryLayoutTest.cpp.

1390 {
1391 SkSL::TestingOnly_AbortErrorReporter errors;
1392 SkSL::BuiltinTypes types;
1393 SkSL::Context context(types, errors);
1394 SkSL::ProgramConfig config = {};
1395 context.fConfig = &config;
1396
1397 auto testArray = SkSL::Type::MakeArrayType(context, "bool[3]", *context.fTypes.fBool, 3);
1398
1399 TArray<SkSL::Field> fields;
1400 fields.emplace_back(SkSL::Position(),
1401 SkSL::Layout(),
1402 SkSL::ModifierFlag::kNone,
1403 std::string_view("foo"),
1404 testArray.get());
1405 auto testStruct = SkSL::Type::MakeStructType(
1406 context, SkSL::Position(), std::string_view("Test"), std::move(fields));
1407
1408 SkSL::MemoryLayout layout(SkSL::MemoryLayout::Standard::kWGSLUniform_EnableF16);
1409 REPORTER_ASSERT(r, !layout.isSupported(*context.fTypes.fBool));
1410 REPORTER_ASSERT(r, !layout.isSupported(*context.fTypes.fBool2));
1411 REPORTER_ASSERT(r, !layout.isSupported(*context.fTypes.fBool3));
1412 REPORTER_ASSERT(r, !layout.isSupported(*context.fTypes.fBool4));
1413 REPORTER_ASSERT(r, !layout.isSupported(*testArray));
1414 REPORTER_ASSERT(r, !layout.isSupported(*testStruct));
1415}
Generated on Sun Jun 23 2024 21:57:47 for Flutter Engine by doxygen 1.9.4