32static constexpr float kFloats[16] = { 1.0f, 2.0f, 3.0f, 4.0f,
33 5.0f, 6.0f, 7.0f, 8.0f,
34 9.0f, 10.0f, 11.0f, 12.0f,
35 13.0f, 14.0f, 15.0f, 16.0f };
37static constexpr SkHalf kHalfs[16] = { 0x3C00, 0x4000, 0x4200, 0x4400,
38 0x4500, 0x4600, 0x4700, 0x4800,
39 0x4880, 0x4900, 0x4980, 0x4A00,
40 0x4A80, 0x4B00, 0x4B80, 0x4C00 };
42static constexpr int32_t
kInts[16] = { 1, -2, 3, -4,
91 const void* validData = (elementSize == 4) ? (
const void*)
kFloats : (
const void*)
kHalfs;
93 REPORTER_ASSERT(r, 0 == memcmp(validData, uniformData.data(), vecLength * elementSize),
94 "Layout: %s - Type: %s float encoding failed",
112 const Uniform expectations[] = {{
"uniform",
type}};
123 "Layout: %s - Type: %s int encoding failed",
153 size_t effectiveVecLength = (vecLength == 3) ? 4 : vecLength;
154 REPORTER_ASSERT(r, uniformData.size() == elementSize * effectiveVecLength * 3,
155 "Layout: %s - Type: %s tight packing failed",
169 if (matrixSize < 2) {
187 if (matrixSize == 3) {
189 }
else if (matrixSize == 2 && layout == Layout::kStd140) {
192 numElements = matrixSize * matrixSize;
194 REPORTER_ASSERT(r, uniformData.size() == elementSize * numElements * 3,
195 "Layout: %s - Type: %s matrix packing failed",
209 if (vecLength1 < 1) {
215 if (vecLength2 < 1) {
220 const Uniform expectations[] = {{
"a", type1}, {
"b", type2}};
227 const size_t elementSize1 =
element_size(layout, type1);
228 const size_t elementSize2 =
element_size(layout, type2);
229 if (elementSize1 == elementSize2) {
235 static constexpr const char* kExpectedLayout[2][5][5] = {
237 {{
"",
"",
"",
"",
"" },
238 {
"",
"AB",
"A_BB",
"A___BBBb",
"A___BBBB" },
239 {
"",
"AAB_",
"AABB",
"AA__BBBb",
"AA__BBBB" },
240 {
"",
"AAAaB___",
"AAAaBB__",
"AAAaBBBb",
"AAAaBBBB" },
241 {
"",
"AAAAB___",
"AAAABB__",
"AAAABBBb",
"AAAABBBB" }},
243 {{
"",
"",
"",
"",
"" },
244 {
"",
"AB",
"A_BB",
"A___BBBb",
"A___BBBB" },
245 {
"",
"AAB_",
"AABB",
"AA__BBBb",
"AA__BBBB" },
246 {
"",
"AAAB",
"AAA_BB__",
"AAA_BBBb",
"AAA_BBBB" },
247 {
"",
"AAAAB___",
"AAAABB__",
"AAAABBBb",
"AAAABBBB" }},
249 int layoutIdx =
static_cast<int>(layout != Layout::kMetal);
250 const size_t size = strlen(kExpectedLayout[layoutIdx][vecLength1][vecLength2]) *
254 "Layout: %s - Types: %s, %s padding test failed",
257 }
else if (elementSize1 == 2 && elementSize2 == 4) {
263 static constexpr const char* kExpectedLayout[5][5] = {
264 {
"",
"",
"",
"",
"" },
265 {
"",
"A_BB",
"A___BBBB",
"A_______BBBBBBbb",
"A_______BBBBBBBB" },
266 {
"",
"AABB",
"AA__BBBB",
"AA______BBBBBBbb",
"AA______BBBBBBBB" },
267 {
"",
"AAAaBB__",
"AAAaBBBB",
"AAAa____BBBBBBbb",
"AAAa____BBBBBBBB" },
268 {
"",
"AAAABB__",
"AAAABBBB",
"AAAA____BBBBBBbb",
"AAAA____BBBBBBBB" },
270 const size_t size = strlen(kExpectedLayout[vecLength1][vecLength2]) * 2;
273 "Layout: %s - Types: %s, %s padding test failed",
276 }
else if (elementSize1 == 4 && elementSize2 == 2) {
282 static constexpr const char* kExpectedLayout[5][5] = {
283 {
"",
"",
"",
"",
"" },
284 {
"",
"AAB_",
"AABB",
"AA__BBBb",
"AA__BBBB" },
285 {
"",
"AAAAB___",
"AAAABB__",
"AAAABBBb",
"AAAABBBB" },
290 "AAAAAAaaBBBB____" },
295 "AAAAAAAABBBB____" },
297 const size_t size = strlen(kExpectedLayout[vecLength1][vecLength2]) * 2;
300 "Layout: %s - Types: %s, %s padding test failed",
304 ERRORF(r,
"Unexpected element sizes: %zu %zu", elementSize1, elementSize2);
319 if (vecLength1 < 1) {
330 const Uniform expectations[] = {{
"a", type1}, {
"b", type2}};
337 const size_t elementSize1 =
element_size(layout, type1);
338 const size_t elementSize2 =
element_size(layout, type2);
339 if (elementSize1 == elementSize2) {
345 static constexpr const char* kExpectedLayout[2][5][5] = {
348 {
"",
"",
"",
"",
"" },
349 {
"",
"",
"A___BBbbBBbb",
"A___BBBbBBBbBBBb",
"A___BBBBBBBBBBBBBBBB" },
350 {
"",
"",
"AA__BBbbBBbb",
"AA__BBBbBBBbBBBb",
"AA__BBBBBBBBBBBBBBBB" },
351 {
"",
"",
"AAAaBBbbBBbb",
"AAAaBBBbBBBbBBBb",
"AAAaBBBBBBBBBBBBBBBB" },
352 {
"",
"",
"AAAABBbbBBbb",
"AAAABBBbBBBbBBBb",
"AAAABBBBBBBBBBBBBBBB" },
356 {
"",
"",
"",
"",
"" },
357 {
"",
"",
"A_BBBB",
"A___BBBbBBBbBBBb",
"A___BBBBBBBBBBBBBBBB" },
358 {
"",
"",
"AABBBB",
"AA__BBBbBBBbBBBb",
"AA__BBBBBBBBBBBBBBBB" },
359 {
"",
"",
"AAAaBBBB",
"AAAaBBBbBBBbBBBb",
"AAAaBBBBBBBBBBBBBBBB" },
360 {
"",
"",
"AAAABBBB",
"AAAABBBbBBBbBBBb",
"AAAABBBBBBBBBBBBBBBB" },
363 int layoutIdx =
static_cast<int>(layout != Layout::kStd140);
364 const size_t size = strlen(kExpectedLayout[layoutIdx][vecLength1][matSize2]) *
368 "Layout: %s - Types: %s, %s vector-matrix padding test failed",
371 }
else if (elementSize1 == 2 && elementSize2 == 4) {
377 static constexpr const char* kExpectedLayout[5][5] = {
378 {
"",
"",
"",
"",
""},
381 "A_______BBBBBBbbBBBBBBbbBBBBBBbb",
382 "A_______BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"},
385 "AA______BBBBBBbbBBBBBBbbBBBBBBbb",
386 "AA______BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"},
389 "AAAa____BBBBBBbbBBBBBBbbBBBBBBbb",
390 "AAAa____BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"},
393 "AAAA____BBBBBBbbBBBBBBbbBBBBBBbb",
394 "AAAA____BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"},
396 const size_t size = strlen(kExpectedLayout[vecLength1][matSize2]) * 2;
399 "Layout: %s - Types: %s, %s vector-matrix padding test failed",
402 }
else if (elementSize1 == 4 && elementSize2 == 2) {
408 static constexpr const char* kExpectedLayout[5][5] = {
409 {
"",
"",
"",
"",
""},
410 {
"",
"",
"AABBBB",
"AA__BBBbBBBbBBBb",
"AA__BBBBBBBBBBBBBBBB"},
411 {
"",
"",
"AAAABBBB",
"AAAABBBbBBBbBBBb",
"AAAABBBBBBBBBBBBBBBB"},
414 "AAAAAAaaBBBbBBBbBBBb____",
415 "AAAAAAaaBBBBBBBBBBBBBBBB"},
418 "AAAAAAAABBBbBBBbBBBb____",
419 "AAAAAAAABBBBBBBBBBBBBBBB"},
421 const size_t size = strlen(kExpectedLayout[vecLength1][matSize2]) * 2;
424 "Layout: %s - Types: %s, %s vector-matrix padding test failed",
447 if (vecLength2 < 1) {
452 const Uniform expectations[] = {{
"a", type1}, {
"b", type2}};
459 const size_t elementSize1 =
element_size(layout, type1);
460 const size_t elementSize2 =
element_size(layout, type2);
461 if (elementSize1 == elementSize2) {
467 static constexpr const char* kExpectedLayout[2][5][5] = {
470 {
"",
"",
"",
"",
"" },
471 {
"",
"",
"",
"",
"" },
472 {
"",
"AAaaAAaaB___",
"AAaaAAaaBB__",
"AAaaAAaaBBBb",
"AAaaAAaaBBBB" },
477 "AAAaAAAaAAAaBBBB" },
479 "AAAAAAAAAAAAAAAAB___",
480 "AAAAAAAAAAAAAAAABB__",
481 "AAAAAAAAAAAAAAAABBBb",
482 "AAAAAAAAAAAAAAAABBBB" },
486 {
"",
"",
"",
"",
"" },
487 {
"",
"",
"",
"",
"" },
488 {
"",
"AAAAB_",
"AAAABB",
"AAAABBBb",
"AAAABBBB" },
493 "AAAaAAAaAAAaBBBB" },
495 "AAAAAAAAAAAAAAAAB___",
496 "AAAAAAAAAAAAAAAABB__",
497 "AAAAAAAAAAAAAAAABBBb",
498 "AAAAAAAAAAAAAAAABBBB" },
501 int layoutIdx =
static_cast<int>(layout != Layout::kStd140);
502 const size_t size = strlen(kExpectedLayout[layoutIdx][matSize1][vecLength2]) *
506 "Layout: %s - Types: %s, %s matrix-vector padding test failed",
509 }
else if (elementSize1 == 2 && elementSize2 == 4) {
515 static constexpr const char* kExpectedLayout[5][5] = {
516 {
"",
"",
"",
"",
"" },
517 {
"",
"",
"",
"",
"" },
518 {
"",
"AAAABB",
"AAAABBBB",
"AAAA____BBBBBBbb",
"AAAA____BBBBBBBB" },
522 "AAAaAAAaAAAa____BBBBBBbb",
523 "AAAaAAAaAAAa____BBBBBBBB" },
525 "AAAAAAAAAAAAAAAABB__",
526 "AAAAAAAAAAAAAAAABBBB",
527 "AAAAAAAAAAAAAAAABBBBBBbb",
528 "AAAAAAAAAAAAAAAABBBBBBBB" },
530 const size_t size = strlen(kExpectedLayout[matSize1][vecLength2]) * 2;
533 "Layout: %s - Types: %s, %s matrix-vector padding test failed",
536 }
else if (elementSize1 == 4 && elementSize2 == 2) {
542 static constexpr const char* kExpectedLayout[5][5] = {
543 {
"",
"",
"",
"",
"" },
544 {
"",
"",
"",
"",
"" },
545 {
"",
"AAAAAAAAB___",
"AAAAAAAABB__",
"AAAAAAAABBBb",
"AAAAAAAABBBB" },
547 "AAAAAAaaAAAAAAaaAAAAAAaaB_______",
548 "AAAAAAaaAAAAAAaaAAAAAAaaBB______",
549 "AAAAAAaaAAAAAAaaAAAAAAaaBBBb____",
550 "AAAAAAaaAAAAAAaaAAAAAAaaBBBB____" },
552 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB_______",
553 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABB______",
554 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBb____",
555 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBB____" },
557 const size_t size = strlen(kExpectedLayout[matSize1][vecLength2]) * 2;
560 "Layout: %s - Types: %s, %s matrix-vector padding test failed",
578 static constexpr uint8_t kBuffer[192] = {};
579 static const char* kExpectedLayout[] = {
587 "AA______BBBBBBBBBBBBBBBBBBBBBBBB",
588 "AA______________BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb",
589 "AA______________BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
592 "AA______BBBBBBbbBBBBBBbbBBBBBBbb",
593 "AA______BBBBBBBBBBBBBBBBBBBBBBBB",
595 "AA______BBBBBBBBBBBBBBBBBBBBBBBB",
596 "AA______________BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb",
597 "AA______________BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
599 "AA______BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
601 "BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb"
602 "BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb"
603 "BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb",
605 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
606 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
607 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
609 "AA__BBBBBBBBBBBBBBBBBBBBBBBB",
611 "BBBBBBbbBBBBBBbbBBBBBBbb"
612 "BBBBBBbbBBBBBBbbBBBBBBbb"
613 "BBBBBBbbBBBBBBbbBBBBBBbb",
615 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
616 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
617 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
619 for (
size_t i = 0; i < std::size(kExpectedLayout); i++) {
625 mgr.
write(expectations[1], kBuffer);
628 const size_t expectedSize = strlen(kExpectedLayout[i]);
631 "array test %d for type %s failed - expected size: %zu, actual size: %zu",
646 static constexpr uint8_t kBuffer[192] = {};
647 static const char* kExpectedLayout[] = {
655 "AA______BBBBBBBBBBBBBBBBBBBBBBBB",
656 "AA______________BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb",
657 "AA______________BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
659 "AA______BBBBBBBBBBBBBBBBBBBBBBBB",
660 "AA______________BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb",
661 "AA______________BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
663 "AA______BBBBBBBBBBBBBBBBBBBBBBBB",
664 "AA______________BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb",
665 "AA______________BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
667 "AA______BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
669 "BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb"
670 "BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb"
671 "BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb",
673 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
674 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
675 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
677 "AA______BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
679 "BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb"
680 "BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb"
681 "BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb",
683 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
684 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
685 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
687 for (
size_t i = 0; i < std::size(kExpectedLayout); i++) {
693 mgr.
write(expectations[1], kBuffer);
696 const size_t expectedSize = strlen(kExpectedLayout[i]);
699 "array test %d for type %s failed - expected size: %zu, actual size: %zu",
714 static constexpr uint8_t kBuffer[192] = {};
715 static const char* kExpectedLayout[] = {
722 "AA______________BBBBbbbbbbbbbbbbBBBBbbbbbbbbbbbbBBBBbbbbbbbbbbbb",
723 "AA______________BBBBBBBBbbbbbbbbBBBBBBBBbbbbbbbbBBBBBBBBbbbbbbbb",
724 "AA______________BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb",
725 "AA______________BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
726 "AA______________BBbbbbbbbbbbbbbbBBbbbbbbbbbbbbbbBBbbbbbbbbbbbbbb",
727 "AA______________BBBBbbbbbbbbbbbbBBBBbbbbbbbbbbbbBBBBbbbbbbbbbbbb",
728 "AA______________BBBBBBbbbbbbbbbbBBBBBBbbbbbbbbbbBBBBBBbbbbbbbbbb",
729 "AA______________BBBBBBBBbbbbbbbbBBBBBBBBbbbbbbbbBBBBBBBBbbbbbbbb",
730 "AA______________BBBBbbbbbbbbbbbbBBBBbbbbbbbbbbbbBBBBbbbbbbbbbbbb",
731 "AA______________BBBBBBBBbbbbbbbbBBBBBBBBbbbbbbbbBBBBBBBBbbbbbbbb",
732 "AA______________BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb",
733 "AA______________BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
736 "BBBBBBBBbbbbbbbbBBBBBBBBbbbbbbbb"
737 "BBBBBBBBbbbbbbbbBBBBBBBBbbbbbbbb"
738 "BBBBBBBBbbbbbbbbBBBBBBBBbbbbbbbb",
740 "BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb"
741 "BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb"
742 "BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb",
744 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
745 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
746 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
749 "BBBBBBBBbbbbbbbbBBBBBBBBbbbbbbbb"
750 "BBBBBBBBbbbbbbbbBBBBBBBBbbbbbbbb"
751 "BBBBBBBBbbbbbbbbBBBBBBBBbbbbbbbb",
753 "BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb"
754 "BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb"
755 "BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb",
757 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
758 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
759 "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
761 for (
size_t i = 0; i < std::size(kExpectedLayout); i++) {
767 mgr.
write(expectations[1], kBuffer);
770 const size_t expectedSize = strlen(kExpectedLayout[i]);
773 "array test %d for type %s failed - expected size: %zu, actual size: %zu",
793 "%s layout size expected 32, got %zu",
797 const int kOffsets[4] = {0, 1, 4, 5};
798 const float* elements =
reinterpret_cast<const float*
>(uniformData.data());
799 for (
size_t i = 0u; i < std::size(kOffsets); ++i) {
801 float el = elements[kOffsets[i]];
803 "Incorrect %s element %zu - expected %f, got %f",
817 "%s layout size expected 48, got %zu",
821 const int kOffsets[9] = {0, 1, 2, 4, 5, 6, 8, 9, 10};
822 const float* elements =
reinterpret_cast<const float*
>(uniformData.data());
823 for (
size_t i = 0u; i < std::size(kOffsets); ++i) {
825 float el = elements[kOffsets[i]];
827 "Incorrect %s element %zu - expected %f, got %f",
847 "%s layout size expected 16, got %zu",
852 const int kOffsets[4] = {0, 1, 2, 3};
853 const float* elements =
reinterpret_cast<const float*
>(uniformData.data());
854 for (
size_t i = 0u; i < std::size(kOffsets); ++i) {
856 float el = elements[kOffsets[i]];
858 "Incorrect %s element %zu - expected %f, got %f",
872 "%s layout size expected 48, got %zu",
876 const int kOffsets[9] = {0, 1, 2, 4, 5, 6, 8, 9, 10};
877 const float* elements =
reinterpret_cast<const float*
>(uniformData.data());
878 for (
size_t i = 0u; i < std::size(kOffsets); ++i) {
880 float el = elements[kOffsets[i]];
882 "Incorrect %s element %zu - expected %f, got %f",
static const uint32_t kArraySize
int SkSLTypeMatrixSize(SkSLType type)
bool SkSLTypeIsFullPrecisionNumericType(SkSLType type)
const char * SkSLTypeString(SkSLType t)
static constexpr bool SkSLTypeIsIntegralType(SkSLType type)
static constexpr bool SkSLTypeIsFloatType(SkSLType type)
static constexpr int SkSLTypeVecLength(SkSLType type)
#define DEF_GRAPHITE_TEST(name, reporter, ctsEnforcement)
#define REPORTER_ASSERT(r, cond,...)
static constexpr const char * LayoutString(Layout layout)