1 // Copyright 2020 The Tint Authors.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 #include "src/writer/hlsl/test_helper.h"
16
17 namespace tint {
18 namespace writer {
19 namespace hlsl {
20 namespace {
21
22 using HlslGeneratorImplTest_Assign = TestHelper;
23
TEST_F(HlslGeneratorImplTest_Assign,Emit_Assign)24 TEST_F(HlslGeneratorImplTest_Assign, Emit_Assign) {
25 Func("fn", {}, ty.void_(),
26 {
27 Decl(Var("lhs", ty.i32())),
28 Decl(Var("rhs", ty.i32())),
29 Assign("lhs", "rhs"),
30 });
31
32 GeneratorImpl& gen = Build();
33
34 ASSERT_TRUE(gen.Generate());
35 EXPECT_EQ(gen.result(),
36 R"(void fn() {
37 int lhs = 0;
38 int rhs = 0;
39 lhs = rhs;
40 }
41 )");
42 }
43
TEST_F(HlslGeneratorImplTest_Assign,Emit_Vector_Assign_ConstantIndex)44 TEST_F(HlslGeneratorImplTest_Assign, Emit_Vector_Assign_ConstantIndex) {
45 Func("fn", {}, ty.void_(),
46 {
47 Decl(Var("lhs", ty.vec3<f32>())),
48 Decl(Var("rhs", ty.f32())),
49 Decl(Const("index", ty.u32(), Expr(0u))),
50 Assign(IndexAccessor("lhs", "index"), "rhs"),
51 });
52
53 GeneratorImpl& gen = Build();
54
55 ASSERT_TRUE(gen.Generate());
56 EXPECT_EQ(gen.result(),
57 R"(void fn() {
58 float3 lhs = float3(0.0f, 0.0f, 0.0f);
59 float rhs = 0.0f;
60 const uint index = 0u;
61 lhs[index] = rhs;
62 }
63 )");
64 }
65
TEST_F(HlslGeneratorImplTest_Assign,Emit_Vector_Assign_DynamicIndex)66 TEST_F(HlslGeneratorImplTest_Assign, Emit_Vector_Assign_DynamicIndex) {
67 Func("fn", {}, ty.void_(),
68 {
69 Decl(Var("lhs", ty.vec3<f32>())),
70 Decl(Var("rhs", ty.f32())),
71 Decl(Var("index", ty.u32())),
72 Assign(IndexAccessor("lhs", "index"), "rhs"),
73 });
74
75 GeneratorImpl& gen = Build();
76
77 ASSERT_TRUE(gen.Generate());
78 EXPECT_EQ(gen.result(),
79 R"(void set_float3(inout float3 vec, int idx, float val) {
80 vec = (idx.xxx == int3(0, 1, 2)) ? val.xxx : vec;
81 }
82
83 void fn() {
84 float3 lhs = float3(0.0f, 0.0f, 0.0f);
85 float rhs = 0.0f;
86 uint index = 0u;
87 set_float3(lhs, index, rhs);
88 }
89 )");
90 }
91
TEST_F(HlslGeneratorImplTest_Assign,Emit_Matrix_Assign_Vector_ConstantIndex)92 TEST_F(HlslGeneratorImplTest_Assign, Emit_Matrix_Assign_Vector_ConstantIndex) {
93 Func("fn", {}, ty.void_(),
94 {
95 Decl(Var("lhs", ty.mat4x2<f32>())),
96 Decl(Var("rhs", ty.vec2<f32>())),
97 Decl(Const("index", ty.u32(), Expr(0u))),
98 Assign(IndexAccessor("lhs", "index"), "rhs"),
99 });
100
101 GeneratorImpl& gen = Build();
102
103 ASSERT_TRUE(gen.Generate());
104 EXPECT_EQ(gen.result(),
105 R"(void fn() {
106 float4x2 lhs = float4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
107 float2 rhs = float2(0.0f, 0.0f);
108 const uint index = 0u;
109 lhs[index] = rhs;
110 }
111 )");
112 }
113
TEST_F(HlslGeneratorImplTest_Assign,Emit_Matrix_Assign_Vector_DynamicIndex)114 TEST_F(HlslGeneratorImplTest_Assign, Emit_Matrix_Assign_Vector_DynamicIndex) {
115 Func("fn", {}, ty.void_(),
116 {
117 Decl(Var("lhs", ty.mat4x2<f32>())),
118 Decl(Var("rhs", ty.vec2<f32>())),
119 Decl(Var("index", ty.u32())),
120 Assign(IndexAccessor("lhs", "index"), "rhs"),
121 });
122
123 GeneratorImpl& gen = Build();
124
125 ASSERT_TRUE(gen.Generate());
126 EXPECT_EQ(
127 gen.result(),
128 R"(void set_vector_float4x2(inout float4x2 mat, int col, float2 val) {
129 switch (col) {
130 case 0: mat[0] = val; break;
131 case 1: mat[1] = val; break;
132 case 2: mat[2] = val; break;
133 case 3: mat[3] = val; break;
134 }
135 }
136
137 void fn() {
138 float4x2 lhs = float4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
139 float2 rhs = float2(0.0f, 0.0f);
140 uint index = 0u;
141 set_vector_float4x2(lhs, index, rhs);
142 }
143 )");
144 }
145
TEST_F(HlslGeneratorImplTest_Assign,Emit_Matrix_Assign_Scalar_ConstantIndex)146 TEST_F(HlslGeneratorImplTest_Assign, Emit_Matrix_Assign_Scalar_ConstantIndex) {
147 Func("fn", {}, ty.void_(),
148 {
149 Decl(Var("lhs", ty.mat4x2<f32>())),
150 Decl(Var("rhs", ty.f32())),
151 Decl(Const("index", ty.u32(), Expr(0u))),
152 Assign(IndexAccessor(IndexAccessor("lhs", "index"), "index"), "rhs"),
153 });
154
155 GeneratorImpl& gen = Build();
156
157 ASSERT_TRUE(gen.Generate());
158 EXPECT_EQ(gen.result(),
159 R"(void fn() {
160 float4x2 lhs = float4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
161 float rhs = 0.0f;
162 const uint index = 0u;
163 lhs[index][index] = rhs;
164 }
165 )");
166 }
167
TEST_F(HlslGeneratorImplTest_Assign,Emit_Matrix_Assign_Scalar_DynamicIndex)168 TEST_F(HlslGeneratorImplTest_Assign, Emit_Matrix_Assign_Scalar_DynamicIndex) {
169 Func("fn", {}, ty.void_(),
170 {
171 Decl(Var("lhs", ty.mat4x2<f32>())),
172 Decl(Var("rhs", ty.f32())),
173 Decl(Var("index", ty.u32())),
174 Assign(IndexAccessor(IndexAccessor("lhs", "index"), "index"), "rhs"),
175 });
176
177 GeneratorImpl& gen = Build();
178
179 ASSERT_TRUE(gen.Generate());
180 EXPECT_EQ(
181 gen.result(),
182 R"(void set_scalar_float4x2(inout float4x2 mat, int col, int row, float val) {
183 switch (col) {
184 case 0:
185 mat[0] = (row.xx == int2(0, 1)) ? val.xx : mat[0];
186 break;
187 case 1:
188 mat[1] = (row.xx == int2(0, 1)) ? val.xx : mat[1];
189 break;
190 case 2:
191 mat[2] = (row.xx == int2(0, 1)) ? val.xx : mat[2];
192 break;
193 case 3:
194 mat[3] = (row.xx == int2(0, 1)) ? val.xx : mat[3];
195 break;
196 }
197 }
198
199 void fn() {
200 float4x2 lhs = float4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
201 float rhs = 0.0f;
202 uint index = 0u;
203 set_scalar_float4x2(lhs, index, index, rhs);
204 }
205 )");
206 }
207
208 } // namespace
209 } // namespace hlsl
210 } // namespace writer
211 } // namespace tint
212