« back to all changes in this revision
Viewing changes to test/gtest/Attribute_test.cpp
- browse files at revision 46
- compare with another revision
- download diff
- download tarball
- view history from revision 46
- Committer: Michi Henning
- Date: 2012-12-17 03:42:57 UTC
- Revision ID: michi.henning@canonical.com-20121217034257-m1icr5l6tk5082th
Improved coverage
added
removed
test/gtest/Attribute_test.cpp
77
77
boost::regex::egrep);
78
78
EXPECT_TRUE(boost::regex_match(e.to_string(), r));
79
79
}
80
81
uv.set_array_state(AttributeVariable::ArrayState::disabled);
82
EXPECT_EQ(AttributeVariable::ArrayState::disabled, uv.array_state());
83
uv.set_array_state(AttributeVariable::ArrayState::enabled);
84
EXPECT_EQ(AttributeVariable::ArrayState::enabled, uv.array_state());
85
uv.set_array_state(AttributeVariable::ArrayState::disabled);
86
EXPECT_EQ(AttributeVariable::ArrayState::disabled, uv.array_state());
80
87
}
81
88
82
89
TEST(Attribute, attributes)
113
120
av.set(2.0f);
114
121
FloatAttribute& a = dynamic_cast<FloatAttribute&>(av);
115
122
EXPECT_EQ(2.0f, a.get());
123
a.set(3.0f);
124
EXPECT_EQ(3.0f, a.get());
116
125
}
117
126
118
127
{
121
130
av.set(in);
122
131
FloatVec2Attribute& a = dynamic_cast<FloatVec2Attribute&>(av);
123
132
FloatVec2 r = a.get();
133
in[1] = 3.0f;
134
a.set(in);
135
r = a.get();
124
136
EXPECT_EQ(in, r);
125
137
}
126
138
131
143
FloatVec3Attribute& a = dynamic_cast<FloatVec3Attribute&>(av);
132
144
FloatVec3 r = a.get();
133
145
EXPECT_EQ(in, r);
146
in[2] = 4.0f;
147
a.set(in);
148
r = a.get();
149
EXPECT_EQ(in, r);
134
150
}
135
151
136
152
{
140
156
FloatVec4Attribute& a = dynamic_cast<FloatVec4Attribute&>(av);
141
157
FloatVec4 r = a.get();
142
158
EXPECT_EQ(in, r);
159
in[3] = 5.0f;
160
a.set(in);
161
r = a.get();
162
EXPECT_EQ(in, r);
143
163
}
144
164
145
165
{
152
172
FloatMat2Attribute& a = dynamic_cast<FloatMat2Attribute&>(av);
153
173
FloatMat2 r = a.get();
154
174
EXPECT_EQ(in, r);
175
in[1][1] = 5.0f;
176
a.set(in);
177
r = a.get();
178
EXPECT_EQ(in, r);
155
179
}
156
180
157
181
{
165
189
FloatMat3Attribute& a = dynamic_cast<FloatMat3Attribute&>(av);
166
190
FloatMat3 r = a.get();
167
191
EXPECT_EQ(in, r);
192
in[2][2] = 10.0f;
193
a.set(in);
194
r = a.get();
195
EXPECT_EQ(in, r);
168
196
}
169
197
170
198
{
179
207
FloatMat4Attribute& a = dynamic_cast<FloatMat4Attribute&>(av);
180
208
FloatMat4 r = a.get();
181
209
EXPECT_EQ(in, r);
182
}
183
}
184
185
#if 0
186
template<typename T, typename U>
187
void
188
assign_test(U& u)
189
{
190
// Type-specific test
191
T val;
192
val = u;
193
EXPECT_EQ(u.get(), val);
194
u = val;
195
u = u;
196
EXPECT_EQ(u.get(), val);
197
198
// Assignment to base.
199
200
UniformVariable& v(u);
201
v = val;
202
EXPECT_EQ(u.get(), val);
203
v.set(val);
204
EXPECT_EQ(u.get(), val);
205
}
206
207
TEST(Uniform, uniforms)
208
{
209
auto rt = Runtime::create();
210
rt->create_display(200, 200);
211
212
// Shader with all possible types of uniform. Silly use of these in the body of the shader, so they
213
// are not optimized out of existence.
214
const char* v_source = "uniform float f;"
215
"uniform vec2 fv2;"
216
"uniform vec3 fv3;"
217
"uniform vec4 fv4;"
218
"uniform mat2 fm2;"
219
"uniform mat3 fm3;"
220
"uniform mat4 fm4;"
221
"uniform float fa[2];"
222
"uniform vec2 fv2a[2];"
223
"uniform vec3 fv3a[2];"
224
"uniform vec4 fv4a[2];"
225
"uniform mat2 fm2a[2];"
226
"uniform mat3 fm3a[2];"
227
"uniform mat4 fm4a[2];"
228
"uniform int i;"
229
"uniform ivec2 iv2;"
230
"uniform ivec3 iv3;"
231
"uniform ivec4 iv4;"
232
"uniform int ia[2];"
233
"uniform ivec2 iv2a[2];"
234
"uniform ivec3 iv3a[2];"
235
"uniform ivec4 iv4a[2];"
236
"uniform bool b;"
237
"uniform bvec2 bv2;"
238
"uniform bvec3 bv3;"
239
"uniform bvec4 bv4;"
240
"uniform bool ba[2];"
241
"uniform bvec2 bv2a[2];"
242
"uniform bvec3 bv3a[2];"
243
"uniform bvec4 bv4a[2];"
244
"void main()"
245
"{"
246
" gl_Position = vec4(f + fv2.x + fv3.x + fv4.x);"
247
" gl_Position = gl_Position + vec4(fm2[0][0] + fm3[0][0] + fm4[0][0]);"
248
" gl_Position = gl_Position + vec4(fa[1] + fv2a[1].x + fv3a[1].x + fv4a[1].x);"
249
" gl_Position = gl_Position + vec4(fm2a[1][0][0] + fm3a[1][0][0] + fm4a[1][0][0]);"
250
" gl_Position = gl_Position + vec4(i + iv2.x + iv3.x + iv4.x);"
251
" gl_Position = gl_Position + vec4(ia[1] + iv2a[1].x + iv3a[1].x + iv4a[1].x);"
252
" gl_Position = gl_Position + vec4(int(b) + int(bv2.x) + int(bv3.x) + int(bv4.x));"
253
" gl_Position = gl_Position + vec4(int(ba[1]) + int(bv2a[1]) + int(bv3a[1]) + int(bv4a[1]));"
254
"}";
255
256
const char* f_source = "uniform sampler2D s;"
257
"uniform sampler2D sa[2];"
258
"uniform samplerCube c;"
259
"uniform samplerCube ca[2];"
260
"void main()"
261
"{"
262
" gl_FragColor = texture2D(s, vec2(0));"
263
" gl_FragColor = gl_FragColor + texture2D(sa[1], vec2(0));"
264
" gl_FragColor = gl_FragColor + textureCube(c, vec3(0));"
265
" gl_FragColor = gl_FragColor + textureCube(ca[1], vec3(0));"
266
"}";
267
268
Program::UPtr p;
269
try
270
{
271
auto v = VertexShader::create(v_source);
272
auto f = FragmentShader::create(f_source);
273
p = Program::create(*v, *f);
274
p->use();
275
}
276
catch (const Exception& e)
277
{
278
FAIL() << e.to_string();
279
}
280
281
try
282
{
283
// Float types
284
285
{
286
UniformVariable& uv = p->uniform("f");
287
FloatUniform& u = dynamic_cast<FloatUniform&>(uv);
288
u = 0.5f;
289
EXPECT_EQ(0.5f, u.get());
290
291
assign_test<GLfloat>(u);
292
}
293
294
{
295
UniformVariable& uv = p->uniform("fv2");
296
FloatVec2Uniform& u = dynamic_cast<FloatVec2Uniform&>(uv);
297
u = { { 0.1f, 0.2f } };
298
EXPECT_EQ(0.1f, u.get()[0]);
299
EXPECT_EQ(0.2f, u.get()[1]);
300
301
u.set(0.0f, 0.1f); // Separate parameter interface
302
float x, y;
303
u.get(x, y);
304
EXPECT_EQ(0.0f, x);
305
EXPECT_EQ(0.1f, y);
306
307
assign_test<FloatVec2>(u);
308
}
309
310
{
311
UniformVariable& uv = p->uniform("fv3");
312
FloatVec3Uniform& u = dynamic_cast<FloatVec3Uniform&>(uv);
313
u.set({ { 0.1f, 0.2f, 0.3f } });
314
EXPECT_EQ(0.1f, u.get()[0]);
315
EXPECT_EQ(0.2f, u.get()[1]);
316
EXPECT_EQ(0.3f, u.get()[2]);
317
318
u.set(0.0f, 0.1f, 0.2f); // Separate parameter interface
319
float x, y, z;
320
u.get(x, y, z);
321
EXPECT_EQ(0.0f, x);
322
EXPECT_EQ(0.1f, y);
323
EXPECT_EQ(0.2f, z);
324
325
FloatVec3 val = u;
326
EXPECT_EQ(u.get(), val);
327
u = val;
328
u = u;
329
EXPECT_EQ(u.get(), val);
330
331
assign_test<FloatVec3>(u);
332
}
333
334
{
335
UniformVariable& uv = p->uniform("fv4");
336
FloatVec4Uniform& u = dynamic_cast<FloatVec4Uniform&>(uv);
337
u.set({ { 0.1f, 0.2f, 0.3f, 0.4f } });
338
EXPECT_EQ(0.1f, u.get()[0]);
339
EXPECT_EQ(0.2f, u.get()[1]);
340
EXPECT_EQ(0.3f, u.get()[2]);
341
EXPECT_EQ(0.4f, u.get()[3]);
342
343
u.set(0.0f, 0.1f, 0.2f, 0.3f); // Separate parameter interface
344
float x, y, z, w;
345
u.get(x, y, z, w);
346
EXPECT_EQ(0.0f, x);
347
EXPECT_EQ(0.1f, y);
348
EXPECT_EQ(0.2f, z);
349
EXPECT_EQ(0.3f, w);
350
351
assign_test<FloatVec4>(u);
352
}
353
354
{
355
UniformVariable& uv = p->uniform("fm2");
356
FloatMat2Uniform& u = dynamic_cast<FloatMat2Uniform&>(uv);
357
FloatMat2 m = { { { { 1.0f, 2.0f } },
358
{ { 3.0f, 4.0f } } } };
359
u.set(m);
360
EXPECT_EQ(m, u.get());
361
362
assign_test<FloatMat2>(u);
363
}
364
365
{
366
UniformVariable& uv = p->uniform("fm3");
367
FloatMat3Uniform& u = dynamic_cast<FloatMat3Uniform&>(uv);
368
FloatMat3 m = { { { { 1.0f, 2.0f, 3.0f } },
369
{ { 4.0f, 5.0f, 6.0f } },
370
{ { 7.0f, 8.0f, 9.0f } } } };
371
u.set(m);
372
EXPECT_EQ(m, u.get());
373
374
assign_test<FloatMat3>(u);
375
}
376
377
{
378
UniformVariable& uv = p->uniform("fm4");
379
FloatMat4Uniform& u = dynamic_cast<FloatMat4Uniform&>(uv);
380
FloatMat4 m = { { { { 1.0f, 2.0f, 3.0f, 4.0f } },
381
{ { 5.0f, 6.0f, 7.0f, 8.0f } },
382
{ { 9.0f, 10.0f, 11.0f, 12.0f } },
383
{ { 13.0f, 14.0f, 15.0f, 16.0f } } } };
384
u.set(m);
385
EXPECT_EQ(m, u.get());
386
387
assign_test<FloatMat4>(u);
388
}
389
390
// Float array types
391
392
{
393
UniformVariable& uv = p->uniform("fa");
394
FloatArrayUniform& u = dynamic_cast<FloatArrayUniform&>(uv);
395
u.set({ { 0.1f, 0.2f } });
396
EXPECT_EQ(0.1f, u.get()[0]);
397
EXPECT_EQ(0.2f, u.get()[1]);
398
399
assign_test<FloatArray>(u);
400
size_test<GLfloat>(u);
401
}
402
403
{
404
UniformVariable& uv = p->uniform("fv2a");
405
FloatVec2ArrayUniform& u = dynamic_cast<FloatVec2ArrayUniform&>(uv);
406
FloatVec2Array a { { { { 1.0f, 2.0f } },
407
{ { 3.0f, 4.0f } } } };
408
u.set(a);
409
EXPECT_EQ(a, u.get());
410
411
assign_test<FloatVec2Array>(u);
412
size_test<FloatVec2>(u);
413
}
414
415
{
416
UniformVariable& uv = p->uniform("fv3a");
417
FloatVec3ArrayUniform& u = dynamic_cast<FloatVec3ArrayUniform&>(uv);
418
FloatVec3Array a { { { { 1.0f, 2.0f, 3.0f } },
419
{ { 4.0f, 5.0f, 6.0f } } } };
420
u.set(a);
421
EXPECT_EQ(a, u.get());
422
423
assign_test<FloatVec3Array>(u);
424
size_test<FloatVec3>(u);
425
}
426
427
{
428
UniformVariable& uv = p->uniform("fv4a");
429
FloatVec4ArrayUniform& u = dynamic_cast<FloatVec4ArrayUniform&>(uv);
430
FloatVec4Array a { { { { 1.0f, 2.0f, 3.0f, 4.0f } },
431
{ { 3.0f, 4.0f, 5.0f, 8.0f } } } };
432
u.set(a);
433
EXPECT_EQ(a, u.get());
434
435
assign_test<FloatVec4Array>(u);
436
size_test<FloatVec4>(u);
437
}
438
439
{
440
UniformVariable& uv = p->uniform("fm2a");
441
FloatMat2ArrayUniform& u = dynamic_cast<FloatMat2ArrayUniform&>(uv);
442
FloatMat2Array a { {
443
{ { { { 1.0f, 2.0f } },
444
{ { 3.0f, 4.0f } } } },
445
{ { { { 5.0f, 6.0f } },
446
{ { 7.0f, 8.0f } } } }
447
} };
448
u.set(a);
449
EXPECT_EQ(a, u.get());
450
451
assign_test<FloatMat2Array>(u);
452
size_test<FloatMat2>(u);
453
}
454
455
{
456
UniformVariable& uv = p->uniform("fm3a");
457
FloatMat3ArrayUniform& u = dynamic_cast<FloatMat3ArrayUniform&>(uv);
458
FloatMat3Array a { {
459
{ { { { 1.0f, 2.0f, 3.0f } },
460
{ { 4.0f, 5.0f, 6.0f } },
461
{ { 7.0f, 8.0f, 9.0f } } } },
462
{ { { { 10.0f, 11.0f, 12.0f } },
463
{ { 13.0f, 14.0f, 15.0f } },
464
{ { 16.0f, 17.0f, 18.0f } } } }
465
} };
466
u.set(a);
467
EXPECT_EQ(a, u.get());
468
469
assign_test<FloatMat3Array>(u);
470
size_test<FloatMat3>(u);
471
}
472
473
{
474
UniformVariable& uv = p->uniform("fm4a");
475
FloatMat4ArrayUniform& u = dynamic_cast<FloatMat4ArrayUniform&>(uv);
476
FloatMat4Array a { {
477
{ { { { 1.0f, 2.0f, 3.0f, 4.0f } },
478
{ { 5.0f, 6.0f, 7.0f, 8.0f } },
479
{ { 9.0f, 10.0f, 11.0f, 12.0f } },
480
{ { 13.0f, 14.0f, 15.0f, 16.0f } } } },
481
{ { { { 21.0f, 22.0f, 23.0f, 24.0f } },
482
{ { 25.0f, 26.0f, 27.0f, 28.0f } },
483
{ { 29.0f, 20.0f, 21.0f, 22.0f } },
484
{ { 23.0f, 24.0f, 25.0f, 26.0f } } } },
485
} };
486
u.set(a);
487
EXPECT_EQ(a, u.get());
488
489
assign_test<FloatMat4Array>(u);
490
size_test<FloatMat4>(u);
491
}
492
493
// Integer types
494
495
{
496
UniformVariable& uv = p->uniform("i");
497
IntUniform& u = dynamic_cast<IntUniform&>(uv);
498
u.set(99);
499
EXPECT_EQ(99, u.get());
500
501
assign_test<GLint>(u);
502
}
503
504
{
505
UniformVariable& uv = p->uniform("iv2");
506
IntVec2Uniform& u = dynamic_cast<IntVec2Uniform&>(uv);
507
u.set({ { 1, 2 } });
508
EXPECT_EQ(1, u.get()[0]);
509
EXPECT_EQ(2, u.get()[1]);
510
511
u.set(0, 1); // Separate parameter interface
512
int x, y;
513
u.get(x, y);
514
EXPECT_EQ(0, x);
515
EXPECT_EQ(1, y);
516
517
assign_test<IntVec2>(u);
518
}
519
520
{
521
UniformVariable& uv = p->uniform("iv3");
522
IntVec3Uniform& u = dynamic_cast<IntVec3Uniform&>(uv);
523
u.set({ { 1, 2, 3 } });
524
EXPECT_EQ(1, u.get()[0]);
525
EXPECT_EQ(2, u.get()[1]);
526
EXPECT_EQ(3, u.get()[2]);
527
528
u.set(0, 1, 2); // Separate parameter interface
529
int x, y, z;
530
u.get(x, y, z);
531
EXPECT_EQ(0, x);
532
EXPECT_EQ(1, y);
533
EXPECT_EQ(2, z);
534
535
assign_test<IntVec3>(u);
536
}
537
538
{
539
UniformVariable& uv = p->uniform("iv4");
540
IntVec4Uniform& u = dynamic_cast<IntVec4Uniform&>(uv);
541
u.set({ { 1, 2, 3, 4 } });
542
EXPECT_EQ(1, u.get()[0]);
543
EXPECT_EQ(2, u.get()[1]);
544
EXPECT_EQ(3, u.get()[2]);
545
EXPECT_EQ(4, u.get()[3]);
546
547
u.set(0, 1, 2, 3); // Separate parameter interface
548
int x, y, z, w;
549
u.get(x, y, z, w);
550
EXPECT_EQ(0, x);
551
EXPECT_EQ(1, y);
552
EXPECT_EQ(2, z);
553
EXPECT_EQ(3, w);
554
555
assign_test<IntVec4>(u);
556
}
557
558
// Int array types
559
560
{
561
UniformVariable& uv = p->uniform("ia");
562
IntArrayUniform& u = dynamic_cast<IntArrayUniform&>(uv);
563
u.set({ { 1, 2 } });
564
EXPECT_EQ(1, u.get()[0]);
565
EXPECT_EQ(2, u.get()[1]);
566
567
assign_test<IntArray>(u);
568
size_test<GLint>(u);
569
}
570
571
{
572
UniformVariable& uv = p->uniform("iv2a");
573
IntVec2ArrayUniform& u = dynamic_cast<IntVec2ArrayUniform&>(uv);
574
IntVec2Array a { {
575
{ { 1, 2 } },
576
{ { 3, 4 } }
577
} };
578
u.set(a);
579
EXPECT_EQ(a, u.get());
580
581
assign_test<IntVec2Array>(u);
582
size_test<IntVec2>(u);
583
}
584
585
{
586
UniformVariable& uv = p->uniform("iv3a");
587
IntVec3ArrayUniform& u = dynamic_cast<IntVec3ArrayUniform&>(uv);
588
IntVec3Array a { {
589
{ { 1, 2, 3 } },
590
{ { 4, 5, 6 } }
591
} };
592
u.set(a);
593
EXPECT_EQ(a, u.get());
594
595
assign_test<IntVec3Array>(u);
596
size_test<IntVec3>(u);
597
}
598
599
{
600
UniformVariable& uv = p->uniform("iv4a");
601
IntVec4ArrayUniform& u = dynamic_cast<IntVec4ArrayUniform&>(uv);
602
IntVec4Array a { {
603
{ { 1, 2, 3, 4 } },
604
{ { 5, 6, 7, 8 } }
605
} };
606
u.set(a);
607
EXPECT_EQ(a, u.get());
608
609
assign_test<IntVec4Array>(u);
610
size_test<IntVec4>(u);
611
}
612
613
// Bool types
614
615
{
616
UniformVariable& uv = p->uniform("b");
617
BoolUniform& u = dynamic_cast<BoolUniform&>(uv);
618
u.set(GL_TRUE);
619
EXPECT_EQ(GL_TRUE, u.get());
620
u.set(GL_FALSE);
621
EXPECT_EQ(GL_FALSE, u.get());
622
623
assign_test<GLboolean>(u);
624
}
625
626
{
627
UniformVariable& uv = p->uniform("bv2");
628
BoolVec2Uniform& u = dynamic_cast<BoolVec2Uniform&>(uv);
629
u.set({ { GL_TRUE, GL_TRUE } });
630
EXPECT_EQ(GL_TRUE, u.get()[0]);
631
EXPECT_EQ(GL_TRUE, u.get()[1]);
632
u.set({ { GL_FALSE, GL_FALSE } });
633
EXPECT_EQ(GL_FALSE, u.get()[0]);
634
EXPECT_EQ(GL_FALSE, u.get()[1]);
635
636
u.set(true, false); // Separate parameter interface
637
GLboolean x, y;
638
u.get(x, y);
639
EXPECT_EQ(GL_TRUE, x);
640
EXPECT_EQ(GL_FALSE, y);
641
642
assign_test<BoolVec2>(u);
643
}
644
645
{
646
UniformVariable& uv = p->uniform("bv3");
647
BoolVec3Uniform& u = dynamic_cast<BoolVec3Uniform&>(uv);
648
u.set({ { GL_TRUE, GL_TRUE , GL_TRUE } });
649
EXPECT_EQ(GL_TRUE, u.get()[0]);
650
EXPECT_EQ(GL_TRUE, u.get()[1]);
651
EXPECT_EQ(GL_TRUE, u.get()[2]);
652
u.set({ { GL_FALSE, GL_FALSE , GL_FALSE } });
653
EXPECT_EQ(GL_FALSE, u.get()[0]);
654
EXPECT_EQ(GL_FALSE, u.get()[1]);
655
EXPECT_EQ(GL_FALSE, u.get()[2]);
656
657
u.set(true, false, true); // Separate parameter interface
658
GLboolean x, y, z;
659
u.get(x, y, z);
660
EXPECT_EQ(GL_TRUE, x);
661
EXPECT_EQ(GL_FALSE, y);
662
EXPECT_EQ(GL_TRUE, z);
663
664
assign_test<BoolVec3>(u);
665
}
666
667
{
668
UniformVariable& uv = p->uniform("bv4");
669
BoolVec4Uniform& u = dynamic_cast<BoolVec4Uniform&>(uv);
670
u.set({ { GL_TRUE, GL_TRUE , GL_TRUE, GL_TRUE } });
671
EXPECT_EQ(GL_TRUE, u.get()[0]);
672
EXPECT_EQ(GL_TRUE, u.get()[1]);
673
EXPECT_EQ(GL_TRUE, u.get()[2]);
674
EXPECT_EQ(GL_TRUE, u.get()[3]);
675
u.set({ { GL_FALSE, GL_FALSE , GL_FALSE, GL_FALSE } });
676
EXPECT_EQ(GL_FALSE, u.get()[0]);
677
EXPECT_EQ(GL_FALSE, u.get()[1]);
678
EXPECT_EQ(GL_FALSE, u.get()[2]);
679
EXPECT_EQ(GL_FALSE, u.get()[3]);
680
681
u.set(true, false, true, true); // Separate parameter interface
682
GLboolean x, y, z, w;
683
u.get(x, y, z, w);
684
EXPECT_EQ(GL_TRUE, x);
685
EXPECT_EQ(GL_FALSE, y);
686
EXPECT_EQ(GL_TRUE, z);
687
EXPECT_EQ(GL_TRUE, w);
688
689
assign_test<BoolVec4>(u);
690
}
691
692
// Bool array types
693
694
{
695
UniformVariable& uv = p->uniform("ba");
696
BoolArrayUniform& u = dynamic_cast<BoolArrayUniform&>(uv);
697
u.set({ { GL_FALSE, GL_TRUE } });
698
EXPECT_EQ(GL_FALSE, u.get()[0]);
699
EXPECT_EQ(GL_TRUE, u.get()[1]);
700
u.set({ { GL_TRUE, GL_FALSE } });
701
EXPECT_EQ(GL_TRUE, u.get()[0]);
702
EXPECT_EQ(GL_FALSE, u.get()[1]);
703
704
assign_test<BoolArray>(u);
705
size_test<GLboolean>(u);
706
}
707
708
{
709
UniformVariable& uv = p->uniform("bv2a");
710
BoolVec2ArrayUniform& u = dynamic_cast<BoolVec2ArrayUniform&>(uv);
711
BoolVec2Array a { {
712
{ { GL_FALSE, GL_FALSE } },
713
{ { GL_FALSE, GL_FALSE } }
714
} };
715
u.set(a);
716
EXPECT_EQ(a, u.get());
717
718
BoolVec2Array a2 { {
719
{ { GL_TRUE, GL_TRUE } },
720
{ { GL_TRUE, GL_TRUE } }
721
} };
722
u.set(a);
723
EXPECT_EQ(a, u.get());
724
725
assign_test<BoolVec2Array>(u);
726
size_test<BoolVec2>(u);
727
}
728
729
{
730
UniformVariable& uv = p->uniform("bv3a");
731
BoolVec3ArrayUniform& u = dynamic_cast<BoolVec3ArrayUniform&>(uv);
732
BoolVec3Array a { {
733
{ { GL_FALSE, GL_FALSE, GL_FALSE } },
734
{ { GL_FALSE, GL_FALSE, GL_FALSE } }
735
} };
736
u.set(a);
737
EXPECT_EQ(a, u.get());
738
739
BoolVec3Array a2 { {
740
{ { GL_TRUE, GL_TRUE, GL_TRUE } },
741
{ { GL_TRUE, GL_TRUE, GL_TRUE } }
742
} };
743
u.set(a);
744
EXPECT_EQ(a, u.get());
745
746
assign_test<BoolVec3Array>(u);
747
size_test<BoolVec3>(u);
748
}
749
750
{
751
UniformVariable& uv = p->uniform("bv4a");
752
BoolVec4ArrayUniform& u = dynamic_cast<BoolVec4ArrayUniform&>(uv);
753
BoolVec4Array a { {
754
{ { GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE } },
755
{ { GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE } }
756
} };
757
u.set(a);
758
EXPECT_EQ(a, u.get());
759
760
BoolVec4Array a2 { {
761
{ { GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE } },
762
{ { GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE } }
763
} };
764
u.set(a);
765
EXPECT_EQ(a, u.get());
766
767
assign_test<BoolVec4Array>(u);
768
size_test<BoolVec4>(u);
769
}
770
771
// Sampler2D
772
773
{
774
UniformVariable& uv = p->uniform("s");
775
Sampler2DUniform& u = dynamic_cast<Sampler2DUniform&>(uv);
776
u.set(0);
777
EXPECT_EQ(0, u.get());
778
779
assign_test<GLint>(u);
780
}
781
782
// Sampler2D array
783
784
{
785
UniformVariable& uv = p->uniform("sa");
786
Sampler2DArrayUniform& u = dynamic_cast<Sampler2DArrayUniform&>(uv);
787
u.set({ { 1, 2 } });
788
EXPECT_EQ(1, u.get()[0]);
789
EXPECT_EQ(2, u.get()[1]);
790
791
assign_test<Sampler2DArray>(u);
792
size_test<GLint>(u);
793
}
794
795
// SamplerCube
796
797
{
798
UniformVariable& uv = p->uniform("c");
799
SamplerCubeUniform& u = dynamic_cast<SamplerCubeUniform&>(uv);
800
u.set(0);
801
EXPECT_EQ(0, u.get());
802
803
assign_test<GLint>(u);
804
}
805
806
// SamplerCube array
807
808
{
809
UniformVariable& uv = p->uniform("ca");
810
SamplerCubeArrayUniform& u = dynamic_cast<SamplerCubeArrayUniform&>(uv);
811
u.set({ { 1, 2 } });
812
EXPECT_EQ(1, u.get()[0]);
813
EXPECT_EQ(2, u.get()[1]);
814
815
assign_test<SamplerCubeArray>(u);
816
size_test<GLint>(u);
817
}
818
}
819
catch (const Exception& e)
820
{
821
FAIL() << e.to_string();
822
}
823
}
824
#endif
210
in[3][3] = 17.0f;
211
a.set(in);
212
r = a.get();
213
EXPECT_EQ(in, r);
214
}
215
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1