skia2/tests/sksl/shared/StructsInFunctions.metal

82 lines
2.2 KiB
Metal
Raw Normal View History

#include <metal_stdlib>
#include <simd/simd.h>
using namespace metal;
struct S {
float x;
int y;
};
struct Nested {
S a;
S b;
};
struct Uniforms {
float4 colorRed;
float4 colorGreen;
};
struct Inputs {
};
struct Outputs {
float4 sk_FragColor [[color(0)]];
};
void modifies_a_struct_vS(thread S& s);
void _skOutParamHelper0_modifies_a_struct_vS(thread S& s) {
S _var0 = s;
modifies_a_struct_vS(_var0);
s = _var0;
}
void modifies_a_struct_vS(thread S& s);
void _skOutParamHelper1_modifies_a_struct_vS(thread Nested& n3) {
S _var0 = n3.b;
modifies_a_struct_vS(_var0);
n3.b = _var0;
}
Reland "Implement operator== and != for Metal structs and arrays." This is a reland of 830c69ca66d339067cdc06775f59443a06fc15a2 Original change's description: > Implement operator== and != for Metal structs and arrays. > > GLSL/SkSL assumes that == and != on struct/array types should work. > We need to emit equality and inequality operators whenever we find code > that compares a struct or array. > > Structs and arrays can be arbitrarily nested, and either type can > contain a matrix. All of these things need custom equality operators in > Metal. Therefore, we need to recursively generate comparison operators > when any of these types are encountered. > > For arrays we get lucky, and we can cover all possible array types and > sizes with a single templated operator== method. Structs and matrices > have no such luck, and are generated separately on a per-type basis. > > For each of these types, operator== is implemented as an equality check > on each field, and operator!= is implemented in terms of operator==. > Equality and inequality are always emitted together. (Previously, matrix > equality and inequality were emitted and implemented independently, but > this is no longer the case.) > > Change-Id: I69ee01c0a390d7db6bcb2253ed6336ab20cc4d1d > Bug: skia:11908, skia:11924 > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/402016 > Auto-Submit: John Stiles <johnstiles@google.com> > Commit-Queue: Brian Osman <brianosman@google.com> > Reviewed-by: Brian Osman <brianosman@google.com> Bug: skia:11908, skia:11924, skia:11929 Change-Id: I6336b6125e9774c1ca73e3d497e3466f11f6f25f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/402559 Commit-Queue: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2021-04-29 18:39:35 +00:00
thread bool operator==(thread const S& left, thread const S& right) {
return (left.x == right.x) &&
(left.y == right.y);
}
thread bool operator!=(thread const S& left, thread const S& right) {
return !(left == right);
}
thread bool operator==(thread const Nested& left, thread const Nested& right) {
return (left.a == right.a) &&
(left.b == right.b);
}
thread bool operator!=(thread const Nested& left, thread const Nested& right) {
return !(left == right);
}
S returns_a_struct_S() {
S s;
s.x = 1.0;
s.y = 2;
return s;
}
S constructs_a_struct_S() {
return S{2.0, 3};
}
float accepts_a_struct_fS(S s) {
return s.x + float(s.y);
}
void modifies_a_struct_vS(thread S& s) {
s.x++;
s.y++;
}
fragment Outputs fragmentMain(Inputs _in [[stage_in]], constant Uniforms& _uniforms [[buffer(0)]], bool _frontFacing [[front_facing]], float4 _fragCoord [[position]]) {
Outputs _out;
(void)_out;
S s = returns_a_struct_S();
float x = accepts_a_struct_fS(s);
_skOutParamHelper0_modifies_a_struct_vS(s);
S expected = constructs_a_struct_S();
Nested n1;
Nested n2;
Nested n3;
Reland "Implement operator== and != for Metal structs and arrays." This is a reland of 830c69ca66d339067cdc06775f59443a06fc15a2 Original change's description: > Implement operator== and != for Metal structs and arrays. > > GLSL/SkSL assumes that == and != on struct/array types should work. > We need to emit equality and inequality operators whenever we find code > that compares a struct or array. > > Structs and arrays can be arbitrarily nested, and either type can > contain a matrix. All of these things need custom equality operators in > Metal. Therefore, we need to recursively generate comparison operators > when any of these types are encountered. > > For arrays we get lucky, and we can cover all possible array types and > sizes with a single templated operator== method. Structs and matrices > have no such luck, and are generated separately on a per-type basis. > > For each of these types, operator== is implemented as an equality check > on each field, and operator!= is implemented in terms of operator==. > Equality and inequality are always emitted together. (Previously, matrix > equality and inequality were emitted and implemented independently, but > this is no longer the case.) > > Change-Id: I69ee01c0a390d7db6bcb2253ed6336ab20cc4d1d > Bug: skia:11908, skia:11924 > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/402016 > Auto-Submit: John Stiles <johnstiles@google.com> > Commit-Queue: Brian Osman <brianosman@google.com> > Reviewed-by: Brian Osman <brianosman@google.com> Bug: skia:11908, skia:11924, skia:11929 Change-Id: I6336b6125e9774c1ca73e3d497e3466f11f6f25f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/402559 Commit-Queue: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2021-04-29 18:39:35 +00:00
n1.a = returns_a_struct_S();
n1.b = n1.a;
n2 = n1;
n3 = n2;
_skOutParamHelper1_modifies_a_struct_vS(n3);
bool valid = (((((((x == 3.0 && s.x == 2.0) && s.y == 3) && s == expected) && s == S{2.0, 3}) && s != returns_a_struct_S()) && n1 == n2) && n1 != n3) && n3 == Nested{S{1.0, 2}, S{2.0, 3}};
_out.sk_FragColor = valid ? _uniforms.colorGreen : _uniforms.colorRed;
return _out;
}