blob: 77d648e23338361250b43b5a000426f2bb9c2e09 [file] [log] [blame]
/*
* Copyright 2022 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "include/private/SkHalf.h"
#include "src/core/SkSLTypeShared.h"
#include "src/gpu/graphite/PipelineData.h"
#include "src/gpu/graphite/Uniform.h"
#include "src/gpu/graphite/UniformManager.h"
#include "tests/Test.h"
using namespace skgpu::graphite;
static constexpr Layout kLayouts[] = {
Layout::kStd140,
Layout::kStd430,
Layout::kMetal,
};
// This list excludes SkSLTypes that we don't support in uniforms, like Bool, UInt or UShort.
static constexpr SkSLType kTypes[] = {
SkSLType::kShort, SkSLType::kShort2, SkSLType::kShort3, SkSLType::kShort4, //
SkSLType::kFloat, SkSLType::kFloat2, SkSLType::kFloat3, SkSLType::kFloat4, //
SkSLType::kHalf, SkSLType::kHalf2, SkSLType::kHalf3, SkSLType::kHalf4, //
SkSLType::kInt, SkSLType::kInt2, SkSLType::kInt3, SkSLType::kInt4, //
SkSLType::kFloat2x2, SkSLType::kFloat3x3, SkSLType::kFloat4x4, //
SkSLType::kHalf2x2, SkSLType::kHalf3x3, SkSLType::kHalf4x4,
};
static constexpr float kFloats[16] = { 1.0f, 2.0f, 3.0f, 4.0f,
5.0f, 6.0f, 7.0f, 8.0f,
9.0f, 10.0f, 11.0f, 12.0f,
13.0f, 14.0f, 15.0f, 16.0f };
static constexpr SkHalf kHalfs[16] = { 0x3C00, 0x4000, 0x4200, 0x4400,
0x4500, 0x4600, 0x4700, 0x4800,
0x4880, 0x4900, 0x4980, 0x4A00,
0x4A80, 0x4B00, 0x4B80, 0x4C00 };
static constexpr int16_t kShorts[16] = { 1, -2, 3, -4,
5, -6, 7, -8,
9, -10, 11, -12,
13, -14, 15, -16 };
static constexpr int32_t kInts[16] = { 1, -2, 3, -4,
5, -6, 7, -8,
9, -10, 11, -12,
13, -14, 15, -16 };
static size_t element_size(Layout layout, SkSLType type) {
// Metal should encode half-precision uniforms in 16 bits.
// Other layouts should always encode uniforms in 32 bit.
return (layout == Layout::kMetal && !SkSLTypeIsFullPrecisionNumericType(type)) ? 2 : 4;
}
DEF_TEST(UniformManagerCheckSingleUniform, r) {
// Verify that the uniform manager can hold all the basic uniform types, in every layout.
for (Layout layout : kLayouts) {
UniformManager mgr(layout);
for (SkSLType type : kTypes) {
const Uniform expectations[] = {{"uniform", type}};
mgr.setExpectedUniforms(SkSpan(expectations));
mgr.write(type, kFloats);
mgr.doneWithExpectedUniforms();
REPORTER_ASSERT(r, mgr.size() > 0);
mgr.reset();
}
}
}
DEF_TEST(UniformManagerCheckFloatEncoding, r) {
// Verify that the uniform manager encodes float data properly.
for (Layout layout : kLayouts) {
UniformManager mgr(layout);
for (SkSLType type : kTypes) {
// Only test scalar and vector floats. (Matrices can introduce padding between values.)
int vecLength = SkSLTypeVecLength(type);
if (!SkSLTypeIsFloatType(type) || vecLength < 1) {
continue;
}
// Write our uniform float scalar/vector.
const Uniform expectations[] = {{"uniform", type}};
mgr.setExpectedUniforms(SkSpan(expectations));
mgr.write(type, kFloats);
mgr.doneWithExpectedUniforms();
// Read back the uniform data.
UniformDataBlock uniformData = mgr.finishUniformDataBlock();
size_t elementSize = element_size(layout, type);
const void* validData = (elementSize == 4) ? (const void*)kFloats : (const void*)kHalfs;
REPORTER_ASSERT(r, uniformData.size() >= vecLength * elementSize);
REPORTER_ASSERT(r, 0 == memcmp(validData, uniformData.data(), vecLength * elementSize),
"Layout:%d Type:%d float encoding failed", (int)layout, (int)type);
mgr.reset();
}
}
}
DEF_TEST(UniformManagerCheckIntEncoding, r) {
// Verify that the uniform manager encodes int data properly.
for (Layout layout : kLayouts) {
UniformManager mgr(layout);
for (SkSLType type : kTypes) {
if (!SkSLTypeIsIntegralType(type)) {
continue;
}
// Write our uniform int scalar/vector.
const Uniform expectations[] = {{"uniform", type}};
mgr.setExpectedUniforms(SkSpan(expectations));
mgr.write(type, kInts);
mgr.doneWithExpectedUniforms();
// Read back the uniform data.
UniformDataBlock uniformData = mgr.finishUniformDataBlock();
int vecLength = SkSLTypeVecLength(type);
size_t elementSize = element_size(layout, type);
const void* validData = (elementSize == 4) ? (const void*)kInts : (const void*)kShorts;
REPORTER_ASSERT(r, uniformData.size() >= vecLength * elementSize);
REPORTER_ASSERT(r, 0 == memcmp(validData, uniformData.data(), vecLength * elementSize),
"Layout:%d Type:%d int encoding failed", (int)layout, (int)type);
mgr.reset();
}
}
}
DEF_TEST(UniformManagerCheckScalarVectorPacking, r) {
// Verify that the uniform manager can pack scalars and vectors of identical type correctly.
for (Layout layout : kLayouts) {
UniformManager mgr(layout);
for (SkSLType type : kTypes) {
int vecLength = SkSLTypeVecLength(type);
if (vecLength < 1) {
continue;
}
// Write three matching uniforms.
const Uniform expectations[] = {{"a", type}, {"b", type}, {"c", type}};
mgr.setExpectedUniforms(SkSpan(expectations));
mgr.write(type, kFloats);
mgr.write(type, kFloats);
mgr.write(type, kFloats);
mgr.doneWithExpectedUniforms();
// Verify that the uniform data was packed as tight as it should be.
UniformDataBlock uniformData = mgr.finishUniformDataBlock();
size_t elementSize = element_size(layout, type);
// Vec3s should be packed as if they were vec4s.
size_t effectiveVecLength = (vecLength == 3) ? 4 : vecLength;
REPORTER_ASSERT(r, uniformData.size() == elementSize * effectiveVecLength * 3,
"Layout:%d Type:%d tight packing failed", (int)layout, (int)type);
mgr.reset();
}
}
}
DEF_TEST(UniformManagerCheckMatrixPacking, r) {
// Verify that the uniform manager can pack matrices correctly.
for (Layout layout : kLayouts) {
UniformManager mgr(layout);
for (SkSLType type : kTypes) {
int matrixSize = SkSLTypeMatrixSize(type);
if (matrixSize < 2) {
continue;
}
// Write three matching uniforms.
const Uniform expectations[] = {{"a", type}, {"b", type}, {"c", type}};
mgr.setExpectedUniforms(SkSpan(expectations));
mgr.write(type, kFloats);
mgr.write(type, kFloats);
mgr.write(type, kFloats);
mgr.doneWithExpectedUniforms();
// Verify that the uniform data was packed as tight as it should be.
UniformDataBlock uniformData = mgr.finishUniformDataBlock();
size_t elementSize = element_size(layout, type);
// In all layouts, mat3s should burn 12 elements, not 9.
size_t numElements = (matrixSize == 3) ? 12 : (matrixSize * matrixSize);
REPORTER_ASSERT(r, uniformData.size() == elementSize * numElements * 3,
"Layout:%d Type:%d matrix packing failed", (int)layout, (int)type);
mgr.reset();
}
}
}
DEF_TEST(UniformManagerCheckPaddingScalarVector, r) {
// Verify that the uniform manager properly adds padding between pairs of scalar/vector.
for (Layout layout : kLayouts) {
UniformManager mgr(layout);
for (SkSLType type1 : kTypes) {
const int vecLength1 = SkSLTypeVecLength(type1);
if (vecLength1 < 1) {
continue;
}
for (SkSLType type2 : kTypes) {
const int vecLength2 = SkSLTypeVecLength(type2);
if (vecLength2 < 1) {
continue;
}
// Write two scalar/vector uniforms.
const Uniform expectations[] = {{"a", type1}, {"b", type2}};
mgr.setExpectedUniforms(SkSpan(expectations));
mgr.write(type1, kFloats);
mgr.write(type2, kFloats);
mgr.doneWithExpectedUniforms();
// The expected packing varies depending on the bit-widths of each element.
const size_t elementSize1 = element_size(layout, type1);
const size_t elementSize2 = element_size(layout, type2);
if (elementSize1 == elementSize2) {
// Elements in the array correspond to the element size (either 16 or 32 bits).
// The expected uniform layout is listed as strings below.
// A/B: uniform values.
// a/b: padding as part of the uniform type (vec3 takes 4 slots)
// _ : padding between uniforms for alignment
static constexpr const char* kExpectedLayout[5][5] = {
{ "", "", "", "", "" },
{ "", "AB", "A_BB", "A___BBBb", "A___BBBB" },
{ "", "AAB_", "AABB", "AA__BBBb", "AA__BBBB" },
{ "", "AAAaB___", "AAAaBB__", "AAAaBBBb", "AAAaBBBB" },
{ "", "AAAAB___", "AAAABB__", "AAAABBBb", "AAAABBBB" },
};
const size_t size = strlen(kExpectedLayout[vecLength1][vecLength2]) *
elementSize1;
UniformDataBlock uniformData = mgr.finishUniformDataBlock();
REPORTER_ASSERT(r, uniformData.size() == size,
"Layout:%d Types:%d %d padding test failed",
(int)layout, (int)type1, (int)type2);
} else if (elementSize1 == 2 && elementSize2 == 4) {
// Elements in the array below correspond to 16 bits apiece.
// The expected uniform layout is listed as strings below.
// A/B: uniform values.
// a/b: padding as part of the uniform type (vec3 takes 4 slots)
// _ : padding between uniforms for alignment
static constexpr const char* kExpectedLayout[5][5] = {
{ "", "", "", "", "" },
{ "", "A_BB", "A___BBBB", "A_______BBBBBBbb", "A_______BBBBBBBB" },
{ "", "AABB", "AA__BBBB", "AA______BBBBBBbb", "AA______BBBBBBBB" },
{ "", "AAAaBB__", "AAAaBBBB", "AAAa____BBBBBBbb", "AAAa____BBBBBBBB" },
{ "", "AAAABB__", "AAAABBBB", "AAAA____BBBBBBbb", "AAAA____BBBBBBBB" },
};
const size_t size = strlen(kExpectedLayout[vecLength1][vecLength2]) * 2;
UniformDataBlock uniformData = mgr.finishUniformDataBlock();
REPORTER_ASSERT(r, uniformData.size() == size,
"Layout:%d Types:%d %d padding test failed",
(int)layout, (int)type1, (int)type2);
} else if (elementSize1 == 4 && elementSize2 == 2) {
// Elements in the array below correspond to 16 bits apiece.
// The expected uniform layout is listed as strings below.
// A/B: uniform values.
// a/b: padding as part of the uniform type (vec3 takes 4 slots)
// _ : padding between uniforms for alignment
static constexpr const char* kExpectedLayout[5][5] = {
{ "", "", "", "", "" },
{ "", "AAB_", "AABB", "AA__BBBb", "AA__BBBB" },
{ "", "AAAAB___", "AAAABB__", "AAAABBBb", "AAAABBBB" },
{ "",
"AAAAAAaaB_______",
"AAAAAAaaBB______",
"AAAAAAaaBBBb____",
"AAAAAAaaBBBB____" },
{ "",
"AAAAAAAAB_______",
"AAAAAAAABB______",
"AAAAAAAABBBb____",
"AAAAAAAABBBB____" },
};
const size_t size = strlen(kExpectedLayout[vecLength1][vecLength2]) * 2;
UniformDataBlock uniformData = mgr.finishUniformDataBlock();
REPORTER_ASSERT(r, uniformData.size() == size,
"Layout:%d Types:%d %d padding test failed",
(int)layout, (int)type1, (int)type2);
} else {
ERRORF(r, "Unexpected element sizes: %zu %zu", elementSize1, elementSize2);
}
mgr.reset();
}
}
}
}
DEF_TEST(UniformManagerCheckPaddingVectorMatrix, r) {
// Verify that the uniform manager properly adds padding between vectors and matrices.
for (Layout layout : kLayouts) {
UniformManager mgr(layout);
for (SkSLType type1 : kTypes) {
const int vecLength1 = SkSLTypeVecLength(type1);
if (vecLength1 < 1) {
continue;
}
for (SkSLType type2 : kTypes) {
const int matSize2 = SkSLTypeMatrixSize(type2);
if (matSize2 < 2) {
continue;
}
// Write the scalar/vector and matrix uniforms.
const Uniform expectations[] = {{"a", type1}, {"b", type2}};
mgr.setExpectedUniforms(SkSpan(expectations));
mgr.write(type1, kFloats);
mgr.write(type2, kFloats);
mgr.doneWithExpectedUniforms();
// The expected packing varies depending on the bit-widths of each element.
const size_t elementSize1 = element_size(layout, type1);
const size_t elementSize2 = element_size(layout, type2);
if (elementSize1 == elementSize2) {
// Elements in the array correspond to the element size (32 bits).
// The expected uniform layout is listed as strings below.
// A/B: uniform values.
// a/b: padding as part of the uniform type (vec3 takes 4 slots)
// _ : padding between uniforms for alignment
static constexpr const char* kExpectedLayout[5][5] = {
{ "", "", "", "", "" },
{ "", "", "A_BBBB", "A___BBBbBBBbBBBb", "A___BBBBBBBBBBBBBBBB" },
{ "", "", "AABBBB", "AA__BBBbBBBbBBBb", "AA__BBBBBBBBBBBBBBBB" },
{ "", "", "AAAaBBBB", "AAAaBBBbBBBbBBBb", "AAAaBBBBBBBBBBBBBBBB" },
{ "", "", "AAAABBBB", "AAAABBBbBBBbBBBb", "AAAABBBBBBBBBBBBBBBB" },
};
const size_t size = strlen(kExpectedLayout[vecLength1][matSize2]) *
elementSize1;
UniformDataBlock uniformData = mgr.finishUniformDataBlock();
REPORTER_ASSERT(r, uniformData.size() == size,
"Types:%d %d vector-matrix padding test failed",
(int)type1, (int)type2);
} else if (elementSize1 == 2 && elementSize2 == 4) {
// Elements in the array below correspond to 16 bits apiece.
// The expected uniform layout is listed as strings below.
// A/B: uniform values.
// a/b: padding as part of the uniform type (vec3 takes 4 slots)
// _ : padding between uniforms for alignment
static constexpr const char* kExpectedLayout[5][5] = {
{"", "", "", "", ""},
{"", "",
"A___BBBBBBBB",
"A_______BBBBBBbbBBBBBBbbBBBBBBbb",
"A_______BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"},
{"", "",
"AA__BBBBBBBB",
"AA______BBBBBBbbBBBBBBbbBBBBBBbb",
"AA______BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"},
{"", "",
"AAAaBBBBBBBB",
"AAAa____BBBBBBbbBBBBBBbbBBBBBBbb",
"AAAa____BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"},
{"", "",
"AAAABBBBBBBB",
"AAAA____BBBBBBbbBBBBBBbbBBBBBBbb",
"AAAA____BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"},
};
const size_t size = strlen(kExpectedLayout[vecLength1][matSize2]) * 2;
UniformDataBlock uniformData = mgr.finishUniformDataBlock();
REPORTER_ASSERT(r, uniformData.size() == size,
"Types:%d %d vector-matrix padding test failed",
(int)type1, (int)type2);
} else if (elementSize1 == 4 && elementSize2 == 2) {
// Elements in the array below correspond to 16 bits apiece.
// The expected uniform layout is listed as strings below.
// A/B: uniform values.
// a/b: padding as part of the uniform type (vec3 takes 4 slots)
// _ : padding between uniforms for alignment
static constexpr const char* kExpectedLayout[5][5] = {
{"", "", "", "", ""},
{"", "", "AABBBB", "AA__BBBbBBBbBBBb", "AA__BBBBBBBBBBBBBBBB"},
{"", "", "AAAABBBB", "AAAABBBbBBBbBBBb", "AAAABBBBBBBBBBBBBBBB"},
{"", "",
"AAAAAAaaBBBB____",
"AAAAAAaaBBBbBBBbBBBb____",
"AAAAAAaaBBBBBBBBBBBBBBBB"},
{"", "",
"AAAAAAAABBBB____",
"AAAAAAAABBBbBBBbBBBb____",
"AAAAAAAABBBBBBBBBBBBBBBB"},
};
const size_t size = strlen(kExpectedLayout[vecLength1][matSize2]) * 2;
UniformDataBlock uniformData = mgr.finishUniformDataBlock();
REPORTER_ASSERT(r, uniformData.size() == size,
"Types:%d %d vector-matrix padding test failed",
(int)type1, (int)type2);
}
mgr.reset();
}
}
}
}
DEF_TEST(UniformManagerCheckPaddingMatrixVector, r) {
// Verify that the uniform manager properly adds padding between matrices and vectors.
for (Layout layout : kLayouts) {
UniformManager mgr(layout);
for (SkSLType type1 : kTypes) {
const int matSize1 = SkSLTypeMatrixSize(type1);
if (matSize1 < 2) {
continue;
}
for (SkSLType type2 : kTypes) {
const int vecLength2 = SkSLTypeVecLength(type2);
if (vecLength2 < 1) {
continue;
}
// Write the scalar/vector and matrix uniforms.
const Uniform expectations[] = {{"a", type1}, {"b", type2}};
mgr.setExpectedUniforms(SkSpan(expectations));
mgr.write(type1, kFloats);
mgr.write(type2, kFloats);
mgr.doneWithExpectedUniforms();
// The expected packing varies depending on the bit-widths of each element.
const size_t elementSize1 = element_size(layout, type1);
const size_t elementSize2 = element_size(layout, type2);
if (elementSize1 == elementSize2) {
// Elements in the array correspond to the element size (32 bits).
// The expected uniform layout is listed as strings below.
// A/B: uniform values.
// a/b: padding as part of the uniform type (vec3 takes 4 slots)
// _ : padding between uniforms for alignment
static constexpr const char* kExpectedLayout[5][5] = {
{ "", "", "", "", "" },
{ "", "", "", "", "" },
{ "", "AAAAB_", "AAAABB", "AAAABBBb", "AAAABBBB" },
{ "",
"AAAaAAAaAAAaB___",
"AAAaAAAaAAAaBB__",
"AAAaAAAaAAAaBBBb",
"AAAaAAAaAAAaBBBB" },
{ "",
"AAAAAAAAAAAAAAAAB___",
"AAAAAAAAAAAAAAAABB__",
"AAAAAAAAAAAAAAAABBBb",
"AAAAAAAAAAAAAAAABBBB" },
};
const size_t size = strlen(kExpectedLayout[matSize1][vecLength2]) *
elementSize1;
UniformDataBlock uniformData = mgr.finishUniformDataBlock();
REPORTER_ASSERT(r, uniformData.size() == size,
"Types:%d %d matrix-vector padding test failed",
(int)type1, (int)type2);
} else if (elementSize1 == 2 && elementSize2 == 4) {
// Elements in the array below correspond to 16 bits apiece.
// The expected uniform layout is listed as strings below.
// A/B: uniform values.
// a/b: padding as part of the uniform type (vec3 takes 4 slots)
// _ : padding between uniforms for alignment
static constexpr const char* kExpectedLayout[5][5] = {
{ "", "", "", "", "" },
{ "", "", "", "", "" },
{ "", "AAAABB", "AAAABBBB", "AAAA____BBBBBBbb", "AAAA____BBBBBBBB" },
{ "",
"AAAaAAAaAAAaBB__",
"AAAaAAAaAAAaBBBB",
"AAAaAAAaAAAa____BBBBBBbb",
"AAAaAAAaAAAa____BBBBBBBB" },
{ "",
"AAAAAAAAAAAAAAAABB__",
"AAAAAAAAAAAAAAAABBBB",
"AAAAAAAAAAAAAAAABBBBBBbb",
"AAAAAAAAAAAAAAAABBBBBBBB" },
};
const size_t size = strlen(kExpectedLayout[matSize1][vecLength2]) * 2;
UniformDataBlock uniformData = mgr.finishUniformDataBlock();
REPORTER_ASSERT(r, uniformData.size() == size,
"Types:%d %d matrix-vector padding test failed",
(int)type1, (int)type2);
} else if (elementSize1 == 4 && elementSize2 == 2) {
// Elements in the array below correspond to 16 bits apiece.
// The expected uniform layout is listed as strings below.
// A/B: uniform values.
// a/b: padding as part of the uniform type (vec3 takes 4 slots)
// _ : padding between uniforms for alignment
static constexpr const char* kExpectedLayout[5][5] = {
{ "", "", "", "", "" },
{ "", "", "", "", "" },
{ "", "AAAAAAAAB___", "AAAAAAAABB__", "AAAAAAAABBBb", "AAAAAAAABBBB" },
{ "",
"AAAAAAaaAAAAAAaaAAAAAAaaB_______",
"AAAAAAaaAAAAAAaaAAAAAAaaBB______",
"AAAAAAaaAAAAAAaaAAAAAAaaBBBb____",
"AAAAAAaaAAAAAAaaAAAAAAaaBBBB____" },
{ "",
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB_______",
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABB______",
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBb____",
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBB____" },
};
const size_t size = strlen(kExpectedLayout[matSize1][vecLength2]) * 2;
UniformDataBlock uniformData = mgr.finishUniformDataBlock();
REPORTER_ASSERT(r, uniformData.size() == size,
"Types:%d %d matrix-vector padding test failed",
(int)type1, (int)type2);
}
mgr.reset();
}
}
}
}
DEF_TEST(UniformManagerMetalArrayLayout, r) {
UniformManager mgr(Layout::kMetal);
// Tests set up a uniform block with a single half (to force alignment) and an array of 3
// elements. Test every type that can appear in an array.
constexpr size_t kArraySize = 3;
// Buffer large enough to hold a float4x4[3] array.
static constexpr uint8_t kBuffer[192] = {};
static const char* kExpectedLayout[] = {
// Elements in the array below correspond to 16 bits apiece.
// The expected uniform layout is listed as strings below.
// A/B: uniform values.
// a/b: padding as part of the uniform type (vec3 takes 4 slots)
// _ : padding between uniforms for alignment.
/* {half, short[3]} */ "AABBBBBB",
/* {half, short2[3]} */ "AA__BBBBBBBBBBBB",
/* {half, short3[3]} */ "AA______BBBBBBbbBBBBBBbbBBBBBBbb",
/* {half, short4[3]} */ "AA______BBBBBBBBBBBBBBBBBBBBBBBB",
/* {half, float[3]} */ "AA__BBBBBBBBBBBB",
/* {half, float2[3]} */ "AA______BBBBBBBBBBBBBBBBBBBBBBBB",
/* {half, float3[3]} */ "AA______________BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb",
/* {half, float4[3]} */ "AA______________BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
/* {half, half[3]} */ "AABBBBBB",
/* {half, half2[3]} */ "AA__BBBBBBBBBBBB",
/* {half, half3[3]} */ "AA______BBBBBBbbBBBBBBbbBBBBBBbb",
/* {half, half4[3]} */ "AA______BBBBBBBBBBBBBBBBBBBBBBBB",
/* {half, int[3]} */ "AA__BBBBBBBBBBBB",
/* {half, int2[3]} */ "AA______BBBBBBBBBBBBBBBBBBBBBBBB",
/* {half, int3[3]} */ "AA______________BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb",
/* {half, int4[3]} */ "AA______________BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
/* {half, float2x2[3] */ "AA______BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
/* {half, float3x3[3] */ "AA______________"
"BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb"
"BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb"
"BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb",
/* {half, float4x4[3] */ "AA______________"
"BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
"BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
"BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
/* {half, half2x2[3] */ "AA__BBBBBBBBBBBBBBBBBBBBBBBB",
/* {half, half3x3[3] */ "AA______"
"BBBBBBbbBBBBBBbbBBBBBBbb"
"BBBBBBbbBBBBBBbbBBBBBBbb"
"BBBBBBbbBBBBBBbbBBBBBBbb",
/* {half, half4x4[3] */ "AA______"
"BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
"BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
"BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
};
for (size_t i = 0; i < std::size(kExpectedLayout); i++) {
const SkSLType arrayType = kTypes[i];
const Uniform expectations[] = {{"a", SkSLType::kHalf}, {"b", arrayType, kArraySize}};
mgr.setExpectedUniforms(SkSpan(expectations));
mgr.write(SkSLType::kHalf, kHalfs);
mgr.writeArray(arrayType, kBuffer, kArraySize);
mgr.doneWithExpectedUniforms();
const size_t expectedSize = strlen(kExpectedLayout[i]);
const UniformDataBlock uniformData = mgr.finishUniformDataBlock();
REPORTER_ASSERT(r, uniformData.size() == expectedSize,
"array test %d for type %s failed - expected size: %zu, actual size: %zu",
(int)i, SkSLTypeString(arrayType), expectedSize, uniformData.size());
mgr.reset();
}
}
DEF_TEST(UniformManagerStd430ArrayLayout, r) {
UniformManager mgr(Layout::kStd430);
// Tests set up a uniform block with a single half (to force alignment) and an array of 3
// elements. Test every type that can appear in an array.
constexpr size_t kArraySize = 3;
// Buffer large enough to hold a float4x4[3] array.
static constexpr uint8_t kBuffer[192] = {};
static const char* kExpectedLayout[] = {
// Elements in the array below correspond to 16 bits apiece.
// The expected uniform layout is listed as strings below.
// A/B: uniform values.
// a/b: padding as part of the uniform type (vec3 takes 4 slots)
// _ : padding between uniforms for alignment.
/* {half, short[3]} */ "AA__BBBBBBBBBBBB",
/* {half, short2[3]} */ "AA______BBBBBBBBBBBBBBBBBBBBBBBB",
/* {half, short3[3]} */ "AA______________BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb",
/* {half, short4[3]} */ "AA______________BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
/* {half, float[3]} */ "AA__BBBBBBBBBBBB",
/* {half, float2[3]} */ "AA______BBBBBBBBBBBBBBBBBBBBBBBB",
/* {half, float3[3]} */ "AA______________BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb",
/* {half, float4[3]} */ "AA______________BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
/* {half, half[3]} */ "AA__BBBBBBBBBBBB",
/* {half, half2[3]} */ "AA______BBBBBBBBBBBBBBBBBBBBBBBB",
/* {half, half3[3]} */ "AA______________BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb",
/* {half, half4[3]} */ "AA______________BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
/* {half, int[3]} */ "AA__BBBBBBBBBBBB",
/* {half, int2[3]} */ "AA______BBBBBBBBBBBBBBBBBBBBBBBB",
/* {half, int3[3]} */ "AA______________BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb",
/* {half, int4[3]} */ "AA______________BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
/* {half, float2x2[3] */ "AA______BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
/* {half, float3x3[3] */ "AA______________"
"BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb"
"BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb"
"BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb",
/* {half, float4x4[3] */ "AA______________"
"BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
"BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
"BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
/* {half, half2x2[3] */ "AA______BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
/* {half, half3x3[3] */ "AA______________"
"BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb"
"BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb"
"BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb",
/* {half, half4x4[3] */ "AA______________"
"BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
"BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
"BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
};
for (size_t i = 0; i < std::size(kExpectedLayout); i++) {
const SkSLType arrayType = kTypes[i];
const Uniform expectations[] = {{"a", SkSLType::kHalf}, {"b", arrayType, kArraySize}};
mgr.setExpectedUniforms(SkSpan(expectations));
mgr.write(SkSLType::kHalf, kHalfs);
mgr.writeArray(arrayType, kBuffer, kArraySize);
mgr.doneWithExpectedUniforms();
const size_t expectedSize = strlen(kExpectedLayout[i]);
const UniformDataBlock uniformData = mgr.finishUniformDataBlock();
REPORTER_ASSERT(r, uniformData.size() == expectedSize,
"array test %d for type %s failed - expected size: %zu, actual size: %zu",
(int)i, SkSLTypeString(arrayType), expectedSize, uniformData.size());
mgr.reset();
}
}
DEF_TEST(UniformManagerStd140ArrayLayout, r) {
UniformManager mgr(Layout::kStd140);
// Tests set up a uniform block with a single half (to force alignment) and an array of 3
// elements. Test every type that can appear in an array.
constexpr size_t kArraySize = 3;
// Buffer large enough to hold a float4x4[3] array.
static constexpr uint8_t kBuffer[192] = {};
static const char* kExpectedLayout[] = {
// Elements in the array below correspond to 16 bits apiece.
// The expected uniform layout is listed as strings below.
// A/B: uniform values.
// a/b: padding as part of the uniform type (vec3 takes 4 slots)
// _ : padding between uniforms for alignment.
/* {half, short[3]} */ "AA______________BBbbbbbbbbbbbbbbBBbbbbbbbbbbbbbbBBbbbbbbbbbbbbbb",
/* {half, short2[3]} */ "AA______________BBBBbbbbbbbbbbbbBBBBbbbbbbbbbbbbBBBBbbbbbbbbbbbb",
/* {half, short3[3]} */ "AA______________BBBBBBbbbbbbbbbbBBBBBBbbbbbbbbbbBBBBBBbbbbbbbbbb",
/* {half, short4[3]} */ "AA______________BBBBBBBBbbbbbbbbBBBBBBBBbbbbbbbbBBBBBBBBbbbbbbbb",
/* {half, float[3]} */ "AA______________BBBBbbbbbbbbbbbbBBBBbbbbbbbbbbbbBBBBbbbbbbbbbbbb",
/* {half, float2[3]} */ "AA______________BBBBBBBBbbbbbbbbBBBBBBBBbbbbbbbbBBBBBBBBbbbbbbbb",
/* {half, float3[3]} */ "AA______________BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb",
/* {half, float4[3]} */ "AA______________BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
/* {half, half[3]} */ "AA______________BBbbbbbbbbbbbbbbBBbbbbbbbbbbbbbbBBbbbbbbbbbbbbbb",
/* {half, half2[3]} */ "AA______________BBBBbbbbbbbbbbbbBBBBbbbbbbbbbbbbBBBBbbbbbbbbbbbb",
/* {half, half3[3]} */ "AA______________BBBBBBbbbbbbbbbbBBBBBBbbbbbbbbbbBBBBBBbbbbbbbbbb",
/* {half, half4[3]} */ "AA______________BBBBBBBBbbbbbbbbBBBBBBBBbbbbbbbbBBBBBBBBbbbbbbbb",
/* {half, int[3]} */ "AA______________BBBBbbbbbbbbbbbbBBBBbbbbbbbbbbbbBBBBbbbbbbbbbbbb",
/* {half, int2[3]} */ "AA______________BBBBBBBBbbbbbbbbBBBBBBBBbbbbbbbbBBBBBBBBbbbbbbbb",
/* {half, int3[3]} */ "AA______________BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb",
/* {half, int4[3]} */ "AA______________BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
/* {half, float2x2[3] */ "AA______________BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
/* {half, float3x3[3] */ "AA______________"
"BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb"
"BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb"
"BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb",
/* {half, float4x4[3] */ "AA______________"
"BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
"BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
"BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
/* {half, half2x2[3] */ "AA______________BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
/* {half, half3x3[3] */ "AA______________"
"BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb"
"BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb"
"BBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbbBBBBBBBBBBBBbbbb",
/* {half, half4x4[3] */ "AA______________"
"BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
"BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
"BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
};
for (size_t i = 0; i < std::size(kExpectedLayout); i++) {
const SkSLType arrayType = kTypes[i];
const Uniform expectations[] = {{"a", SkSLType::kHalf}, {"b", arrayType, kArraySize}};
mgr.setExpectedUniforms(SkSpan(expectations));
mgr.write(SkSLType::kHalf, kHalfs);
mgr.writeArray(arrayType, kBuffer, kArraySize);
mgr.doneWithExpectedUniforms();
const size_t expectedSize = strlen(kExpectedLayout[i]);
const UniformDataBlock uniformData = mgr.finishUniformDataBlock();
REPORTER_ASSERT(r, uniformData.size() == expectedSize,
"array test %d for type %s failed - expected size: %zu, actual size: %zu",
(int)i, SkSLTypeString(arrayType), expectedSize, uniformData.size());
mgr.reset();
}
}