1 // Copyright 2024 The Amber 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 parseried.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 #include "gtest/gtest.h"
16 #include "src/amberscript/parser.h"
17
18 namespace amber {
19 namespace amberscript {
20
21 using AmberScriptParserTest = testing::Test;
22
TEST_F(AmberScriptParserTest,RunComputeTimedExecution)23 TEST_F(AmberScriptParserTest, RunComputeTimedExecution) {
24 std::string in = R"(
25 SHADER compute my_shader GLSL
26 void main() {
27 gl_FragColor = vec3(2, 3, 4);
28 }
29 END
30
31 PIPELINE compute my_pipeline
32 ATTACH my_shader
33 END
34
35 RUN TIMED_EXECUTION my_pipeline 2 4 5
36 )";
37
38 Parser parser;
39 Result r = parser.Parse(in);
40 ASSERT_TRUE(r.IsSuccess()) << r.Error();
41
42 auto script = parser.GetScript();
43 const auto& commands = script->GetCommands();
44 ASSERT_EQ(1U, commands.size());
45
46 auto* cmd = commands[0].get();
47 ASSERT_TRUE(cmd->IsCompute());
48 EXPECT_EQ(2U, cmd->AsCompute()->GetX());
49 EXPECT_EQ(4U, cmd->AsCompute()->GetY());
50 EXPECT_EQ(5U, cmd->AsCompute()->GetZ());
51 EXPECT_TRUE(cmd->AsCompute()->IsTimedExecution());
52 }
53
TEST_F(AmberScriptParserTest,RunComputeNoTimedExecution)54 TEST_F(AmberScriptParserTest, RunComputeNoTimedExecution) {
55 std::string in = R"(
56 SHADER compute my_shader GLSL
57 void main() {
58 gl_FragColor = vec3(2, 3, 4);
59 }
60 END
61
62 PIPELINE compute my_pipeline
63 ATTACH my_shader
64 END
65
66 RUN my_pipeline 2 4 5
67 )";
68
69 Parser parser;
70 Result r = parser.Parse(in);
71 ASSERT_TRUE(r.IsSuccess()) << r.Error();
72
73 auto script = parser.GetScript();
74 const auto& commands = script->GetCommands();
75 ASSERT_EQ(1U, commands.size());
76
77 auto* cmd = commands[0].get();
78 ASSERT_TRUE(cmd->IsCompute());
79 EXPECT_EQ(2U, cmd->AsCompute()->GetX());
80 EXPECT_EQ(4U, cmd->AsCompute()->GetY());
81 EXPECT_EQ(5U, cmd->AsCompute()->GetZ());
82 EXPECT_FALSE(cmd->AsCompute()->IsTimedExecution());
83 }
84
TEST_F(AmberScriptParserTest,RunDrawRectTimedExecution)85 TEST_F(AmberScriptParserTest, RunDrawRectTimedExecution) {
86 std::string in = R"(
87 SHADER vertex my_shader PASSTHROUGH
88 SHADER fragment my_fragment GLSL
89 # GLSL Shader
90 END
91
92 PIPELINE graphics my_pipeline
93 ATTACH my_shader
94 ATTACH my_fragment
95 END
96
97 RUN TIMED_EXECUTION my_pipeline DRAW_RECT POS 2 4 SIZE 10 20)";
98
99 Parser parser;
100 Result r = parser.Parse(in);
101 ASSERT_TRUE(r.IsSuccess()) << r.Error();
102
103 auto script = parser.GetScript();
104 const auto& commands = script->GetCommands();
105 ASSERT_EQ(1U, commands.size());
106
107 auto* cmd = commands[0].get();
108 ASSERT_TRUE(cmd->IsDrawRect());
109 EXPECT_TRUE(cmd->AsDrawRect()->IsOrtho());
110 EXPECT_FALSE(cmd->AsDrawRect()->IsPatch());
111 EXPECT_FLOAT_EQ(2.f, cmd->AsDrawRect()->GetX());
112 EXPECT_FLOAT_EQ(4.f, cmd->AsDrawRect()->GetY());
113 EXPECT_FLOAT_EQ(10.f, cmd->AsDrawRect()->GetWidth());
114 EXPECT_FLOAT_EQ(20.f, cmd->AsDrawRect()->GetHeight());
115 EXPECT_TRUE(cmd->AsDrawRect()->IsTimedExecution());
116 }
117
TEST_F(AmberScriptParserTest,RunDrawGridTimedExecution)118 TEST_F(AmberScriptParserTest, RunDrawGridTimedExecution) {
119 std::string in = R"(
120 SHADER vertex my_shader PASSTHROUGH
121 SHADER fragment my_fragment GLSL
122 # GLSL Shader
123 END
124
125 PIPELINE graphics my_pipeline
126 ATTACH my_shader
127 ATTACH my_fragment
128 END
129
130 RUN TIMED_EXECUTION my_pipeline DRAW_GRID POS 2 4 SIZE 10 20 CELLS 4 5)";
131
132 Parser parser;
133 Result r = parser.Parse(in);
134 ASSERT_TRUE(r.IsSuccess()) << r.Error();
135
136 auto script = parser.GetScript();
137 const auto& commands = script->GetCommands();
138 ASSERT_EQ(1U, commands.size());
139
140 auto* cmd = commands[0].get();
141 ASSERT_TRUE(cmd->IsDrawGrid());
142 EXPECT_FLOAT_EQ(2.f, cmd->AsDrawGrid()->GetX());
143 EXPECT_FLOAT_EQ(4.f, cmd->AsDrawGrid()->GetY());
144 EXPECT_FLOAT_EQ(10.f, cmd->AsDrawGrid()->GetWidth());
145 EXPECT_FLOAT_EQ(20.f, cmd->AsDrawGrid()->GetHeight());
146 EXPECT_EQ(4u, cmd->AsDrawGrid()->GetColumns());
147 EXPECT_EQ(5u, cmd->AsDrawGrid()->GetRows());
148 EXPECT_TRUE(cmd->AsDrawGrid()->IsTimedExecution());
149 }
150
TEST_F(AmberScriptParserTest,RunDrawArraysTimedExecution)151 TEST_F(AmberScriptParserTest, RunDrawArraysTimedExecution) {
152 std::string in = R"(
153 SHADER vertex my_shader PASSTHROUGH
154 SHADER fragment my_fragment GLSL
155 # GLSL Shader
156 END
157 BUFFER vtex_buf DATA_TYPE vec3<float> DATA
158 1 2 3
159 4 5 6
160 7 8 9
161 END
162
163 PIPELINE graphics my_pipeline
164 ATTACH my_shader
165 ATTACH my_fragment
166 VERTEX_DATA vtex_buf LOCATION 0
167 END
168
169 RUN TIMED_EXECUTION my_pipeline DRAW_ARRAY AS TRIANGLE_LIST START_IDX 1 COUNT 2)";
170
171 Parser parser;
172 Result r = parser.Parse(in);
173 ASSERT_TRUE(r.IsSuccess()) << r.Error();
174
175 auto script = parser.GetScript();
176 const auto& commands = script->GetCommands();
177 ASSERT_EQ(1U, commands.size());
178
179 ASSERT_TRUE(commands[0]->IsDrawArrays());
180
181 auto* cmd = commands[0]->AsDrawArrays();
182 EXPECT_FALSE(cmd->IsIndexed());
183 EXPECT_EQ(static_cast<uint32_t>(1U), cmd->GetInstanceCount());
184 EXPECT_EQ(static_cast<uint32_t>(0U), cmd->GetFirstInstance());
185 EXPECT_EQ(Topology::kTriangleList, cmd->GetTopology());
186 EXPECT_EQ(1U, cmd->GetFirstVertexIndex());
187 EXPECT_EQ(2U, cmd->GetVertexCount());
188 EXPECT_TRUE(cmd->IsTimedExecution());
189 }
190
TEST_F(AmberScriptParserTest,RunDrawArraysInstancedTimedExecution)191 TEST_F(AmberScriptParserTest, RunDrawArraysInstancedTimedExecution) {
192 std::string in = R"(
193 SHADER vertex my_shader PASSTHROUGH
194 SHADER fragment my_fragment GLSL
195 # GLSL Shader
196 END
197 BUFFER vtex_buf DATA_TYPE vec3<float> DATA
198 1 2 3
199 4 5 6
200 7 8 9
201 END
202
203 PIPELINE graphics my_pipeline
204 ATTACH my_shader
205 ATTACH my_fragment
206 VERTEX_DATA vtex_buf LOCATION 0
207 END
208
209 RUN TIMED_EXECUTION my_pipeline DRAW_ARRAY AS TRIANGLE_LIST START_IDX 1 COUNT 2 START_INSTANCE 2 INSTANCE_COUNT 10)";
210
211 Parser parser;
212 Result r = parser.Parse(in);
213 ASSERT_TRUE(r.IsSuccess()) << r.Error();
214
215 auto script = parser.GetScript();
216 const auto& commands = script->GetCommands();
217 ASSERT_EQ(1U, commands.size());
218
219 ASSERT_TRUE(commands[0]->IsDrawArrays());
220
221 auto* cmd = commands[0]->AsDrawArrays();
222 EXPECT_FALSE(cmd->IsIndexed());
223 EXPECT_EQ(static_cast<uint32_t>(10U), cmd->GetInstanceCount());
224 EXPECT_EQ(static_cast<uint32_t>(2U), cmd->GetFirstInstance());
225 EXPECT_EQ(Topology::kTriangleList, cmd->GetTopology());
226 EXPECT_EQ(1U, cmd->GetFirstVertexIndex());
227 EXPECT_EQ(2U, cmd->GetVertexCount());
228 EXPECT_TRUE(cmd->IsTimedExecution());
229 }
230
TEST_F(AmberScriptParserTest,RunDrawArraysIndexedTimedExecution)231 TEST_F(AmberScriptParserTest, RunDrawArraysIndexedTimedExecution) {
232 std::string in = R"(
233 SHADER vertex my_shader PASSTHROUGH
234 SHADER fragment my_fragment GLSL
235 # GLSL Shader
236 END
237 BUFFER vtex_buf DATA_TYPE vec3<float> DATA
238 1 2 3
239 4 5 6
240 7 8 9
241 END
242 BUFFER idx_buf DATA_TYPE vec3<float> DATA
243 9 8 7
244 6 5 4
245 3 2 1
246 END
247
248 PIPELINE graphics my_pipeline
249 ATTACH my_shader
250 ATTACH my_fragment
251 VERTEX_DATA vtex_buf LOCATION 0
252 INDEX_DATA idx_buf
253 END
254
255 RUN TIMED_EXECUTION my_pipeline DRAW_ARRAY AS TRIANGLE_LIST INDEXED)";
256
257 Parser parser;
258 Result r = parser.Parse(in);
259 ASSERT_TRUE(r.IsSuccess()) << r.Error();
260
261 auto script = parser.GetScript();
262 const auto& commands = script->GetCommands();
263 ASSERT_EQ(1U, commands.size());
264
265 ASSERT_TRUE(commands[0]->IsDrawArrays());
266
267 auto* cmd = commands[0]->AsDrawArrays();
268 EXPECT_TRUE(cmd->IsIndexed());
269 EXPECT_EQ(static_cast<uint32_t>(1U), cmd->GetInstanceCount());
270 EXPECT_EQ(static_cast<uint32_t>(0U), cmd->GetFirstInstance());
271 EXPECT_EQ(Topology::kTriangleList, cmd->GetTopology());
272 EXPECT_EQ(static_cast<uint32_t>(0U), cmd->GetFirstVertexIndex());
273 // There are 3 elements in the vertex buffer.
274 EXPECT_EQ(3U, cmd->GetVertexCount());
275 EXPECT_TRUE(cmd->IsTimedExecution());
276 }
277
278 } // namespace amberscript
279 } // namespace amber
280