Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
5564 | serge | 1 | /* |
2 | * Copyright © 2012 Intel Corporation |
||
3 | * |
||
4 | * Permission is hereby granted, free of charge, to any person obtaining a |
||
5 | * copy of this software and associated documentation files (the "Software"), |
||
6 | * to deal in the Software without restriction, including without limitation |
||
7 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
||
8 | * and/or sell copies of the Software, and to permit persons to whom the |
||
9 | * Software is furnished to do so, subject to the following conditions: |
||
10 | * |
||
11 | * The above copyright notice and this permission notice (including the next |
||
12 | * paragraph) shall be included in all copies or substantial portions of the |
||
13 | * Software. |
||
14 | * |
||
15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||
16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||
17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
||
18 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||
19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
||
20 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
||
21 | * DEALINGS IN THE SOFTWARE. |
||
22 | */ |
||
23 | #include |
||
24 | #include "main/compiler.h" |
||
25 | #include "main/mtypes.h" |
||
26 | #include "main/macros.h" |
||
27 | #include "util/ralloc.h" |
||
28 | #include "uniform_initializer_utils.h" |
||
29 | |||
30 | namespace linker { |
||
31 | extern void |
||
32 | set_uniform_initializer(void *mem_ctx, gl_shader_program *prog, |
||
33 | const char *name, const glsl_type *type, |
||
34 | ir_constant *val, unsigned int boolean_true); |
||
35 | } |
||
36 | |||
37 | class set_uniform_initializer : public ::testing::Test { |
||
38 | public: |
||
39 | virtual void SetUp(); |
||
40 | virtual void TearDown(); |
||
41 | |||
42 | /** |
||
43 | * Index of the uniform to be tested. |
||
44 | * |
||
45 | * All of the \c set_uniform_initializer tests create several slots for |
||
46 | * unifroms. All but one of the slots is fake. This field holds the index |
||
47 | * of the slot for the uniform being tested. |
||
48 | */ |
||
49 | unsigned actual_index; |
||
50 | |||
51 | /** |
||
52 | * Name of the uniform to be tested. |
||
53 | */ |
||
54 | const char *name; |
||
55 | |||
56 | /** |
||
57 | * Shader program used in the test. |
||
58 | */ |
||
59 | struct gl_shader_program *prog; |
||
60 | |||
61 | /** |
||
62 | * Ralloc memory context used for all temporary allocations. |
||
63 | */ |
||
64 | void *mem_ctx; |
||
65 | }; |
||
66 | |||
67 | void |
||
68 | set_uniform_initializer::SetUp() |
||
69 | { |
||
70 | this->mem_ctx = ralloc_context(NULL); |
||
71 | this->prog = rzalloc(NULL, struct gl_shader_program); |
||
72 | |||
73 | /* Set default values used by the test cases. |
||
74 | */ |
||
75 | this->actual_index = 1; |
||
76 | this->name = "i"; |
||
77 | } |
||
78 | |||
79 | void |
||
80 | set_uniform_initializer::TearDown() |
||
81 | { |
||
82 | ralloc_free(this->mem_ctx); |
||
83 | this->mem_ctx = NULL; |
||
84 | |||
85 | ralloc_free(this->prog); |
||
86 | this->prog = NULL; |
||
87 | } |
||
88 | |||
89 | /** |
||
90 | * Create some uniform storage for a program. |
||
91 | * |
||
92 | * \param prog Program to get some storage |
||
93 | * \param num_storage Total number of storage slots |
||
94 | * \param index_to_set Storage slot that will actually get a value |
||
95 | * \param name Name for the actual storage slot |
||
96 | * \param type Type for the elements of the actual storage slot |
||
97 | * \param array_size Size for the array of the actual storage slot. This |
||
98 | * should be zero for non-arrays. |
||
99 | */ |
||
100 | static unsigned |
||
101 | establish_uniform_storage(struct gl_shader_program *prog, unsigned num_storage, |
||
102 | unsigned index_to_set, const char *name, |
||
103 | const glsl_type *type, unsigned array_size) |
||
104 | { |
||
105 | const unsigned elements = MAX2(1, array_size); |
||
106 | const unsigned data_components = elements * type->components(); |
||
107 | const unsigned total_components = MAX2(17, (data_components |
||
108 | + type->components())); |
||
109 | const unsigned red_zone_components = total_components - data_components; |
||
110 | |||
111 | prog->UniformStorage = rzalloc_array(prog, struct gl_uniform_storage, |
||
112 | num_storage); |
||
113 | prog->NumUserUniformStorage = num_storage; |
||
114 | |||
115 | prog->UniformStorage[index_to_set].name = (char *) name; |
||
116 | prog->UniformStorage[index_to_set].type = type; |
||
117 | prog->UniformStorage[index_to_set].array_elements = array_size; |
||
118 | prog->UniformStorage[index_to_set].initialized = false; |
||
119 | for (int sh = 0; sh < MESA_SHADER_STAGES; sh++) { |
||
120 | prog->UniformStorage[index_to_set].sampler[sh].index = ~0; |
||
121 | prog->UniformStorage[index_to_set].sampler[sh].active = false; |
||
122 | } |
||
123 | prog->UniformStorage[index_to_set].num_driver_storage = 0; |
||
124 | prog->UniformStorage[index_to_set].driver_storage = NULL; |
||
125 | prog->UniformStorage[index_to_set].storage = |
||
126 | rzalloc_array(prog, union gl_constant_value, total_components); |
||
127 | |||
128 | fill_storage_array_with_sentinels(prog->UniformStorage[index_to_set].storage, |
||
129 | data_components, |
||
130 | red_zone_components); |
||
131 | |||
132 | for (unsigned i = 0; i < num_storage; i++) { |
||
133 | if (i == index_to_set) |
||
134 | continue; |
||
135 | |||
136 | prog->UniformStorage[i].name = (char *) "invalid slot"; |
||
137 | prog->UniformStorage[i].type = glsl_type::void_type; |
||
138 | prog->UniformStorage[i].array_elements = 0; |
||
139 | prog->UniformStorage[i].initialized = false; |
||
140 | for (int sh = 0; sh < MESA_SHADER_STAGES; sh++) { |
||
141 | prog->UniformStorage[i].sampler[sh].index = ~0; |
||
142 | prog->UniformStorage[i].sampler[sh].active = false; |
||
143 | } |
||
144 | prog->UniformStorage[i].num_driver_storage = 0; |
||
145 | prog->UniformStorage[i].driver_storage = NULL; |
||
146 | prog->UniformStorage[i].storage = NULL; |
||
147 | } |
||
148 | |||
149 | return red_zone_components; |
||
150 | } |
||
151 | |||
152 | /** |
||
153 | * Verify that the correct uniform is marked as having been initialized. |
||
154 | */ |
||
155 | static void |
||
156 | verify_initialization(struct gl_shader_program *prog, unsigned actual_index) |
||
157 | { |
||
158 | for (unsigned i = 0; i < prog->NumUserUniformStorage; i++) { |
||
159 | if (i == actual_index) { |
||
160 | EXPECT_TRUE(prog->UniformStorage[actual_index].initialized); |
||
161 | } else { |
||
162 | EXPECT_FALSE(prog->UniformStorage[i].initialized); |
||
163 | } |
||
164 | } |
||
165 | } |
||
166 | |||
167 | static void |
||
168 | non_array_test(void *mem_ctx, struct gl_shader_program *prog, |
||
169 | unsigned actual_index, const char *name, |
||
170 | enum glsl_base_type base_type, |
||
171 | unsigned columns, unsigned rows) |
||
172 | { |
||
173 | const glsl_type *const type = |
||
174 | glsl_type::get_instance(base_type, rows, columns); |
||
175 | |||
176 | unsigned red_zone_components = |
||
177 | establish_uniform_storage(prog, 3, actual_index, name, type, 0); |
||
178 | |||
179 | ir_constant *val; |
||
180 | generate_data(mem_ctx, base_type, columns, rows, val); |
||
181 | |||
182 | linker::set_uniform_initializer(mem_ctx, prog, name, type, val, 0xF00F); |
||
183 | |||
184 | verify_initialization(prog, actual_index); |
||
185 | verify_data(prog->UniformStorage[actual_index].storage, 0, val, |
||
186 | red_zone_components, 0xF00F); |
||
187 | } |
||
188 | |||
189 | TEST_F(set_uniform_initializer, int_uniform) |
||
190 | { |
||
191 | non_array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_INT, 1, 1); |
||
192 | } |
||
193 | |||
194 | TEST_F(set_uniform_initializer, ivec2_uniform) |
||
195 | { |
||
196 | non_array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_INT, 1, 2); |
||
197 | } |
||
198 | |||
199 | TEST_F(set_uniform_initializer, ivec3_uniform) |
||
200 | { |
||
201 | non_array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_INT, 1, 3); |
||
202 | } |
||
203 | |||
204 | TEST_F(set_uniform_initializer, ivec4_uniform) |
||
205 | { |
||
206 | non_array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_INT, 1, 4); |
||
207 | } |
||
208 | |||
209 | TEST_F(set_uniform_initializer, uint_uniform) |
||
210 | { |
||
211 | non_array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_UINT, 1, 1); |
||
212 | } |
||
213 | |||
214 | TEST_F(set_uniform_initializer, uvec2_uniform) |
||
215 | { |
||
216 | non_array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_UINT, 1, 2); |
||
217 | } |
||
218 | |||
219 | TEST_F(set_uniform_initializer, uvec3_uniform) |
||
220 | { |
||
221 | non_array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_UINT, 1, 3); |
||
222 | } |
||
223 | |||
224 | TEST_F(set_uniform_initializer, uvec4_uniform) |
||
225 | { |
||
226 | non_array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_UINT, 1, 4); |
||
227 | } |
||
228 | |||
229 | TEST_F(set_uniform_initializer, bool_uniform) |
||
230 | { |
||
231 | non_array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_BOOL, 1, 1); |
||
232 | } |
||
233 | |||
234 | TEST_F(set_uniform_initializer, bvec2_uniform) |
||
235 | { |
||
236 | non_array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_BOOL, 1, 2); |
||
237 | } |
||
238 | |||
239 | TEST_F(set_uniform_initializer, bvec3_uniform) |
||
240 | { |
||
241 | non_array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_BOOL, 1, 3); |
||
242 | } |
||
243 | |||
244 | TEST_F(set_uniform_initializer, bvec4_uniform) |
||
245 | { |
||
246 | non_array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_BOOL, 1, 4); |
||
247 | } |
||
248 | |||
249 | TEST_F(set_uniform_initializer, float_uniform) |
||
250 | { |
||
251 | non_array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 1, 2); |
||
252 | } |
||
253 | |||
254 | TEST_F(set_uniform_initializer, vec2_uniform) |
||
255 | { |
||
256 | non_array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 1, 2); |
||
257 | } |
||
258 | |||
259 | TEST_F(set_uniform_initializer, vec3_uniform) |
||
260 | { |
||
261 | non_array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 1, 3); |
||
262 | } |
||
263 | |||
264 | TEST_F(set_uniform_initializer, vec4_uniform) |
||
265 | { |
||
266 | non_array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 1, 4); |
||
267 | } |
||
268 | |||
269 | TEST_F(set_uniform_initializer, mat2x2_uniform) |
||
270 | { |
||
271 | non_array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 2, 2); |
||
272 | } |
||
273 | |||
274 | TEST_F(set_uniform_initializer, mat2x3_uniform) |
||
275 | { |
||
276 | non_array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 2, 3); |
||
277 | } |
||
278 | |||
279 | TEST_F(set_uniform_initializer, mat2x4_uniform) |
||
280 | { |
||
281 | non_array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 2, 4); |
||
282 | } |
||
283 | |||
284 | TEST_F(set_uniform_initializer, mat3x2_uniform) |
||
285 | { |
||
286 | non_array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 3, 2); |
||
287 | } |
||
288 | |||
289 | TEST_F(set_uniform_initializer, mat3x3_uniform) |
||
290 | { |
||
291 | non_array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 3, 3); |
||
292 | } |
||
293 | |||
294 | TEST_F(set_uniform_initializer, mat3x4_uniform) |
||
295 | { |
||
296 | non_array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 3, 4); |
||
297 | } |
||
298 | |||
299 | TEST_F(set_uniform_initializer, mat4x2_uniform) |
||
300 | { |
||
301 | non_array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 4, 2); |
||
302 | } |
||
303 | |||
304 | TEST_F(set_uniform_initializer, mat4x3_uniform) |
||
305 | { |
||
306 | non_array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 4, 3); |
||
307 | } |
||
308 | |||
309 | TEST_F(set_uniform_initializer, mat4x4_uniform) |
||
310 | { |
||
311 | non_array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 4, 4); |
||
312 | } |
||
313 | |||
314 | static void |
||
315 | array_test(void *mem_ctx, struct gl_shader_program *prog, |
||
316 | unsigned actual_index, const char *name, |
||
317 | enum glsl_base_type base_type, |
||
318 | unsigned columns, unsigned rows, unsigned array_size, |
||
319 | unsigned excess_data_size) |
||
320 | { |
||
321 | const glsl_type *const element_type = |
||
322 | glsl_type::get_instance(base_type, rows, columns); |
||
323 | |||
324 | const unsigned red_zone_components = |
||
325 | establish_uniform_storage(prog, 3, actual_index, name, element_type, |
||
326 | array_size); |
||
327 | |||
328 | /* The constant value generated may have more array elements than the |
||
329 | * uniform that it initializes. In the real compiler and linker this can |
||
330 | * happen when a uniform array is compacted because some of the tail |
||
331 | * elements are not used. In this case, the type of the uniform will be |
||
332 | * modified, but the initializer will not. |
||
333 | */ |
||
334 | ir_constant *val; |
||
335 | generate_array_data(mem_ctx, base_type, columns, rows, |
||
336 | array_size + excess_data_size, val); |
||
337 | |||
338 | linker::set_uniform_initializer(mem_ctx, prog, name, element_type, val, |
||
339 | 0xF00F); |
||
340 | |||
341 | verify_initialization(prog, actual_index); |
||
342 | verify_data(prog->UniformStorage[actual_index].storage, array_size, |
||
343 | val, red_zone_components, 0xF00F); |
||
344 | } |
||
345 | |||
346 | TEST_F(set_uniform_initializer, int_array_uniform) |
||
347 | { |
||
348 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_INT, 1, 1, 4, 0); |
||
349 | } |
||
350 | |||
351 | TEST_F(set_uniform_initializer, ivec2_array_uniform) |
||
352 | { |
||
353 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_INT, 1, 2, 4, 0); |
||
354 | } |
||
355 | |||
356 | TEST_F(set_uniform_initializer, ivec3_array_uniform) |
||
357 | { |
||
358 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_INT, 1, 3, 4, 0); |
||
359 | } |
||
360 | |||
361 | TEST_F(set_uniform_initializer, ivec4_array_uniform) |
||
362 | { |
||
363 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_INT, 1, 4, 4, 0); |
||
364 | } |
||
365 | |||
366 | TEST_F(set_uniform_initializer, uint_array_uniform) |
||
367 | { |
||
368 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_UINT, 1, 1, 4, 0); |
||
369 | } |
||
370 | |||
371 | TEST_F(set_uniform_initializer, uvec2_array_uniform) |
||
372 | { |
||
373 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_UINT, 1, 2, 4, 0); |
||
374 | } |
||
375 | |||
376 | TEST_F(set_uniform_initializer, uvec3_array_uniform) |
||
377 | { |
||
378 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_UINT, 1, 3, 4, 0); |
||
379 | } |
||
380 | |||
381 | TEST_F(set_uniform_initializer, uvec4_array_uniform) |
||
382 | { |
||
383 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_UINT, 1, 4, 4, 0); |
||
384 | } |
||
385 | |||
386 | TEST_F(set_uniform_initializer, bool_array_uniform) |
||
387 | { |
||
388 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_BOOL, 1, 1, 4, 0); |
||
389 | } |
||
390 | |||
391 | TEST_F(set_uniform_initializer, bvec2_array_uniform) |
||
392 | { |
||
393 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_BOOL, 1, 2, 4, 0); |
||
394 | } |
||
395 | |||
396 | TEST_F(set_uniform_initializer, bvec3_array_uniform) |
||
397 | { |
||
398 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_BOOL, 1, 3, 4, 0); |
||
399 | } |
||
400 | |||
401 | TEST_F(set_uniform_initializer, bvec4_array_uniform) |
||
402 | { |
||
403 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_BOOL, 1, 4, 4, 0); |
||
404 | } |
||
405 | |||
406 | TEST_F(set_uniform_initializer, float_array_uniform) |
||
407 | { |
||
408 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 1, 1, 4, 0); |
||
409 | } |
||
410 | |||
411 | TEST_F(set_uniform_initializer, vec2_array_uniform) |
||
412 | { |
||
413 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 1, 2, 4, 0); |
||
414 | } |
||
415 | |||
416 | TEST_F(set_uniform_initializer, vec3_array_uniform) |
||
417 | { |
||
418 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 1, 3, 4, 0); |
||
419 | } |
||
420 | |||
421 | TEST_F(set_uniform_initializer, vec4_array_uniform) |
||
422 | { |
||
423 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 1, 4, 4, 0); |
||
424 | } |
||
425 | |||
426 | TEST_F(set_uniform_initializer, mat2x2_array_uniform) |
||
427 | { |
||
428 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 2, 2, 4, 0); |
||
429 | } |
||
430 | |||
431 | TEST_F(set_uniform_initializer, mat2x3_array_uniform) |
||
432 | { |
||
433 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 2, 3, 4, 0); |
||
434 | } |
||
435 | |||
436 | TEST_F(set_uniform_initializer, mat2x4_array_uniform) |
||
437 | { |
||
438 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 2, 4, 4, 0); |
||
439 | } |
||
440 | |||
441 | TEST_F(set_uniform_initializer, mat3x2_array_uniform) |
||
442 | { |
||
443 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 3, 2, 4, 0); |
||
444 | } |
||
445 | |||
446 | TEST_F(set_uniform_initializer, mat3x3_array_uniform) |
||
447 | { |
||
448 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 3, 3, 4, 0); |
||
449 | } |
||
450 | |||
451 | TEST_F(set_uniform_initializer, mat3x4_array_uniform) |
||
452 | { |
||
453 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 3, 4, 4, 0); |
||
454 | } |
||
455 | |||
456 | TEST_F(set_uniform_initializer, mat4x2_array_uniform) |
||
457 | { |
||
458 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 4, 2, 4, 0); |
||
459 | } |
||
460 | |||
461 | TEST_F(set_uniform_initializer, mat4x3_array_uniform) |
||
462 | { |
||
463 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 4, 3, 4, 0); |
||
464 | } |
||
465 | |||
466 | TEST_F(set_uniform_initializer, mat4x4_array_uniform) |
||
467 | { |
||
468 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 4, 4, 4, 0); |
||
469 | } |
||
470 | |||
471 | TEST_F(set_uniform_initializer, int_array_uniform_excess_initializer) |
||
472 | { |
||
473 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_INT, 1, 1, 4, 5); |
||
474 | } |
||
475 | |||
476 | TEST_F(set_uniform_initializer, ivec2_array_uniform_excess_initializer) |
||
477 | { |
||
478 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_INT, 1, 2, 4, 5); |
||
479 | } |
||
480 | |||
481 | TEST_F(set_uniform_initializer, ivec3_array_uniform_excess_initializer) |
||
482 | { |
||
483 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_INT, 1, 3, 4, 5); |
||
484 | } |
||
485 | |||
486 | TEST_F(set_uniform_initializer, ivec4_array_uniform_excess_initializer) |
||
487 | { |
||
488 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_INT, 1, 4, 4, 5); |
||
489 | } |
||
490 | |||
491 | TEST_F(set_uniform_initializer, uint_array_uniform_excess_initializer) |
||
492 | { |
||
493 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_UINT, 1, 1, 4, 5); |
||
494 | } |
||
495 | |||
496 | TEST_F(set_uniform_initializer, uvec2_array_uniform_excess_initializer) |
||
497 | { |
||
498 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_UINT, 1, 2, 4, 5); |
||
499 | } |
||
500 | |||
501 | TEST_F(set_uniform_initializer, uvec3_array_uniform_excess_initializer) |
||
502 | { |
||
503 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_UINT, 1, 3, 4, 5); |
||
504 | } |
||
505 | |||
506 | TEST_F(set_uniform_initializer, uvec4_array_uniform_excess_initializer) |
||
507 | { |
||
508 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_UINT, 1, 4, 4, 5); |
||
509 | } |
||
510 | |||
511 | TEST_F(set_uniform_initializer, bool_array_uniform_excess_initializer) |
||
512 | { |
||
513 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_BOOL, 1, 1, 4, 5); |
||
514 | } |
||
515 | |||
516 | TEST_F(set_uniform_initializer, bvec2_array_uniform_excess_initializer) |
||
517 | { |
||
518 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_BOOL, 1, 2, 4, 5); |
||
519 | } |
||
520 | |||
521 | TEST_F(set_uniform_initializer, bvec3_array_uniform_excess_initializer) |
||
522 | { |
||
523 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_BOOL, 1, 3, 4, 5); |
||
524 | } |
||
525 | |||
526 | TEST_F(set_uniform_initializer, bvec4_array_uniform_excess_initializer) |
||
527 | { |
||
528 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_BOOL, 1, 4, 4, 5); |
||
529 | } |
||
530 | |||
531 | TEST_F(set_uniform_initializer, float_array_uniform_excess_initializer) |
||
532 | { |
||
533 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 1, 1, 4, 5); |
||
534 | } |
||
535 | |||
536 | TEST_F(set_uniform_initializer, vec2_array_uniform_excess_initializer) |
||
537 | { |
||
538 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 1, 2, 4, 5); |
||
539 | } |
||
540 | |||
541 | TEST_F(set_uniform_initializer, vec3_array_uniform_excess_initializer) |
||
542 | { |
||
543 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 1, 3, 4, 5); |
||
544 | } |
||
545 | |||
546 | TEST_F(set_uniform_initializer, vec4_array_uniform_excess_initializer) |
||
547 | { |
||
548 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 1, 4, 4, 5); |
||
549 | } |
||
550 | |||
551 | TEST_F(set_uniform_initializer, mat2x2_array_uniform_excess_initializer) |
||
552 | { |
||
553 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 2, 2, 4, 5); |
||
554 | } |
||
555 | |||
556 | TEST_F(set_uniform_initializer, mat2x3_array_uniform_excess_initializer) |
||
557 | { |
||
558 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 2, 3, 4, 5); |
||
559 | } |
||
560 | |||
561 | TEST_F(set_uniform_initializer, mat2x4_array_uniform_excess_initializer) |
||
562 | { |
||
563 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 2, 4, 4, 5); |
||
564 | } |
||
565 | |||
566 | TEST_F(set_uniform_initializer, mat3x2_array_uniform_excess_initializer) |
||
567 | { |
||
568 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 3, 2, 4, 5); |
||
569 | } |
||
570 | |||
571 | TEST_F(set_uniform_initializer, mat3x3_array_uniform_excess_initializer) |
||
572 | { |
||
573 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 3, 3, 4, 5); |
||
574 | } |
||
575 | |||
576 | TEST_F(set_uniform_initializer, mat3x4_array_uniform_excess_initializer) |
||
577 | { |
||
578 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 3, 4, 4, 5); |
||
579 | } |
||
580 | |||
581 | TEST_F(set_uniform_initializer, mat4x2_array_uniform_excess_initializer) |
||
582 | { |
||
583 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 4, 2, 4, 5); |
||
584 | } |
||
585 | |||
586 | TEST_F(set_uniform_initializer, mat4x3_array_uniform_excess_initializer) |
||
587 | { |
||
588 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 4, 3, 4, 5); |
||
589 | } |
||
590 | |||
591 | TEST_F(set_uniform_initializer, mat4x4_array_uniform_excess_initializer) |
||
592 | { |
||
593 | array_test(mem_ctx, prog, actual_index, name, GLSL_TYPE_FLOAT, 4, 4, 4, 5); |
||
594 | }>>>> |