AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Migrate even more SkSL tests to run in dm.

Browse Source 
- ResizeMatrix
- ScalarConversionConstructorsES2
- StackingVectorCasts
- StaticIf
- SwizzleBoolConstants

Non-ES2 compatible tests:

- ResizeMatrixNonsquare
- ScalarConversionConstructorsES3

Newly discovered bugs:
- skia:11278 SPIR-V does not support casting non-square matrices

Change-Id: I7feb78f0380d0a9cb328ec61f96a364ad1281432
Bug: skia:11009, skia:11278
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/366408
Commit-Queue: Brian Osman <brianosman@google.com>
Reviewed-by: Brian Osman <brianosman@google.com>
Auto-Submit: John Stiles <johnstiles@google.com>
This commit is contained in:
John Stiles 2021-02-05 09:31:21 -05:00 committed by Skia Commit-Bot
parent 1f4cd07af8
commit d437478348
34 changed files with 1343 additions and 634 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
gn/sksl_tests.gni
View File

@ -366,11 +366,13 @@ sksl_shared_tests = [
"/sksl/shared/OutParamsTricky.sksl",
"/sksl/shared/RectangleTexture.sksl",
"/sksl/shared/ResizeMatrix.sksl",
"/sksl/shared/ResizeMatrixNonsquare.sksl",
"/sksl/shared/ReturnBadTypeFromMain.sksl",
"/sksl/shared/ReturnColorFromMain.sksl",
"/sksl/shared/SampleLocations.vert",
"/sksl/shared/SampleMask.sksl",
"/sksl/shared/ScalarConversionConstructors.sksl",
"/sksl/shared/ScalarConversionConstructorsES2.sksl",
"/sksl/shared/ScalarConversionConstructorsES3.sksl",
"/sksl/shared/ScopedSymbol.sksl",
"/sksl/shared/StackingVectorCasts.sksl",
"/sksl/shared/StaticIf.sksl",

24
resources/sksl/shared/ResizeMatrix.sksl
View File

@ -1,13 +1,13 @@
void main() {
float2x2 a = float2x2(float3x3(1)); sk_FragColor.r = half(a[0][0]);
float2x2 b = float2x2(float4x4(1)); sk_FragColor.r = half(b[0][0]);
float3x3 c = float3x3(float4x4(1)); sk_FragColor.r = half(c[0][0]);
float3x3 d = float3x3(float2x2(1)); sk_FragColor.r = half(d[0][0]);
float3x3 e = float3x3(float2x3(1)); sk_FragColor.r = half(e[0][0]);
float3x3 f = float3x3(float3x2(1)); sk_FragColor.r = half(f[0][0]);
float4x4 g = float4x4(float3x3(float2x2(1))); sk_FragColor.r = half(g[0][0]);
float4x4 h = float4x4(float4x3(float4x2(1))); sk_FragColor.r = half(h[0][0]);
float4x4 i = float4x4(float3x4(float2x4(1))); sk_FragColor.r = half(i[0][0]);
float2x4 j = float2x4(float4x2(1)); sk_FragColor.r = half(j[0][0]);
float4x2 k = float4x2(float2x4(1)); sk_FragColor.r = half(k[0][0]);
uniform half4 colorGreen, colorRed;
half4 main() {
float result = 0;
float2x2 a = float2x2(float3x3(1)); result += a[0][0];
float2x2 b = float2x2(float4x4(1)); result += b[0][0];
float3x3 c = float3x3(float4x4(1)); result += c[0][0];
float3x3 d = float3x3(float2x2(1)); result += d[0][0];
float4x4 e = float4x4(float3x3(float2x2(1))); result += e[0][0];
float2x2 f = float2x2(float3x3(float4x4(1))); result += f[0][0];
return result == 6 ? colorGreen : colorRed;
}

13
resources/sksl/shared/ResizeMatrixNonsquare.sksl Normal file
View File

@ -0,0 +1,13 @@
uniform half4 colorGreen, colorRed;
half4 main() {
float result = 0;
float3x3 g = float3x3(float2x3(1)); result += g[0][0];
float3x3 h = float3x3(float3x2(1)); result += h[0][0];
float4x4 i = float4x4(float4x3(float4x2(1))); result += i[0][0];
float4x4 j = float4x4(float3x4(float2x4(1))); result += j[0][0];
float2x4 k = float2x4(float4x2(1)); result += k[0][0];
float4x2 l = float4x2(float2x4(1)); result += l[0][0];
return result == 6 ? colorGreen : colorRed;
}

28
resources/sksl/shared/ScalarConversionConstructors.sksl
View File

@ -1,28 +0,0 @@
float f = 1.0;
int i = 1;
uint u = 1;
bool b = true;
void main() {
float f1 = float(f);
float f2 = float(i);
float f3 = float(u);
float f4 = float(b);
int i1 = int(f);
int i2 = int(i);
int i3 = int(u);
int i4 = int(b);
uint u1 = uint(f);
uint u2 = uint(i);
uint u3 = uint(u);
uint u4 = uint(b);
bool b1 = bool(f);
bool b2 = bool(i);
bool b3 = bool(u);
bool b4 = bool(b);
sk_FragColor.x = half(f1 + f2 + f3 + f4);
sk_FragColor.x = half(i1 + i2 + i3 + i4);
sk_FragColor.x = half(u1 + u2 + u3 + u4);
sk_FragColor.x = half(b1 || b2 || b3 || b4);
}

22
resources/sksl/shared/ScalarConversionConstructorsES2.sksl Normal file
View File

@ -0,0 +1,22 @@
uniform half4 colorGreen, colorRed;
half4 main() {
float f = colorGreen.g;
int i = int(colorGreen.g);
bool b = bool(colorGreen.g);
float f1 = float(f);
float f2 = float(i);
float f3 = float(b);
int i1 = int(f);
int i2 = int(i);
int i3 = int(b);
bool b1 = bool(f);
bool b2 = bool(i);
bool b3 = bool(b);
return half(f1) + half(f2) + half(f3) +
half(i1) + half(i2) + half(i3) +
half(b1) + half(b2) + half(b3) == 9 ? colorGreen : colorRed;
}

31
resources/sksl/shared/ScalarConversionConstructorsES3.sksl Normal file
View File

@ -0,0 +1,31 @@
uniform half4 colorGreen, colorRed;
half4 main() {
float f = colorGreen.g;
int i = int(colorGreen.g);
uint u = uint(colorGreen.g);
bool b = bool(colorGreen.g);
float f1 = float(f);
float f2 = float(i);
float f3 = float(u);
float f4 = float(b);
int i1 = int(f);
int i2 = int(i);
int i3 = int(u);
int i4 = int(b);
uint u1 = uint(f);
uint u2 = uint(i);
uint u3 = uint(u);
uint u4 = uint(b);
bool b1 = bool(f);
bool b2 = bool(i);
bool b3 = bool(u);
bool b4 = bool(b);
return half(f1) + half(f2) + half(f3) + half(f4) +
half(i1) + half(i2) + half(i3) + half(i4) +
half(u1) + half(u2) + half(u3) + half(u4) +
half(b1) + half(b2) + half(b3) + half(b4) == 16 ? colorGreen : colorRed;
}

8
resources/sksl/shared/StackingVectorCasts.sksl
View File

@ -1,6 +1,8 @@
void main() {
uniform half4 colorGreen, colorRed;
half4 main() {
if (half4(0, 0, 1, 1) == half4(int4(0, 0, 1, 1)))
sk_FragColor = half4(1);
return colorGreen;
else
sk_FragColor = half4(-1);
return colorRed;
}

8
resources/sksl/shared/StaticIf.sksl
View File

@ -1,7 +1,11 @@
void main() {
uniform half4 colorRed, colorGreen;
half4 main() {
half4 result = colorRed;
float x = 5;
float y = 10;
@if (x < y) {
sk_FragColor = half4(1);
result = colorGreen;
}
return result;
}

8
resources/sksl/shared/SwizzleBoolConstants.sksl
View File

@ -1,6 +1,8 @@
uniform half4 colorGreen, colorRed;
half4 main() {
bool4 v = bool4(colorGreen.g);
void main() {
bool4 v = bool4(sqrt(1) == 1);
bool4 result;
result = bool4(v.x, true, true, true);
result = bool4(v.xy, false, true);
@ -28,5 +30,5 @@ void main() {
result = v.00zw;
result = v.00z1;
result = v.011w;
sk_FragColor = any(result) ? half4(1) : half4(0);
return any(result) ? colorGreen : colorRed;
}

117
tests/SkSLTest.cpp
View File

@ -115,47 +115,52 @@ static void test_gpu(skiatest::Reporter* r, GrDirectContext* ctx, const char* te
}
#define SKSL_TEST(name, path) SKSL_TEST_CPU(name, path) SKSL_TEST_GPU(name, path)
SKSL_TEST(SkSLBoolFolding, "folding/BoolFolding.sksl")
SKSL_TEST(SkSLIntFoldingES2, "folding/IntFoldingES2.sksl")
SKSL_TEST(SkSLFloatFolding, "folding/FloatFolding.sksl")
SKSL_TEST(SkSLMatrixFoldingES2, "folding/MatrixFoldingES2.sksl")
SKSL_TEST(SkSLShortCircuitBoolFolding, "folding/ShortCircuitBoolFolding.sksl")
SKSL_TEST(SkSLVectorScalarFolding, "folding/VectorScalarFolding.sksl")
SKSL_TEST(SkSLVectorVectorFolding, "folding/VectorVectorFolding.sksl")
SKSL_TEST(SkSLBoolFolding, "folding/BoolFolding.sksl")
SKSL_TEST(SkSLIntFoldingES2, "folding/IntFoldingES2.sksl")
SKSL_TEST(SkSLFloatFolding, "folding/FloatFolding.sksl")
SKSL_TEST(SkSLMatrixFoldingES2, "folding/MatrixFoldingES2.sksl")
SKSL_TEST(SkSLShortCircuitBoolFolding, "folding/ShortCircuitBoolFolding.sksl")
SKSL_TEST(SkSLVectorScalarFolding, "folding/VectorScalarFolding.sksl")
SKSL_TEST(SkSLVectorVectorFolding, "folding/VectorVectorFolding.sksl")
SKSL_TEST(SkSLIntrinsicAbsFloat, "intrinsics/AbsFloat.sksl")
SKSL_TEST(SkSLIntrinsicCeil, "intrinsics/Ceil.sksl")
SKSL_TEST(SkSLIntrinsicClampFloat, "intrinsics/ClampFloat.sksl")
SKSL_TEST(SkSLIntrinsicMaxFloat, "intrinsics/MaxFloat.sksl")
SKSL_TEST(SkSLIntrinsicMinFloat, "intrinsics/MinFloat.sksl")
SKSL_TEST(SkSLIntrinsicMixFloat, "intrinsics/MixFloat.sksl")
SKSL_TEST(SkSLIntrinsicSignFloat, "intrinsics/SignFloat.sksl")
SKSL_TEST(SkSLIntrinsicAbsFloat, "intrinsics/AbsFloat.sksl")
SKSL_TEST(SkSLIntrinsicCeil, "intrinsics/Ceil.sksl")
SKSL_TEST(SkSLIntrinsicClampFloat, "intrinsics/ClampFloat.sksl")
SKSL_TEST(SkSLIntrinsicMaxFloat, "intrinsics/MaxFloat.sksl")
SKSL_TEST(SkSLIntrinsicMinFloat, "intrinsics/MinFloat.sksl")
SKSL_TEST(SkSLIntrinsicMixFloat, "intrinsics/MixFloat.sksl")
SKSL_TEST(SkSLIntrinsicSignFloat, "intrinsics/SignFloat.sksl")
SKSL_TEST(SkSLArrayTypes, "shared/ArrayTypes.sksl")
SKSL_TEST(SkSLAssignment, "shared/Assignment.sksl")
SKSL_TEST(SkSLCastsRoundTowardZero, "shared/CastsRoundTowardZero.sksl")
SKSL_TEST(SkSLCommaMixedTypes, "shared/CommaMixedTypes.sksl")
SKSL_TEST(SkSLCommaSideEffects, "shared/CommaSideEffects.sksl")
SKSL_TEST(SkSLConstantIf, "shared/ConstantIf.sksl")
SKSL_TEST(SkSLConstVariableComparison, "shared/ConstVariableComparison.sksl")
SKSL_TEST(SkSLDeadIfStatement, "shared/DeadIfStatement.sksl")
SKSL_TEST(SkSLDeadStripFunctions, "shared/DeadStripFunctions.sksl")
SKSL_TEST(SkSLDependentInitializers, "shared/DependentInitializers.sksl")
SKSL_TEST(SkSLEmptyBlocksES2, "shared/EmptyBlocksES2.sksl")
SKSL_TEST(SkSLForLoopControlFlow, "shared/ForLoopControlFlow.sksl")
SKSL_TEST(SkSLFunctionArgTypeMatch, "shared/FunctionArgTypeMatch.sksl")
SKSL_TEST(SkSLFunctionReturnTypeMatch, "shared/FunctionReturnTypeMatch.sksl")
SKSL_TEST(SkSLFunctions, "shared/Functions.sksl")
SKSL_TEST(SkSLGeometricIntrinsics, "shared/GeometricIntrinsics.sksl")
SKSL_TEST(SkSLHelloWorld, "shared/HelloWorld.sksl")
SKSL_TEST(SkSLHex, "shared/Hex.sksl")
SKSL_TEST(SkSLMatrices, "shared/Matrices.sksl")
SKSL_TEST(SkSLMultipleAssignments, "shared/MultipleAssignments.sksl")
SKSL_TEST(SkSLNegatedVectorLiteral, "shared/NegatedVectorLiteral.sksl")
SKSL_TEST(SkSLNumberCasts, "shared/NumberCasts.sksl")
SKSL_TEST(SkSLOperatorsES2, "shared/OperatorsES2.sksl")
SKSL_TEST(SkSLOutParams, "shared/OutParams.sksl")
SKSL_TEST(SkSLOutParamsTricky, "shared/OutParamsTricky.sksl")
SKSL_TEST(SkSLArrayTypes, "shared/ArrayTypes.sksl")
SKSL_TEST(SkSLAssignment, "shared/Assignment.sksl")
SKSL_TEST(SkSLCastsRoundTowardZero, "shared/CastsRoundTowardZero.sksl")
SKSL_TEST(SkSLCommaMixedTypes, "shared/CommaMixedTypes.sksl")
SKSL_TEST(SkSLCommaSideEffects, "shared/CommaSideEffects.sksl")
SKSL_TEST(SkSLConstantIf, "shared/ConstantIf.sksl")
SKSL_TEST(SkSLConstVariableComparison, "shared/ConstVariableComparison.sksl")
SKSL_TEST(SkSLDeadIfStatement, "shared/DeadIfStatement.sksl")
SKSL_TEST(SkSLDeadStripFunctions, "shared/DeadStripFunctions.sksl")
SKSL_TEST(SkSLDependentInitializers, "shared/DependentInitializers.sksl")
SKSL_TEST(SkSLEmptyBlocksES2, "shared/EmptyBlocksES2.sksl")
SKSL_TEST(SkSLForLoopControlFlow, "shared/ForLoopControlFlow.sksl")
SKSL_TEST(SkSLFunctionArgTypeMatch, "shared/FunctionArgTypeMatch.sksl")
SKSL_TEST(SkSLFunctionReturnTypeMatch, "shared/FunctionReturnTypeMatch.sksl")
SKSL_TEST(SkSLFunctions, "shared/Functions.sksl")
SKSL_TEST(SkSLGeometricIntrinsics, "shared/GeometricIntrinsics.sksl")
SKSL_TEST(SkSLHelloWorld, "shared/HelloWorld.sksl")
SKSL_TEST(SkSLHex, "shared/Hex.sksl")
SKSL_TEST(SkSLMatrices, "shared/Matrices.sksl")
SKSL_TEST(SkSLMultipleAssignments, "shared/MultipleAssignments.sksl")
SKSL_TEST(SkSLNegatedVectorLiteral, "shared/NegatedVectorLiteral.sksl")
SKSL_TEST(SkSLNumberCasts, "shared/NumberCasts.sksl")
SKSL_TEST(SkSLOperatorsES2, "shared/OperatorsES2.sksl")
SKSL_TEST(SkSLOutParams, "shared/OutParams.sksl")
SKSL_TEST(SkSLOutParamsTricky, "shared/OutParamsTricky.sksl")
SKSL_TEST(SkSLResizeMatrix, "shared/ResizeMatrix.sksl")
SKSL_TEST(SkSLScalarConversionConstructorsES2, "shared/ScalarConversionConstructorsES2.sksl")
SKSL_TEST(SkSLStackingVectorCasts, "shared/StackingVectorCasts.sksl")
SKSL_TEST(SkSLStaticIf, "shared/StaticIf.sksl")
SKSL_TEST(SkSLSwizzleBoolConstants, "shared/SwizzleBoolConstants.sksl")
/*
// Incompatible with Runtime Effects because calling a function before its definition is disallowed.
@ -171,22 +176,24 @@ SKSL_TEST(SkSLStructsInFunctions, "shared/StructsInFunctions.sksl")
/*
TODO(skia:11209): enable these tests when Runtime Effects have support for ES3
SKSL_TEST(SkSLIntFoldingES3, "folding/IntFoldingES3.sksl")
SKSL_TEST(SkSLMatrixFoldingES3, "folding/MatrixFoldingES3.sksl")
SKSL_TEST(SkSLIntFoldingES3, "folding/IntFoldingES3.sksl")
SKSL_TEST(SkSLMatrixFoldingES3, "folding/MatrixFoldingES3.sksl")
SKSL_TEST(SkSLIntrinsicAbsInt, "intrinsics/AbsInt.sksl")
SKSL_TEST(SkSLIntrinsicClampInt, "intrinsics/ClampInt.sksl")
SKSL_TEST(SkSLIntrinsicMaxInt, "intrinsics/MaxInt.sksl")
SKSL_TEST(SkSLIntrinsicMinInt, "intrinsics/MinInt.sksl")
SKSL_TEST(SkSLIntrinsicMixBool, "intrinsics/MixBool.sksl")
SKSL_TEST(SkSLIntrinsicSignInt, "intrinsics/SignInt.sksl")
SKSL_TEST(SkSLIntrinsicAbsInt, "intrinsics/AbsInt.sksl")
SKSL_TEST(SkSLIntrinsicClampInt, "intrinsics/ClampInt.sksl")
SKSL_TEST(SkSLIntrinsicMaxInt, "intrinsics/MaxInt.sksl")
SKSL_TEST(SkSLIntrinsicMinInt, "intrinsics/MinInt.sksl")
SKSL_TEST(SkSLIntrinsicMixBool, "intrinsics/MixBool.sksl")
SKSL_TEST(SkSLIntrinsicSignInt, "intrinsics/SignInt.sksl")
SKSL_TEST(SkSLArrayConstructors, "shared/ArrayConstructors.sksl")
SKSL_TEST(SkSLDeadLoopVariable, "shared/DeadLoopVariable.sksl")
SKSL_TEST(SkSLDoWhileControlFlow, "shared/DoWhileControlFlow.sksl")
SKSL_TEST(SkSLEmptyBlocksES3, "shared/EmptyBlocksES3.sksl")
SKSL_TEST(SkSLHexUnsigned, "shared/HexUnsigned.sksl")
SKSL_TEST(SkSLMatricesNonsquare, "shared/MatricesNonsquare.sksl")
SKSL_TEST(SkSLOperatorsES3, "shared/OperatorsES3.sksl")
SKSL_TEST(SkSLWhileLoopControlFlow, "shared/WhileLoopControlFlow.sksl")
SKSL_TEST(SkSLArrayConstructors, "shared/ArrayConstructors.sksl")
SKSL_TEST(SkSLDeadLoopVariable, "shared/DeadLoopVariable.sksl")
SKSL_TEST(SkSLDoWhileControlFlow, "shared/DoWhileControlFlow.sksl")
SKSL_TEST(SkSLEmptyBlocksES3, "shared/EmptyBlocksES3.sksl")
SKSL_TEST(SkSLHexUnsigned, "shared/HexUnsigned.sksl")
SKSL_TEST(SkSLMatricesNonsquare, "shared/MatricesNonsquare.sksl")
SKSL_TEST(SkSLOperatorsES3, "shared/OperatorsES3.sksl")
SKSL_TEST(SkSLResizeMatrixNonsquare, "shared/ResizeMatrixNonsquare.sksl")
SKSL_TEST(SkSLScalarConversionConstructorsES3, "shared/ScalarConversionConstructorsES3.sksl")
SKSL_TEST(SkSLWhileLoopControlFlow, "shared/WhileLoopControlFlow.sksl")
*/

217
tests/sksl/shared/ResizeMatrix.asm.frag
View File

@ -1,6 +1,211 @@
### Compilation failed:
error: SPIR-V validation error: Invalid instruction word count: 0
SPIR-V validation error: Invalid instruction word count: 0
1 error
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %_entrypoint "_entrypoint" %sk_FragColor %sk_Clockwise
OpExecutionMode %_entrypoint OriginUpperLeft
OpName %sk_FragColor "sk_FragColor"
OpName %sk_Clockwise "sk_Clockwise"
OpName %_UniformBuffer "_UniformBuffer"
OpMemberName %_UniformBuffer 0 "colorGreen"
OpMemberName %_UniformBuffer 1 "colorRed"
OpName %_entrypoint "_entrypoint"
OpName %main "main"
OpName %result "result"
OpDecorate %sk_FragColor RelaxedPrecision
OpDecorate %sk_FragColor Location 0
OpDecorate %sk_FragColor Index 0
OpDecorate %sk_Clockwise RelaxedPrecision
OpDecorate %sk_Clockwise BuiltIn FrontFacing
OpMemberDecorate %_UniformBuffer 0 Offset 0
OpMemberDecorate %_UniformBuffer 0 RelaxedPrecision
OpMemberDecorate %_UniformBuffer 1 Offset 16
OpMemberDecorate %_UniformBuffer 1 RelaxedPrecision
OpDecorate %_UniformBuffer Block
OpDecorate %10 Binding 0
OpDecorate %10 DescriptorSet 0
OpDecorate %156 RelaxedPrecision
OpDecorate %159 RelaxedPrecision
OpDecorate %160 RelaxedPrecision
%float = OpTypeFloat 32
%v4float = OpTypeVector %float 4
%_ptr_Output_v4float = OpTypePointer Output %v4float
%sk_FragColor = OpVariable %_ptr_Output_v4float Output
%bool = OpTypeBool
%_ptr_Input_bool = OpTypePointer Input %bool
%sk_Clockwise = OpVariable %_ptr_Input_bool Input
%_UniformBuffer = OpTypeStruct %v4float %v4float
%_ptr_Uniform__UniformBuffer = OpTypePointer Uniform %_UniformBuffer
%10 = OpVariable %_ptr_Uniform__UniformBuffer Uniform
%void = OpTypeVoid
%15 = OpTypeFunction %void
%18 = OpTypeFunction %v4float
%_ptr_Function_float = OpTypePointer Function %float
%float_0 = OpConstant %float 0
%v2float = OpTypeVector %float 2
%mat2v2float = OpTypeMatrix %v2float 2
%_ptr_Function_mat2v2float = OpTypePointer Function %mat2v2float
%float_1 = OpConstant %float 1
%v3float = OpTypeVector %float 3
%mat3v3float = OpTypeMatrix %v3float 3
%int = OpTypeInt 32 1
%int_0 = OpConstant %int 0
%_ptr_Function_v2float = OpTypePointer Function %v2float
%mat4v4float = OpTypeMatrix %v4float 4
%_ptr_Function_mat3v3float = OpTypePointer Function %mat3v3float
%_ptr_Function_v3float = OpTypePointer Function %v3float
%_ptr_Function_mat4v4float = OpTypePointer Function %mat4v4float
%_ptr_Function_v4float = OpTypePointer Function %v4float
%float_6 = OpConstant %float 6
%_ptr_Uniform_v4float = OpTypePointer Uniform %v4float
%int_1 = OpConstant %int 1
%_entrypoint = OpFunction %void None %15
%16 = OpLabel
%17 = OpFunctionCall %v4float %main
OpStore %sk_FragColor %17
OpReturn
OpFunctionEnd
%main = OpFunction %v4float None %18
%19 = OpLabel
%result = OpVariable %_ptr_Function_float Function
%24 = OpVariable %_ptr_Function_mat2v2float Function
%48 = OpVariable %_ptr_Function_mat2v2float Function
%65 = OpVariable %_ptr_Function_mat3v3float Function
%85 = OpVariable %_ptr_Function_mat3v3float Function
%100 = OpVariable %_ptr_Function_mat4v4float Function
%125 = OpVariable %_ptr_Function_mat2v2float Function
%150 = OpVariable %_ptr_Function_v4float Function
OpStore %result %float_0
%23 = OpLoad %float %result
%31 = OpCompositeConstruct %v3float %float_1 %float_0 %float_0
%32 = OpCompositeConstruct %v3float %float_0 %float_1 %float_0
%33 = OpCompositeConstruct %v3float %float_0 %float_0 %float_1
%29 = OpCompositeConstruct %mat3v3float %31 %32 %33
%36 = OpCompositeExtract %v3float %29 0
%37 = OpVectorShuffle %v2float %36 %36 0 1
%38 = OpCompositeExtract %v3float %29 1
%39 = OpVectorShuffle %v2float %38 %38 0 1
%35 = OpCompositeConstruct %mat2v2float %37 %39
OpStore %24 %35
%42 = OpAccessChain %_ptr_Function_v2float %24 %int_0
%44 = OpLoad %v2float %42
%45 = OpCompositeExtract %float %44 0
%46 = OpFAdd %float %23 %45
OpStore %result %46
%47 = OpLoad %float %result
%50 = OpCompositeConstruct %v4float %float_1 %float_0 %float_0 %float_0
%51 = OpCompositeConstruct %v4float %float_0 %float_1 %float_0 %float_0
%52 = OpCompositeConstruct %v4float %float_0 %float_0 %float_1 %float_0
%53 = OpCompositeConstruct %v4float %float_0 %float_0 %float_0 %float_1
%49 = OpCompositeConstruct %mat4v4float %50 %51 %52 %53
%56 = OpCompositeExtract %v4float %49 0
%57 = OpVectorShuffle %v2float %56 %56 0 1
%58 = OpCompositeExtract %v4float %49 1
%59 = OpVectorShuffle %v2float %58 %58 0 1
%55 = OpCompositeConstruct %mat2v2float %57 %59
OpStore %48 %55
%60 = OpAccessChain %_ptr_Function_v2float %48 %int_0
%61 = OpLoad %v2float %60
%62 = OpCompositeExtract %float %61 0
%63 = OpFAdd %float %47 %62
OpStore %result %63
%64 = OpLoad %float %result
%68 = OpCompositeConstruct %v4float %float_1 %float_0 %float_0 %float_0
%69 = OpCompositeConstruct %v4float %float_0 %float_1 %float_0 %float_0
%70 = OpCompositeConstruct %v4float %float_0 %float_0 %float_1 %float_0
%71 = OpCompositeConstruct %v4float %float_0 %float_0 %float_0 %float_1
%67 = OpCompositeConstruct %mat4v4float %68 %69 %70 %71
%73 = OpCompositeExtract %v4float %67 0
%74 = OpVectorShuffle %v3float %73 %73 0 1 2
%75 = OpCompositeExtract %v4float %67 1
%76 = OpVectorShuffle %v3float %75 %75 0 1 2
%77 = OpCompositeExtract %v4float %67 2
%78 = OpVectorShuffle %v3float %77 %77 0 1 2
%72 = OpCompositeConstruct %mat3v3float %74 %76 %78
OpStore %65 %72
%79 = OpAccessChain %_ptr_Function_v3float %65 %int_0
%81 = OpLoad %v3float %79
%82 = OpCompositeExtract %float %81 0
%83 = OpFAdd %float %64 %82
OpStore %result %83
%84 = OpLoad %float %result
%87 = OpCompositeConstruct %v2float %float_1 %float_0
%88 = OpCompositeConstruct %v2float %float_0 %float_1
%86 = OpCompositeConstruct %mat2v2float %87 %88
%90 = OpCompositeExtract %v2float %86 0
%91 = OpCompositeConstruct %v3float %90 %float_0
%92 = OpCompositeExtract %v2float %86 1
%93 = OpCompositeConstruct %v3float %92 %float_0
%94 = OpCompositeConstruct %v3float %float_0 %float_0 %float_0
%89 = OpCompositeConstruct %mat3v3float %91 %93 %94
OpStore %85 %89
%95 = OpAccessChain %_ptr_Function_v3float %85 %int_0
%96 = OpLoad %v3float %95
%97 = OpCompositeExtract %float %96 0
%98 = OpFAdd %float %84 %97
OpStore %result %98
%99 = OpLoad %float %result
%103 = OpCompositeConstruct %v2float %float_1 %float_0
%104 = OpCompositeConstruct %v2float %float_0 %float_1
%102 = OpCompositeConstruct %mat2v2float %103 %104
%106 = OpCompositeExtract %v2float %102 0
%107 = OpCompositeConstruct %v3float %106 %float_0
%108 = OpCompositeExtract %v2float %102 1
%109 = OpCompositeConstruct %v3float %108 %float_0
%110 = OpCompositeConstruct %v3float %float_0 %float_0 %float_0
%105 = OpCompositeConstruct %mat3v3float %107 %109 %110
%112 = OpCompositeExtract %v3float %105 0
%113 = OpCompositeConstruct %v4float %112 %float_0
%114 = OpCompositeExtract %v3float %105 1
%115 = OpCompositeConstruct %v4float %114 %float_0
%116 = OpCompositeExtract %v3float %105 2
%117 = OpCompositeConstruct %v4float %116 %float_0
%118 = OpCompositeConstruct %v4float %float_0 %float_0 %float_0 %float_0
%111 = OpCompositeConstruct %mat4v4float %113 %115 %117 %118
OpStore %100 %111
%119 = OpAccessChain %_ptr_Function_v4float %100 %int_0
%121 = OpLoad %v4float %119
%122 = OpCompositeExtract %float %121 0
%123 = OpFAdd %float %99 %122
OpStore %result %123
%124 = OpLoad %float %result
%127 = OpCompositeConstruct %v4float %float_1 %float_0 %float_0 %float_0
%128 = OpCompositeConstruct %v4float %float_0 %float_1 %float_0 %float_0
%129 = OpCompositeConstruct %v4float %float_0 %float_0 %float_1 %float_0
%130 = OpCompositeConstruct %v4float %float_0 %float_0 %float_0 %float_1
%126 = OpCompositeConstruct %mat4v4float %127 %128 %129 %130
%132 = OpCompositeExtract %v4float %126 0
%133 = OpVectorShuffle %v3float %132 %132 0 1 2
%134 = OpCompositeExtract %v4float %126 1
%135 = OpVectorShuffle %v3float %134 %134 0 1 2
%136 = OpCompositeExtract %v4float %126 2
%137 = OpVectorShuffle %v3float %136 %136 0 1 2
%131 = OpCompositeConstruct %mat3v3float %133 %135 %137
%139 = OpCompositeExtract %v3float %131 0
%140 = OpVectorShuffle %v2float %139 %139 0 1
%141 = OpCompositeExtract %v3float %131 1
%142 = OpVectorShuffle %v2float %141 %141 0 1
%138 = OpCompositeConstruct %mat2v2float %140 %142
OpStore %125 %138
%143 = OpAccessChain %_ptr_Function_v2float %125 %int_0
%144 = OpLoad %v2float %143
%145 = OpCompositeExtract %float %144 0
%146 = OpFAdd %float %124 %145
OpStore %result %146
%147 = OpLoad %float %result
%149 = OpFOrdEqual %bool %147 %float_6
OpSelectionMerge %153 None
OpBranchConditional %149 %151 %152
%151 = OpLabel
%154 = OpAccessChain %_ptr_Uniform_v4float %10 %int_0
%156 = OpLoad %v4float %154
OpStore %150 %156
OpBranch %153
%152 = OpLabel
%157 = OpAccessChain %_ptr_Uniform_v4float %10 %int_1
%159 = OpLoad %v4float %157
OpStore %150 %159
OpBranch %153
%153 = OpLabel
%160 = OpLoad %v4float %150
OpReturnValue %160
OpFunctionEnd

23
tests/sksl/shared/ResizeMatrix.glsl
View File

@ -1,15 +1,14 @@
out vec4 sk_FragColor;
void main() {
sk_FragColor.x = mat2(mat3(1.0))[0].x;
sk_FragColor.x = mat2(mat4(1.0))[0].x;
sk_FragColor.x = mat3(mat4(1.0))[0].x;
sk_FragColor.x = mat3(mat2(1.0))[0].x;
sk_FragColor.x = mat3(mat2x3(1.0))[0].x;
sk_FragColor.x = mat3(mat3x2(1.0))[0].x;
sk_FragColor.x = mat4(mat3(mat2(1.0)))[0].x;
sk_FragColor.x = mat4(mat4x3(mat4x2(1.0)))[0].x;
sk_FragColor.x = mat4(mat3x4(mat2x4(1.0)))[0].x;
sk_FragColor.x = mat2x4(mat4x2(1.0))[0].x;
sk_FragColor.x = mat4x2(mat2x4(1.0))[0].x;
uniform vec4 colorGreen;
uniform vec4 colorRed;
vec4 main() {
float result = 0.0;
result += mat2(mat3(1.0))[0].x;
result += mat2(mat4(1.0))[0].x;
result += mat3(mat4(1.0))[0].x;
result += mat3(mat2(1.0))[0].x;
result += mat4(mat3(mat2(1.0)))[0].x;
result += mat2(mat3(mat4(1.0)))[0].x;
return result == 6.0 ? colorGreen : colorRed;
}

51
tests/sksl/shared/ResizeMatrix.metal
View File

@ -1,6 +1,10 @@
#include <metal_stdlib>
#include <simd/simd.h>
using namespace metal;
struct Uniforms {
float4 colorGreen;
float4 colorRed;
};
struct Inputs {
};
struct Outputs {
@ -18,46 +22,21 @@ float3x3 float3x3_from_float4x4(float4x4 x0) {
float3x3 float3x3_from_float2x2(float2x2 x0) {
return float3x3(float3(x0[0].xy, 0.0), float3(x0[1].xy, 0.0), float3(0.0, 0.0, 1.0));
}
float3x3 float3x3_from_float2x3(float2x3 x0) {
return float3x3(float3(x0[0].xyz), float3(x0[1].xyz), float3(0.0, 0.0, 1.0));
}
float3x3 float3x3_from_float3x2(float3x2 x0) {
return float3x3(float3(x0[0].xy, 0.0), float3(x0[1].xy, 0.0), float3(x0[2].xy, 1.0));
}
float4x4 float4x4_from_float3x3(float3x3 x0) {
return float4x4(float4(x0[0].xyz, 0.0), float4(x0[1].xyz, 0.0), float4(x0[2].xyz, 0.0), float4(0.0, 0.0, 0.0, 1.0));
}
float4x4 float4x4_from_float4x3(float4x3 x0) {
return float4x4(float4(x0[0].xyz, 0.0), float4(x0[1].xyz, 0.0), float4(x0[2].xyz, 0.0), float4(x0[3].xyz, 1.0));
}
float4x3 float4x3_from_float4x2(float4x2 x0) {
return float4x3(float3(x0[0].xy, 0.0), float3(x0[1].xy, 0.0), float3(x0[2].xy, 1.0), float3(x0[3].xy, 0.0));
}
float4x4 float4x4_from_float3x4(float3x4 x0) {
return float4x4(float4(x0[0].xyzw), float4(x0[1].xyzw), float4(x0[2].xyzw), float4(0.0, 0.0, 0.0, 1.0));
}
float3x4 float3x4_from_float2x4(float2x4 x0) {
return float3x4(float4(x0[0].xyzw), float4(x0[1].xyzw), float4(0.0, 0.0, 1.0, 0.0));
}
float2x4 float2x4_from_float4x2(float4x2 x0) {
return float2x4(float4(x0[0].xy, 0.0, 0.0), float4(x0[1].xy, 0.0, 0.0));
}
float4x2 float4x2_from_float2x4(float2x4 x0) {
return float4x2(float2(x0[0].xy), float2(x0[1].xy), float2(0.0, 0.0), float2(0.0, 0.0));
}
fragment Outputs fragmentMain(Inputs _in [[stage_in]], bool _frontFacing [[front_facing]], float4 _fragCoord [[position]]) {
fragment Outputs fragmentMain(Inputs _in [[stage_in]], constant Uniforms& _uniforms [[buffer(0)]], bool _frontFacing [[front_facing]], float4 _fragCoord [[position]]) {
Outputs _out;
(void)_out;
_out.sk_FragColor.x = float2x2_from_float3x3(float3x3(1.0))[0].x;
_out.sk_FragColor.x = float2x2_from_float4x4(float4x4(1.0))[0].x;
_out.sk_FragColor.x = float3x3_from_float4x4(float4x4(1.0))[0].x;
_out.sk_FragColor.x = float3x3_from_float2x2(float2x2(1.0))[0].x;
_out.sk_FragColor.x = float3x3_from_float2x3(float2x3(1.0))[0].x;
_out.sk_FragColor.x = float3x3_from_float3x2(float3x2(1.0))[0].x;
_out.sk_FragColor.x = float4x4_from_float3x3(float3x3_from_float2x2(float2x2(1.0)))[0].x;
_out.sk_FragColor.x = float4x4_from_float4x3(float4x3_from_float4x2(float4x2(1.0)))[0].x;
_out.sk_FragColor.x = float4x4_from_float3x4(float3x4_from_float2x4(float2x4(1.0)))[0].x;
_out.sk_FragColor.x = float2x4_from_float4x2(float4x2(1.0))[0].x;
_out.sk_FragColor.x = float4x2_from_float2x4(float2x4(1.0))[0].x;
float result = 0.0;
result += float2x2_from_float3x3(float3x3(1.0))[0].x;
result += float2x2_from_float4x4(float4x4(1.0))[0].x;
result += float3x3_from_float4x4(float4x4(1.0))[0].x;
result += float3x3_from_float2x2(float2x2(1.0))[0].x;
result += float4x4_from_float3x3(float3x3_from_float2x2(float2x2(1.0)))[0].x;
result += float2x2_from_float3x3(float3x3_from_float4x4(float4x4(1.0)))[0].x;
_out.sk_FragColor = result == 6.0 ? _uniforms.colorGreen : _uniforms.colorRed;
return _out;
}

6
tests/sksl/shared/ResizeMatrixNonsquare.asm.frag Normal file
View File

@ -0,0 +1,6 @@
### Compilation failed:
error: SPIR-V validation error: Invalid instruction word count: 0
SPIR-V validation error: Invalid instruction word count: 0
1 error

14
tests/sksl/shared/ResizeMatrixNonsquare.glsl Normal file
View File

@ -0,0 +1,14 @@
out vec4 sk_FragColor;
uniform vec4 colorGreen;
uniform vec4 colorRed;
vec4 main() {
float result = 0.0;
result += mat3(mat2x3(1.0))[0].x;
result += mat3(mat3x2(1.0))[0].x;
result += mat4(mat4x3(mat4x2(1.0)))[0].x;
result += mat4(mat3x4(mat2x4(1.0)))[0].x;
result += mat2x4(mat4x2(1.0))[0].x;
result += mat4x2(mat2x4(1.0))[0].x;
return result == 6.0 ? colorGreen : colorRed;
}

51
tests/sksl/shared/ResizeMatrixNonsquare.metal Normal file
View File

@ -0,0 +1,51 @@
#include <metal_stdlib>
#include <simd/simd.h>
using namespace metal;
struct Uniforms {
float4 colorGreen;
float4 colorRed;
};
struct Inputs {
};
struct Outputs {
float4 sk_FragColor [[color(0)]];
};
float3x3 float3x3_from_float2x3(float2x3 x0) {
return float3x3(float3(x0[0].xyz), float3(x0[1].xyz), float3(0.0, 0.0, 1.0));
}
float3x3 float3x3_from_float3x2(float3x2 x0) {
return float3x3(float3(x0[0].xy, 0.0), float3(x0[1].xy, 0.0), float3(x0[2].xy, 1.0));
}
float4x4 float4x4_from_float4x3(float4x3 x0) {
return float4x4(float4(x0[0].xyz, 0.0), float4(x0[1].xyz, 0.0), float4(x0[2].xyz, 0.0), float4(x0[3].xyz, 1.0));
}
float4x3 float4x3_from_float4x2(float4x2 x0) {
return float4x3(float3(x0[0].xy, 0.0), float3(x0[1].xy, 0.0), float3(x0[2].xy, 1.0), float3(x0[3].xy, 0.0));
}
float4x4 float4x4_from_float3x4(float3x4 x0) {
return float4x4(float4(x0[0].xyzw), float4(x0[1].xyzw), float4(x0[2].xyzw), float4(0.0, 0.0, 0.0, 1.0));
}
float3x4 float3x4_from_float2x4(float2x4 x0) {
return float3x4(float4(x0[0].xyzw), float4(x0[1].xyzw), float4(0.0, 0.0, 1.0, 0.0));
}
float2x4 float2x4_from_float4x2(float4x2 x0) {
return float2x4(float4(x0[0].xy, 0.0, 0.0), float4(x0[1].xy, 0.0, 0.0));
}
float4x2 float4x2_from_float2x4(float2x4 x0) {
return float4x2(float2(x0[0].xy), float2(x0[1].xy), float2(0.0, 0.0), float2(0.0, 0.0));
}
fragment Outputs fragmentMain(Inputs _in [[stage_in]], constant Uniforms& _uniforms [[buffer(0)]], bool _frontFacing [[front_facing]], float4 _fragCoord [[position]]) {
Outputs _out;
(void)_out;
float result = 0.0;
result += float3x3_from_float2x3(float2x3(1.0))[0].x;
result += float3x3_from_float3x2(float3x2(1.0))[0].x;
result += float4x4_from_float4x3(float4x3_from_float4x2(float4x2(1.0)))[0].x;
result += float4x4_from_float3x4(float3x4_from_float2x4(float2x4(1.0)))[0].x;
result += float2x4_from_float4x2(float4x2(1.0))[0].x;
result += float4x2_from_float2x4(float2x4(1.0))[0].x;
_out.sk_FragColor = result == 6.0 ? _uniforms.colorGreen : _uniforms.colorRed;
return _out;
}

195
tests/sksl/shared/ScalarConversionConstructors.asm.frag
View File

@ -1,195 +0,0 @@
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %main "main" %sk_FragColor %sk_Clockwise
OpExecutionMode %main OriginUpperLeft
OpName %sk_FragColor "sk_FragColor"
OpName %sk_Clockwise "sk_Clockwise"
OpName %f "f"
OpName %i "i"
OpName %u "u"
OpName %b "b"
OpName %main "main"
OpName %f1 "f1"
OpName %f2 "f2"
OpName %f3 "f3"
OpName %f4 "f4"
OpName %i1 "i1"
OpName %i2 "i2"
OpName %i3 "i3"
OpName %i4 "i4"
OpName %u1 "u1"
OpName %u2 "u2"
OpName %u3 "u3"
OpName %u4 "u4"
OpName %b1 "b1"
OpName %b2 "b2"
OpName %b3 "b3"
OpName %b4 "b4"
OpDecorate %sk_FragColor RelaxedPrecision
OpDecorate %sk_FragColor Location 0
OpDecorate %sk_FragColor Index 0
OpDecorate %sk_Clockwise RelaxedPrecision
OpDecorate %sk_Clockwise BuiltIn FrontFacing
OpDecorate %b RelaxedPrecision
OpDecorate %37 RelaxedPrecision
OpDecorate %50 RelaxedPrecision
OpDecorate %63 RelaxedPrecision
OpDecorate %77 RelaxedPrecision
OpDecorate %105 RelaxedPrecision
OpDecorate %108 RelaxedPrecision
OpDecorate %112 RelaxedPrecision
OpDecorate %116 RelaxedPrecision
%float = OpTypeFloat 32
%v4float = OpTypeVector %float 4
%_ptr_Output_v4float = OpTypePointer Output %v4float
%sk_FragColor = OpVariable %_ptr_Output_v4float Output
%bool = OpTypeBool
%_ptr_Input_bool = OpTypePointer Input %bool
%sk_Clockwise = OpVariable %_ptr_Input_bool Input
%_ptr_Private_float = OpTypePointer Private %float
%f = OpVariable %_ptr_Private_float Private
%float_1 = OpConstant %float 1
%int = OpTypeInt 32 1
%_ptr_Private_int = OpTypePointer Private %int
%i = OpVariable %_ptr_Private_int Private
%int_1 = OpConstant %int 1
%uint = OpTypeInt 32 0
%_ptr_Private_uint = OpTypePointer Private %uint
%u = OpVariable %_ptr_Private_uint Private
%uint_1 = OpConstant %uint 1
%_ptr_Private_bool = OpTypePointer Private %bool
%b = OpVariable %_ptr_Private_bool Private
%true = OpConstantTrue %bool
%void = OpTypeVoid
%25 = OpTypeFunction %void
%_ptr_Function_float = OpTypePointer Function %float
%float_0 = OpConstant %float 0
%_ptr_Function_int = OpTypePointer Function %int
%int_0 = OpConstant %int 0
%_ptr_Function_uint = OpTypePointer Function %uint
%uint_0 = OpConstant %uint 0
%_ptr_Function_bool = OpTypePointer Function %bool
%_ptr_Output_float = OpTypePointer Output %float
%main = OpFunction %void None %25
%26 = OpLabel
%f1 = OpVariable %_ptr_Function_float Function
%f2 = OpVariable %_ptr_Function_float Function
%f3 = OpVariable %_ptr_Function_float Function
%f4 = OpVariable %_ptr_Function_float Function
%i1 = OpVariable %_ptr_Function_int Function
%i2 = OpVariable %_ptr_Function_int Function
%i3 = OpVariable %_ptr_Function_int Function
%i4 = OpVariable %_ptr_Function_int Function
%u1 = OpVariable %_ptr_Function_uint Function
%u2 = OpVariable %_ptr_Function_uint Function
%u3 = OpVariable %_ptr_Function_uint Function
%u4 = OpVariable %_ptr_Function_uint Function
%b1 = OpVariable %_ptr_Function_bool Function
%b2 = OpVariable %_ptr_Function_bool Function
%b3 = OpVariable %_ptr_Function_bool Function
%b4 = OpVariable %_ptr_Function_bool Function
OpStore %f %float_1
OpStore %i %int_1
OpStore %u %uint_1
OpStore %b %true
%29 = OpLoad %float %f
OpStore %f1 %29
%31 = OpLoad %int %i
%32 = OpConvertSToF %float %31
OpStore %f2 %32
%34 = OpLoad %uint %u
%35 = OpConvertUToF %float %34
OpStore %f3 %35
%37 = OpLoad %bool %b
%38 = OpSelect %float %37 %float_1 %float_0
OpStore %f4 %38
%42 = OpLoad %float %f
%43 = OpConvertFToS %int %42
OpStore %i1 %43
%45 = OpLoad %int %i
OpStore %i2 %45
%47 = OpLoad %uint %u
%48 = OpBitcast %int %47
OpStore %i3 %48
%50 = OpLoad %bool %b
%51 = OpSelect %int %50 %int_1 %int_0
OpStore %i4 %51
%55 = OpLoad %float %f
%56 = OpConvertFToU %uint %55
OpStore %u1 %56
%58 = OpLoad %int %i
%59 = OpBitcast %uint %58
OpStore %u2 %59
%61 = OpLoad %uint %u
OpStore %u3 %61
%63 = OpLoad %bool %b
%64 = OpSelect %uint %63 %uint_1 %uint_0
OpStore %u4 %64
%68 = OpLoad %float %f
%69 = OpFUnordNotEqual %bool %68 %float_0
OpStore %b1 %69
%71 = OpLoad %int %i
%72 = OpINotEqual %bool %71 %int_0
OpStore %b2 %72
%74 = OpLoad %uint %u
%75 = OpINotEqual %bool %74 %uint_0
OpStore %b3 %75
%77 = OpLoad %bool %b
OpStore %b4 %77
%78 = OpLoad %float %f1
%79 = OpLoad %float %f2
%80 = OpFAdd %float %78 %79
%81 = OpLoad %float %f3
%82 = OpFAdd %float %80 %81
%83 = OpLoad %float %f4
%84 = OpFAdd %float %82 %83
%85 = OpAccessChain %_ptr_Output_float %sk_FragColor %int_0
OpStore %85 %84
%87 = OpLoad %int %i1
%88 = OpLoad %int %i2
%89 = OpIAdd %int %87 %88
%90 = OpLoad %int %i3
%91 = OpIAdd %int %89 %90
%92 = OpLoad %int %i4
%93 = OpIAdd %int %91 %92
%94 = OpConvertSToF %float %93
%95 = OpAccessChain %_ptr_Output_float %sk_FragColor %int_0
OpStore %95 %94
%96 = OpLoad %uint %u1
%97 = OpLoad %uint %u2
%98 = OpIAdd %uint %96 %97
%99 = OpLoad %uint %u3
%100 = OpIAdd %uint %98 %99
%101 = OpLoad %uint %u4
%102 = OpIAdd %uint %100 %101
%103 = OpConvertUToF %float %102
%104 = OpAccessChain %_ptr_Output_float %sk_FragColor %int_0
OpStore %104 %103
%105 = OpLoad %bool %b1
OpSelectionMerge %107 None
OpBranchConditional %105 %107 %106
%106 = OpLabel
%108 = OpLoad %bool %b2
OpBranch %107
%107 = OpLabel
%109 = OpPhi %bool %true %26 %108 %106
OpSelectionMerge %111 None
OpBranchConditional %109 %111 %110
%110 = OpLabel
%112 = OpLoad %bool %b3
OpBranch %111
%111 = OpLabel
%113 = OpPhi %bool %true %107 %112 %110
OpSelectionMerge %115 None
OpBranchConditional %113 %115 %114
%114 = OpLabel
%116 = OpLoad %bool %b4
OpBranch %115
%115 = OpLabel
%117 = OpPhi %bool %true %111 %116 %114
%118 = OpSelect %float %117 %float_1 %float_0
%119 = OpAccessChain %_ptr_Output_float %sk_FragColor %int_0
OpStore %119 %118
OpReturn
OpFunctionEnd

28
tests/sksl/shared/ScalarConversionConstructors.glsl
View File

@ -1,28 +0,0 @@
out vec4 sk_FragColor;
float f = 1.0;
int i = 1;
uint u = 1u;
bool b = true;
void main() {
float f1 = f;
float f2 = float(i);
float f3 = float(u);
float f4 = float(b);
int i1 = int(f);
int i2 = i;
int i3 = int(u);
int i4 = int(b);
uint u1 = uint(f);
uint u2 = uint(i);
uint u3 = u;
uint u4 = uint(b);
bool b1 = bool(f);
bool b2 = bool(i);
bool b3 = bool(u);
bool b4 = b;
sk_FragColor.x = ((f1 + f2) + f3) + f4;
sk_FragColor.x = float(((i1 + i2) + i3) + i4);
sk_FragColor.x = float(((u1 + u2) + u3) + u4);
sk_FragColor.x = float(((b1 || b2) || b3) || b4);
}

45
tests/sksl/shared/ScalarConversionConstructors.metal
View File

@ -1,45 +0,0 @@
#include <metal_stdlib>
#include <simd/simd.h>
using namespace metal;
struct Inputs {
};
struct Outputs {
float4 sk_FragColor [[color(0)]];
};
struct Globals {
float f;
int i;
uint u;
bool b;
};
fragment Outputs fragmentMain(Inputs _in [[stage_in]], bool _frontFacing [[front_facing]], float4 _fragCoord [[position]]) {
Globals _globals{1.0, 1, 1u, true};
(void)_globals;
Outputs _out;
(void)_out;
float f1 = _globals.f;
float f2 = float(_globals.i);
float f3 = float(_globals.u);
float f4 = float(_globals.b);
int i1 = int(_globals.f);
int i2 = _globals.i;
int i3 = int(_globals.u);
int i4 = int(_globals.b);
uint u1 = uint(_globals.f);
uint u2 = uint(_globals.i);
uint u3 = _globals.u;
uint u4 = uint(_globals.b);
bool b1 = bool(_globals.f);
bool b2 = bool(_globals.i);
bool b3 = bool(_globals.u);
bool b4 = _globals.b;
_out.sk_FragColor.x = ((f1 + f2) + f3) + f4;
_out.sk_FragColor.x = float(((i1 + i2) + i3) + i4);
_out.sk_FragColor.x = float(((u1 + u2) + u3) + u4);
_out.sk_FragColor.x = float(((b1 || b2) || b3) || b4);
return _out;
}

179
tests/sksl/shared/ScalarConversionConstructorsES2.asm.frag Normal file
View File

@ -0,0 +1,179 @@
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %_entrypoint "_entrypoint" %sk_FragColor %sk_Clockwise
OpExecutionMode %_entrypoint OriginUpperLeft
OpName %sk_FragColor "sk_FragColor"
OpName %sk_Clockwise "sk_Clockwise"
OpName %_UniformBuffer "_UniformBuffer"
OpMemberName %_UniformBuffer 0 "colorGreen"
OpMemberName %_UniformBuffer 1 "colorRed"
OpName %_entrypoint "_entrypoint"
OpName %main "main"
OpName %f "f"
OpName %i "i"
OpName %b "b"
OpName %f1 "f1"
OpName %f2 "f2"
OpName %f3 "f3"
OpName %i1 "i1"
OpName %i2 "i2"
OpName %i3 "i3"
OpName %b1 "b1"
OpName %b2 "b2"
OpName %b3 "b3"
OpDecorate %sk_FragColor RelaxedPrecision
OpDecorate %sk_FragColor Location 0
OpDecorate %sk_FragColor Index 0
OpDecorate %sk_Clockwise RelaxedPrecision
OpDecorate %sk_Clockwise BuiltIn FrontFacing
OpMemberDecorate %_UniformBuffer 0 Offset 0
OpMemberDecorate %_UniformBuffer 0 RelaxedPrecision
OpMemberDecorate %_UniformBuffer 1 Offset 16
OpMemberDecorate %_UniformBuffer 1 RelaxedPrecision
OpDecorate %_UniformBuffer Block
OpDecorate %10 Binding 0
OpDecorate %10 DescriptorSet 0
OpDecorate %26 RelaxedPrecision
OpDecorate %31 RelaxedPrecision
OpDecorate %37 RelaxedPrecision
OpDecorate %47 RelaxedPrecision
OpDecorate %56 RelaxedPrecision
OpDecorate %66 RelaxedPrecision
OpDecorate %69 RelaxedPrecision
OpDecorate %71 RelaxedPrecision
OpDecorate %74 RelaxedPrecision
OpDecorate %77 RelaxedPrecision
OpDecorate %80 RelaxedPrecision
OpDecorate %81 RelaxedPrecision
OpDecorate %83 RelaxedPrecision
OpDecorate %84 RelaxedPrecision
OpDecorate %86 RelaxedPrecision
OpDecorate %87 RelaxedPrecision
OpDecorate %89 RelaxedPrecision
OpDecorate %98 RelaxedPrecision
OpDecorate %100 RelaxedPrecision
OpDecorate %101 RelaxedPrecision
%float = OpTypeFloat 32
%v4float = OpTypeVector %float 4
%_ptr_Output_v4float = OpTypePointer Output %v4float
%sk_FragColor = OpVariable %_ptr_Output_v4float Output
%bool = OpTypeBool
%_ptr_Input_bool = OpTypePointer Input %bool
%sk_Clockwise = OpVariable %_ptr_Input_bool Input
%_UniformBuffer = OpTypeStruct %v4float %v4float
%_ptr_Uniform__UniformBuffer = OpTypePointer Uniform %_UniformBuffer
%10 = OpVariable %_ptr_Uniform__UniformBuffer Uniform
%void = OpTypeVoid
%15 = OpTypeFunction %void
%18 = OpTypeFunction %v4float
%_ptr_Function_float = OpTypePointer Function %float
%_ptr_Uniform_v4float = OpTypePointer Uniform %v4float
%int = OpTypeInt 32 1
%int_0 = OpConstant %int 0
%_ptr_Function_int = OpTypePointer Function %int
%_ptr_Function_bool = OpTypePointer Function %bool
%float_0 = OpConstant %float 0
%float_1 = OpConstant %float 1
%int_1 = OpConstant %int 1
%float_9 = OpConstant %float 9
%_ptr_Function_v4float = OpTypePointer Function %v4float
%_entrypoint = OpFunction %void None %15
%16 = OpLabel
%17 = OpFunctionCall %v4float %main
OpStore %sk_FragColor %17
OpReturn
OpFunctionEnd
%main = OpFunction %v4float None %18
%19 = OpLabel
%f = OpVariable %_ptr_Function_float Function
%i = OpVariable %_ptr_Function_int Function
%b = OpVariable %_ptr_Function_bool Function
%f1 = OpVariable %_ptr_Function_float Function
%f2 = OpVariable %_ptr_Function_float Function
%f3 = OpVariable %_ptr_Function_float Function
%i1 = OpVariable %_ptr_Function_int Function
%i2 = OpVariable %_ptr_Function_int Function
%i3 = OpVariable %_ptr_Function_int Function
%b1 = OpVariable %_ptr_Function_bool Function
%b2 = OpVariable %_ptr_Function_bool Function
%b3 = OpVariable %_ptr_Function_bool Function
%92 = OpVariable %_ptr_Function_v4float Function
%22 = OpAccessChain %_ptr_Uniform_v4float %10 %int_0
%26 = OpLoad %v4float %22
%27 = OpCompositeExtract %float %26 1
OpStore %f %27
%30 = OpAccessChain %_ptr_Uniform_v4float %10 %int_0
%31 = OpLoad %v4float %30
%32 = OpCompositeExtract %float %31 1
%33 = OpConvertFToS %int %32
OpStore %i %33
%36 = OpAccessChain %_ptr_Uniform_v4float %10 %int_0
%37 = OpLoad %v4float %36
%38 = OpCompositeExtract %float %37 1
%39 = OpFUnordNotEqual %bool %38 %float_0
OpStore %b %39
%42 = OpLoad %float %f
OpStore %f1 %42
%44 = OpLoad %int %i
%45 = OpConvertSToF %float %44
OpStore %f2 %45
%47 = OpLoad %bool %b
%48 = OpSelect %float %47 %float_1 %float_0
OpStore %f3 %48
%51 = OpLoad %float %f
%52 = OpConvertFToS %int %51
OpStore %i1 %52
%54 = OpLoad %int %i
OpStore %i2 %54
%56 = OpLoad %bool %b
%57 = OpSelect %int %56 %int_1 %int_0
OpStore %i3 %57
%60 = OpLoad %float %f
%61 = OpFUnordNotEqual %bool %60 %float_0
OpStore %b1 %61
%63 = OpLoad %int %i
%64 = OpINotEqual %bool %63 %int_0
OpStore %b2 %64
%66 = OpLoad %bool %b
OpStore %b3 %66
%67 = OpLoad %float %f1
%68 = OpLoad %float %f2
%69 = OpFAdd %float %67 %68
%70 = OpLoad %float %f3
%71 = OpFAdd %float %69 %70
%72 = OpLoad %int %i1
%73 = OpConvertSToF %float %72
%74 = OpFAdd %float %71 %73
%75 = OpLoad %int %i2
%76 = OpConvertSToF %float %75
%77 = OpFAdd %float %74 %76
%78 = OpLoad %int %i3
%79 = OpConvertSToF %float %78
%80 = OpFAdd %float %77 %79
%81 = OpLoad %bool %b1
%82 = OpSelect %float %81 %float_1 %float_0
%83 = OpFAdd %float %80 %82
%84 = OpLoad %bool %b2
%85 = OpSelect %float %84 %float_1 %float_0
%86 = OpFAdd %float %83 %85
%87 = OpLoad %bool %b3
%88 = OpSelect %float %87 %float_1 %float_0
%89 = OpFAdd %float %86 %88
%91 = OpFOrdEqual %bool %89 %float_9
OpSelectionMerge %96 None
OpBranchConditional %91 %94 %95
%94 = OpLabel
%97 = OpAccessChain %_ptr_Uniform_v4float %10 %int_0
%98 = OpLoad %v4float %97
OpStore %92 %98
OpBranch %96
%95 = OpLabel
%99 = OpAccessChain %_ptr_Uniform_v4float %10 %int_1
%100 = OpLoad %v4float %99
OpStore %92 %100
OpBranch %96
%96 = OpLabel
%101 = OpLoad %v4float %92
OpReturnValue %101
OpFunctionEnd

19
tests/sksl/shared/ScalarConversionConstructorsES2.glsl Normal file
View File

@ -0,0 +1,19 @@
out vec4 sk_FragColor;
uniform vec4 colorGreen;
uniform vec4 colorRed;
vec4 main() {
float f = colorGreen.y;
int i = int(colorGreen.y);
bool b = bool(colorGreen.y);
float f1 = f;
float f2 = float(i);
float f3 = float(b);
int i1 = int(f);
int i2 = i;
int i3 = int(b);
bool b1 = bool(f);
bool b2 = bool(i);
bool b3 = b;
return (((((((f1 + f2) + f3) + float(i1)) + float(i2)) + float(i3)) + float(b1)) + float(b2)) + float(b3) == 9.0 ? colorGreen : colorRed;
}

32
tests/sksl/shared/ScalarConversionConstructorsES2.metal Normal file
View File

@ -0,0 +1,32 @@
#include <metal_stdlib>
#include <simd/simd.h>
using namespace metal;
struct Uniforms {
float4 colorGreen;
float4 colorRed;
};
struct Inputs {
};
struct Outputs {
float4 sk_FragColor [[color(0)]];
};
fragment Outputs fragmentMain(Inputs _in [[stage_in]], constant Uniforms& _uniforms [[buffer(0)]], bool _frontFacing [[front_facing]], float4 _fragCoord [[position]]) {
Outputs _out;
(void)_out;
float f = _uniforms.colorGreen.y;
int i = int(_uniforms.colorGreen.y);
bool b = bool(_uniforms.colorGreen.y);
float f1 = f;
float f2 = float(i);
float f3 = float(b);
int i1 = int(f);
int i2 = i;
int i3 = int(b);
bool b1 = bool(f);
bool b2 = bool(i);
bool b3 = b;
_out.sk_FragColor = (((((((f1 + f2) + f3) + float(i1)) + float(i2)) + float(i3)) + float(b1)) + float(b2)) + float(b3) == 9.0 ? _uniforms.colorGreen : _uniforms.colorRed;
return _out;
}

254
tests/sksl/shared/ScalarConversionConstructorsES3.asm.frag Normal file
View File

@ -0,0 +1,254 @@
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %_entrypoint "_entrypoint" %sk_FragColor %sk_Clockwise
OpExecutionMode %_entrypoint OriginUpperLeft
OpName %sk_FragColor "sk_FragColor"
OpName %sk_Clockwise "sk_Clockwise"
OpName %_UniformBuffer "_UniformBuffer"
OpMemberName %_UniformBuffer 0 "colorGreen"
OpMemberName %_UniformBuffer 1 "colorRed"
OpName %_entrypoint "_entrypoint"
OpName %main "main"
OpName %f "f"
OpName %i "i"
OpName %u "u"
OpName %b "b"
OpName %f1 "f1"
OpName %f2 "f2"
OpName %f3 "f3"
OpName %f4 "f4"
OpName %i1 "i1"
OpName %i2 "i2"
OpName %i3 "i3"
OpName %i4 "i4"
OpName %u1 "u1"
OpName %u2 "u2"
OpName %u3 "u3"
OpName %u4 "u4"
OpName %b1 "b1"
OpName %b2 "b2"
OpName %b3 "b3"
OpName %b4 "b4"
OpDecorate %sk_FragColor RelaxedPrecision
OpDecorate %sk_FragColor Location 0
OpDecorate %sk_FragColor Index 0
OpDecorate %sk_Clockwise RelaxedPrecision
OpDecorate %sk_Clockwise BuiltIn FrontFacing
OpMemberDecorate %_UniformBuffer 0 Offset 0
OpMemberDecorate %_UniformBuffer 0 RelaxedPrecision
OpMemberDecorate %_UniformBuffer 1 Offset 16
OpMemberDecorate %_UniformBuffer 1 RelaxedPrecision
OpDecorate %_UniformBuffer Block
OpDecorate %10 Binding 0
OpDecorate %10 DescriptorSet 0
OpDecorate %26 RelaxedPrecision
OpDecorate %31 RelaxedPrecision
OpDecorate %38 RelaxedPrecision
OpDecorate %44 RelaxedPrecision
OpDecorate %57 RelaxedPrecision
OpDecorate %69 RelaxedPrecision
OpDecorate %81 RelaxedPrecision
OpDecorate %95 RelaxedPrecision
OpDecorate %98 RelaxedPrecision
OpDecorate %100 RelaxedPrecision
OpDecorate %102 RelaxedPrecision
OpDecorate %105 RelaxedPrecision
OpDecorate %108 RelaxedPrecision
OpDecorate %111 RelaxedPrecision
OpDecorate %114 RelaxedPrecision
OpDecorate %117 RelaxedPrecision
OpDecorate %120 RelaxedPrecision
OpDecorate %123 RelaxedPrecision
OpDecorate %126 RelaxedPrecision
OpDecorate %127 RelaxedPrecision
OpDecorate %129 RelaxedPrecision
OpDecorate %130 RelaxedPrecision
OpDecorate %132 RelaxedPrecision
OpDecorate %133 RelaxedPrecision
OpDecorate %135 RelaxedPrecision
OpDecorate %136 RelaxedPrecision
OpDecorate %138 RelaxedPrecision
OpDecorate %147 RelaxedPrecision
OpDecorate %149 RelaxedPrecision
OpDecorate %150 RelaxedPrecision
%float = OpTypeFloat 32
%v4float = OpTypeVector %float 4
%_ptr_Output_v4float = OpTypePointer Output %v4float
%sk_FragColor = OpVariable %_ptr_Output_v4float Output
%bool = OpTypeBool
%_ptr_Input_bool = OpTypePointer Input %bool
%sk_Clockwise = OpVariable %_ptr_Input_bool Input
%_UniformBuffer = OpTypeStruct %v4float %v4float
%_ptr_Uniform__UniformBuffer = OpTypePointer Uniform %_UniformBuffer
%10 = OpVariable %_ptr_Uniform__UniformBuffer Uniform
%void = OpTypeVoid
%15 = OpTypeFunction %void
%18 = OpTypeFunction %v4float
%_ptr_Function_float = OpTypePointer Function %float
%_ptr_Uniform_v4float = OpTypePointer Uniform %v4float
%int = OpTypeInt 32 1
%int_0 = OpConstant %int 0
%_ptr_Function_int = OpTypePointer Function %int
%uint = OpTypeInt 32 0
%_ptr_Function_uint = OpTypePointer Function %uint
%_ptr_Function_bool = OpTypePointer Function %bool
%float_0 = OpConstant %float 0
%float_1 = OpConstant %float 1
%int_1 = OpConstant %int 1
%uint_1 = OpConstant %uint 1
%uint_0 = OpConstant %uint 0
%float_16 = OpConstant %float 16
%_ptr_Function_v4float = OpTypePointer Function %v4float
%_entrypoint = OpFunction %void None %15
%16 = OpLabel
%17 = OpFunctionCall %v4float %main
OpStore %sk_FragColor %17
OpReturn
OpFunctionEnd
%main = OpFunction %v4float None %18
%19 = OpLabel
%f = OpVariable %_ptr_Function_float Function
%i = OpVariable %_ptr_Function_int Function
%u = OpVariable %_ptr_Function_uint Function
%b = OpVariable %_ptr_Function_bool Function
%f1 = OpVariable %_ptr_Function_float Function
%f2 = OpVariable %_ptr_Function_float Function
%f3 = OpVariable %_ptr_Function_float Function
%f4 = OpVariable %_ptr_Function_float Function
%i1 = OpVariable %_ptr_Function_int Function
%i2 = OpVariable %_ptr_Function_int Function
%i3 = OpVariable %_ptr_Function_int Function
%i4 = OpVariable %_ptr_Function_int Function
%u1 = OpVariable %_ptr_Function_uint Function
%u2 = OpVariable %_ptr_Function_uint Function
%u3 = OpVariable %_ptr_Function_uint Function
%u4 = OpVariable %_ptr_Function_uint Function
%b1 = OpVariable %_ptr_Function_bool Function
%b2 = OpVariable %_ptr_Function_bool Function
%b3 = OpVariable %_ptr_Function_bool Function
%b4 = OpVariable %_ptr_Function_bool Function
%141 = OpVariable %_ptr_Function_v4float Function
%22 = OpAccessChain %_ptr_Uniform_v4float %10 %int_0
%26 = OpLoad %v4float %22
%27 = OpCompositeExtract %float %26 1
OpStore %f %27
%30 = OpAccessChain %_ptr_Uniform_v4float %10 %int_0
%31 = OpLoad %v4float %30
%32 = OpCompositeExtract %float %31 1
%33 = OpConvertFToS %int %32
OpStore %i %33
%37 = OpAccessChain %_ptr_Uniform_v4float %10 %int_0
%38 = OpLoad %v4float %37
%39 = OpCompositeExtract %float %38 1
%40 = OpConvertFToU %uint %39
OpStore %u %40
%43 = OpAccessChain %_ptr_Uniform_v4float %10 %int_0
%44 = OpLoad %v4float %43
%45 = OpCompositeExtract %float %44 1
%46 = OpFUnordNotEqual %bool %45 %float_0
OpStore %b %46
%49 = OpLoad %float %f
OpStore %f1 %49
%51 = OpLoad %int %i
%52 = OpConvertSToF %float %51
OpStore %f2 %52
%54 = OpLoad %uint %u
%55 = OpConvertUToF %float %54
OpStore %f3 %55
%57 = OpLoad %bool %b
%58 = OpSelect %float %57 %float_1 %float_0
OpStore %f4 %58
%61 = OpLoad %float %f
%62 = OpConvertFToS %int %61
OpStore %i1 %62
%64 = OpLoad %int %i
OpStore %i2 %64
%66 = OpLoad %uint %u
%67 = OpBitcast %int %66
OpStore %i3 %67
%69 = OpLoad %bool %b
%70 = OpSelect %int %69 %int_1 %int_0
OpStore %i4 %70
%73 = OpLoad %float %f
%74 = OpConvertFToU %uint %73
OpStore %u1 %74
%76 = OpLoad %int %i
%77 = OpBitcast %uint %76
OpStore %u2 %77
%79 = OpLoad %uint %u
OpStore %u3 %79
%81 = OpLoad %bool %b
%82 = OpSelect %uint %81 %uint_1 %uint_0
OpStore %u4 %82
%86 = OpLoad %float %f
%87 = OpFUnordNotEqual %bool %86 %float_0
OpStore %b1 %87
%89 = OpLoad %int %i
%90 = OpINotEqual %bool %89 %int_0
OpStore %b2 %90
%92 = OpLoad %uint %u
%93 = OpINotEqual %bool %92 %uint_0
OpStore %b3 %93
%95 = OpLoad %bool %b
OpStore %b4 %95
%96 = OpLoad %float %f1
%97 = OpLoad %float %f2
%98 = OpFAdd %float %96 %97
%99 = OpLoad %float %f3
%100 = OpFAdd %float %98 %99
%101 = OpLoad %float %f4
%102 = OpFAdd %float %100 %101
%103 = OpLoad %int %i1
%104 = OpConvertSToF %float %103
%105 = OpFAdd %float %102 %104
%106 = OpLoad %int %i2
%107 = OpConvertSToF %float %106
%108 = OpFAdd %float %105 %107
%109 = OpLoad %int %i3
%110 = OpConvertSToF %float %109
%111 = OpFAdd %float %108 %110
%112 = OpLoad %int %i4
%113 = OpConvertSToF %float %112
%114 = OpFAdd %float %111 %113
%115 = OpLoad %uint %u1
%116 = OpConvertUToF %float %115
%117 = OpFAdd %float %114 %116
%118 = OpLoad %uint %u2
%119 = OpConvertUToF %float %118
%120 = OpFAdd %float %117 %119
%121 = OpLoad %uint %u3
%122 = OpConvertUToF %float %121
%123 = OpFAdd %float %120 %122
%124 = OpLoad %uint %u4
%125 = OpConvertUToF %float %124
%126 = OpFAdd %float %123 %125
%127 = OpLoad %bool %b1
%128 = OpSelect %float %127 %float_1 %float_0
%129 = OpFAdd %float %126 %128
%130 = OpLoad %bool %b2
%131 = OpSelect %float %130 %float_1 %float_0
%132 = OpFAdd %float %129 %131
%133 = OpLoad %bool %b3
%134 = OpSelect %float %133 %float_1 %float_0
%135 = OpFAdd %float %132 %134
%136 = OpLoad %bool %b4
%137 = OpSelect %float %136 %float_1 %float_0
%138 = OpFAdd %float %135 %137
%140 = OpFOrdEqual %bool %138 %float_16
OpSelectionMerge %145 None
OpBranchConditional %140 %143 %144
%143 = OpLabel
%146 = OpAccessChain %_ptr_Uniform_v4float %10 %int_0
%147 = OpLoad %v4float %146
OpStore %141 %147
OpBranch %145
%144 = OpLabel
%148 = OpAccessChain %_ptr_Uniform_v4float %10 %int_1
%149 = OpLoad %v4float %148
OpStore %141 %149
OpBranch %145
%145 = OpLabel
%150 = OpLoad %v4float %141
OpReturnValue %150
OpFunctionEnd

27
tests/sksl/shared/ScalarConversionConstructorsES3.glsl Normal file
View File

@ -0,0 +1,27 @@
out vec4 sk_FragColor;
uniform vec4 colorGreen;
uniform vec4 colorRed;
vec4 main() {
float f = colorGreen.y;
int i = int(colorGreen.y);
uint u = uint(colorGreen.y);
bool b = bool(colorGreen.y);
float f1 = f;
float f2 = float(i);
float f3 = float(u);
float f4 = float(b);
int i1 = int(f);
int i2 = i;
int i3 = int(u);
int i4 = int(b);
uint u1 = uint(f);
uint u2 = uint(i);
uint u3 = u;
uint u4 = uint(b);
bool b1 = bool(f);
bool b2 = bool(i);
bool b3 = bool(u);
bool b4 = b;
return ((((((((((((((f1 + f2) + f3) + f4) + float(i1)) + float(i2)) + float(i3)) + float(i4)) + float(u1)) + float(u2)) + float(u3)) + float(u4)) + float(b1)) + float(b2)) + float(b3)) + float(b4) == 16.0 ? colorGreen : colorRed;
}

40
tests/sksl/shared/ScalarConversionConstructorsES3.metal Normal file
View File

@ -0,0 +1,40 @@
#include <metal_stdlib>
#include <simd/simd.h>
using namespace metal;
struct Uniforms {
float4 colorGreen;
float4 colorRed;
};
struct Inputs {
};
struct Outputs {
float4 sk_FragColor [[color(0)]];
};
fragment Outputs fragmentMain(Inputs _in [[stage_in]], constant Uniforms& _uniforms [[buffer(0)]], bool _frontFacing [[front_facing]], float4 _fragCoord [[position]]) {
Outputs _out;
(void)_out;
float f = _uniforms.colorGreen.y;
int i = int(_uniforms.colorGreen.y);
uint u = uint(_uniforms.colorGreen.y);
bool b = bool(_uniforms.colorGreen.y);
float f1 = f;
float f2 = float(i);
float f3 = float(u);
float f4 = float(b);
int i1 = int(f);
int i2 = i;
int i3 = int(u);
int i4 = int(b);
uint u1 = uint(f);
uint u2 = uint(i);
uint u3 = u;
uint u4 = uint(b);
bool b1 = bool(f);
bool b2 = bool(i);
bool b3 = bool(u);
bool b4 = b;
_out.sk_FragColor = ((((((((((((((f1 + f2) + f3) + f4) + float(i1)) + float(i2)) + float(i3)) + float(i4)) + float(u1)) + float(u2)) + float(u3)) + float(u4)) + float(b1)) + float(b2)) + float(b3)) + float(b4) == 16.0 ? _uniforms.colorGreen : _uniforms.colorRed;
return _out;
}

40
tests/sksl/shared/StackingVectorCasts.asm.frag
View File

@ -1,16 +1,28 @@
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %main "main" %sk_FragColor %sk_Clockwise
OpExecutionMode %main OriginUpperLeft
OpEntryPoint Fragment %_entrypoint "_entrypoint" %sk_FragColor %sk_Clockwise
OpExecutionMode %_entrypoint OriginUpperLeft
OpName %sk_FragColor "sk_FragColor"
OpName %sk_Clockwise "sk_Clockwise"
OpName %_UniformBuffer "_UniformBuffer"
OpMemberName %_UniformBuffer 0 "colorGreen"
OpMemberName %_UniformBuffer 1 "colorRed"
OpName %_entrypoint "_entrypoint"
OpName %main "main"
OpDecorate %sk_FragColor RelaxedPrecision
OpDecorate %sk_FragColor Location 0
OpDecorate %sk_FragColor Index 0
OpDecorate %sk_Clockwise RelaxedPrecision
OpDecorate %sk_Clockwise BuiltIn FrontFacing
OpMemberDecorate %_UniformBuffer 0 Offset 0
OpMemberDecorate %_UniformBuffer 0 RelaxedPrecision
OpMemberDecorate %_UniformBuffer 1 Offset 16
OpMemberDecorate %_UniformBuffer 1 RelaxedPrecision
OpDecorate %_UniformBuffer Block
OpDecorate %10 Binding 0
OpDecorate %10 DescriptorSet 0
OpDecorate %24 RelaxedPrecision
%float = OpTypeFloat 32
%v4float = OpTypeVector %float 4
%_ptr_Output_v4float = OpTypePointer Output %v4float
@ -18,12 +30,24 @@ OpDecorate %sk_Clockwise BuiltIn FrontFacing
%bool = OpTypeBool
%_ptr_Input_bool = OpTypePointer Input %bool
%sk_Clockwise = OpVariable %_ptr_Input_bool Input
%_UniformBuffer = OpTypeStruct %v4float %v4float
%_ptr_Uniform__UniformBuffer = OpTypePointer Uniform %_UniformBuffer
%10 = OpVariable %_ptr_Uniform__UniformBuffer Uniform
%void = OpTypeVoid
%11 = OpTypeFunction %void
%float_1 = OpConstant %float 1
%14 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1
%main = OpFunction %void None %11
%12 = OpLabel
OpStore %sk_FragColor %14
%15 = OpTypeFunction %void
%18 = OpTypeFunction %v4float
%_ptr_Uniform_v4float = OpTypePointer Uniform %v4float
%int = OpTypeInt 32 1
%int_0 = OpConstant %int 0
%_entrypoint = OpFunction %void None %15
%16 = OpLabel
%17 = OpFunctionCall %v4float %main
OpStore %sk_FragColor %17
OpReturn
OpFunctionEnd
%main = OpFunction %v4float None %18
%19 = OpLabel
%20 = OpAccessChain %_ptr_Uniform_v4float %10 %int_0
%24 = OpLoad %v4float %20
OpReturnValue %24
OpFunctionEnd

6
tests/sksl/shared/StackingVectorCasts.glsl
View File

@ -1,5 +1,7 @@
out vec4 sk_FragColor;
void main() {
sk_FragColor = vec4(1.0);
uniform vec4 colorGreen;
uniform vec4 colorRed;
vec4 main() {
return colorGreen;
}

10
tests/sksl/shared/StackingVectorCasts.metal
View File

@ -1,14 +1,20 @@
#include <metal_stdlib>
#include <simd/simd.h>
using namespace metal;
struct Uniforms {
float4 colorGreen;
float4 colorRed;
};
struct Inputs {
};
struct Outputs {
float4 sk_FragColor [[color(0)]];
};
fragment Outputs fragmentMain(Inputs _in [[stage_in]], bool _frontFacing [[front_facing]], float4 _fragCoord [[position]]) {
fragment Outputs fragmentMain(Inputs _in [[stage_in]], constant Uniforms& _uniforms [[buffer(0)]], bool _frontFacing [[front_facing]], float4 _fragCoord [[position]]) {
Outputs _out;
(void)_out;
_out.sk_FragColor = float4(1.0);
_out.sk_FragColor = _uniforms.colorGreen;
return _out;
}

51
tests/sksl/shared/StaticIf.asm.frag
View File

@ -1,16 +1,31 @@
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %main "main" %sk_FragColor %sk_Clockwise
OpExecutionMode %main OriginUpperLeft
OpEntryPoint Fragment %_entrypoint "_entrypoint" %sk_FragColor %sk_Clockwise
OpExecutionMode %_entrypoint OriginUpperLeft
OpName %sk_FragColor "sk_FragColor"
OpName %sk_Clockwise "sk_Clockwise"
OpName %_UniformBuffer "_UniformBuffer"
OpMemberName %_UniformBuffer 0 "colorRed"
OpMemberName %_UniformBuffer 1 "colorGreen"
OpName %_entrypoint "_entrypoint"
OpName %main "main"
OpName %result "result"
OpDecorate %sk_FragColor RelaxedPrecision
OpDecorate %sk_FragColor Location 0
OpDecorate %sk_FragColor Index 0
OpDecorate %sk_Clockwise RelaxedPrecision
OpDecorate %sk_Clockwise BuiltIn FrontFacing
OpMemberDecorate %_UniformBuffer 0 Offset 0
OpMemberDecorate %_UniformBuffer 0 RelaxedPrecision
OpMemberDecorate %_UniformBuffer 1 Offset 16
OpMemberDecorate %_UniformBuffer 1 RelaxedPrecision
OpDecorate %_UniformBuffer Block
OpDecorate %10 Binding 0
OpDecorate %10 DescriptorSet 0
OpDecorate %26 RelaxedPrecision
OpDecorate %29 RelaxedPrecision
OpDecorate %30 RelaxedPrecision
%float = OpTypeFloat 32
%v4float = OpTypeVector %float 4
%_ptr_Output_v4float = OpTypePointer Output %v4float
@ -18,12 +33,32 @@ OpDecorate %sk_Clockwise BuiltIn FrontFacing
%bool = OpTypeBool
%_ptr_Input_bool = OpTypePointer Input %bool
%sk_Clockwise = OpVariable %_ptr_Input_bool Input
%_UniformBuffer = OpTypeStruct %v4float %v4float
%_ptr_Uniform__UniformBuffer = OpTypePointer Uniform %_UniformBuffer
%10 = OpVariable %_ptr_Uniform__UniformBuffer Uniform
%void = OpTypeVoid
%11 = OpTypeFunction %void
%float_1 = OpConstant %float 1
%14 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1
%main = OpFunction %void None %11
%12 = OpLabel
OpStore %sk_FragColor %14
%15 = OpTypeFunction %void
%18 = OpTypeFunction %v4float
%_ptr_Function_v4float = OpTypePointer Function %v4float
%_ptr_Uniform_v4float = OpTypePointer Uniform %v4float
%int = OpTypeInt 32 1
%int_0 = OpConstant %int 0
%int_1 = OpConstant %int 1
%_entrypoint = OpFunction %void None %15
%16 = OpLabel
%17 = OpFunctionCall %v4float %main
OpStore %sk_FragColor %17
OpReturn
OpFunctionEnd
%main = OpFunction %v4float None %18
%19 = OpLabel
%result = OpVariable %_ptr_Function_v4float Function
%22 = OpAccessChain %_ptr_Uniform_v4float %10 %int_0
%26 = OpLoad %v4float %22
OpStore %result %26
%27 = OpAccessChain %_ptr_Uniform_v4float %10 %int_1
%29 = OpLoad %v4float %27
OpStore %result %29
%30 = OpLoad %v4float %result
OpReturnValue %30
OpFunctionEnd

8
tests/sksl/shared/StaticIf.glsl
View File

@ -1,7 +1,11 @@
out vec4 sk_FragColor;
void main() {
uniform vec4 colorRed;
uniform vec4 colorGreen;
vec4 main() {
vec4 result = colorRed;
{
sk_FragColor = vec4(1.0);
result = colorGreen;
}
return result;
}

12
tests/sksl/shared/StaticIf.metal
View File

@ -1,16 +1,24 @@
#include <metal_stdlib>
#include <simd/simd.h>
using namespace metal;
struct Uniforms {
float4 colorRed;
float4 colorGreen;
};
struct Inputs {
};
struct Outputs {
float4 sk_FragColor [[color(0)]];
};
fragment Outputs fragmentMain(Inputs _in [[stage_in]], bool _frontFacing [[front_facing]], float4 _fragCoord [[position]]) {
fragment Outputs fragmentMain(Inputs _in [[stage_in]], constant Uniforms& _uniforms [[buffer(0)]], bool _frontFacing [[front_facing]], float4 _fragCoord [[position]]) {
Outputs _out;
(void)_out;
float4 result = _uniforms.colorRed;
{
_out.sk_FragColor = float4(1.0);
result = _uniforms.colorGreen;
}
_out.sk_FragColor = result;
return _out;
}

386
tests/sksl/shared/SwizzleBoolConstants.asm.frag
View File

@ -1,10 +1,14 @@
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %main "main" %sk_FragColor %sk_Clockwise
OpExecutionMode %main OriginUpperLeft
OpEntryPoint Fragment %_entrypoint "_entrypoint" %sk_FragColor %sk_Clockwise
OpExecutionMode %_entrypoint OriginUpperLeft
OpName %sk_FragColor "sk_FragColor"
OpName %sk_Clockwise "sk_Clockwise"
OpName %_UniformBuffer "_UniformBuffer"
OpMemberName %_UniformBuffer 0 "colorGreen"
OpMemberName %_UniformBuffer 1 "colorRed"
OpName %_entrypoint "_entrypoint"
OpName %main "main"
OpName %v "v"
OpName %result "result"
@ -13,40 +17,50 @@ OpDecorate %sk_FragColor Location 0
OpDecorate %sk_FragColor Index 0
OpDecorate %sk_Clockwise RelaxedPrecision
OpDecorate %sk_Clockwise BuiltIn FrontFacing
OpDecorate %21 RelaxedPrecision
OpDecorate %25 RelaxedPrecision
OpDecorate %32 RelaxedPrecision
OpDecorate %35 RelaxedPrecision
OpDecorate %38 RelaxedPrecision
OpDecorate %45 RelaxedPrecision
OpMemberDecorate %_UniformBuffer 0 Offset 0
OpMemberDecorate %_UniformBuffer 0 RelaxedPrecision
OpMemberDecorate %_UniformBuffer 1 Offset 16
OpMemberDecorate %_UniformBuffer 1 RelaxedPrecision
OpDecorate %_UniformBuffer Block
OpDecorate %10 Binding 0
OpDecorate %10 DescriptorSet 0
OpDecorate %27 RelaxedPrecision
OpDecorate %33 RelaxedPrecision
OpDecorate %37 RelaxedPrecision
OpDecorate %44 RelaxedPrecision
OpDecorate %47 RelaxedPrecision
OpDecorate %50 RelaxedPrecision
OpDecorate %52 RelaxedPrecision
OpDecorate %55 RelaxedPrecision
OpDecorate %58 RelaxedPrecision
OpDecorate %63 RelaxedPrecision
OpDecorate %66 RelaxedPrecision
OpDecorate %69 RelaxedPrecision
OpDecorate %57 RelaxedPrecision
OpDecorate %62 RelaxedPrecision
OpDecorate %64 RelaxedPrecision
OpDecorate %67 RelaxedPrecision
OpDecorate %70 RelaxedPrecision
OpDecorate %76 RelaxedPrecision
OpDecorate %80 RelaxedPrecision
OpDecorate %83 RelaxedPrecision
OpDecorate %75 RelaxedPrecision
OpDecorate %78 RelaxedPrecision
OpDecorate %81 RelaxedPrecision
OpDecorate %82 RelaxedPrecision
OpDecorate %88 RelaxedPrecision
OpDecorate %90 RelaxedPrecision
OpDecorate %92 RelaxedPrecision
OpDecorate %95 RelaxedPrecision
OpDecorate %97 RelaxedPrecision
OpDecorate %100 RelaxedPrecision
OpDecorate %102 RelaxedPrecision
OpDecorate %105 RelaxedPrecision
OpDecorate %108 RelaxedPrecision
OpDecorate %107 RelaxedPrecision
OpDecorate %109 RelaxedPrecision
OpDecorate %112 RelaxedPrecision
OpDecorate %114 RelaxedPrecision
OpDecorate %119 RelaxedPrecision
OpDecorate %121 RelaxedPrecision
OpDecorate %124 RelaxedPrecision
OpDecorate %127 RelaxedPrecision
OpDecorate %132 RelaxedPrecision
OpDecorate %135 RelaxedPrecision
OpDecorate %117 RelaxedPrecision
OpDecorate %120 RelaxedPrecision
OpDecorate %126 RelaxedPrecision
OpDecorate %131 RelaxedPrecision
OpDecorate %133 RelaxedPrecision
OpDecorate %136 RelaxedPrecision
OpDecorate %139 RelaxedPrecision
OpDecorate %148 RelaxedPrecision
OpDecorate %144 RelaxedPrecision
OpDecorate %147 RelaxedPrecision
OpDecorate %151 RelaxedPrecision
OpDecorate %158 RelaxedPrecision
OpDecorate %161 RelaxedPrecision
OpDecorate %162 RelaxedPrecision
%float = OpTypeFloat 32
%v4float = OpTypeVector %float 4
%_ptr_Output_v4float = OpTypePointer Output %v4float
@ -54,179 +68,195 @@ OpDecorate %148 RelaxedPrecision
%bool = OpTypeBool
%_ptr_Input_bool = OpTypePointer Input %bool
%sk_Clockwise = OpVariable %_ptr_Input_bool Input
%_UniformBuffer = OpTypeStruct %v4float %v4float
%_ptr_Uniform__UniformBuffer = OpTypePointer Uniform %_UniformBuffer
%10 = OpVariable %_ptr_Uniform__UniformBuffer Uniform
%void = OpTypeVoid
%11 = OpTypeFunction %void
%15 = OpTypeFunction %void
%18 = OpTypeFunction %v4float
%v4bool = OpTypeVector %bool 4
%_ptr_Function_v4bool = OpTypePointer Function %v4bool
%float_1 = OpConstant %float 1
%_ptr_Uniform_v4float = OpTypePointer Uniform %v4float
%int = OpTypeInt 32 1
%int_0 = OpConstant %int 0
%float_0 = OpConstant %float 0
%true = OpConstantTrue %bool
%v2bool = OpTypeVector %bool 2
%false = OpConstantFalse %bool
%v3bool = OpTypeVector %bool 3
%_ptr_Function_v4float = OpTypePointer Function %v4float
%145 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1
%float_0 = OpConstant %float 0
%147 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0
%main = OpFunction %void None %11
%12 = OpLabel
%int_1 = OpConstant %int 1
%_entrypoint = OpFunction %void None %15
%16 = OpLabel
%17 = OpFunctionCall %v4float %main
OpStore %sk_FragColor %17
OpReturn
OpFunctionEnd
%main = OpFunction %v4float None %18
%19 = OpLabel
%v = OpVariable %_ptr_Function_v4bool Function
%result = OpVariable %_ptr_Function_v4bool Function
%140 = OpVariable %_ptr_Function_v4float Function
%16 = OpExtInst %float %1 Sqrt %float_1
%18 = OpFOrdEqual %bool %16 %float_1
%19 = OpCompositeConstruct %v4bool %18 %18 %18 %18
OpStore %v %19
%21 = OpLoad %v4bool %v
%22 = OpCompositeExtract %bool %21 0
%24 = OpCompositeConstruct %v4bool %22 %true %true %true
OpStore %result %24
%25 = OpLoad %v4bool %v
%26 = OpVectorShuffle %v2bool %25 %25 0 1
%28 = OpCompositeExtract %bool %26 0
%29 = OpCompositeExtract %bool %26 1
%31 = OpCompositeConstruct %v4bool %28 %29 %false %true
OpStore %result %31
%32 = OpLoad %v4bool %v
%33 = OpCompositeExtract %bool %32 0
%34 = OpCompositeConstruct %v4bool %33 %true %true %false
OpStore %result %34
%35 = OpLoad %v4bool %v
%36 = OpCompositeExtract %bool %35 1
%37 = OpCompositeConstruct %v4bool %false %36 %true %true
OpStore %result %37
%38 = OpLoad %v4bool %v
%39 = OpVectorShuffle %v3bool %38 %38 0 1 2
%41 = OpCompositeExtract %bool %39 0
%42 = OpCompositeExtract %bool %39 1
%43 = OpCompositeExtract %bool %39 2
%44 = OpCompositeConstruct %v4bool %41 %42 %43 %true
OpStore %result %44
%45 = OpLoad %v4bool %v
%46 = OpVectorShuffle %v2bool %45 %45 0 1
%47 = OpCompositeExtract %bool %46 0
%48 = OpCompositeExtract %bool %46 1
%49 = OpCompositeConstruct %v4bool %47 %48 %true %true
%152 = OpVariable %_ptr_Function_v4float Function
%23 = OpAccessChain %_ptr_Uniform_v4float %10 %int_0
%27 = OpLoad %v4float %23
%28 = OpCompositeExtract %float %27 1
%29 = OpFUnordNotEqual %bool %28 %float_0
%31 = OpCompositeConstruct %v4bool %29 %29 %29 %29
OpStore %v %31
%33 = OpLoad %v4bool %v
%34 = OpCompositeExtract %bool %33 0
%36 = OpCompositeConstruct %v4bool %34 %true %true %true
OpStore %result %36
%37 = OpLoad %v4bool %v
%38 = OpVectorShuffle %v2bool %37 %37 0 1
%40 = OpCompositeExtract %bool %38 0
%41 = OpCompositeExtract %bool %38 1
%43 = OpCompositeConstruct %v4bool %40 %41 %false %true
OpStore %result %43
%44 = OpLoad %v4bool %v
%45 = OpCompositeExtract %bool %44 0
%46 = OpCompositeConstruct %v4bool %45 %true %true %false
OpStore %result %46
%47 = OpLoad %v4bool %v
%48 = OpCompositeExtract %bool %47 1
%49 = OpCompositeConstruct %v4bool %false %48 %true %true
OpStore %result %49
%50 = OpLoad %v4bool %v
%51 = OpCompositeExtract %bool %50 0
%52 = OpLoad %v4bool %v
%53 = OpCompositeExtract %bool %52 2
%54 = OpCompositeConstruct %v4bool %51 %false %53 %true
OpStore %result %54
%55 = OpLoad %v4bool %v
%56 = OpCompositeExtract %bool %55 0
%57 = OpCompositeConstruct %v4bool %56 %true %false %false
OpStore %result %57
%58 = OpLoad %v4bool %v
%59 = OpVectorShuffle %v2bool %58 %58 1 2
%60 = OpCompositeExtract %bool %59 0
%61 = OpCompositeExtract %bool %59 1
%62 = OpCompositeConstruct %v4bool %true %60 %61 %false
OpStore %result %62
%63 = OpLoad %v4bool %v
%64 = OpCompositeExtract %bool %63 1
%65 = OpCompositeConstruct %v4bool %false %64 %true %false
OpStore %result %65
%66 = OpLoad %v4bool %v
%67 = OpCompositeExtract %bool %66 2
%68 = OpCompositeConstruct %v4bool %true %true %67 %false
OpStore %result %68
%69 = OpLoad %v4bool %v
%51 = OpVectorShuffle %v3bool %50 %50 0 1 2
%53 = OpCompositeExtract %bool %51 0
%54 = OpCompositeExtract %bool %51 1
%55 = OpCompositeExtract %bool %51 2
%56 = OpCompositeConstruct %v4bool %53 %54 %55 %true
OpStore %result %56
%57 = OpLoad %v4bool %v
%58 = OpVectorShuffle %v2bool %57 %57 0 1
%59 = OpCompositeExtract %bool %58 0
%60 = OpCompositeExtract %bool %58 1
%61 = OpCompositeConstruct %v4bool %59 %60 %true %true
OpStore %result %61
%62 = OpLoad %v4bool %v
%63 = OpCompositeExtract %bool %62 0
%64 = OpLoad %v4bool %v
%65 = OpCompositeExtract %bool %64 2
%66 = OpCompositeConstruct %v4bool %63 %false %65 %true
OpStore %result %66
%67 = OpLoad %v4bool %v
%68 = OpCompositeExtract %bool %67 0
%69 = OpCompositeConstruct %v4bool %68 %true %false %false
OpStore %result %69
%70 = OpLoad %v4bool %v
%71 = OpVectorShuffle %v3bool %70 %70 0 1 2
%71 = OpVectorShuffle %v2bool %70 %70 1 2
%72 = OpCompositeExtract %bool %71 0
%73 = OpCompositeExtract %bool %71 1
%74 = OpCompositeExtract %bool %71 2
%75 = OpCompositeConstruct %v4bool %72 %73 %74 %true
OpStore %result %75
%76 = OpLoad %v4bool %v
%77 = OpVectorShuffle %v2bool %76 %76 0 1
%78 = OpCompositeExtract %bool %77 0
%79 = OpCompositeExtract %bool %77 1
%80 = OpLoad %v4bool %v
%81 = OpCompositeExtract %bool %80 3
%82 = OpCompositeConstruct %v4bool %78 %79 %false %81
OpStore %result %82
%83 = OpLoad %v4bool %v
%84 = OpVectorShuffle %v2bool %83 %83 0 1
%85 = OpCompositeExtract %bool %84 0
%86 = OpCompositeExtract %bool %84 1
%87 = OpCompositeConstruct %v4bool %85 %86 %true %false
%74 = OpCompositeConstruct %v4bool %true %72 %73 %false
OpStore %result %74
%75 = OpLoad %v4bool %v
%76 = OpCompositeExtract %bool %75 1
%77 = OpCompositeConstruct %v4bool %false %76 %true %false
OpStore %result %77
%78 = OpLoad %v4bool %v
%79 = OpCompositeExtract %bool %78 2
%80 = OpCompositeConstruct %v4bool %true %true %79 %false
OpStore %result %80
%81 = OpLoad %v4bool %v
OpStore %result %81
%82 = OpLoad %v4bool %v
%83 = OpVectorShuffle %v3bool %82 %82 0 1 2
%84 = OpCompositeExtract %bool %83 0
%85 = OpCompositeExtract %bool %83 1
%86 = OpCompositeExtract %bool %83 2
%87 = OpCompositeConstruct %v4bool %84 %85 %86 %true
OpStore %result %87
%88 = OpLoad %v4bool %v
%89 = OpCompositeExtract %bool %88 0
%90 = OpLoad %v4bool %v
%91 = OpVectorShuffle %v2bool %90 %90 2 3
%92 = OpCompositeExtract %bool %91 0
%93 = OpCompositeExtract %bool %91 1
%94 = OpCompositeConstruct %v4bool %89 %true %92 %93
%89 = OpVectorShuffle %v2bool %88 %88 0 1
%90 = OpCompositeExtract %bool %89 0
%91 = OpCompositeExtract %bool %89 1
%92 = OpLoad %v4bool %v
%93 = OpCompositeExtract %bool %92 3
%94 = OpCompositeConstruct %v4bool %90 %91 %false %93
OpStore %result %94
%95 = OpLoad %v4bool %v
%96 = OpCompositeExtract %bool %95 0
%97 = OpLoad %v4bool %v
%98 = OpCompositeExtract %bool %97 2
%99 = OpCompositeConstruct %v4bool %96 %false %98 %true
%96 = OpVectorShuffle %v2bool %95 %95 0 1
%97 = OpCompositeExtract %bool %96 0
%98 = OpCompositeExtract %bool %96 1
%99 = OpCompositeConstruct %v4bool %97 %98 %true %false
OpStore %result %99
%100 = OpLoad %v4bool %v
%101 = OpCompositeExtract %bool %100 0
%102 = OpLoad %v4bool %v
%103 = OpCompositeExtract %bool %102 3
%104 = OpCompositeConstruct %v4bool %101 %true %true %103
OpStore %result %104
%105 = OpLoad %v4bool %v
%106 = OpCompositeExtract %bool %105 0
%107 = OpCompositeConstruct %v4bool %106 %true %false %true
OpStore %result %107
%108 = OpLoad %v4bool %v
%109 = OpVectorShuffle %v3bool %108 %108 1 2 3
%110 = OpCompositeExtract %bool %109 0
%111 = OpCompositeExtract %bool %109 1
%112 = OpCompositeExtract %bool %109 2
%113 = OpCompositeConstruct %v4bool %true %110 %111 %112
OpStore %result %113
%103 = OpVectorShuffle %v2bool %102 %102 2 3
%104 = OpCompositeExtract %bool %103 0
%105 = OpCompositeExtract %bool %103 1
%106 = OpCompositeConstruct %v4bool %101 %true %104 %105
OpStore %result %106
%107 = OpLoad %v4bool %v
%108 = OpCompositeExtract %bool %107 0
%109 = OpLoad %v4bool %v
%110 = OpCompositeExtract %bool %109 2
%111 = OpCompositeConstruct %v4bool %108 %false %110 %true
OpStore %result %111
%112 = OpLoad %v4bool %v
%113 = OpCompositeExtract %bool %112 0
%114 = OpLoad %v4bool %v
%115 = OpVectorShuffle %v2bool %114 %114 1 2
%116 = OpCompositeExtract %bool %115 0
%117 = OpCompositeExtract %bool %115 1
%118 = OpCompositeConstruct %v4bool %false %116 %117 %true
OpStore %result %118
%119 = OpLoad %v4bool %v
%120 = OpCompositeExtract %bool %119 1
%121 = OpLoad %v4bool %v
%122 = OpCompositeExtract %bool %121 3
%123 = OpCompositeConstruct %v4bool %false %120 %true %122
OpStore %result %123
%124 = OpLoad %v4bool %v
%125 = OpCompositeExtract %bool %124 1
%126 = OpCompositeConstruct %v4bool %true %125 %true %true
OpStore %result %126
%127 = OpLoad %v4bool %v
%128 = OpVectorShuffle %v2bool %127 %127 2 3
%129 = OpCompositeExtract %bool %128 0
%130 = OpCompositeExtract %bool %128 1
%131 = OpCompositeConstruct %v4bool %false %false %129 %130
OpStore %result %131
%132 = OpLoad %v4bool %v
%133 = OpCompositeExtract %bool %132 2
%134 = OpCompositeConstruct %v4bool %false %false %133 %true
OpStore %result %134
%135 = OpLoad %v4bool %v
%136 = OpCompositeExtract %bool %135 3
%137 = OpCompositeConstruct %v4bool %false %true %true %136
OpStore %result %137
%139 = OpLoad %v4bool %result
%138 = OpAny %bool %139
OpSelectionMerge %144 None
OpBranchConditional %138 %142 %143
%142 = OpLabel
OpStore %140 %145
OpBranch %144
%143 = OpLabel
OpStore %140 %147
OpBranch %144
%144 = OpLabel
%148 = OpLoad %v4float %140
OpStore %sk_FragColor %148
OpReturn
%115 = OpCompositeExtract %bool %114 3
%116 = OpCompositeConstruct %v4bool %113 %true %true %115
OpStore %result %116
%117 = OpLoad %v4bool %v
%118 = OpCompositeExtract %bool %117 0
%119 = OpCompositeConstruct %v4bool %118 %true %false %true
OpStore %result %119
%120 = OpLoad %v4bool %v
%121 = OpVectorShuffle %v3bool %120 %120 1 2 3
%122 = OpCompositeExtract %bool %121 0
%123 = OpCompositeExtract %bool %121 1
%124 = OpCompositeExtract %bool %121 2
%125 = OpCompositeConstruct %v4bool %true %122 %123 %124
OpStore %result %125
%126 = OpLoad %v4bool %v
%127 = OpVectorShuffle %v2bool %126 %126 1 2
%128 = OpCompositeExtract %bool %127 0
%129 = OpCompositeExtract %bool %127 1
%130 = OpCompositeConstruct %v4bool %false %128 %129 %true
OpStore %result %130
%131 = OpLoad %v4bool %v
%132 = OpCompositeExtract %bool %131 1
%133 = OpLoad %v4bool %v
%134 = OpCompositeExtract %bool %133 3
%135 = OpCompositeConstruct %v4bool %false %132 %true %134
OpStore %result %135
%136 = OpLoad %v4bool %v
%137 = OpCompositeExtract %bool %136 1
%138 = OpCompositeConstruct %v4bool %true %137 %true %true
OpStore %result %138
%139 = OpLoad %v4bool %v
%140 = OpVectorShuffle %v2bool %139 %139 2 3
%141 = OpCompositeExtract %bool %140 0
%142 = OpCompositeExtract %bool %140 1
%143 = OpCompositeConstruct %v4bool %false %false %141 %142
OpStore %result %143
%144 = OpLoad %v4bool %v
%145 = OpCompositeExtract %bool %144 2
%146 = OpCompositeConstruct %v4bool %false %false %145 %true
OpStore %result %146
%147 = OpLoad %v4bool %v
%148 = OpCompositeExtract %bool %147 3
%149 = OpCompositeConstruct %v4bool %false %true %true %148
OpStore %result %149
%151 = OpLoad %v4bool %result
%150 = OpAny %bool %151
OpSelectionMerge %156 None
OpBranchConditional %150 %154 %155
%154 = OpLabel
%157 = OpAccessChain %_ptr_Uniform_v4float %10 %int_0
%158 = OpLoad %v4float %157
OpStore %152 %158
OpBranch %156
%155 = OpLabel
%159 = OpAccessChain %_ptr_Uniform_v4float %10 %int_1
%161 = OpLoad %v4float %159
OpStore %152 %161
OpBranch %156
%156 = OpLabel
%162 = OpLoad %v4float %152
OpReturnValue %162
OpFunctionEnd

8
tests/sksl/shared/SwizzleBoolConstants.glsl
View File

@ -1,7 +1,9 @@
out vec4 sk_FragColor;
void main() {
bvec4 v = bvec4(sqrt(1.0) == 1.0);
uniform vec4 colorGreen;
uniform vec4 colorRed;
vec4 main() {
bvec4 v = bvec4(bool(colorGreen.y));
bvec4 result;
result = bvec4(v.x, true, true, true);
result = bvec4(v.xy, false, true);
@ -29,5 +31,5 @@ void main() {
result = bvec4(false, false, v.zw);
result = bvec4(false, false, v.z, true);
result = bvec4(false, true, true, v.w);
sk_FragColor = any(result) ? vec4(1.0) : vec4(0.0);
return any(result) ? colorGreen : colorRed;
}

12
tests/sksl/shared/SwizzleBoolConstants.metal
View File

@ -1,15 +1,21 @@
#include <metal_stdlib>
#include <simd/simd.h>
using namespace metal;
struct Uniforms {
float4 colorGreen;
float4 colorRed;
};
struct Inputs {
};
struct Outputs {
float4 sk_FragColor [[color(0)]];
};
fragment Outputs fragmentMain(Inputs _in [[stage_in]], bool _frontFacing [[front_facing]], float4 _fragCoord [[position]]) {
fragment Outputs fragmentMain(Inputs _in [[stage_in]], constant Uniforms& _uniforms [[buffer(0)]], bool _frontFacing [[front_facing]], float4 _fragCoord [[position]]) {
Outputs _out;
(void)_out;
bool4 v = bool4(sqrt(1.0) == 1.0);
bool4 v = bool4(bool(_uniforms.colorGreen.y));
bool4 result;
result = bool4(v.x, true, true, true);
result = bool4(v.xy, false, true);
@ -37,6 +43,6 @@ fragment Outputs fragmentMain(Inputs _in [[stage_in]], bool _frontFacing [[front
result = bool4(false, false, v.zw);
result = bool4(false, false, v.z, true);
result = bool4(false, true, true, v.w);
_out.sk_FragColor = any(result) ? float4(1.0) : float4(0.0);
_out.sk_FragColor = any(result) ? _uniforms.colorGreen : _uniforms.colorRed;
return _out;
}