Change WGSL indentation level to 2 spaces.
WGSL often ends up with very deep brace-scoping, since it mandates
braced blocks in many places where GLSL/SkSL does not, and we
compensate by always emitting a set of braces. Additionally, we
are going to need an extra braced-scope around every function body
now, since we will need to inject an extra return statement at the
end of some functions. (WGSL will report an error if a function's
only return is inside a loop structure, even if it unambiguously
returns from inside the loop, and the proposed fix from the WGSL
team is to add a dead return at the bottom and let Tint optimize
it away.)
Change-Id: I4a48b693870b91410f104d71d2f88b33543e4776
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/708378
Auto-Submit: John Stiles <johnstiles@google.com>
Reviewed-by: Arman Uguray <armansito@google.com>
diff --git a/src/sksl/codegen/SkSLWGSLCodeGenerator.cpp b/src/sksl/codegen/SkSLWGSLCodeGenerator.cpp
index e19d132..dacba7e 100644
--- a/src/sksl/codegen/SkSLWGSLCodeGenerator.cpp
+++ b/src/sksl/codegen/SkSLWGSLCodeGenerator.cpp
@@ -636,7 +636,7 @@
}
if (fAtLineStart) {
for (int i = 0; i < fIndentation; i++) {
- fOut->writeText(" ");
+ fOut->writeText(" ");
}
}
fOut->writeText(std::string(s).c_str());
@@ -732,8 +732,13 @@
void WGSLCodeGenerator::writeFunction(const FunctionDefinition& f) {
this->writeFunctionDeclaration(f.declaration());
- this->write(" ");
+ this->writeLine(" {");
+
+ ++fIndentation;
this->writeBlock(f.body()->as<Block>());
+ --fIndentation;
+
+ this->writeLine("}");
if (f.declaration().isMain()) {
// We just emitted the user-defined main function. Next, we generate a program entry point
@@ -2114,7 +2119,7 @@
this->write("struct _GlobalUniforms {\n");
fDeclaredUniformsStruct = true;
}
- this->write(" ");
+ this->write(" ");
this->writeVariableDecl(var.type(), var.mangledName(), Delimiter::kComma);
}
}
diff --git a/tests/sksl/inliner/DoWhileTestCannotBeInlined.wgsl b/tests/sksl/inliner/DoWhileTestCannotBeInlined.wgsl
index 573fa71..3c4cc25 100644
--- a/tests/sksl/inliner/DoWhileTestCannotBeInlined.wgsl
+++ b/tests/sksl/inliner/DoWhileTestCannotBeInlined.wgsl
@@ -1,33 +1,37 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn shouldLoop_bh4(value: vec4<f32>) -> bool {
+ {
return any(value != _globalUniforms.colorGreen);
+ }
}
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var result: vec4<f32> = _globalUniforms.colorRed;
loop {
- {
- result = _globalUniforms.colorGreen;
- }
- continuing {
- let _skTemp0 = shouldLoop_bh4(result);
- break if !(_skTemp0);
- }
+ {
+ result = _globalUniforms.colorGreen;
+ }
+ continuing {
+ let _skTemp0 = shouldLoop_bh4(result);
+ break if !(_skTemp0);
+ }
}
return result;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/runtime/GLSLTypeNames.wgsl b/tests/sksl/runtime/GLSLTypeNames.wgsl
index 9b29452..7899315 100644
--- a/tests/sksl/runtime/GLSLTypeNames.wgsl
+++ b/tests/sksl/runtime/GLSLTypeNames.wgsl
@@ -1,8 +1,10 @@
var<private> f: f32;
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var fv: vec4<f32> = vec4<f32>(f);
return fv;
+ }
}
@fragment fn runtimeShaderMain(@location(0) _coords: vec2<f32>) -> @location(0) vec4<f32> {
- return main(_coords);
+ return main(_coords);
}
diff --git a/tests/sksl/runtime/GlobalVariables.wgsl b/tests/sksl/runtime/GlobalVariables.wgsl
index 95f7dc1..336e553 100644
--- a/tests/sksl/runtime/GlobalVariables.wgsl
+++ b/tests/sksl/runtime/GlobalVariables.wgsl
@@ -2,12 +2,16 @@
var<private> gInitializedFromOther: f32 = 1.0;
var<private> gUninitialized: f32;
fn init_globals_v() {
+ {
gUninitialized = 1.0;
+ }
}
fn main(xy: vec2<f32>) -> vec4<f32> {
+ {
init_globals_v();
return vec4<f32>(0.0, gInitializedFromOther, 0.0, gUninitialized);
+ }
}
@fragment fn runtimeShaderMain(@location(0) _coords: vec2<f32>) -> @location(0) vec4<f32> {
- return main(_coords);
+ return main(_coords);
}
diff --git a/tests/sksl/runtime/LargeProgram_BlocklessLoops.wgsl b/tests/sksl/runtime/LargeProgram_BlocklessLoops.wgsl
index a954676..7a9c3ef 100644
--- a/tests/sksl/runtime/LargeProgram_BlocklessLoops.wgsl
+++ b/tests/sksl/runtime/LargeProgram_BlocklessLoops.wgsl
@@ -1,56 +1,58 @@
fn main(xy: vec2<f32>) -> vec4<f32> {
+ {
var i: i32;
{
- var a: i32 = 0;
- loop {
- if a < 10 {
+ var a: i32 = 0;
+ loop {
+ if a < 10 {
+ {
+ var b: i32 = 0;
+ loop {
+ if b < 10 {
{
- var b: i32 = 0;
- loop {
- if b < 10 {
- {
- var c: i32 = 0;
- loop {
- if c < 10 {
- {
- var d: i32 = 0;
- loop {
- if d < 10 {
- i = i + i32(1);
- } else {
- break;
- }
- continuing {
- d = d + i32(1);
- }
- }
- }
- } else {
- break;
- }
- continuing {
- c = c + i32(1);
- }
- }
- }
- } else {
+ var c: i32 = 0;
+ loop {
+ if c < 10 {
+ {
+ var d: i32 = 0;
+ loop {
+ if d < 10 {
+ i = i + i32(1);
+ } else {
break;
+ }
+ continuing {
+ d = d + i32(1);
+ }
}
- continuing {
- b = b + i32(1);
- }
+ }
+ } else {
+ break;
}
+ continuing {
+ c = c + i32(1);
+ }
+ }
}
- } else {
+ } else {
break;
+ }
+ continuing {
+ b = b + i32(1);
+ }
}
- continuing {
- a = a + i32(1);
- }
+ }
+ } else {
+ break;
}
+ continuing {
+ a = a + i32(1);
+ }
+ }
}
return vec4<f32>(0.0);
+ }
}
@fragment fn runtimeShaderMain(@location(0) _coords: vec2<f32>) -> @location(0) vec4<f32> {
- return main(_coords);
+ return main(_coords);
}
diff --git a/tests/sksl/runtime/LargeProgram_FlatLoop.wgsl b/tests/sksl/runtime/LargeProgram_FlatLoop.wgsl
index 642222e..745bb06 100644
--- a/tests/sksl/runtime/LargeProgram_FlatLoop.wgsl
+++ b/tests/sksl/runtime/LargeProgram_FlatLoop.wgsl
@@ -1,511 +1,513 @@
fn main(xy: vec2<f32>) -> vec4<f32> {
+ {
var i: i32;
{
- var a: i32 = 0;
- loop {
- if a < 100 {
- {
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- i = i + i32(1);
- }
- } else {
- break;
- }
- continuing {
- a = a + i32(1);
- }
+ var a: i32 = 0;
+ loop {
+ if a < 100 {
+ {
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ i = i + i32(1);
+ }
+ } else {
+ break;
}
+ continuing {
+ a = a + i32(1);
+ }
+ }
}
return vec4<f32>(0.0);
+ }
}
@fragment fn runtimeShaderMain(@location(0) _coords: vec2<f32>) -> @location(0) vec4<f32> {
- return main(_coords);
+ return main(_coords);
}
diff --git a/tests/sksl/runtime/LargeProgram_Functions.wgsl b/tests/sksl/runtime/LargeProgram_Functions.wgsl
index e3ab14a..731106a 100644
--- a/tests/sksl/runtime/LargeProgram_Functions.wgsl
+++ b/tests/sksl/runtime/LargeProgram_Functions.wgsl
@@ -1,4 +1,5 @@
fn d_vi(i: ptr<function, i32>) {
+ {
(*i) = (*i) + i32(1);
(*i) = (*i) + i32(1);
(*i) = (*i) + i32(1);
@@ -9,8 +10,10 @@
(*i) = (*i) + i32(1);
(*i) = (*i) + i32(1);
(*i) = (*i) + i32(1);
+ }
}
fn c_vi(i: ptr<function, i32>) {
+ {
var _skTemp0: i32 = (*i);
d_vi(&_skTemp0);
(*i) = _skTemp0;
@@ -41,8 +44,10 @@
var _skTemp9: i32 = (*i);
d_vi(&_skTemp9);
(*i) = _skTemp9;
+ }
}
fn b_vi(i: ptr<function, i32>) {
+ {
var _skTemp10: i32 = (*i);
c_vi(&_skTemp10);
(*i) = _skTemp10;
@@ -73,8 +78,10 @@
var _skTemp19: i32 = (*i);
c_vi(&_skTemp19);
(*i) = _skTemp19;
+ }
}
fn a_vi(i: ptr<function, i32>) {
+ {
var _skTemp20: i32 = (*i);
b_vi(&_skTemp20);
(*i) = _skTemp20;
@@ -105,14 +112,17 @@
var _skTemp29: i32 = (*i);
b_vi(&_skTemp29);
(*i) = _skTemp29;
+ }
}
fn main(xy: vec2<f32>) -> vec4<f32> {
+ {
var i: i32 = 0;
var _skTemp30: i32 = i;
a_vi(&_skTemp30);
i = _skTemp30;
return vec4<f32>(0.0);
+ }
}
@fragment fn runtimeShaderMain(@location(0) _coords: vec2<f32>) -> @location(0) vec4<f32> {
- return main(_coords);
+ return main(_coords);
}
diff --git a/tests/sksl/runtime/LargeProgram_NestedLoops.wgsl b/tests/sksl/runtime/LargeProgram_NestedLoops.wgsl
index 3962e94..10e4b66 100644
--- a/tests/sksl/runtime/LargeProgram_NestedLoops.wgsl
+++ b/tests/sksl/runtime/LargeProgram_NestedLoops.wgsl
@@ -1,64 +1,66 @@
fn main(xy: vec2<f32>) -> vec4<f32> {
+ {
var i: i32;
{
- var a: i32 = 0;
- loop {
- if a < 10 {
- {
+ var a: i32 = 0;
+ loop {
+ if a < 10 {
+ {
+ {
+ var b: i32 = 0;
+ loop {
+ if b < 10 {
+ {
{
- var b: i32 = 0;
- loop {
- if b < 10 {
- {
- {
- var c: i32 = 0;
- loop {
- if c < 10 {
- {
- {
- var d: i32 = 0;
- loop {
- if d < 10 {
- {
- i = i + i32(1);
- }
- } else {
- break;
- }
- continuing {
- d = d + i32(1);
- }
- }
- }
- }
- } else {
- break;
- }
- continuing {
- c = c + i32(1);
- }
- }
- }
+ var c: i32 = 0;
+ loop {
+ if c < 10 {
+ {
+ {
+ var d: i32 = 0;
+ loop {
+ if d < 10 {
+ {
+ i = i + i32(1);
+ }
+ } else {
+ break;
}
- } else {
- break;
+ continuing {
+ d = d + i32(1);
+ }
+ }
}
- continuing {
- b = b + i32(1);
- }
+ }
+ } else {
+ break;
}
+ continuing {
+ c = c + i32(1);
+ }
+ }
}
+ }
+ } else {
+ break;
}
- } else {
- break;
+ continuing {
+ b = b + i32(1);
+ }
+ }
}
- continuing {
- a = a + i32(1);
- }
+ }
+ } else {
+ break;
}
+ continuing {
+ a = a + i32(1);
+ }
+ }
}
return vec4<f32>(0.0);
+ }
}
@fragment fn runtimeShaderMain(@location(0) _coords: vec2<f32>) -> @location(0) vec4<f32> {
- return main(_coords);
+ return main(_coords);
}
diff --git a/tests/sksl/runtime/LargeProgram_SplitLoops.wgsl b/tests/sksl/runtime/LargeProgram_SplitLoops.wgsl
index 8551601..035a043 100644
--- a/tests/sksl/runtime/LargeProgram_SplitLoops.wgsl
+++ b/tests/sksl/runtime/LargeProgram_SplitLoops.wgsl
@@ -1,76 +1,86 @@
fn d_vi(i: ptr<function, i32>) {
+ {
{
- var x: i32 = 0;
- loop {
- if x < 10 {
- (*i) = (*i) + i32(1);
- } else {
- break;
- }
- continuing {
- x = x + i32(1);
- }
+ var x: i32 = 0;
+ loop {
+ if x < 10 {
+ (*i) = (*i) + i32(1);
+ } else {
+ break;
}
+ continuing {
+ x = x + i32(1);
+ }
+ }
}
+ }
}
fn c_vi(i: ptr<function, i32>) {
+ {
{
- var x: i32 = 0;
- loop {
- if x < 10 {
- var _skTemp0: i32 = (*i);
- d_vi(&_skTemp0);
- (*i) = _skTemp0;
- } else {
- break;
- }
- continuing {
- x = x + i32(1);
- }
+ var x: i32 = 0;
+ loop {
+ if x < 10 {
+ var _skTemp0: i32 = (*i);
+ d_vi(&_skTemp0);
+ (*i) = _skTemp0;
+ } else {
+ break;
}
+ continuing {
+ x = x + i32(1);
+ }
+ }
}
+ }
}
fn b_vi(i: ptr<function, i32>) {
+ {
{
- var x: i32 = 0;
- loop {
- if x < 10 {
- var _skTemp1: i32 = (*i);
- c_vi(&_skTemp1);
- (*i) = _skTemp1;
- } else {
- break;
- }
- continuing {
- x = x + i32(1);
- }
+ var x: i32 = 0;
+ loop {
+ if x < 10 {
+ var _skTemp1: i32 = (*i);
+ c_vi(&_skTemp1);
+ (*i) = _skTemp1;
+ } else {
+ break;
}
+ continuing {
+ x = x + i32(1);
+ }
+ }
}
+ }
}
fn a_vi(i: ptr<function, i32>) {
+ {
{
- var x: i32 = 0;
- loop {
- if x < 10 {
- var _skTemp2: i32 = (*i);
- b_vi(&_skTemp2);
- (*i) = _skTemp2;
- } else {
- break;
- }
- continuing {
- x = x + i32(1);
- }
+ var x: i32 = 0;
+ loop {
+ if x < 10 {
+ var _skTemp2: i32 = (*i);
+ b_vi(&_skTemp2);
+ (*i) = _skTemp2;
+ } else {
+ break;
}
+ continuing {
+ x = x + i32(1);
+ }
+ }
}
+ }
}
fn main(xy: vec2<f32>) -> vec4<f32> {
+ {
var i: i32 = 0;
var _skTemp3: i32 = i;
a_vi(&_skTemp3);
i = _skTemp3;
return vec4<f32>(0.0);
+ }
}
@fragment fn runtimeShaderMain(@location(0) _coords: vec2<f32>) -> @location(0) vec4<f32> {
- return main(_coords);
+ return main(_coords);
}
diff --git a/tests/sksl/runtime/LargeProgram_ZeroIterFor.wgsl b/tests/sksl/runtime/LargeProgram_ZeroIterFor.wgsl
index 5630a20..bb20317 100644
--- a/tests/sksl/runtime/LargeProgram_ZeroIterFor.wgsl
+++ b/tests/sksl/runtime/LargeProgram_ZeroIterFor.wgsl
@@ -1,7 +1,9 @@
fn main(xy: vec2<f32>) -> vec4<f32> {
+ {
var i: i32 = 0;
return vec4<f32>(f32(i));
+ }
}
@fragment fn runtimeShaderMain(@location(0) _coords: vec2<f32>) -> @location(0) vec4<f32> {
- return main(_coords);
+ return main(_coords);
}
diff --git a/tests/sksl/runtime/LoopFloat.wgsl b/tests/sksl/runtime/LoopFloat.wgsl
index 908189c..407ac22 100644
--- a/tests/sksl/runtime/LoopFloat.wgsl
+++ b/tests/sksl/runtime/LoopFloat.wgsl
@@ -1,215 +1,236 @@
struct _GlobalUniforms {
- colorRed: vec4<f32>,
- colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
+ colorGreen: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
const kZero: f32 = 0.0;
fn return_loop_ff(five: f32) -> f32 {
+ {
{
- var i: f32 = kZero;
- loop {
- if i < 10.0 {
- {
- if (i == five) {
- {
- return i;
- }
- }
- }
- } else {
- break;
+ var i: f32 = kZero;
+ loop {
+ if i < 10.0 {
+ {
+ if (i == five) {
+ {
+ return i;
+ }
}
- continuing {
- i = i + f32(1);
- }
+ }
+ } else {
+ break;
}
+ continuing {
+ i = i + f32(1);
+ }
+ }
}
return 0.0;
+ }
}
const kTen: f32 = 10.0;
fn continue_loop_ff(five: f32) -> f32 {
+ {
var sum: f32 = 0.0;
{
- var i: f32 = 0.0;
- loop {
- if i < kTen {
- {
- if (i < five) {
- {
- continue;
- }
- }
- sum = sum + i;
- }
- } else {
- break;
+ var i: f32 = 0.0;
+ loop {
+ if i < kTen {
+ {
+ if (i < five) {
+ {
+ continue;
+ }
}
- continuing {
- i = i + f32(1);
- }
+ sum = sum + i;
+ }
+ } else {
+ break;
}
+ continuing {
+ i = i + f32(1);
+ }
+ }
}
return sum;
+ }
}
fn break_loop_ff(five: f32) -> f32 {
+ {
var sum: f32 = 0.0;
let kOne: f32 = 1.0;
{
- var i: f32 = 0.0;
- loop {
- if i < 10.0 {
- {
- if (i > five) {
- {
- break;
- }
- }
- sum = sum + i;
- }
- } else {
+ var i: f32 = 0.0;
+ loop {
+ if i < 10.0 {
+ {
+ if (i > five) {
+ {
break;
+ }
}
- continuing {
- i = i + kOne;
- }
+ sum = sum + i;
+ }
+ } else {
+ break;
}
+ continuing {
+ i = i + kOne;
+ }
+ }
}
return sum;
+ }
}
fn float_loop_f() -> f32 {
+ {
var sum: f32 = 0.0;
{
- var i: f32 = 0.123;
- loop {
- if i < 0.6 {
- {
- sum = sum + i;
- }
- } else {
- break;
- }
- continuing {
- i = i + 0.111;
- }
+ var i: f32 = 0.123;
+ loop {
+ if i < 0.6 {
+ {
+ sum = sum + i;
+ }
+ } else {
+ break;
}
+ continuing {
+ i = i + 0.111;
+ }
+ }
}
return sum - 1.725;
+ }
}
fn loop_operator_le_b() -> bool {
+ {
var result: vec4<f32> = vec4<f32>(9.0);
{
- var i: f32 = 1.0;
- loop {
- if i <= 3.0 {
- {
- result = vec4<f32>(result.yzw, i);
- }
- } else {
- break;
- }
- continuing {
- i = i + f32(1);
- }
+ var i: f32 = 1.0;
+ loop {
+ if i <= 3.0 {
+ {
+ result = vec4<f32>(result.yzw, i);
+ }
+ } else {
+ break;
}
+ continuing {
+ i = i + f32(1);
+ }
+ }
}
return all(result == vec4<f32>(9.0, 1.0, 2.0, 3.0));
+ }
}
fn loop_operator_lt_b() -> bool {
+ {
var result: vec4<f32> = vec4<f32>(9.0);
{
- var i: f32 = 1.0;
- loop {
- if i < 4.0 {
- {
- result = vec4<f32>(result.yzw, i);
- }
- } else {
- break;
- }
- continuing {
- i = i + f32(1);
- }
+ var i: f32 = 1.0;
+ loop {
+ if i < 4.0 {
+ {
+ result = vec4<f32>(result.yzw, i);
+ }
+ } else {
+ break;
}
+ continuing {
+ i = i + f32(1);
+ }
+ }
}
return all(result == vec4<f32>(9.0, 1.0, 2.0, 3.0));
+ }
}
fn loop_operator_ge_b() -> bool {
+ {
var result: vec4<f32> = vec4<f32>(9.0);
{
- var i: f32 = 3.0;
- loop {
- if i >= 1.0 {
- {
- result = vec4<f32>(result.yzw, i);
- }
- } else {
- break;
- }
- continuing {
- i = i - f32(1);
- }
+ var i: f32 = 3.0;
+ loop {
+ if i >= 1.0 {
+ {
+ result = vec4<f32>(result.yzw, i);
+ }
+ } else {
+ break;
}
+ continuing {
+ i = i - f32(1);
+ }
+ }
}
return all(result == vec4<f32>(9.0, 3.0, 2.0, 1.0));
+ }
}
fn loop_operator_gt_b() -> bool {
+ {
var result: vec4<f32> = vec4<f32>(9.0);
{
- var i: f32 = 3.0;
- loop {
- if i > 0.0 {
- {
- result = vec4<f32>(result.yzw, i);
- }
- } else {
- break;
- }
- continuing {
- i = i - f32(1);
- }
+ var i: f32 = 3.0;
+ loop {
+ if i > 0.0 {
+ {
+ result = vec4<f32>(result.yzw, i);
+ }
+ } else {
+ break;
}
+ continuing {
+ i = i - f32(1);
+ }
+ }
}
return all(result == vec4<f32>(9.0, 3.0, 2.0, 1.0));
+ }
}
fn loop_operator_ne_b() -> bool {
+ {
var result: vec4<f32> = vec4<f32>(9.0);
{
- var i: f32 = 1.0;
- loop {
- if i < 4.0 {
- {
- result = vec4<f32>(result.yzw, i);
- }
- } else {
- break;
- }
- continuing {
- i = i + f32(1);
- }
+ var i: f32 = 1.0;
+ loop {
+ if i < 4.0 {
+ {
+ result = vec4<f32>(result.yzw, i);
+ }
+ } else {
+ break;
}
+ continuing {
+ i = i + f32(1);
+ }
+ }
}
return all(result == vec4<f32>(9.0, 1.0, 2.0, 3.0));
+ }
}
fn loop_operator_eq_b() -> bool {
+ {
var result: vec4<f32> = vec4<f32>(9.0);
{
- var i: f32 = 1.0;
- loop {
- if i == 1.0 {
- {
- result = vec4<f32>(result.yzw, i);
- }
- } else {
- break;
- }
- continuing {
- i = i + f32(1);
- }
+ var i: f32 = 1.0;
+ loop {
+ if i == 1.0 {
+ {
+ result = vec4<f32>(result.yzw, i);
+ }
+ } else {
+ break;
}
+ continuing {
+ i = i + f32(1);
+ }
+ }
}
return all(result == vec4<f32>(9.0, 9.0, 9.0, 1.0));
+ }
}
fn main(pos: vec2<f32>) -> vec4<f32> {
+ {
let _skTemp0 = clamp(pos.x, f32(_globalUniforms.colorGreen.y), f32(_globalUniforms.colorGreen.w));
var five: f32 = _skTemp0 * 5.0;
var _skTemp1: vec4<f32>;
@@ -224,67 +245,68 @@
var _skTemp10: bool;
let _skTemp11 = return_loop_ff(five);
if _skTemp11 == 5.0 {
- let _skTemp12 = continue_loop_ff(five);
- _skTemp10 = _skTemp12 == 35.0;
+ let _skTemp12 = continue_loop_ff(five);
+ _skTemp10 = _skTemp12 == 35.0;
} else {
- _skTemp10 = false;
+ _skTemp10 = false;
}
if _skTemp10 {
- let _skTemp13 = break_loop_ff(five);
- _skTemp9 = _skTemp13 == 15.0;
+ let _skTemp13 = break_loop_ff(five);
+ _skTemp9 = _skTemp13 == 15.0;
} else {
- _skTemp9 = false;
+ _skTemp9 = false;
}
if _skTemp9 {
- let _skTemp14 = float_loop_f();
- let _skTemp15 = abs(_skTemp14);
- _skTemp8 = _skTemp15 < 0.025;
+ let _skTemp14 = float_loop_f();
+ let _skTemp15 = abs(_skTemp14);
+ _skTemp8 = _skTemp15 < 0.025;
} else {
- _skTemp8 = false;
+ _skTemp8 = false;
}
if _skTemp8 {
- let _skTemp16 = loop_operator_le_b();
- _skTemp7 = _skTemp16;
+ let _skTemp16 = loop_operator_le_b();
+ _skTemp7 = _skTemp16;
} else {
- _skTemp7 = false;
+ _skTemp7 = false;
}
if _skTemp7 {
- let _skTemp17 = loop_operator_lt_b();
- _skTemp6 = _skTemp17;
+ let _skTemp17 = loop_operator_lt_b();
+ _skTemp6 = _skTemp17;
} else {
- _skTemp6 = false;
+ _skTemp6 = false;
}
if _skTemp6 {
- let _skTemp18 = loop_operator_ge_b();
- _skTemp5 = _skTemp18;
+ let _skTemp18 = loop_operator_ge_b();
+ _skTemp5 = _skTemp18;
} else {
- _skTemp5 = false;
+ _skTemp5 = false;
}
if _skTemp5 {
- let _skTemp19 = loop_operator_gt_b();
- _skTemp4 = _skTemp19;
+ let _skTemp19 = loop_operator_gt_b();
+ _skTemp4 = _skTemp19;
} else {
- _skTemp4 = false;
+ _skTemp4 = false;
}
if _skTemp4 {
- let _skTemp20 = loop_operator_eq_b();
- _skTemp3 = _skTemp20;
+ let _skTemp20 = loop_operator_eq_b();
+ _skTemp3 = _skTemp20;
} else {
- _skTemp3 = false;
+ _skTemp3 = false;
}
if _skTemp3 {
- let _skTemp21 = loop_operator_ne_b();
- _skTemp2 = _skTemp21;
+ let _skTemp21 = loop_operator_ne_b();
+ _skTemp2 = _skTemp21;
} else {
- _skTemp2 = false;
+ _skTemp2 = false;
}
if _skTemp2 {
- _skTemp1 = _globalUniforms.colorGreen;
+ _skTemp1 = _globalUniforms.colorGreen;
} else {
- _skTemp1 = _globalUniforms.colorRed;
+ _skTemp1 = _globalUniforms.colorRed;
}
return _skTemp1;
+ }
}
@fragment fn runtimeShaderMain(@location(0) _coords: vec2<f32>) -> @location(0) vec4<f32> {
- return main(_coords);
+ return main(_coords);
}
diff --git a/tests/sksl/runtime/LoopInt.wgsl b/tests/sksl/runtime/LoopInt.wgsl
index 067412a..3bf6871 100644
--- a/tests/sksl/runtime/LoopInt.wgsl
+++ b/tests/sksl/runtime/LoopInt.wgsl
@@ -1,196 +1,215 @@
struct _GlobalUniforms {
- colorRed: vec4<f32>,
- colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
+ colorGreen: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
const kZero: i32 = 0;
fn return_loop_ii(five: i32) -> i32 {
+ {
{
- var i: i32 = kZero;
- loop {
- if i < 10 {
- {
- if (i == five) {
- {
- return i;
- }
- }
- }
- } else {
- break;
+ var i: i32 = kZero;
+ loop {
+ if i < 10 {
+ {
+ if (i == five) {
+ {
+ return i;
+ }
}
- continuing {
- i = i + i32(1);
- }
+ }
+ } else {
+ break;
}
+ continuing {
+ i = i + i32(1);
+ }
+ }
}
return 0;
+ }
}
const kTen: i32 = 10;
fn continue_loop_ii(five: i32) -> i32 {
+ {
var sum: i32 = 0;
{
- var i: i32 = 0;
- loop {
- if i < kTen {
- {
- if (i < five) {
- {
- continue;
- }
- }
- sum = sum + i;
- }
- } else {
- break;
+ var i: i32 = 0;
+ loop {
+ if i < kTen {
+ {
+ if (i < five) {
+ {
+ continue;
+ }
}
- continuing {
- i = i + i32(1);
- }
+ sum = sum + i;
+ }
+ } else {
+ break;
}
+ continuing {
+ i = i + i32(1);
+ }
+ }
}
return sum;
+ }
}
fn break_loop_ii(five: i32) -> i32 {
+ {
var sum: i32 = 0;
let kOne: i32 = 1;
{
- var i: i32 = 0;
- loop {
- if i < 10 {
- {
- if (i > five) {
- {
- break;
- }
- }
- sum = sum + i;
- }
- } else {
+ var i: i32 = 0;
+ loop {
+ if i < 10 {
+ {
+ if (i > five) {
+ {
break;
+ }
}
- continuing {
- i = i + kOne;
- }
+ sum = sum + i;
+ }
+ } else {
+ break;
}
+ continuing {
+ i = i + kOne;
+ }
+ }
}
return sum;
+ }
}
fn loop_operator_le_b() -> bool {
+ {
var result: vec4<i32> = vec4<i32>(9);
{
- var i: i32 = 1;
- loop {
- if i <= 3 {
- {
- result = vec4<i32>(result.yzw, i);
- }
- } else {
- break;
- }
- continuing {
- i = i + i32(1);
- }
+ var i: i32 = 1;
+ loop {
+ if i <= 3 {
+ {
+ result = vec4<i32>(result.yzw, i);
+ }
+ } else {
+ break;
}
+ continuing {
+ i = i + i32(1);
+ }
+ }
}
return all(result == vec4<i32>(9, 1, 2, 3));
+ }
}
fn loop_operator_lt_b() -> bool {
+ {
var result: vec4<i32> = vec4<i32>(9);
{
- var i: i32 = 1;
- loop {
- if i < 4 {
- {
- result = vec4<i32>(result.yzw, i);
- }
- } else {
- break;
- }
- continuing {
- i = i + i32(1);
- }
+ var i: i32 = 1;
+ loop {
+ if i < 4 {
+ {
+ result = vec4<i32>(result.yzw, i);
+ }
+ } else {
+ break;
}
+ continuing {
+ i = i + i32(1);
+ }
+ }
}
return all(result == vec4<i32>(9, 1, 2, 3));
+ }
}
fn loop_operator_ge_b() -> bool {
+ {
var result: vec4<i32> = vec4<i32>(9);
{
- var i: i32 = 3;
- loop {
- if i >= 1 {
- {
- result = vec4<i32>(result.yzw, i);
- }
- } else {
- break;
- }
- continuing {
- i = i - i32(1);
- }
+ var i: i32 = 3;
+ loop {
+ if i >= 1 {
+ {
+ result = vec4<i32>(result.yzw, i);
+ }
+ } else {
+ break;
}
+ continuing {
+ i = i - i32(1);
+ }
+ }
}
return all(result == vec4<i32>(9, 3, 2, 1));
+ }
}
fn loop_operator_gt_b() -> bool {
+ {
var result: vec4<i32> = vec4<i32>(9);
{
- var i: i32 = 3;
- loop {
- if i > 0 {
- {
- result = vec4<i32>(result.yzw, i);
- }
- } else {
- break;
- }
- continuing {
- i = i - i32(1);
- }
+ var i: i32 = 3;
+ loop {
+ if i > 0 {
+ {
+ result = vec4<i32>(result.yzw, i);
+ }
+ } else {
+ break;
}
+ continuing {
+ i = i - i32(1);
+ }
+ }
}
return all(result == vec4<i32>(9, 3, 2, 1));
+ }
}
fn loop_operator_ne_b() -> bool {
+ {
var result: vec4<i32> = vec4<i32>(9);
{
- var i: i32 = 1;
- loop {
- if i != 4 {
- {
- result = vec4<i32>(result.yzw, i);
- }
- } else {
- break;
- }
- continuing {
- i = i + i32(1);
- }
+ var i: i32 = 1;
+ loop {
+ if i != 4 {
+ {
+ result = vec4<i32>(result.yzw, i);
+ }
+ } else {
+ break;
}
+ continuing {
+ i = i + i32(1);
+ }
+ }
}
return all(result == vec4<i32>(9, 1, 2, 3));
+ }
}
fn loop_operator_eq_b() -> bool {
+ {
var result: vec4<i32> = vec4<i32>(9);
{
- var i: i32 = 1;
- loop {
- if i == 1 {
- {
- result = vec4<i32>(result.yzw, i);
- }
- } else {
- break;
- }
- continuing {
- i = i + i32(1);
- }
+ var i: i32 = 1;
+ loop {
+ if i == 1 {
+ {
+ result = vec4<i32>(result.yzw, i);
+ }
+ } else {
+ break;
}
+ continuing {
+ i = i + i32(1);
+ }
+ }
}
return all(result == vec4<i32>(9, 9, 9, 1));
+ }
}
fn main(pos: vec2<f32>) -> vec4<f32> {
+ {
let _skTemp0 = clamp(pos.x, f32(_globalUniforms.colorGreen.y), f32(_globalUniforms.colorGreen.w));
var five: i32 = i32(_skTemp0) * 5;
var _skTemp1: vec4<f32>;
@@ -204,60 +223,61 @@
var _skTemp9: bool;
let _skTemp10 = return_loop_ii(five);
if _skTemp10 == 5 {
- let _skTemp11 = continue_loop_ii(five);
- _skTemp9 = _skTemp11 == 35;
+ let _skTemp11 = continue_loop_ii(five);
+ _skTemp9 = _skTemp11 == 35;
} else {
- _skTemp9 = false;
+ _skTemp9 = false;
}
if _skTemp9 {
- let _skTemp12 = break_loop_ii(5);
- _skTemp8 = _skTemp12 == 15;
+ let _skTemp12 = break_loop_ii(5);
+ _skTemp8 = _skTemp12 == 15;
} else {
- _skTemp8 = false;
+ _skTemp8 = false;
}
if _skTemp8 {
- let _skTemp13 = loop_operator_le_b();
- _skTemp7 = _skTemp13;
+ let _skTemp13 = loop_operator_le_b();
+ _skTemp7 = _skTemp13;
} else {
- _skTemp7 = false;
+ _skTemp7 = false;
}
if _skTemp7 {
- let _skTemp14 = loop_operator_lt_b();
- _skTemp6 = _skTemp14;
+ let _skTemp14 = loop_operator_lt_b();
+ _skTemp6 = _skTemp14;
} else {
- _skTemp6 = false;
+ _skTemp6 = false;
}
if _skTemp6 {
- let _skTemp15 = loop_operator_ge_b();
- _skTemp5 = _skTemp15;
+ let _skTemp15 = loop_operator_ge_b();
+ _skTemp5 = _skTemp15;
} else {
- _skTemp5 = false;
+ _skTemp5 = false;
}
if _skTemp5 {
- let _skTemp16 = loop_operator_gt_b();
- _skTemp4 = _skTemp16;
+ let _skTemp16 = loop_operator_gt_b();
+ _skTemp4 = _skTemp16;
} else {
- _skTemp4 = false;
+ _skTemp4 = false;
}
if _skTemp4 {
- let _skTemp17 = loop_operator_eq_b();
- _skTemp3 = _skTemp17;
+ let _skTemp17 = loop_operator_eq_b();
+ _skTemp3 = _skTemp17;
} else {
- _skTemp3 = false;
+ _skTemp3 = false;
}
if _skTemp3 {
- let _skTemp18 = loop_operator_ne_b();
- _skTemp2 = _skTemp18;
+ let _skTemp18 = loop_operator_ne_b();
+ _skTemp2 = _skTemp18;
} else {
- _skTemp2 = false;
+ _skTemp2 = false;
}
if _skTemp2 {
- _skTemp1 = _globalUniforms.colorGreen;
+ _skTemp1 = _globalUniforms.colorGreen;
} else {
- _skTemp1 = _globalUniforms.colorRed;
+ _skTemp1 = _globalUniforms.colorRed;
}
return _skTemp1;
+ }
}
@fragment fn runtimeShaderMain(@location(0) _coords: vec2<f32>) -> @location(0) vec4<f32> {
- return main(_coords);
+ return main(_coords);
}
diff --git a/tests/sksl/shared/ArrayConstructors.wgsl b/tests/sksl/shared/ArrayConstructors.wgsl
index cdfb9cb..2224fb9 100644
--- a/tests/sksl/shared/ArrayConstructors.wgsl
+++ b/tests/sksl/shared/ArrayConstructors.wgsl
@@ -1,23 +1,25 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var test1: array<f32, 4> = array<f32, 4>(1.0, 2.0, 3.0, 4.0);
var test2: array<vec2<f32>, 2> = array<vec2<f32>, 2>(vec2<f32>(1.0, 2.0), vec2<f32>(3.0, 4.0));
var test3: array<mat4x4<f32>, 1> = array<mat4x4<f32>, 1>(mat4x4<f32>(16.0, 0.0, 0.0, 0.0, 0.0, 16.0, 0.0, 0.0, 0.0, 0.0, 16.0, 0.0, 0.0, 0.0, 0.0, 16.0));
return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>((test1[3] + test2[1].y) + test3[0][3].w == 24.0));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/ArrayFollowedByScalar.wgsl b/tests/sksl/shared/ArrayFollowedByScalar.wgsl
index febaf80..2d2dc11 100644
--- a/tests/sksl/shared/ArrayFollowedByScalar.wgsl
+++ b/tests/sksl/shared/ArrayFollowedByScalar.wgsl
@@ -1,11 +1,12 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var rgb: array<f32, 3>;
var a: f32;
rgb[0] = 0.0;
@@ -13,9 +14,10 @@
rgb[2] = 0.0;
a = 1.0;
return vec4<f32>(rgb[0], rgb[1], rgb[2], a);
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/ArrayIndexTypes.wgsl b/tests/sksl/shared/ArrayIndexTypes.wgsl
index 038d2e0..f1bedf5 100644
--- a/tests/sksl/shared/ArrayIndexTypes.wgsl
+++ b/tests/sksl/shared/ArrayIndexTypes.wgsl
@@ -1,19 +1,21 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(front_facing) sk_Clockwise: bool,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
fn main(_stageOut: ptr<function, FSOut>) {
+ {
var _array: array<f32, 4> = array<f32, 4>(1.0, 2.0, 3.0, 4.0);
var x: i32 = 0;
var y: u32 = 1u;
var z: i32 = 2;
var w: u32 = 3u;
(*_stageOut).sk_FragColor = vec4<f32>(f32(_array[x]), f32(_array[y]), f32(_array[z]), f32(_array[w]));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- main(&_stageOut);
- return _stageOut;
+ var _stageOut: FSOut;
+ main(&_stageOut);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/ArrayTypes.wgsl b/tests/sksl/shared/ArrayTypes.wgsl
index 4e102b4..9c218ff 100644
--- a/tests/sksl/shared/ArrayTypes.wgsl
+++ b/tests/sksl/shared/ArrayTypes.wgsl
@@ -1,18 +1,21 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct S {
- v: vec2<f32>,
+ v: vec2<f32>,
};
fn initialize_vS(z: ptr<function, array<S, 2>>) {
+ {
(*z)[0].v = vec2<f32>(0.0, 1.0);
(*z)[1].v = vec2<f32>(2.0, 1.0);
+ }
}
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var x: array<vec2<f32>, 2>;
x[0] = vec2<f32>(0.0);
x[1] = vec2<f32>(1.0, 0.0);
@@ -24,9 +27,10 @@
initialize_vS(&_skTemp0);
z = _skTemp0;
return vec4<f32>(f32(x[0].x * x[0].y + z[0].v.x), f32(x[1].x - x[1].y * z[0].v.y), f32((y[0].x / y[0].y) / z[1].v.x), f32(y[1].x + y[1].y * z[1].v.y));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/CommaMixedTypes.wgsl b/tests/sksl/shared/CommaMixedTypes.wgsl
index c284654..4a7abe9 100644
--- a/tests/sksl/shared/CommaMixedTypes.wgsl
+++ b/tests/sksl/shared/CommaMixedTypes.wgsl
@@ -1,25 +1,27 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- unknownInput: f32,
+ colorGreen: vec4<f32>,
+ unknownInput: f32,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var result: vec4<f32>;
result.x = _globalUniforms.colorGreen.x;
result.y = _globalUniforms.colorGreen.y;
result.z = _globalUniforms.colorGreen.z;
result.w = _globalUniforms.colorGreen.w;
return result;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/CommaSideEffects.wgsl b/tests/sksl/shared/CommaSideEffects.wgsl
index 0764320..3058bc9 100644
--- a/tests/sksl/shared/CommaSideEffects.wgsl
+++ b/tests/sksl/shared/CommaSideEffects.wgsl
@@ -1,21 +1,24 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorRed: vec4<f32>,
- colorGreen: vec4<f32>,
- colorWhite: vec4<f32>,
- colorBlack: vec4<f32>,
+ colorRed: vec4<f32>,
+ colorGreen: vec4<f32>,
+ colorWhite: vec4<f32>,
+ colorBlack: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn setToColorBlack_vh4(x: ptr<function, vec4<f32>>) {
+ {
(*x) = _globalUniforms.colorBlack;
+ }
}
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var a: vec4<f32>;
var b: vec4<f32>;
var c: vec4<f32>;
@@ -31,9 +34,10 @@
c = c * c;
d = d * d;
return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>(((all(a == _globalUniforms.colorWhite) && all(b == _globalUniforms.colorRed)) && all(c == _globalUniforms.colorGreen)) && all(d == _globalUniforms.colorBlack)));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/ConstArray.wgsl b/tests/sksl/shared/ConstArray.wgsl
index d5503d1..0608fb6 100644
--- a/tests/sksl/shared/ConstArray.wgsl
+++ b/tests/sksl/shared/ConstArray.wgsl
@@ -1,15 +1,17 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
fn main(xy: vec2<f32>) -> vec4<f32> {
+ {
return vec4<f32>(0.0, 1.0, 0.0, 1.0);
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/ConstGlobal.wgsl b/tests/sksl/shared/ConstGlobal.wgsl
index 4ecb52e..d035c4f 100644
--- a/tests/sksl/shared/ConstGlobal.wgsl
+++ b/tests/sksl/shared/ConstGlobal.wgsl
@@ -1,35 +1,39 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
const SEVEN: i32 = 7;
const TEN: i32 = 10;
const MATRIXFIVE: mat4x4<f32> = mat4x4<f32>(5.0, 0.0, 0.0, 0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 5.0);
fn verify_const_globals_biih44(seven: i32, ten: i32, matrixFive: mat4x4<f32>) -> bool {
+ {
let _skTemp0 = matrixFive;
let _skTemp1 = mat4x4<f32>(5.0, 0.0, 0.0, 0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 5.0);
return (seven == 7 && ten == 10) && (all(_skTemp0[0] == _skTemp1[0]) && all(_skTemp0[1] == _skTemp1[1]) && all(_skTemp0[2] == _skTemp1[2]) && all(_skTemp0[3] == _skTemp1[3]));
+ }
}
fn main(xy: vec2<f32>) -> vec4<f32> {
+ {
var _skTemp2: vec4<f32>;
let _skTemp3 = verify_const_globals_biih44(SEVEN, TEN, MATRIXFIVE);
if _skTemp3 {
- _skTemp2 = _globalUniforms.colorGreen;
+ _skTemp2 = _globalUniforms.colorGreen;
} else {
- _skTemp2 = _globalUniforms.colorRed;
+ _skTemp2 = _globalUniforms.colorRed;
}
return _skTemp2;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/ConstantIf.wgsl b/tests/sksl/shared/ConstantIf.wgsl
index 1af772c..a42cfea 100644
--- a/tests/sksl/shared/ConstantIf.wgsl
+++ b/tests/sksl/shared/ConstantIf.wgsl
@@ -1,16 +1,17 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var a: i32 = 0;
var b: i32 = 0;
var c: i32 = 0;
@@ -19,9 +20,10 @@
b = 2;
c = 5;
return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>(((a == 1 && b == 2) && c == 5) && d == 0));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/DeadDoWhileLoop.wgsl b/tests/sksl/shared/DeadDoWhileLoop.wgsl
index ddce8ac..385e8e3 100644
--- a/tests/sksl/shared/DeadDoWhileLoop.wgsl
+++ b/tests/sksl/shared/DeadDoWhileLoop.wgsl
@@ -1,21 +1,23 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(front_facing) sk_Clockwise: bool,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
fn main(_stageOut: ptr<function, FSOut>) {
+ {
loop {
- {
- (*_stageOut).sk_FragColor = vec4<f32>(1.0);
- }
- continuing {
- break if !(false);
- }
+ {
+ (*_stageOut).sk_FragColor = vec4<f32>(1.0);
+ }
+ continuing {
+ break if !(false);
+ }
}
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- main(&_stageOut);
- return _stageOut;
+ var _stageOut: FSOut;
+ main(&_stageOut);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/DeadReturn.wgsl b/tests/sksl/shared/DeadReturn.wgsl
index 3de92ee..f5d42b6 100644
--- a/tests/sksl/shared/DeadReturn.wgsl
+++ b/tests/sksl/shared/DeadReturn.wgsl
@@ -1,103 +1,113 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
var<private> scratchVar: i32 = 0;
fn test_flat_b() -> bool {
+ {
return true;
+ }
}
fn test_if_b() -> bool {
+ {
if (_globalUniforms.colorGreen.y > 0.0) {
- {
- return true;
- }
+ {
+ return true;
+ }
} else {
- {
- scratchVar = scratchVar + i32(1);
- }
+ {
+ scratchVar = scratchVar + i32(1);
+ }
}
scratchVar = scratchVar + i32(1);
return false;
+ }
}
fn test_else_b() -> bool {
+ {
if (_globalUniforms.colorGreen.y == 0.0) {
- {
- return false;
- }
+ {
+ return false;
+ }
} else {
- {
- return true;
- }
+ {
+ return true;
+ }
}
+ }
}
fn test_loop_if_b() -> bool {
+ {
{
- var x: i32 = 0;
- loop {
- if x <= 1 {
- {
- if (_globalUniforms.colorGreen.y == 0.0) {
- {
- return false;
- }
- } else {
- {
- return true;
- }
- }
- }
+ var x: i32 = 0;
+ loop {
+ if x <= 1 {
+ {
+ if (_globalUniforms.colorGreen.y == 0.0) {
+ {
+ return false;
+ }
} else {
- break;
+ {
+ return true;
+ }
}
- continuing {
- x = x + i32(1);
- }
+ }
+ } else {
+ break;
}
+ continuing {
+ x = x + i32(1);
+ }
+ }
}
scratchVar = scratchVar + i32(1);
return true;
+ }
}
fn main(xy: vec2<f32>) -> vec4<f32> {
+ {
var _skTemp0: vec4<f32>;
var _skTemp1: bool;
var _skTemp2: bool;
var _skTemp3: bool;
let _skTemp4 = test_flat_b();
if _skTemp4 {
- let _skTemp5 = test_if_b();
- _skTemp3 = _skTemp5;
+ let _skTemp5 = test_if_b();
+ _skTemp3 = _skTemp5;
} else {
- _skTemp3 = false;
+ _skTemp3 = false;
}
if _skTemp3 {
- let _skTemp6 = test_else_b();
- _skTemp2 = _skTemp6;
+ let _skTemp6 = test_else_b();
+ _skTemp2 = _skTemp6;
} else {
- _skTemp2 = false;
+ _skTemp2 = false;
}
if _skTemp2 {
- let _skTemp7 = test_loop_if_b();
- _skTemp1 = _skTemp7;
+ let _skTemp7 = test_loop_if_b();
+ _skTemp1 = _skTemp7;
} else {
- _skTemp1 = false;
+ _skTemp1 = false;
}
if _skTemp1 {
- _skTemp0 = _globalUniforms.colorGreen;
+ _skTemp0 = _globalUniforms.colorGreen;
} else {
- _skTemp0 = _globalUniforms.colorRed;
+ _skTemp0 = _globalUniforms.colorRed;
}
return _skTemp0;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/DoWhileControlFlow.wgsl b/tests/sksl/shared/DoWhileControlFlow.wgsl
index 8711ea0..404e65b 100644
--- a/tests/sksl/shared/DoWhileControlFlow.wgsl
+++ b/tests/sksl/shared/DoWhileControlFlow.wgsl
@@ -1,39 +1,41 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var x: vec4<f32> = vec4<f32>(1.0);
loop {
- {
- x.x = x.x - 0.25;
- if (x.x <= 0.0) {
- break;
- }
+ {
+ x.x = x.x - 0.25;
+ if (x.x <= 0.0) {
+ break;
}
- continuing {
- break if !(x.w == 1.0);
- }
+ }
+ continuing {
+ break if !(x.w == 1.0);
+ }
}
loop {
- {
- x.z = x.z - 0.25;
- if (x.w == 1.0) {
- continue;
- }
- x.y = 0.0;
+ {
+ x.z = x.z - 0.25;
+ if (x.w == 1.0) {
+ continue;
}
- continuing {
- break if !(x.z > 0.0);
- }
+ x.y = 0.0;
+ }
+ continuing {
+ break if !(x.z > 0.0);
+ }
}
return x;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/EmptyBlocksES2.wgsl b/tests/sksl/shared/EmptyBlocksES2.wgsl
index 6a2a5f1..543a536 100644
--- a/tests/sksl/shared/EmptyBlocksES2.wgsl
+++ b/tests/sksl/shared/EmptyBlocksES2.wgsl
@@ -1,28 +1,30 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- unknownInput: f32,
+ unknownInput: f32,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var color: vec4<f32> = vec4<f32>(0.0);
if (_globalUniforms.unknownInput == 1.0) {
- color.y = 1.0;
+ color.y = 1.0;
}
if (_globalUniforms.unknownInput == 2.0) {
- ;
+ ;
} else {
- color.w = 1.0;
+ color.w = 1.0;
}
return color;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/EmptyBlocksES3.wgsl b/tests/sksl/shared/EmptyBlocksES3.wgsl
index b4a4d98..830f659 100644
--- a/tests/sksl/shared/EmptyBlocksES3.wgsl
+++ b/tests/sksl/shared/EmptyBlocksES3.wgsl
@@ -1,41 +1,43 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorWhite: vec4<f32>,
+ colorWhite: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var color: vec4<f32> = vec4<f32>(0.0);
if (_globalUniforms.colorWhite.x == 1.0) {
- color.y = 1.0;
+ color.y = 1.0;
}
if (_globalUniforms.colorWhite.x == 2.0) {
- ;
+ ;
} else {
- color.w = 1.0;
+ color.w = 1.0;
}
loop {
- if _globalUniforms.colorWhite.x == 2.0 {
- ;
- } else {
- break;
- }
- }
- loop {
+ if _globalUniforms.colorWhite.x == 2.0 {
;
- continuing {
- break if !(_globalUniforms.colorWhite.x == 2.0);
- }
+ } else {
+ break;
+ }
+ }
+ loop {
+ ;
+ continuing {
+ break if !(_globalUniforms.colorWhite.x == 2.0);
+ }
}
return color;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/ForLoopMultipleInit.wgsl b/tests/sksl/shared/ForLoopMultipleInit.wgsl
index e991de6..67e82a7 100644
--- a/tests/sksl/shared/ForLoopMultipleInit.wgsl
+++ b/tests/sksl/shared/ForLoopMultipleInit.wgsl
@@ -1,78 +1,80 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var result: vec4<f32> = vec4<f32>(0.0);
{
- var a: f32 = 0.0;
- var b: f32 = 0.0;
- loop {
- if a < 10.0 && b < 10.0 {
- {
- result.x = result.x + a;
- result.y = result.y + b;
- }
- } else {
- break;
- }
- continuing {
- a = a + f32(1);
- b = b + f32(1);
- }
+ var a: f32 = 0.0;
+ var b: f32 = 0.0;
+ loop {
+ if a < 10.0 && b < 10.0 {
+ {
+ result.x = result.x + a;
+ result.y = result.y + b;
+ }
+ } else {
+ break;
}
+ continuing {
+ a = a + f32(1);
+ b = b + f32(1);
+ }
+ }
}
{
- var c: i32 = 0;
- loop {
- if c < 10 {
- {
- result.z = result.z + 1.0;
- }
- } else {
- break;
- }
- continuing {
- c = c + i32(1);
- }
+ var c: i32 = 0;
+ loop {
+ if c < 10 {
+ {
+ result.z = result.z + 1.0;
+ }
+ } else {
+ break;
}
+ continuing {
+ c = c + i32(1);
+ }
+ }
}
{
- var d: array<f32, 2> = array<f32, 2>(0.0, 10.0);
- var e: array<f32, 4> = array<f32, 4>(1.0, 2.0, 3.0, 4.0);
- var f: f32 = 9.0;
- loop {
- if d[0] < d[1] {
- {
- result.w = f32(e[0] * f);
- }
- } else {
- break;
- }
- continuing {
- d[0] = d[0] + f32(1);
- }
+ var d: array<f32, 2> = array<f32, 2>(0.0, 10.0);
+ var e: array<f32, 4> = array<f32, 4>(1.0, 2.0, 3.0, 4.0);
+ var f: f32 = 9.0;
+ loop {
+ if d[0] < d[1] {
+ {
+ result.w = f32(e[0] * f);
+ }
+ } else {
+ break;
}
+ continuing {
+ d[0] = d[0] + f32(1);
+ }
+ }
}
{
- loop {
- break;
- }
+ loop {
+ break;
+ }
}
{
- ;
+ ;
- loop {
- break;
- }
+ loop {
+ break;
+ }
}
return result;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/FunctionAnonymousParameters.wgsl b/tests/sksl/shared/FunctionAnonymousParameters.wgsl
index 5b304a4..9b6e138 100644
--- a/tests/sksl/shared/FunctionAnonymousParameters.wgsl
+++ b/tests/sksl/shared/FunctionAnonymousParameters.wgsl
@@ -1,37 +1,43 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
struct S {
- i: i32,
+ i: i32,
};
fn fnGreen_h4bf2(b: bool, _skAnonymous0: vec2<f32>) -> vec4<f32> {
+ {
return _globalUniforms.colorGreen;
+ }
}
fn fnRed_h4ifS(_skAnonymous1: i32, f: f32, _skAnonymous2: S) -> vec4<f32> {
+ {
return _globalUniforms.colorRed;
+ }
}
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var _skTemp3: vec4<f32>;
if bool(_globalUniforms.colorGreen.y) {
- let _skTemp4 = fnGreen_h4bf2(true, coords);
- _skTemp3 = _skTemp4;
+ let _skTemp4 = fnGreen_h4bf2(true, coords);
+ _skTemp3 = _skTemp4;
} else {
- let _skTemp5 = fnRed_h4ifS(123, 3.14, S(0));
- _skTemp3 = _skTemp5;
+ let _skTemp5 = fnRed_h4ifS(123, 3.14, S(0));
+ _skTemp3 = _skTemp5;
}
return _skTemp3;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/HelloWorld.wgsl b/tests/sksl/shared/HelloWorld.wgsl
index 9785171..6416410 100644
--- a/tests/sksl/shared/HelloWorld.wgsl
+++ b/tests/sksl/shared/HelloWorld.wgsl
@@ -1,15 +1,17 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
return vec4<f32>(0.0, 1.0, 0.0, 1.0);
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/InoutParameters.wgsl b/tests/sksl/shared/InoutParameters.wgsl
index 766b9a3..0d60145 100644
--- a/tests/sksl/shared/InoutParameters.wgsl
+++ b/tests/sksl/shared/InoutParameters.wgsl
@@ -1,31 +1,40 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
+ colorGreen: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn outParameterWrite_vh4(x: ptr<function, vec4<f32>>) {
+ {
(*x) = _globalUniforms.colorGreen;
+ }
}
fn outParameterWriteIndirect_vh4(c: ptr<function, vec4<f32>>) {
+ {
var _skTemp0: vec4<f32>;
outParameterWrite_vh4(&_skTemp0);
(*c) = _skTemp0;
+ }
}
fn inoutParameterWrite_vh4(x: ptr<function, vec4<f32>>) {
+ {
(*x) = (*x) * (*x);
+ }
}
fn inoutParameterWriteIndirect_vh4(x: ptr<function, vec4<f32>>) {
+ {
var _skTemp1: vec4<f32> = (*x);
inoutParameterWrite_vh4(&_skTemp1);
(*x) = _skTemp1;
+ }
}
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var c: vec4<f32>;
var _skTemp2: vec4<f32>;
outParameterWrite_vh4(&_skTemp2);
@@ -40,9 +49,10 @@
inoutParameterWriteIndirect_vh4(&_skTemp5);
c = _skTemp5;
return c;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/InoutParamsAreDistinct.wgsl b/tests/sksl/shared/InoutParamsAreDistinct.wgsl
index 87fae1b..942f160 100644
--- a/tests/sksl/shared/InoutParamsAreDistinct.wgsl
+++ b/tests/sksl/shared/InoutParamsAreDistinct.wgsl
@@ -1,21 +1,24 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn inout_params_are_distinct_bhh(x: ptr<function, f32>, y: ptr<function, f32>) -> bool {
+ {
(*x) = 1.0;
(*y) = 2.0;
return (*x) == 1.0 && (*y) == 2.0;
+ }
}
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var x: f32 = 0.0;
var _skTemp0: vec4<f32>;
var _skTemp1: f32 = x;
@@ -24,14 +27,15 @@
x = _skTemp1;
x = _skTemp2;
if _skTemp3 {
- _skTemp0 = _globalUniforms.colorGreen;
+ _skTemp0 = _globalUniforms.colorGreen;
} else {
- _skTemp0 = _globalUniforms.colorRed;
+ _skTemp0 = _globalUniforms.colorRed;
}
return _skTemp0;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/InstanceID.wgsl b/tests/sksl/shared/InstanceID.wgsl
index 58815ee..ca4d1d9 100644
--- a/tests/sksl/shared/InstanceID.wgsl
+++ b/tests/sksl/shared/InstanceID.wgsl
@@ -1,15 +1,17 @@
struct VSIn {
- @builtin(instance_index) sk_InstanceID: u32,
+ @builtin(instance_index) sk_InstanceID: u32,
};
struct VSOut {
- @location(1) @interpolate(flat) id: i32,
- @builtin(position) sk_Position: vec4<f32>,
+ @location(1) @interpolate(flat) id: i32,
+ @builtin(position) sk_Position: vec4<f32>,
};
fn main(_stageIn: VSIn, _stageOut: ptr<function, VSOut>) {
+ {
(*_stageOut).id = i32(_stageIn.sk_InstanceID);
+ }
}
@vertex fn vertexMain(_stageIn: VSIn) -> VSOut {
- var _stageOut: VSOut;
- main(_stageIn, &_stageOut);
- return _stageOut;
+ var _stageOut: VSOut;
+ main(_stageIn, &_stageOut);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/IntegerDivisionES3.wgsl b/tests/sksl/shared/IntegerDivisionES3.wgsl
index 00a4767..a760949 100644
--- a/tests/sksl/shared/IntegerDivisionES3.wgsl
+++ b/tests/sksl/shared/IntegerDivisionES3.wgsl
@@ -1,66 +1,68 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
+ colorGreen: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var zero: i32 = i32(_globalUniforms.colorGreen.x);
var one: i32 = i32(_globalUniforms.colorGreen.y);
{
- var x: i32 = zero;
- loop {
- if x < 100 {
- {
- {
- var y: i32 = one;
- loop {
- if y < 100 {
- {
- var _0_x: i32 = x;
- var _1_result: i32 = 0;
- loop {
- if _0_x >= y {
- {
- _1_result = _1_result + i32(1);
- _0_x = _0_x - y;
- }
- } else {
- break;
- }
- }
- if (x / y != _1_result) {
- {
- return vec4<f32>(1.0, f32(f32(x) * 0.003921569), f32(f32(y) * 0.003921569), 1.0);
- }
- }
- }
- } else {
- break;
- }
- continuing {
- y = y + i32(1);
- }
+ var x: i32 = zero;
+ loop {
+ if x < 100 {
+ {
+ {
+ var y: i32 = one;
+ loop {
+ if y < 100 {
+ {
+ var _0_x: i32 = x;
+ var _1_result: i32 = 0;
+ loop {
+ if _0_x >= y {
+ {
+ _1_result = _1_result + i32(1);
+ _0_x = _0_x - y;
}
+ } else {
+ break;
+ }
}
+ if (x / y != _1_result) {
+ {
+ return vec4<f32>(1.0, f32(f32(x) * 0.003921569), f32(f32(y) * 0.003921569), 1.0);
+ }
+ }
+ }
+ } else {
+ break;
}
- } else {
- break;
+ continuing {
+ y = y + i32(1);
+ }
+ }
}
- continuing {
- x = x + i32(1);
- }
+ }
+ } else {
+ break;
}
+ continuing {
+ x = x + i32(1);
+ }
+ }
}
return _globalUniforms.colorGreen;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/LogicalAndShortCircuit.wgsl b/tests/sksl/shared/LogicalAndShortCircuit.wgsl
index 051b34e..3538f83 100644
--- a/tests/sksl/shared/LogicalAndShortCircuit.wgsl
+++ b/tests/sksl/shared/LogicalAndShortCircuit.wgsl
@@ -1,119 +1,127 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn TrueFalse_b() -> bool {
+ {
var x: i32 = 1;
var y: i32 = 1;
var _skTemp0: bool;
if x == 1 {
- y = y + 1;
- _skTemp0 = y == 3;
+ y = y + 1;
+ _skTemp0 = y == 3;
} else {
- _skTemp0 = false;
+ _skTemp0 = false;
}
if (_skTemp0) {
- {
- return false;
- }
+ {
+ return false;
+ }
} else {
- {
- return x == 1 && y == 2;
- }
+ {
+ return x == 1 && y == 2;
+ }
}
+ }
}
fn FalseTrue_b() -> bool {
+ {
var x: i32 = 1;
var y: i32 = 1;
var _skTemp1: bool;
if x == 2 {
- y = y + 1;
- _skTemp1 = y == 2;
+ y = y + 1;
+ _skTemp1 = y == 2;
} else {
- _skTemp1 = false;
+ _skTemp1 = false;
}
if (_skTemp1) {
- {
- return false;
- }
+ {
+ return false;
+ }
} else {
- {
- return x == 1 && y == 1;
- }
+ {
+ return x == 1 && y == 1;
+ }
}
+ }
}
fn FalseFalse_b() -> bool {
+ {
var x: i32 = 1;
var y: i32 = 1;
var _skTemp2: bool;
if x == 2 {
- y = y + 1;
- _skTemp2 = y == 3;
+ y = y + 1;
+ _skTemp2 = y == 3;
} else {
- _skTemp2 = false;
+ _skTemp2 = false;
}
if (_skTemp2) {
- {
- return false;
- }
+ {
+ return false;
+ }
} else {
- {
- return x == 1 && y == 1;
- }
+ {
+ return x == 1 && y == 1;
+ }
}
+ }
}
fn main(_skAnonymous3: vec2<f32>) -> vec4<f32> {
+ {
var _0_TrueTrue: bool;
var _2_y: i32 = 1;
_2_y = _2_y + 1;
if (_2_y == 2) {
- {
- _0_TrueTrue = _2_y == 2;
- }
+ {
+ _0_TrueTrue = _2_y == 2;
+ }
} else {
- {
- _0_TrueTrue = false;
- }
+ {
+ _0_TrueTrue = false;
+ }
}
var _skTemp4: vec4<f32>;
var _skTemp5: bool;
var _skTemp6: bool;
var _skTemp7: bool;
if _0_TrueTrue {
- let _skTemp8 = TrueFalse_b();
- _skTemp7 = _skTemp8;
+ let _skTemp8 = TrueFalse_b();
+ _skTemp7 = _skTemp8;
} else {
- _skTemp7 = false;
+ _skTemp7 = false;
}
if _skTemp7 {
- let _skTemp9 = FalseTrue_b();
- _skTemp6 = _skTemp9;
+ let _skTemp9 = FalseTrue_b();
+ _skTemp6 = _skTemp9;
} else {
- _skTemp6 = false;
+ _skTemp6 = false;
}
if _skTemp6 {
- let _skTemp10 = FalseFalse_b();
- _skTemp5 = _skTemp10;
+ let _skTemp10 = FalseFalse_b();
+ _skTemp5 = _skTemp10;
} else {
- _skTemp5 = false;
+ _skTemp5 = false;
}
if _skTemp5 {
- _skTemp4 = _globalUniforms.colorGreen;
+ _skTemp4 = _globalUniforms.colorGreen;
} else {
- _skTemp4 = _globalUniforms.colorRed;
+ _skTemp4 = _globalUniforms.colorRed;
}
return _skTemp4;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/LogicalOrShortCircuit.wgsl b/tests/sksl/shared/LogicalOrShortCircuit.wgsl
index 4f323dd..bd07f2c 100644
--- a/tests/sksl/shared/LogicalOrShortCircuit.wgsl
+++ b/tests/sksl/shared/LogicalOrShortCircuit.wgsl
@@ -1,112 +1,120 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn TrueFalse_b() -> bool {
+ {
var x: i32 = 1;
var y: i32 = 1;
var _skTemp0: bool;
if x == 1 {
- _skTemp0 = true;
+ _skTemp0 = true;
} else {
- y = y + 1;
- _skTemp0 = y == 3;
+ y = y + 1;
+ _skTemp0 = y == 3;
}
if (_skTemp0) {
- {
- return x == 1 && y == 1;
- }
+ {
+ return x == 1 && y == 1;
+ }
} else {
- {
- return false;
- }
+ {
+ return false;
+ }
}
+ }
}
fn FalseTrue_b() -> bool {
+ {
var x: i32 = 1;
var y: i32 = 1;
var _skTemp1: bool;
if x == 2 {
- _skTemp1 = true;
+ _skTemp1 = true;
} else {
- y = y + 1;
- _skTemp1 = y == 2;
+ y = y + 1;
+ _skTemp1 = y == 2;
}
if (_skTemp1) {
- {
- return x == 1 && y == 2;
- }
+ {
+ return x == 1 && y == 2;
+ }
} else {
- {
- return false;
- }
+ {
+ return false;
+ }
}
+ }
}
fn FalseFalse_b() -> bool {
+ {
var x: i32 = 1;
var y: i32 = 1;
var _skTemp2: bool;
if x == 2 {
- _skTemp2 = true;
+ _skTemp2 = true;
} else {
- y = y + 1;
- _skTemp2 = y == 3;
+ y = y + 1;
+ _skTemp2 = y == 3;
}
if (_skTemp2) {
- {
- return false;
- }
+ {
+ return false;
+ }
} else {
- {
- return x == 1 && y == 2;
- }
+ {
+ return x == 1 && y == 2;
+ }
}
+ }
}
fn main(_skAnonymous3: vec2<f32>) -> vec4<f32> {
+ {
var _0_TrueTrue: bool;
var _2_y: i32 = 1;
{
- _0_TrueTrue = _2_y == 1;
+ _0_TrueTrue = _2_y == 1;
}
var _skTemp4: vec4<f32>;
var _skTemp5: bool;
var _skTemp6: bool;
var _skTemp7: bool;
if _0_TrueTrue {
- let _skTemp8 = TrueFalse_b();
- _skTemp7 = _skTemp8;
+ let _skTemp8 = TrueFalse_b();
+ _skTemp7 = _skTemp8;
} else {
- _skTemp7 = false;
+ _skTemp7 = false;
}
if _skTemp7 {
- let _skTemp9 = FalseTrue_b();
- _skTemp6 = _skTemp9;
+ let _skTemp9 = FalseTrue_b();
+ _skTemp6 = _skTemp9;
} else {
- _skTemp6 = false;
+ _skTemp6 = false;
}
if _skTemp6 {
- let _skTemp10 = FalseFalse_b();
- _skTemp5 = _skTemp10;
+ let _skTemp10 = FalseFalse_b();
+ _skTemp5 = _skTemp10;
} else {
- _skTemp5 = false;
+ _skTemp5 = false;
}
if _skTemp5 {
- _skTemp4 = _globalUniforms.colorGreen;
+ _skTemp4 = _globalUniforms.colorGreen;
} else {
- _skTemp4 = _globalUniforms.colorRed;
+ _skTemp4 = _globalUniforms.colorRed;
}
return _skTemp4;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/Matrices.wgsl b/tests/sksl/shared/Matrices.wgsl
index da46caf..5a9ef0a 100644
--- a/tests/sksl/shared/Matrices.wgsl
+++ b/tests/sksl/shared/Matrices.wgsl
@@ -1,16 +1,17 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn test_half_b() -> bool {
+ {
var ok: bool = true;
var m1: mat2x2<f32> = mat2x2<f32>(1.0, 2.0, 3.0, 4.0);
let _skTemp0 = m1;
@@ -55,8 +56,10 @@
let _skTemp20 = mat4x4<f32>(9.0, 20.0, 20.0, 20.0, 20.0, 9.0, 20.0, 20.0, 20.0, 20.0, 9.0, 20.0, 20.0, 20.0, 20.0, 9.0);
ok = ok && (all(_skTemp19[0] == _skTemp20[0]) && all(_skTemp19[1] == _skTemp20[1]) && all(_skTemp19[2] == _skTemp20[2]) && all(_skTemp19[3] == _skTemp20[3]));
return ok;
+ }
}
fn test_comma_b() -> bool {
+ {
var x: mat2x2<f32>;
var y: mat2x2<f32>;
x = mat2x2<f32>(1.0, 2.0, 3.0, 4.0);
@@ -64,8 +67,10 @@
let _skTemp21 = x;
let _skTemp22 = y;
return (all(_skTemp21[0] == _skTemp22[0]) && all(_skTemp21[1] == _skTemp22[1]));
+ }
}
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var _0_ok: bool = true;
var _1_m1: mat2x2<f32> = mat2x2<f32>(1.0, 2.0, 3.0, 4.0);
let _skTemp23 = _1_m1;
@@ -99,26 +104,27 @@
var _skTemp37: bool;
var _skTemp38: bool;
if _0_ok {
- let _skTemp39 = test_half_b();
- _skTemp38 = _skTemp39;
+ let _skTemp39 = test_half_b();
+ _skTemp38 = _skTemp39;
} else {
- _skTemp38 = false;
+ _skTemp38 = false;
}
if _skTemp38 {
- let _skTemp40 = test_comma_b();
- _skTemp37 = _skTemp40;
+ let _skTemp40 = test_comma_b();
+ _skTemp37 = _skTemp40;
} else {
- _skTemp37 = false;
+ _skTemp37 = false;
}
if _skTemp37 {
- _skTemp36 = _globalUniforms.colorGreen;
+ _skTemp36 = _globalUniforms.colorGreen;
} else {
- _skTemp36 = _globalUniforms.colorRed;
+ _skTemp36 = _globalUniforms.colorRed;
}
return _skTemp36;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/MatrixConstructorsES2.wgsl b/tests/sksl/shared/MatrixConstructorsES2.wgsl
index 2858748..28b33e3 100644
--- a/tests/sksl/shared/MatrixConstructorsES2.wgsl
+++ b/tests/sksl/shared/MatrixConstructorsES2.wgsl
@@ -1,17 +1,18 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
- testMatrix2x2: mat2x2<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
+ testMatrix2x2: mat2x2<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var f4: vec4<f32> = vec4<f32>(_globalUniforms.testMatrix2x2[0], _globalUniforms.testMatrix2x2[1]);
let _skTemp0 = f4.xyz;
let _skTemp1 = mat2x2<f32>(_skTemp0[0], _skTemp0[1], _skTemp0[2], 4.0);
@@ -30,9 +31,10 @@
let _skTemp12 = mat4x4<f32>(1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0);
ok = ok && (all(_skTemp11[0] == _skTemp12[0]) && all(_skTemp11[1] == _skTemp12[1]) && all(_skTemp11[2] == _skTemp12[2]) && all(_skTemp11[3] == _skTemp12[3]));
return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>(ok));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/MatrixConstructorsES3.wgsl b/tests/sksl/shared/MatrixConstructorsES3.wgsl
index 8cb4017..868ef04 100644
--- a/tests/sksl/shared/MatrixConstructorsES3.wgsl
+++ b/tests/sksl/shared/MatrixConstructorsES3.wgsl
@@ -1,17 +1,18 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
- testMatrix2x2: mat2x2<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
+ testMatrix2x2: mat2x2<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var f4: vec4<f32> = vec4<f32>(_globalUniforms.testMatrix2x2[0], _globalUniforms.testMatrix2x2[1]);
let _skTemp0 = f4.xy;
let _skTemp1 = mat2x3<f32>(f4[0], f4[1], f4[2], f4[3], _skTemp0[0], _skTemp0[1]);
@@ -39,9 +40,10 @@
let _skTemp19 = mat4x3<f32>(1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0);
ok = ok && (all(_skTemp18[0] == _skTemp19[0]) && all(_skTemp18[1] == _skTemp19[1]) && all(_skTemp18[2] == _skTemp19[2]) && all(_skTemp18[3] == _skTemp19[3]));
return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>(ok));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/MatrixEquality.wgsl b/tests/sksl/shared/MatrixEquality.wgsl
index 4aeeb18..1ee5117 100644
--- a/tests/sksl/shared/MatrixEquality.wgsl
+++ b/tests/sksl/shared/MatrixEquality.wgsl
@@ -1,18 +1,19 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
- testMatrix2x2: mat2x2<f32>,
- testMatrix3x3: mat3x3<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
+ testMatrix2x2: mat2x2<f32>,
+ testMatrix3x3: mat3x3<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var _0_ok: bool = true;
let _skTemp0 = _globalUniforms.testMatrix2x2;
let _skTemp1 = mat2x2<f32>(1.0, 2.0, 3.0, 4.0);
@@ -119,9 +120,10 @@
_0_ok = _0_ok && _5_m[2].y == 8.0;
_0_ok = _0_ok && _5_m[2].z == 9.0;
return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>(_0_ok));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/MatrixIndexLookup.wgsl b/tests/sksl/shared/MatrixIndexLookup.wgsl
index e0a8210..4ec6834 100644
--- a/tests/sksl/shared/MatrixIndexLookup.wgsl
+++ b/tests/sksl/shared/MatrixIndexLookup.wgsl
@@ -1,86 +1,92 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
- testMatrix3x3: mat3x3<f32>,
- testMatrix4x4: mat4x4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
+ testMatrix3x3: mat3x3<f32>,
+ testMatrix4x4: mat4x4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn test3x3_b() -> bool {
+ {
var matrix: mat3x3<f32> = _globalUniforms.testMatrix3x3;
var expected: vec3<f32> = vec3<f32>(1.0, 2.0, 3.0);
{
- var index: i32 = 0;
- loop {
- if index < 3 {
- {
- if (any(matrix[index] != expected)) {
- {
- return false;
- }
- }
- expected = expected + 3.0;
- }
- } else {
- break;
+ var index: i32 = 0;
+ loop {
+ if index < 3 {
+ {
+ if (any(matrix[index] != expected)) {
+ {
+ return false;
+ }
}
- continuing {
- index = index + i32(1);
- }
+ expected = expected + 3.0;
+ }
+ } else {
+ break;
}
+ continuing {
+ index = index + i32(1);
+ }
+ }
}
return true;
+ }
}
fn test4x4_b() -> bool {
+ {
var matrix: mat4x4<f32> = _globalUniforms.testMatrix4x4;
var expected: vec4<f32> = vec4<f32>(1.0, 2.0, 3.0, 4.0);
{
- var index: i32 = 0;
- loop {
- if index < 4 {
- {
- if (any(matrix[index] != expected)) {
- {
- return false;
- }
- }
- expected = expected + 4.0;
- }
- } else {
- break;
+ var index: i32 = 0;
+ loop {
+ if index < 4 {
+ {
+ if (any(matrix[index] != expected)) {
+ {
+ return false;
+ }
}
- continuing {
- index = index + i32(1);
- }
+ expected = expected + 4.0;
+ }
+ } else {
+ break;
}
+ continuing {
+ index = index + i32(1);
+ }
+ }
}
return true;
+ }
}
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var _skTemp0: vec4<f32>;
var _skTemp1: bool;
let _skTemp2 = test3x3_b();
if _skTemp2 {
- let _skTemp3 = test4x4_b();
- _skTemp1 = _skTemp3;
+ let _skTemp3 = test4x4_b();
+ _skTemp1 = _skTemp3;
} else {
- _skTemp1 = false;
+ _skTemp1 = false;
}
if _skTemp1 {
- _skTemp0 = _globalUniforms.colorGreen;
+ _skTemp0 = _globalUniforms.colorGreen;
} else {
- _skTemp0 = _globalUniforms.colorRed;
+ _skTemp0 = _globalUniforms.colorRed;
}
return _skTemp0;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/MatrixIndexStore.wgsl b/tests/sksl/shared/MatrixIndexStore.wgsl
index ed9de5b..8ff1c91 100644
--- a/tests/sksl/shared/MatrixIndexStore.wgsl
+++ b/tests/sksl/shared/MatrixIndexStore.wgsl
@@ -1,82 +1,88 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
- testMatrix3x3: mat3x3<f32>,
- testMatrix4x4: mat4x4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
+ testMatrix3x3: mat3x3<f32>,
+ testMatrix4x4: mat4x4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn test3x3_b() -> bool {
+ {
var matrix: mat3x3<f32>;
var values: vec3<f32> = vec3<f32>(1.0, 2.0, 3.0);
{
- var index: i32 = 0;
- loop {
- if index < 3 {
- {
- matrix[index] = values;
- values = values + 3.0;
- }
- } else {
- break;
- }
- continuing {
- index = index + i32(1);
- }
+ var index: i32 = 0;
+ loop {
+ if index < 3 {
+ {
+ matrix[index] = values;
+ values = values + 3.0;
+ }
+ } else {
+ break;
}
+ continuing {
+ index = index + i32(1);
+ }
+ }
}
let _skTemp0 = matrix;
let _skTemp1 = _globalUniforms.testMatrix3x3;
return (all(_skTemp0[0] == _skTemp1[0]) && all(_skTemp0[1] == _skTemp1[1]) && all(_skTemp0[2] == _skTemp1[2]));
+ }
}
fn test4x4_b() -> bool {
+ {
var matrix: mat4x4<f32>;
var values: vec4<f32> = vec4<f32>(1.0, 2.0, 3.0, 4.0);
{
- var index: i32 = 0;
- loop {
- if index < 4 {
- {
- matrix[index] = values;
- values = values + 4.0;
- }
- } else {
- break;
- }
- continuing {
- index = index + i32(1);
- }
+ var index: i32 = 0;
+ loop {
+ if index < 4 {
+ {
+ matrix[index] = values;
+ values = values + 4.0;
+ }
+ } else {
+ break;
}
+ continuing {
+ index = index + i32(1);
+ }
+ }
}
let _skTemp2 = matrix;
let _skTemp3 = _globalUniforms.testMatrix4x4;
return (all(_skTemp2[0] == _skTemp3[0]) && all(_skTemp2[1] == _skTemp3[1]) && all(_skTemp2[2] == _skTemp3[2]) && all(_skTemp2[3] == _skTemp3[3]));
+ }
}
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var _skTemp4: vec4<f32>;
var _skTemp5: bool;
let _skTemp6 = test3x3_b();
if _skTemp6 {
- let _skTemp7 = test4x4_b();
- _skTemp5 = _skTemp7;
+ let _skTemp7 = test4x4_b();
+ _skTemp5 = _skTemp7;
} else {
- _skTemp5 = false;
+ _skTemp5 = false;
}
if _skTemp5 {
- _skTemp4 = _globalUniforms.colorGreen;
+ _skTemp4 = _globalUniforms.colorGreen;
} else {
- _skTemp4 = _globalUniforms.colorRed;
+ _skTemp4 = _globalUniforms.colorRed;
}
return _skTemp4;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/OutParams.wgsl b/tests/sksl/shared/OutParams.wgsl
index 16cec14..ace0ab9 100644
--- a/tests/sksl/shared/OutParams.wgsl
+++ b/tests/sksl/shared/OutParams.wgsl
@@ -1,89 +1,134 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
- colorWhite: vec4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
+ colorWhite: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn out_half_vh(v: ptr<function, f32>) {
+ {
(*v) = _globalUniforms.colorWhite.x;
+ }
}
fn out_half2_vh2(v: ptr<function, vec2<f32>>) {
+ {
(*v) = vec2<f32>(_globalUniforms.colorWhite.y);
+ }
}
fn out_half3_vh3(v: ptr<function, vec3<f32>>) {
+ {
(*v) = vec3<f32>(_globalUniforms.colorWhite.z);
+ }
}
fn out_half4_vh4(v: ptr<function, vec4<f32>>) {
+ {
(*v) = vec4<f32>(_globalUniforms.colorWhite.w);
+ }
}
fn out_half2x2_vh22(v: ptr<function, mat2x2<f32>>) {
+ {
let _skTemp0 = _globalUniforms.colorWhite.x;
(*v) = mat2x2<f32>(_skTemp0, 0.0, 0.0, _skTemp0);
+ }
}
fn out_half3x3_vh33(v: ptr<function, mat3x3<f32>>) {
+ {
let _skTemp1 = _globalUniforms.colorWhite.y;
(*v) = mat3x3<f32>(_skTemp1, 0.0, 0.0, 0.0, _skTemp1, 0.0, 0.0, 0.0, _skTemp1);
+ }
}
fn out_half4x4_vh44(v: ptr<function, mat4x4<f32>>) {
+ {
let _skTemp2 = _globalUniforms.colorWhite.z;
(*v) = mat4x4<f32>(_skTemp2, 0.0, 0.0, 0.0, 0.0, _skTemp2, 0.0, 0.0, 0.0, 0.0, _skTemp2, 0.0, 0.0, 0.0, 0.0, _skTemp2);
+ }
}
fn out_int_vi(v: ptr<function, i32>) {
+ {
(*v) = i32(_globalUniforms.colorWhite.x);
+ }
}
fn out_int2_vi2(v: ptr<function, vec2<i32>>) {
+ {
(*v) = vec2<i32>(i32(_globalUniforms.colorWhite.y));
+ }
}
fn out_int3_vi3(v: ptr<function, vec3<i32>>) {
+ {
(*v) = vec3<i32>(i32(_globalUniforms.colorWhite.z));
+ }
}
fn out_int4_vi4(v: ptr<function, vec4<i32>>) {
+ {
(*v) = vec4<i32>(i32(_globalUniforms.colorWhite.w));
+ }
}
fn out_float_vf(v: ptr<function, f32>) {
+ {
(*v) = f32(_globalUniforms.colorWhite.x);
+ }
}
fn out_float2_vf2(v: ptr<function, vec2<f32>>) {
+ {
(*v) = vec2<f32>(f32(_globalUniforms.colorWhite.y));
+ }
}
fn out_float3_vf3(v: ptr<function, vec3<f32>>) {
+ {
(*v) = vec3<f32>(f32(_globalUniforms.colorWhite.z));
+ }
}
fn out_float4_vf4(v: ptr<function, vec4<f32>>) {
+ {
(*v) = vec4<f32>(f32(_globalUniforms.colorWhite.w));
+ }
}
fn out_float2x2_vf22(v: ptr<function, mat2x2<f32>>) {
+ {
let _skTemp3 = f32(_globalUniforms.colorWhite.x);
(*v) = mat2x2<f32>(_skTemp3, 0.0, 0.0, _skTemp3);
+ }
}
fn out_float3x3_vf33(v: ptr<function, mat3x3<f32>>) {
+ {
let _skTemp4 = f32(_globalUniforms.colorWhite.y);
(*v) = mat3x3<f32>(_skTemp4, 0.0, 0.0, 0.0, _skTemp4, 0.0, 0.0, 0.0, _skTemp4);
+ }
}
fn out_float4x4_vf44(v: ptr<function, mat4x4<f32>>) {
+ {
let _skTemp5 = f32(_globalUniforms.colorWhite.z);
(*v) = mat4x4<f32>(_skTemp5, 0.0, 0.0, 0.0, 0.0, _skTemp5, 0.0, 0.0, 0.0, 0.0, _skTemp5, 0.0, 0.0, 0.0, 0.0, _skTemp5);
+ }
}
fn out_bool_vb(v: ptr<function, bool>) {
+ {
(*v) = bool(_globalUniforms.colorWhite.x);
+ }
}
fn out_bool2_vb2(v: ptr<function, vec2<bool>>) {
+ {
(*v) = vec2<bool>(bool(_globalUniforms.colorWhite.y));
+ }
}
fn out_bool3_vb3(v: ptr<function, vec3<bool>>) {
+ {
(*v) = vec3<bool>(bool(_globalUniforms.colorWhite.z));
+ }
}
fn out_bool4_vb4(v: ptr<function, vec4<bool>>) {
+ {
(*v) = vec4<bool>(bool(_globalUniforms.colorWhite.w));
+ }
}
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var h: f32;
var _skTemp6: f32;
out_half_vh(&_skTemp6);
@@ -217,9 +262,10 @@
ok = ok && 1 == ((i * i2.x) * i3.x) * i4.x;
ok = ok && (((b && b2.x) && b3.x) && b4.x);
return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>(ok));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/OutParamsAreDistinct.wgsl b/tests/sksl/shared/OutParamsAreDistinct.wgsl
index 41e8f4c..eae3adb 100644
--- a/tests/sksl/shared/OutParamsAreDistinct.wgsl
+++ b/tests/sksl/shared/OutParamsAreDistinct.wgsl
@@ -1,21 +1,24 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn out_params_are_distinct_bhh(x: ptr<function, f32>, y: ptr<function, f32>) -> bool {
+ {
(*x) = 1.0;
(*y) = 2.0;
return (*x) == 1.0 && (*y) == 2.0;
+ }
}
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var x: f32 = 0.0;
var _skTemp0: vec4<f32>;
var _skTemp1: f32;
@@ -24,14 +27,15 @@
x = _skTemp1;
x = _skTemp2;
if _skTemp3 {
- _skTemp0 = _globalUniforms.colorGreen;
+ _skTemp0 = _globalUniforms.colorGreen;
} else {
- _skTemp0 = _globalUniforms.colorRed;
+ _skTemp0 = _globalUniforms.colorRed;
}
return _skTemp0;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/OutParamsAreDistinctFromGlobal.wgsl b/tests/sksl/shared/OutParamsAreDistinctFromGlobal.wgsl
index 95f5097..56f3825 100644
--- a/tests/sksl/shared/OutParamsAreDistinctFromGlobal.wgsl
+++ b/tests/sksl/shared/OutParamsAreDistinctFromGlobal.wgsl
@@ -1,34 +1,38 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
var<private> x: f32 = 1.0;
fn out_params_are_distinct_from_global_bh(y: ptr<function, f32>) -> bool {
+ {
(*y) = 2.0;
return x == 1.0 && (*y) == 2.0;
+ }
}
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var _skTemp0: vec4<f32>;
var _skTemp1: f32;
let _skTemp2 = out_params_are_distinct_from_global_bh(&_skTemp1);
x = _skTemp1;
if _skTemp2 {
- _skTemp0 = _globalUniforms.colorGreen;
+ _skTemp0 = _globalUniforms.colorGreen;
} else {
- _skTemp0 = _globalUniforms.colorRed;
+ _skTemp0 = _globalUniforms.colorRed;
}
return _skTemp0;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/OutParamsDoubleSwizzle.wgsl b/tests/sksl/shared/OutParamsDoubleSwizzle.wgsl
index 68144ba..fb55796 100644
--- a/tests/sksl/shared/OutParamsDoubleSwizzle.wgsl
+++ b/tests/sksl/shared/OutParamsDoubleSwizzle.wgsl
@@ -1,35 +1,41 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn swizzle_lvalue_h2hhh2h(x: f32, y: f32, color: ptr<function, vec2<f32>>, z: f32) -> vec2<f32> {
+ {
(*color) = ((*color)).yx;
return vec2<f32>(x + y, z);
+ }
}
fn func_vh4(color: ptr<function, vec4<f32>>) {
+ {
var _skTemp0: vec2<f32> = (*color).xz;
let _skTemp1 = swizzle_lvalue_h2hhh2h(1.0, 2.0, &_skTemp0, 5.0);
(*color) = vec4<f32>((_skTemp0), (*color).yw).xzyw;
var t: vec2<f32> = _skTemp1;
(*color) = vec4<f32>((t), (*color).xz).zxwy;
+ }
}
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var result: vec4<f32> = vec4<f32>(0.0, 1.0, 2.0, 3.0);
var _skTemp2: vec4<f32> = result;
func_vh4(&_skTemp2);
result = _skTemp2;
return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>(all(result == vec4<f32>(2.0, 3.0, 0.0, 5.0))));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/OutParamsFunctionCallInArgument.wgsl b/tests/sksl/shared/OutParamsFunctionCallInArgument.wgsl
index 7b88057..761e1a3 100644
--- a/tests/sksl/shared/OutParamsFunctionCallInArgument.wgsl
+++ b/tests/sksl/shared/OutParamsFunctionCallInArgument.wgsl
@@ -1,23 +1,28 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn out_param_func1_vh(v: ptr<function, f32>) {
+ {
(*v) = _globalUniforms.colorGreen.y;
+ }
}
fn out_param_func2_ih(v: ptr<function, f32>) -> i32 {
+ {
(*v) = _globalUniforms.colorRed.x;
return i32((*v));
+ }
}
fn main(c: vec2<f32>) -> vec4<f32> {
+ {
var testArray: array<f32, 2>;
var _skTemp0: f32;
let _skTemp1 = out_param_func2_ih(&_skTemp0);
@@ -27,9 +32,10 @@
out_param_func1_vh(&_skTemp3);
testArray[_skTemp2] = _skTemp3;
return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>(testArray[0] == 1.0 && testArray[1] == 1.0));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/PostfixExpressions.wgsl b/tests/sksl/shared/PostfixExpressions.wgsl
index dda7da5..434375d 100644
--- a/tests/sksl/shared/PostfixExpressions.wgsl
+++ b/tests/sksl/shared/PostfixExpressions.wgsl
@@ -1,36 +1,37 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main(c: vec2<f32>) -> vec4<f32> {
+ {
var ok: bool = true;
var i: i32 = 5;
i = i + i32(1);
var _skTemp0: bool;
if ok {
- let _skTemp1 = i;
- i = i + i32(1);
- _skTemp0 = _skTemp1 == 6;
+ let _skTemp1 = i;
+ i = i + i32(1);
+ _skTemp0 = _skTemp1 == 6;
} else {
- _skTemp0 = false;
+ _skTemp0 = false;
}
ok = _skTemp0;
ok = ok && i == 7;
var _skTemp2: bool;
if ok {
- let _skTemp3 = i;
- i = i - i32(1);
- _skTemp2 = _skTemp3 == 7;
+ let _skTemp3 = i;
+ i = i - i32(1);
+ _skTemp2 = _skTemp3 == 7;
} else {
- _skTemp2 = false;
+ _skTemp2 = false;
}
ok = _skTemp2;
ok = ok && i == 6;
@@ -40,21 +41,21 @@
f = f + f32(1);
var _skTemp4: bool;
if ok {
- let _skTemp5 = f;
- f = f + f32(1);
- _skTemp4 = _skTemp5 == 1.5;
+ let _skTemp5 = f;
+ f = f + f32(1);
+ _skTemp4 = _skTemp5 == 1.5;
} else {
- _skTemp4 = false;
+ _skTemp4 = false;
}
ok = _skTemp4;
ok = ok && f == 2.5;
var _skTemp6: bool;
if ok {
- let _skTemp7 = f;
- f = f - f32(1);
- _skTemp6 = _skTemp7 == 2.5;
+ let _skTemp7 = f;
+ f = f - f32(1);
+ _skTemp6 = _skTemp7 == 2.5;
} else {
- _skTemp6 = false;
+ _skTemp6 = false;
}
ok = _skTemp6;
ok = ok && f == 1.5;
@@ -64,30 +65,31 @@
f2.x = f2.x + f32(1);
var _skTemp8: bool;
if ok {
- let _skTemp9 = f2.x;
- f2.x = f2.x + f32(1);
- _skTemp8 = _skTemp9 == 1.5;
+ let _skTemp9 = f2.x;
+ f2.x = f2.x + f32(1);
+ _skTemp8 = _skTemp9 == 1.5;
} else {
- _skTemp8 = false;
+ _skTemp8 = false;
}
ok = _skTemp8;
ok = ok && f2.x == 2.5;
var _skTemp10: bool;
if ok {
- let _skTemp11 = f2.x;
- f2.x = f2.x - f32(1);
- _skTemp10 = _skTemp11 == 2.5;
+ let _skTemp11 = f2.x;
+ f2.x = f2.x - f32(1);
+ _skTemp10 = _skTemp11 == 2.5;
} else {
- _skTemp10 = false;
+ _skTemp10 = false;
}
ok = _skTemp10;
ok = ok && f2.x == 1.5;
f2.x = f2.x - f32(1);
ok = ok && f2.x == 0.5;
return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>(ok));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/PrefixExpressionsES2.wgsl b/tests/sksl/shared/PrefixExpressionsES2.wgsl
index 0968fe5..48bd08d 100644
--- a/tests/sksl/shared/PrefixExpressionsES2.wgsl
+++ b/tests/sksl/shared/PrefixExpressionsES2.wgsl
@@ -1,35 +1,36 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
- testMatrix2x2: mat2x2<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
+ testMatrix2x2: mat2x2<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main(_skAnonymous0: vec2<f32>) -> vec4<f32> {
+ {
var ok: bool = true;
var i: i32 = 5;
i = i + i32(1);
ok = ok && i == 6;
var _skTemp1: bool;
if ok {
- i = i + i32(1);
- _skTemp1 = i == 7;
+ i = i + i32(1);
+ _skTemp1 = i == 7;
} else {
- _skTemp1 = false;
+ _skTemp1 = false;
}
ok = _skTemp1;
var _skTemp2: bool;
if ok {
- i = i - i32(1);
- _skTemp2 = i == 6;
+ i = i - i32(1);
+ _skTemp2 = i == 6;
} else {
- _skTemp2 = false;
+ _skTemp2 = false;
}
ok = _skTemp2;
i = i - i32(1);
@@ -39,18 +40,18 @@
ok = ok && f == 1.5;
var _skTemp3: bool;
if ok {
- f = f + f32(1);
- _skTemp3 = f == 2.5;
+ f = f + f32(1);
+ _skTemp3 = f == 2.5;
} else {
- _skTemp3 = false;
+ _skTemp3 = false;
}
ok = _skTemp3;
var _skTemp4: bool;
if ok {
- f = f - f32(1);
- _skTemp4 = f == 1.5;
+ f = f - f32(1);
+ _skTemp4 = f == 1.5;
} else {
- _skTemp4 = false;
+ _skTemp4 = false;
}
ok = _skTemp4;
f = f - f32(1);
@@ -60,18 +61,18 @@
ok = ok && f2.x == 1.5;
var _skTemp5: bool;
if ok {
- f2.x = f2.x + f32(1);
- _skTemp5 = f2.x == 2.5;
+ f2.x = f2.x + f32(1);
+ _skTemp5 = f2.x == 2.5;
} else {
- _skTemp5 = false;
+ _skTemp5 = false;
}
ok = _skTemp5;
var _skTemp6: bool;
if ok {
- f2.x = f2.x - f32(1);
- _skTemp6 = f2.x == 1.5;
+ f2.x = f2.x - f32(1);
+ _skTemp6 = f2.x == 1.5;
} else {
- _skTemp6 = false;
+ _skTemp6 = false;
}
ok = _skTemp6;
f2.x = f2.x - f32(1);
@@ -86,9 +87,10 @@
ok = ok && -i == -5;
ok = ok && all(-iv == vec2<i32>(-5, 5));
return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>(ok));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/PrefixExpressionsES3.wgsl b/tests/sksl/shared/PrefixExpressionsES3.wgsl
index de26328..336d0f2 100644
--- a/tests/sksl/shared/PrefixExpressionsES3.wgsl
+++ b/tests/sksl/shared/PrefixExpressionsES3.wgsl
@@ -1,16 +1,17 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main(_skAnonymous0: vec2<f32>) -> vec4<f32> {
+ {
var ok: bool = true;
var val: u32 = u32(_globalUniforms.colorGreen.x);
var mask: vec2<u32> = vec2<u32>(val, ~val);
@@ -18,9 +19,10 @@
mask = ~mask & vec2<u32>(~imask);
ok = ok && all(mask == vec2<u32>(0u));
return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>(ok));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/StructArrayFollowedByScalar.wgsl b/tests/sksl/shared/StructArrayFollowedByScalar.wgsl
index c88f57b..88d17ff 100644
--- a/tests/sksl/shared/StructArrayFollowedByScalar.wgsl
+++ b/tests/sksl/shared/StructArrayFollowedByScalar.wgsl
@@ -1,24 +1,26 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct S {
- rgb: array<f32, 3>,
- a: f32,
+ rgb: array<f32, 3>,
+ a: f32,
};
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var s: S;
s.rgb[0] = 0.0;
s.rgb[1] = 1.0;
s.rgb[2] = 0.0;
s.a = 1.0;
return vec4<f32>(s.rgb[0], s.rgb[1], s.rgb[2], s.a);
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/Structs.wgsl b/tests/sksl/shared/Structs.wgsl
index 43835d7..faa7da7 100644
--- a/tests/sksl/shared/Structs.wgsl
+++ b/tests/sksl/shared/Structs.wgsl
@@ -1,27 +1,29 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(front_facing) sk_Clockwise: bool,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct A {
- x: i32,
- y: i32,
+ x: i32,
+ y: i32,
};
var<private> a1: A;
struct B {
- x: f32,
- y: array<f32, 2>,
- z: A,
+ x: f32,
+ y: array<f32, 2>,
+ z: A,
};
var<private> b1: B;
fn main(_stageOut: ptr<function, FSOut>) {
+ {
a1.x = 0;
b1.x = 0.0;
(*_stageOut).sk_FragColor.x = f32(a1.x) + f32(b1.x);
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- main(&_stageOut);
- return _stageOut;
+ var _stageOut: FSOut;
+ main(&_stageOut);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/SwizzleAsLValue.wgsl b/tests/sksl/shared/SwizzleAsLValue.wgsl
index a318647..3017498 100644
--- a/tests/sksl/shared/SwizzleAsLValue.wgsl
+++ b/tests/sksl/shared/SwizzleAsLValue.wgsl
@@ -1,16 +1,17 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main(_skAnonymous0: vec2<f32>) -> vec4<f32> {
+ {
var color: vec4<f32> = vec4<f32>(_globalUniforms.colorGreen) * 0.5;
color.w = 2.0;
color.y = color.y * 4.0;
@@ -18,9 +19,10 @@
color = (color.zywx + vec4<f32>(0.25, 0.0, 0.0, 0.75)).wyxz;
color.x = color.x + (select(0.0, color.z, color.w <= 1.0));
return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>(all(color == vec4<f32>(1.0, 1.0, 0.25, 1.0))));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/SwizzleBoolConstants.wgsl b/tests/sksl/shared/SwizzleBoolConstants.wgsl
index 121a45a..073c398 100644
--- a/tests/sksl/shared/SwizzleBoolConstants.wgsl
+++ b/tests/sksl/shared/SwizzleBoolConstants.wgsl
@@ -1,16 +1,17 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var v: vec4<bool> = vec4<bool>(bool(_globalUniforms.colorGreen.y));
var result: vec4<bool> = vec4<bool>(v.x, true, true, true);
result = vec4<bool>(v.xy, false, true);
@@ -40,9 +41,10 @@
result = vec4<bool>(false, true, true, v.w);
let _skTemp0 = any(result);
return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>(_skTemp0));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/SwizzleByConstantIndex.wgsl b/tests/sksl/shared/SwizzleByConstantIndex.wgsl
index a08a2a4..a65d111 100644
--- a/tests/sksl/shared/SwizzleByConstantIndex.wgsl
+++ b/tests/sksl/shared/SwizzleByConstantIndex.wgsl
@@ -1,17 +1,18 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- testInputs: vec4<f32>,
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
+ testInputs: vec4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var _0_v: vec4<f32> = _globalUniforms.testInputs;
var _1_x: f32 = _0_v.x;
var _2_y: f32 = _0_v.y;
@@ -25,9 +26,10 @@
var b: vec4<f32> = vec4<f32>(_9_x, _10_y, _11_z, _12_w);
var c: vec4<f32> = vec4<f32>(0.0, 1.0, 2.0, 3.0);
return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>((all(a == vec4<f32>(-1.25, 0.0, 0.75, 2.25)) && all(b == vec4<f32>(-1.25, 0.0, 0.75, 2.25))) && all(c == vec4<f32>(0.0, 1.0, 2.0, 3.0))));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/SwizzleByIndex.wgsl b/tests/sksl/shared/SwizzleByIndex.wgsl
index 1864b41..1e563d0 100644
--- a/tests/sksl/shared/SwizzleByIndex.wgsl
+++ b/tests/sksl/shared/SwizzleByIndex.wgsl
@@ -1,18 +1,19 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- testInputs: vec4<f32>,
- colorBlack: vec4<f32>,
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
+ testInputs: vec4<f32>,
+ colorBlack: vec4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var _0_v: vec4<f32> = _globalUniforms.testInputs;
var _1_i: vec4<i32> = vec4<i32>(_globalUniforms.colorBlack);
let _skTemp0 = _1_i.x;
@@ -24,9 +25,10 @@
let _skTemp3 = _1_i.w;
var _5_w: f32 = _0_v[_skTemp3];
return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>(all(vec4<f32>(_2_x, _3_y, _4_z, _5_w) == vec4<f32>(-1.25, -1.25, -1.25, 0.0))));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/SwizzleConstants.wgsl b/tests/sksl/shared/SwizzleConstants.wgsl
index 18bcd34..97be196 100644
--- a/tests/sksl/shared/SwizzleConstants.wgsl
+++ b/tests/sksl/shared/SwizzleConstants.wgsl
@@ -1,17 +1,18 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- testInputs: vec4<f32>,
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
+ testInputs: vec4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var v: vec4<f32> = _globalUniforms.testInputs;
v = vec4<f32>(v.x, 1.0, 1.0, 1.0);
v = vec4<f32>(v.xy, 1.0, 1.0);
@@ -39,9 +40,10 @@
v = vec4<f32>(0.0, 0.0, v.z, 1.0);
v = vec4<f32>(0.0, 1.0, 1.0, v.w);
return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>(all(v == vec4<f32>(0.0, 1.0, 1.0, 1.0))));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/SwizzleIndexLookup.wgsl b/tests/sksl/shared/SwizzleIndexLookup.wgsl
index dd45d38..2791cd7 100644
--- a/tests/sksl/shared/SwizzleIndexLookup.wgsl
+++ b/tests/sksl/shared/SwizzleIndexLookup.wgsl
@@ -1,114 +1,120 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
- testMatrix3x3: mat3x3<f32>,
- testMatrix4x4: mat4x4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
+ testMatrix3x3: mat3x3<f32>,
+ testMatrix4x4: mat4x4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn test3x3_b() -> bool {
+ {
var expected: vec3<f32> = vec3<f32>(3.0, 2.0, 1.0);
{
- var c: i32 = 0;
- loop {
- if c < 3 {
- {
- var vec: vec3<f32> = _globalUniforms.testMatrix3x3[c];
- {
- var r: i32 = 0;
- loop {
- if r < 3 {
- {
- if (vec.zyx[r] != expected[r]) {
- {
- return false;
- }
- }
- }
- } else {
- break;
- }
- continuing {
- r = r + i32(1);
- }
- }
+ var c: i32 = 0;
+ loop {
+ if c < 3 {
+ {
+ var vec: vec3<f32> = _globalUniforms.testMatrix3x3[c];
+ {
+ var r: i32 = 0;
+ loop {
+ if r < 3 {
+ {
+ if (vec.zyx[r] != expected[r]) {
+ {
+ return false;
+ }
}
- expected = expected + 3.0;
+ }
+ } else {
+ break;
}
- } else {
- break;
+ continuing {
+ r = r + i32(1);
+ }
+ }
}
- continuing {
- c = c + i32(1);
- }
+ expected = expected + 3.0;
+ }
+ } else {
+ break;
}
+ continuing {
+ c = c + i32(1);
+ }
+ }
}
return true;
+ }
}
fn test4x4_b() -> bool {
+ {
var expected: vec4<f32> = vec4<f32>(4.0, 3.0, 2.0, 1.0);
{
- var c: i32 = 0;
- loop {
- if c < 4 {
- {
- var vec: vec4<f32> = _globalUniforms.testMatrix4x4[c];
- {
- var r: i32 = 0;
- loop {
- if r < 4 {
- {
- if (vec.wzyx[r] != expected[r]) {
- {
- return false;
- }
- }
- }
- } else {
- break;
- }
- continuing {
- r = r + i32(1);
- }
- }
+ var c: i32 = 0;
+ loop {
+ if c < 4 {
+ {
+ var vec: vec4<f32> = _globalUniforms.testMatrix4x4[c];
+ {
+ var r: i32 = 0;
+ loop {
+ if r < 4 {
+ {
+ if (vec.wzyx[r] != expected[r]) {
+ {
+ return false;
+ }
}
- expected = expected + 4.0;
+ }
+ } else {
+ break;
}
- } else {
- break;
+ continuing {
+ r = r + i32(1);
+ }
+ }
}
- continuing {
- c = c + i32(1);
- }
+ expected = expected + 4.0;
+ }
+ } else {
+ break;
}
+ continuing {
+ c = c + i32(1);
+ }
+ }
}
return true;
+ }
}
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var _skTemp0: vec4<f32>;
var _skTemp1: bool;
let _skTemp2 = test3x3_b();
if _skTemp2 {
- let _skTemp3 = test4x4_b();
- _skTemp1 = _skTemp3;
+ let _skTemp3 = test4x4_b();
+ _skTemp1 = _skTemp3;
} else {
- _skTemp1 = false;
+ _skTemp1 = false;
}
if _skTemp1 {
- _skTemp0 = _globalUniforms.colorGreen;
+ _skTemp0 = _globalUniforms.colorGreen;
} else {
- _skTemp0 = _globalUniforms.colorRed;
+ _skTemp0 = _globalUniforms.colorRed;
}
return _skTemp0;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/SwizzleIndexStore.wgsl b/tests/sksl/shared/SwizzleIndexStore.wgsl
index 370c0fc..e984ea0 100644
--- a/tests/sksl/shared/SwizzleIndexStore.wgsl
+++ b/tests/sksl/shared/SwizzleIndexStore.wgsl
@@ -1,118 +1,124 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
- testMatrix3x3: mat3x3<f32>,
- testMatrix4x4: mat4x4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
+ testMatrix3x3: mat3x3<f32>,
+ testMatrix4x4: mat4x4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn test3x3_b() -> bool {
+ {
var expected: vec3<f32> = vec3<f32>(3.0, 2.0, 1.0);
var vec: vec3<f32>;
{
- var c: i32 = 0;
- loop {
- if c < 3 {
- {
- {
- var r: i32 = 0;
- loop {
- if r < 3 {
- {
- let _skTemp0 = vec3<i32>(2, 1, 0)[r];
- vec[_skTemp0] = _globalUniforms.testMatrix3x3[c][r];
- }
- } else {
- break;
- }
- continuing {
- r = r + i32(1);
- }
- }
- }
- if (any(vec != expected)) {
- {
- return false;
- }
- }
- expected = expected + 3.0;
+ var c: i32 = 0;
+ loop {
+ if c < 3 {
+ {
+ {
+ var r: i32 = 0;
+ loop {
+ if r < 3 {
+ {
+ let _skTemp0 = vec3<i32>(2, 1, 0)[r];
+ vec[_skTemp0] = _globalUniforms.testMatrix3x3[c][r];
+ }
+ } else {
+ break;
}
- } else {
- break;
+ continuing {
+ r = r + i32(1);
+ }
+ }
}
- continuing {
- c = c + i32(1);
+ if (any(vec != expected)) {
+ {
+ return false;
+ }
}
+ expected = expected + 3.0;
+ }
+ } else {
+ break;
}
+ continuing {
+ c = c + i32(1);
+ }
+ }
}
return true;
+ }
}
fn test4x4_b() -> bool {
+ {
var expected: vec4<f32> = vec4<f32>(4.0, 3.0, 2.0, 1.0);
var vec: vec4<f32>;
{
- var c: i32 = 0;
- loop {
- if c < 4 {
- {
- {
- var r: i32 = 0;
- loop {
- if r < 4 {
- {
- let _skTemp1 = vec4<i32>(3, 2, 1, 0)[r];
- vec[_skTemp1] = _globalUniforms.testMatrix4x4[c][r];
- }
- } else {
- break;
- }
- continuing {
- r = r + i32(1);
- }
- }
- }
- if (any(vec != expected)) {
- {
- return false;
- }
- }
- expected = expected + 4.0;
+ var c: i32 = 0;
+ loop {
+ if c < 4 {
+ {
+ {
+ var r: i32 = 0;
+ loop {
+ if r < 4 {
+ {
+ let _skTemp1 = vec4<i32>(3, 2, 1, 0)[r];
+ vec[_skTemp1] = _globalUniforms.testMatrix4x4[c][r];
+ }
+ } else {
+ break;
}
- } else {
- break;
+ continuing {
+ r = r + i32(1);
+ }
+ }
}
- continuing {
- c = c + i32(1);
+ if (any(vec != expected)) {
+ {
+ return false;
+ }
}
+ expected = expected + 4.0;
+ }
+ } else {
+ break;
}
+ continuing {
+ c = c + i32(1);
+ }
+ }
}
return true;
+ }
}
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var _skTemp2: vec4<f32>;
var _skTemp3: bool;
let _skTemp4 = test3x3_b();
if _skTemp4 {
- let _skTemp5 = test4x4_b();
- _skTemp3 = _skTemp5;
+ let _skTemp5 = test4x4_b();
+ _skTemp3 = _skTemp5;
} else {
- _skTemp3 = false;
+ _skTemp3 = false;
}
if _skTemp3 {
- _skTemp2 = _globalUniforms.colorGreen;
+ _skTemp2 = _globalUniforms.colorGreen;
} else {
- _skTemp2 = _globalUniforms.colorRed;
+ _skTemp2 = _globalUniforms.colorRed;
}
return _skTemp2;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/SwizzleLTRB.wgsl b/tests/sksl/shared/SwizzleLTRB.wgsl
index 44d747b..24efe77 100644
--- a/tests/sksl/shared/SwizzleLTRB.wgsl
+++ b/tests/sksl/shared/SwizzleLTRB.wgsl
@@ -1,19 +1,21 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorRed: vec4<f32>,
+ colorRed: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
return _globalUniforms.colorRed.zwyx;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/SwizzleOpt.wgsl b/tests/sksl/shared/SwizzleOpt.wgsl
index 04f2d08..6607296 100644
--- a/tests/sksl/shared/SwizzleOpt.wgsl
+++ b/tests/sksl/shared/SwizzleOpt.wgsl
@@ -6,36 +6,39 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorRed: vec4<f32>,
- colorGreen: vec4<f32>,
- testInputs: vec4<f32>,
+ colorRed: vec4<f32>,
+ colorGreen: vec4<f32>,
+ testInputs: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn fn_hh4(v: vec4<f32>) -> f32 {
+ {
{
- var x: i32 = 1;
- loop {
- if x <= 2 {
- {
- return v.x;
- }
- } else {
- break;
- }
- continuing {
- x = x + i32(1);
- }
+ var x: i32 = 1;
+ loop {
+ if x <= 2 {
+ {
+ return v.x;
+ }
+ } else {
+ break;
}
+ continuing {
+ x = x + i32(1);
+ }
+ }
}
+ }
}
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var v: vec4<f32> = _globalUniforms.testInputs;
v = vec4<f32>(0.0, v.zyx);
v = vec4<f32>(0.0, 0.0, v.xw);
@@ -62,11 +65,12 @@
v = vec4<f32>((v.yz), v.yz).xzwy;
v = vec4<f32>((vec3<f32>(v.ww, 1.0)), v.w).zyxw;
return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>(all(v == vec4<f32>(1.0))));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
1 error
diff --git a/tests/sksl/shared/SwizzleScalar.wgsl b/tests/sksl/shared/SwizzleScalar.wgsl
index 31f9b3e..13f6c64 100644
--- a/tests/sksl/shared/SwizzleScalar.wgsl
+++ b/tests/sksl/shared/SwizzleScalar.wgsl
@@ -1,23 +1,25 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- unknownInput: f32,
+ unknownInput: f32,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var h4: vec4<f32> = vec4<f32>(_globalUniforms.unknownInput);
h4 = vec4<f32>(vec2<f32>(_globalUniforms.unknownInput), 0.0, 1.0);
h4 = vec4<f32>(0.0, _globalUniforms.unknownInput, 1.0, 0.0);
h4 = vec4<f32>(0.0, _globalUniforms.unknownInput, 0.0, _globalUniforms.unknownInput);
return h4;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/SwizzleScalarBool.wgsl b/tests/sksl/shared/SwizzleScalarBool.wgsl
index a82710c..d0bbfa7 100644
--- a/tests/sksl/shared/SwizzleScalarBool.wgsl
+++ b/tests/sksl/shared/SwizzleScalarBool.wgsl
@@ -1,24 +1,26 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- unknownInput: f32,
+ unknownInput: f32,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var b: bool = bool(_globalUniforms.unknownInput);
var b4: vec4<bool> = vec4<bool>(b);
b4 = vec4<bool>(vec2<bool>(b), false, true);
b4 = vec4<bool>(false, b, true, false);
b4 = vec4<bool>(false, b, false, b);
return vec4<f32>(b4);
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/SwizzleScalarInt.wgsl b/tests/sksl/shared/SwizzleScalarInt.wgsl
index 68bb5bd..c019fe3 100644
--- a/tests/sksl/shared/SwizzleScalarInt.wgsl
+++ b/tests/sksl/shared/SwizzleScalarInt.wgsl
@@ -1,24 +1,26 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- unknownInput: f32,
+ unknownInput: f32,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var i: i32 = i32(_globalUniforms.unknownInput);
var i4: vec4<i32> = vec4<i32>(i);
i4 = vec4<i32>(vec2<i32>(i), 0, 1);
i4 = vec4<i32>(0, i, 1, 0);
i4 = vec4<i32>(0, i, 0, i);
return vec4<f32>(i4);
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/TernaryComplexNesting.wgsl b/tests/sksl/shared/TernaryComplexNesting.wgsl
index ceb092d..82e3431 100644
--- a/tests/sksl/shared/TernaryComplexNesting.wgsl
+++ b/tests/sksl/shared/TernaryComplexNesting.wgsl
@@ -1,68 +1,72 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorWhite: vec4<f32>,
+ colorWhite: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn IsEqual_bh4h4(x: vec4<f32>, y: vec4<f32>) -> bool {
+ {
return all(x == y);
+ }
}
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var colorBlue: vec4<f32> = vec4<f32>(0.0, 0.0, _globalUniforms.colorWhite.zw);
var colorGreen: vec4<f32> = vec4<f32>(0.0, _globalUniforms.colorWhite.y, 0.0, _globalUniforms.colorWhite.w);
var colorRed: vec4<f32> = vec4<f32>(_globalUniforms.colorWhite.x, 0.0, 0.0, _globalUniforms.colorWhite.w);
var _skTemp0: vec4<f32>;
let _skTemp1 = IsEqual_bh4h4(_globalUniforms.colorWhite, colorBlue);
if !_skTemp1 {
- var _skTemp2: vec4<f32>;
- let _skTemp3 = IsEqual_bh4h4(colorGreen, colorRed);
- if _skTemp3 {
- _skTemp2 = colorRed;
- } else {
- _skTemp2 = colorGreen;
- }
- _skTemp0 = _skTemp2;
+ var _skTemp2: vec4<f32>;
+ let _skTemp3 = IsEqual_bh4h4(colorGreen, colorRed);
+ if _skTemp3 {
+ _skTemp2 = colorRed;
+ } else {
+ _skTemp2 = colorGreen;
+ }
+ _skTemp0 = _skTemp2;
} else {
- var _skTemp4: vec4<f32>;
- let _skTemp5 = IsEqual_bh4h4(colorRed, colorGreen);
- if !_skTemp5 {
- _skTemp4 = colorBlue;
- } else {
- _skTemp4 = _globalUniforms.colorWhite;
- }
- _skTemp0 = _skTemp4;
+ var _skTemp4: vec4<f32>;
+ let _skTemp5 = IsEqual_bh4h4(colorRed, colorGreen);
+ if !_skTemp5 {
+ _skTemp4 = colorBlue;
+ } else {
+ _skTemp4 = _globalUniforms.colorWhite;
+ }
+ _skTemp0 = _skTemp4;
}
var result: vec4<f32> = _skTemp0;
var _skTemp6: vec4<f32>;
let _skTemp7 = IsEqual_bh4h4(colorRed, colorBlue);
if _skTemp7 {
- _skTemp6 = _globalUniforms.colorWhite;
+ _skTemp6 = _globalUniforms.colorWhite;
} else {
- var _skTemp8: vec4<f32>;
- let _skTemp9 = IsEqual_bh4h4(colorRed, colorGreen);
- if !_skTemp9 {
- _skTemp8 = result;
+ var _skTemp8: vec4<f32>;
+ let _skTemp9 = IsEqual_bh4h4(colorRed, colorGreen);
+ if !_skTemp9 {
+ _skTemp8 = result;
+ } else {
+ var _skTemp10: vec4<f32>;
+ let _skTemp11 = IsEqual_bh4h4(colorRed, _globalUniforms.colorWhite);
+ if _skTemp11 {
+ _skTemp10 = colorBlue;
} else {
- var _skTemp10: vec4<f32>;
- let _skTemp11 = IsEqual_bh4h4(colorRed, _globalUniforms.colorWhite);
- if _skTemp11 {
- _skTemp10 = colorBlue;
- } else {
- _skTemp10 = colorRed;
- }
- _skTemp8 = _skTemp10;
+ _skTemp10 = colorRed;
}
- _skTemp6 = _skTemp8;
+ _skTemp8 = _skTemp10;
+ }
+ _skTemp6 = _skTemp8;
}
return _skTemp6;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/TernaryExpression.wgsl b/tests/sksl/shared/TernaryExpression.wgsl
index 9933543..e78bdf9 100644
--- a/tests/sksl/shared/TernaryExpression.wgsl
+++ b/tests/sksl/shared/TernaryExpression.wgsl
@@ -1,25 +1,27 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var check: i32 = 0;
check = check + i32(select(1, 0, _globalUniforms.colorGreen.y == 1.0));
check = check + i32(select(0, 1, _globalUniforms.colorGreen.x == 1.0));
check = check + i32(select(1, 0, all(_globalUniforms.colorGreen.yx == _globalUniforms.colorRed.xy)));
check = check + i32(select(0, 1, any(_globalUniforms.colorGreen.yx != _globalUniforms.colorRed.xy)));
return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>(check == 0));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/TernaryNesting.wgsl b/tests/sksl/shared/TernaryNesting.wgsl
index dfcd2d7..d4b4c40 100644
--- a/tests/sksl/shared/TernaryNesting.wgsl
+++ b/tests/sksl/shared/TernaryNesting.wgsl
@@ -1,23 +1,25 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorWhite: vec4<f32>,
+ colorWhite: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var colorBlue: vec4<f32> = vec4<f32>(0.0, 0.0, _globalUniforms.colorWhite.zw);
var colorGreen: vec4<f32> = vec4<f32>(0.0, _globalUniforms.colorWhite.y, 0.0, _globalUniforms.colorWhite.w);
var colorRed: vec4<f32> = vec4<f32>(_globalUniforms.colorWhite.x, 0.0, 0.0, _globalUniforms.colorWhite.w);
var result: vec4<f32> = select((select(_globalUniforms.colorWhite, colorBlue, vec4<bool>(any(colorRed != colorGreen)))), (select(colorGreen, colorRed, vec4<bool>(all(colorGreen == colorRed)))), vec4<bool>(any(_globalUniforms.colorWhite != colorBlue)));
return select((select((select(colorRed, colorBlue, vec4<bool>(all(colorRed == _globalUniforms.colorWhite)))), result, vec4<bool>(any(colorRed != colorGreen)))), _globalUniforms.colorWhite, vec4<bool>(all(colorRed == colorBlue)));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/TernaryTrueFalseOptimization.wgsl b/tests/sksl/shared/TernaryTrueFalseOptimization.wgsl
index e134349..9ff5182 100644
--- a/tests/sksl/shared/TernaryTrueFalseOptimization.wgsl
+++ b/tests/sksl/shared/TernaryTrueFalseOptimization.wgsl
@@ -1,16 +1,17 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var ok: bool = true;
ok = ok && _globalUniforms.colorGreen.y == 1.0;
ok = ok && !(_globalUniforms.colorGreen.x == 1.0);
@@ -19,9 +20,10 @@
ok = ok && (all(_globalUniforms.colorGreen.yx == _globalUniforms.colorRed.xy) || _globalUniforms.colorGreen.w != _globalUniforms.colorRed.w);
ok = ok && (any(_globalUniforms.colorGreen.yx != _globalUniforms.colorRed.xy) && _globalUniforms.colorGreen.w == _globalUniforms.colorRed.w);
return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>(ok));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/UnaryPositiveNegative.wgsl b/tests/sksl/shared/UnaryPositiveNegative.wgsl
index 14c9466..10168ab 100644
--- a/tests/sksl/shared/UnaryPositiveNegative.wgsl
+++ b/tests/sksl/shared/UnaryPositiveNegative.wgsl
@@ -1,83 +1,102 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorWhite: vec4<f32>,
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
- testMatrix2x2: mat2x2<f32>,
- testMatrix3x3: mat3x3<f32>,
- testMatrix4x4: mat4x4<f32>,
+ colorWhite: vec4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
+ testMatrix2x2: mat2x2<f32>,
+ testMatrix3x3: mat3x3<f32>,
+ testMatrix4x4: mat4x4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn test_iscalar_b() -> bool {
+ {
var x: i32 = i32(_globalUniforms.colorWhite.x);
x = -x;
return x == -1;
+ }
}
fn test_fvec_b() -> bool {
+ {
var x: vec2<f32> = _globalUniforms.colorWhite.xy;
x = -x;
return all(x == vec2<f32>(-1.0));
+ }
}
fn test_ivec_b() -> bool {
+ {
var x: vec2<i32> = vec2<i32>(i32(_globalUniforms.colorWhite.x));
x = -x;
return all(x == vec2<i32>(-1));
+ }
}
fn test_mat2_b() -> bool {
+ {
let negated: mat2x2<f32> = mat2x2<f32>(-1.0, -2.0, -3.0, -4.0);
var x: mat2x2<f32> = _globalUniforms.testMatrix2x2;
x = (-1.0 * x);
let _skTemp0 = x;
let _skTemp1 = negated;
return (all(_skTemp0[0] == _skTemp1[0]) && all(_skTemp0[1] == _skTemp1[1]));
+ }
}
fn test_mat3_b() -> bool {
+ {
let negated: mat3x3<f32> = mat3x3<f32>(-1.0, -2.0, -3.0, -4.0, -5.0, -6.0, -7.0, -8.0, -9.0);
var x: mat3x3<f32> = _globalUniforms.testMatrix3x3;
x = (-1.0 * x);
let _skTemp2 = x;
let _skTemp3 = negated;
return (all(_skTemp2[0] == _skTemp3[0]) && all(_skTemp2[1] == _skTemp3[1]) && all(_skTemp2[2] == _skTemp3[2]));
+ }
}
fn test_mat4_b() -> bool {
+ {
let negated: mat4x4<f32> = mat4x4<f32>(-1.0, -2.0, -3.0, -4.0, -5.0, -6.0, -7.0, -8.0, -9.0, -10.0, -11.0, -12.0, -13.0, -14.0, -15.0, -16.0);
var x: mat4x4<f32> = _globalUniforms.testMatrix4x4;
x = (-1.0 * x);
let _skTemp4 = x;
let _skTemp5 = negated;
return (all(_skTemp4[0] == _skTemp5[0]) && all(_skTemp4[1] == _skTemp5[1]) && all(_skTemp4[2] == _skTemp5[2]) && all(_skTemp4[3] == _skTemp5[3]));
+ }
}
fn test_hmat2_b() -> bool {
+ {
let negated: mat2x2<f32> = mat2x2<f32>(-1.0, -2.0, -3.0, -4.0);
var x: mat2x2<f32> = mat2x2<f32>(_globalUniforms.testMatrix2x2);
x = (-1.0 * x);
let _skTemp6 = x;
let _skTemp7 = negated;
return (all(_skTemp6[0] == _skTemp7[0]) && all(_skTemp6[1] == _skTemp7[1]));
+ }
}
fn test_hmat3_b() -> bool {
+ {
let negated: mat3x3<f32> = mat3x3<f32>(-1.0, -2.0, -3.0, -4.0, -5.0, -6.0, -7.0, -8.0, -9.0);
var x: mat3x3<f32> = mat3x3<f32>(_globalUniforms.testMatrix3x3);
x = (-1.0 * x);
let _skTemp8 = x;
let _skTemp9 = negated;
return (all(_skTemp8[0] == _skTemp9[0]) && all(_skTemp8[1] == _skTemp9[1]) && all(_skTemp8[2] == _skTemp9[2]));
+ }
}
fn test_hmat4_b() -> bool {
+ {
let negated: mat4x4<f32> = mat4x4<f32>(-1.0, -2.0, -3.0, -4.0, -5.0, -6.0, -7.0, -8.0, -9.0, -10.0, -11.0, -12.0, -13.0, -14.0, -15.0, -16.0);
var x: mat4x4<f32> = mat4x4<f32>(_globalUniforms.testMatrix4x4);
x = (-1.0 * x);
let _skTemp10 = x;
let _skTemp11 = negated;
return (all(_skTemp10[0] == _skTemp11[0]) && all(_skTemp10[1] == _skTemp11[1]) && all(_skTemp10[2] == _skTemp11[2]) && all(_skTemp10[3] == _skTemp11[3]));
+ }
}
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var _0_x: f32 = f32(_globalUniforms.colorWhite.x);
_0_x = -_0_x;
var _skTemp12: vec4<f32>;
@@ -91,68 +110,69 @@
var _skTemp20: bool;
var _skTemp21: bool;
if _0_x == -1.0 {
- let _skTemp22 = test_iscalar_b();
- _skTemp21 = _skTemp22;
+ let _skTemp22 = test_iscalar_b();
+ _skTemp21 = _skTemp22;
} else {
- _skTemp21 = false;
+ _skTemp21 = false;
}
if _skTemp21 {
- let _skTemp23 = test_fvec_b();
- _skTemp20 = _skTemp23;
+ let _skTemp23 = test_fvec_b();
+ _skTemp20 = _skTemp23;
} else {
- _skTemp20 = false;
+ _skTemp20 = false;
}
if _skTemp20 {
- let _skTemp24 = test_ivec_b();
- _skTemp19 = _skTemp24;
+ let _skTemp24 = test_ivec_b();
+ _skTemp19 = _skTemp24;
} else {
- _skTemp19 = false;
+ _skTemp19 = false;
}
if _skTemp19 {
- let _skTemp25 = test_mat2_b();
- _skTemp18 = _skTemp25;
+ let _skTemp25 = test_mat2_b();
+ _skTemp18 = _skTemp25;
} else {
- _skTemp18 = false;
+ _skTemp18 = false;
}
if _skTemp18 {
- let _skTemp26 = test_mat3_b();
- _skTemp17 = _skTemp26;
+ let _skTemp26 = test_mat3_b();
+ _skTemp17 = _skTemp26;
} else {
- _skTemp17 = false;
+ _skTemp17 = false;
}
if _skTemp17 {
- let _skTemp27 = test_mat4_b();
- _skTemp16 = _skTemp27;
+ let _skTemp27 = test_mat4_b();
+ _skTemp16 = _skTemp27;
} else {
- _skTemp16 = false;
+ _skTemp16 = false;
}
if _skTemp16 {
- let _skTemp28 = test_hmat2_b();
- _skTemp15 = _skTemp28;
+ let _skTemp28 = test_hmat2_b();
+ _skTemp15 = _skTemp28;
} else {
- _skTemp15 = false;
+ _skTemp15 = false;
}
if _skTemp15 {
- let _skTemp29 = test_hmat3_b();
- _skTemp14 = _skTemp29;
+ let _skTemp29 = test_hmat3_b();
+ _skTemp14 = _skTemp29;
} else {
- _skTemp14 = false;
+ _skTemp14 = false;
}
if _skTemp14 {
- let _skTemp30 = test_hmat4_b();
- _skTemp13 = _skTemp30;
+ let _skTemp30 = test_hmat4_b();
+ _skTemp13 = _skTemp30;
} else {
- _skTemp13 = false;
+ _skTemp13 = false;
}
if _skTemp13 {
- _skTemp12 = _globalUniforms.colorGreen;
+ _skTemp12 = _globalUniforms.colorGreen;
} else {
- _skTemp12 = _globalUniforms.colorRed;
+ _skTemp12 = _globalUniforms.colorRed;
}
return _skTemp12;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/UniformMatrixResize.wgsl b/tests/sksl/shared/UniformMatrixResize.wgsl
index 485950e..909f4f2 100644
--- a/tests/sksl/shared/UniformMatrixResize.wgsl
+++ b/tests/sksl/shared/UniformMatrixResize.wgsl
@@ -1,44 +1,48 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- testMatrix3x3: mat3x3<f32>,
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
+ testMatrix3x3: mat3x3<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn resizeMatrix_f22() -> mat2x2<f32> {
+ {
let _skTemp0 = _globalUniforms.testMatrix3x3;
return mat2x2<f32>(_skTemp0[0][0], _skTemp0[0][1], _skTemp0[1][0], _skTemp0[1][1]);
+ }
}
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var _skTemp1: vec4<f32>;
var _skTemp2: bool;
let _skTemp3 = resizeMatrix_f22();
let _skTemp4 = _skTemp3;
let _skTemp5 = mat2x2<f32>(1.0, 2.0, 4.0, 5.0);
if (all(_skTemp4[0] == _skTemp5[0]) && all(_skTemp4[1] == _skTemp5[1])) {
- let _skTemp6 = resizeMatrix_f22();
- let _skTemp7 = _skTemp6;
- let _skTemp8 = mat3x3<f32>(_skTemp7[0][0], _skTemp7[0][1], 0.0, _skTemp7[1][0], _skTemp7[1][1], 0.0, 0.0, 0.0, 1.0);
- let _skTemp9 = mat3x3<f32>(1.0, 2.0, 0.0, 4.0, 5.0, 0.0, 0.0, 0.0, 1.0);
- _skTemp2 = (all(_skTemp8[0] == _skTemp9[0]) && all(_skTemp8[1] == _skTemp9[1]) && all(_skTemp8[2] == _skTemp9[2]));
+ let _skTemp6 = resizeMatrix_f22();
+ let _skTemp7 = _skTemp6;
+ let _skTemp8 = mat3x3<f32>(_skTemp7[0][0], _skTemp7[0][1], 0.0, _skTemp7[1][0], _skTemp7[1][1], 0.0, 0.0, 0.0, 1.0);
+ let _skTemp9 = mat3x3<f32>(1.0, 2.0, 0.0, 4.0, 5.0, 0.0, 0.0, 0.0, 1.0);
+ _skTemp2 = (all(_skTemp8[0] == _skTemp9[0]) && all(_skTemp8[1] == _skTemp9[1]) && all(_skTemp8[2] == _skTemp9[2]));
} else {
- _skTemp2 = false;
+ _skTemp2 = false;
}
if _skTemp2 {
- _skTemp1 = _globalUniforms.colorGreen;
+ _skTemp1 = _globalUniforms.colorGreen;
} else {
- _skTemp1 = _globalUniforms.colorRed;
+ _skTemp1 = _globalUniforms.colorRed;
}
return _skTemp1;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/UnusedVariables.wgsl b/tests/sksl/shared/UnusedVariables.wgsl
index 7ebfcb3..8201eff 100644
--- a/tests/sksl/shared/UnusedVariables.wgsl
+++ b/tests/sksl/shared/UnusedVariables.wgsl
@@ -1,14 +1,17 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
fn userfunc_ff(v: f32) -> f32 {
+ {
return v + 1.0;
+ }
}
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var b: f32 = 2.0;
var c: f32 = 3.0;
b = 2.0;
@@ -22,27 +25,28 @@
b = _skTemp3;
b = b;
{
- var x: i32 = 0;
- loop {
- if x < 1 {
- {
- continue;
- }
- } else {
- break;
- }
- continuing {
- x = x + i32(1);
- }
+ var x: i32 = 0;
+ loop {
+ if x < 1 {
+ {
+ continue;
+ }
+ } else {
+ break;
}
+ continuing {
+ x = x + i32(1);
+ }
+ }
}
var d: f32 = c;
b = 3.0;
d = d + f32(1);
return vec4<f32>(f32(b == 2.0), f32(b == 3.0), f32(d == 5.0), f32(d == 4.0));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/VectorConstructors.wgsl b/tests/sksl/shared/VectorConstructors.wgsl
index c4f028c..bd9489e 100644
--- a/tests/sksl/shared/VectorConstructors.wgsl
+++ b/tests/sksl/shared/VectorConstructors.wgsl
@@ -1,20 +1,23 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
- unknownInput: f32,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
+ unknownInput: f32,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn check_bf2f2f2f3i2i2f2f2f4i2b4f2f2f2b2b2b3i4(v1: vec2<f32>, v2: vec2<f32>, v3: vec2<f32>, v4: vec3<f32>, v5: vec2<i32>, v6: vec2<i32>, v7: vec2<f32>, v8: vec2<f32>, v9: vec4<f32>, v10: vec2<i32>, v11: vec4<bool>, v12: vec2<f32>, v13: vec2<f32>, v14: vec2<f32>, v15: vec2<bool>, v16: vec2<bool>, v17: vec3<bool>, v18: vec4<i32>) -> bool {
+ {
return ((((((((((((((((f32(v1.x) + f32(v2.x)) + f32(v3.x)) + f32(v4.x)) + f32(v5.x)) + f32(v6.x)) + f32(v7.x)) + f32(v8.x)) + f32(v9.x)) + f32(v10.x)) + f32(v11.x)) + f32(v12.x)) + f32(v13.x)) + f32(v14.x)) + f32(v15.x)) + f32(v16.x)) + f32(v17.x)) + f32(v18.x) == 18.0;
+ }
}
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var v1: vec2<f32> = vec2<f32>(1.0);
var v2: vec2<f32> = vec2<f32>(1.0, 2.0);
var v3: vec2<f32> = vec2<f32>(1.0);
@@ -36,14 +39,15 @@
var _skTemp0: vec4<f32>;
let _skTemp1 = check_bf2f2f2f3i2i2f2f2f4i2b4f2f2f2b2b2b3i4(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18);
if _skTemp1 {
- _skTemp0 = _globalUniforms.colorGreen;
+ _skTemp0 = _globalUniforms.colorGreen;
} else {
- _skTemp0 = _globalUniforms.colorRed;
+ _skTemp0 = _globalUniforms.colorRed;
}
return _skTemp0;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/VertexID.wgsl b/tests/sksl/shared/VertexID.wgsl
index ba6a94e..84315c6 100644
--- a/tests/sksl/shared/VertexID.wgsl
+++ b/tests/sksl/shared/VertexID.wgsl
@@ -1,15 +1,17 @@
struct VSIn {
- @builtin(vertex_index) sk_VertexID: u32,
+ @builtin(vertex_index) sk_VertexID: u32,
};
struct VSOut {
- @location(1) @interpolate(flat) id: i32,
- @builtin(position) sk_Position: vec4<f32>,
+ @location(1) @interpolate(flat) id: i32,
+ @builtin(position) sk_Position: vec4<f32>,
};
fn main(_stageIn: VSIn, _stageOut: ptr<function, VSOut>) {
+ {
(*_stageOut).id = i32(_stageIn.sk_VertexID);
+ }
}
@vertex fn vertexMain(_stageIn: VSIn) -> VSOut {
- var _stageOut: VSOut;
- main(_stageIn, &_stageOut);
- return _stageOut;
+ var _stageOut: VSOut;
+ main(_stageIn, &_stageOut);
+ return _stageOut;
}
diff --git a/tests/sksl/shared/WhileLoopControlFlow.wgsl b/tests/sksl/shared/WhileLoopControlFlow.wgsl
index e7792c6..d2c9817 100644
--- a/tests/sksl/shared/WhileLoopControlFlow.wgsl
+++ b/tests/sksl/shared/WhileLoopControlFlow.wgsl
@@ -1,41 +1,43 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var x: vec4<f32> = vec4<f32>(1.0);
loop {
- if x.w == 1.0 {
- {
- x.x = x.x - 0.25;
- if (x.x <= 0.0) {
- break;
- }
- }
- } else {
+ if x.w == 1.0 {
+ {
+ x.x = x.x - 0.25;
+ if (x.x <= 0.0) {
break;
+ }
}
+ } else {
+ break;
+ }
}
loop {
- if x.z > 0.0 {
- {
- x.z = x.z - 0.25;
- if (x.w == 1.0) {
- continue;
- }
- x.y = 0.0;
- }
- } else {
- break;
+ if x.z > 0.0 {
+ {
+ x.z = x.z - 0.25;
+ if (x.w == 1.0) {
+ continue;
+ }
+ x.y = 0.0;
}
+ } else {
+ break;
+ }
}
return x;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/wgsl/BuiltinFragmentStageIO.wgsl b/tests/sksl/wgsl/BuiltinFragmentStageIO.wgsl
index a8107d1..d794a95 100644
--- a/tests/sksl/wgsl/BuiltinFragmentStageIO.wgsl
+++ b/tests/sksl/wgsl/BuiltinFragmentStageIO.wgsl
@@ -1,17 +1,19 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
fn main(_stageIn: FSIn, _stageOut: ptr<function, FSOut>) {
+ {
var x: f32 = _stageIn.sk_FragCoord.x;
var y: f32 = f32(_stageIn.sk_Clockwise);
(*_stageOut).sk_FragColor = vec4<f32>(f32(x), f32(y), 1.0, 1.0);
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- main(_stageIn, &_stageOut);
- return _stageOut;
+ var _stageOut: FSOut;
+ main(_stageIn, &_stageOut);
+ return _stageOut;
}
diff --git a/tests/sksl/wgsl/BuiltinVertexStageIO.wgsl b/tests/sksl/wgsl/BuiltinVertexStageIO.wgsl
index b3d7b42..4f511fb 100644
--- a/tests/sksl/wgsl/BuiltinVertexStageIO.wgsl
+++ b/tests/sksl/wgsl/BuiltinVertexStageIO.wgsl
@@ -1,19 +1,21 @@
struct VSIn {
- @builtin(instance_index) sk_InstanceID: u32,
- @builtin(vertex_index) sk_VertexID: u32,
+ @builtin(instance_index) sk_InstanceID: u32,
+ @builtin(vertex_index) sk_VertexID: u32,
};
struct VSOut {
- @builtin(position) sk_Position: vec4<f32>,
+ @builtin(position) sk_Position: vec4<f32>,
};
/* unsupported */ var<private> sk_PointSize: f32;
fn main(_stageIn: VSIn, _stageOut: ptr<function, VSOut>) {
+ {
var x: f32 = f32(i32(_stageIn.sk_VertexID));
var y: f32 = f32(i32(_stageIn.sk_InstanceID));
sk_PointSize = x;
(*_stageOut).sk_Position = vec4<f32>(x, y, 1.0, 1.0);
+ }
}
@vertex fn vertexMain(_stageIn: VSIn) -> VSOut {
- var _stageOut: VSOut;
- main(_stageIn, &_stageOut);
- return _stageOut;
+ var _stageOut: VSOut;
+ main(_stageIn, &_stageOut);
+ return _stageOut;
}
diff --git a/tests/sksl/wgsl/CastMat2x2ToMat3x3.wgsl b/tests/sksl/wgsl/CastMat2x2ToMat3x3.wgsl
index 00f7099..b38ed19 100644
--- a/tests/sksl/wgsl/CastMat2x2ToMat3x3.wgsl
+++ b/tests/sksl/wgsl/CastMat2x2ToMat3x3.wgsl
@@ -1,17 +1,19 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(front_facing) sk_Clockwise: bool,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
fn main(_stageOut: ptr<function, FSOut>) {
+ {
var a: mat3x3<f32> = mat3x3<f32>(1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0);
let _skTemp0 = mat2x2<f32>(1.0, 0.0, 0.0, 1.0);
var b: mat3x3<f32> = mat3x3<f32>(_skTemp0[0][0], _skTemp0[0][1], 0.0, _skTemp0[1][0], _skTemp0[1][1], 0.0, 0.0, 0.0, 1.0);
(*_stageOut).sk_FragColor.x = f32(select(1, 0, all(a[0] == b[0])));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- main(&_stageOut);
- return _stageOut;
+ var _stageOut: FSOut;
+ main(&_stageOut);
+ return _stageOut;
}
diff --git a/tests/sksl/wgsl/CastMat2x2ToVec4.wgsl b/tests/sksl/wgsl/CastMat2x2ToVec4.wgsl
index a5c5882..4207d47 100644
--- a/tests/sksl/wgsl/CastMat2x2ToVec4.wgsl
+++ b/tests/sksl/wgsl/CastMat2x2ToVec4.wgsl
@@ -1,19 +1,21 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(front_facing) sk_Clockwise: bool,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- f: mat2x2<f32>,
- h: mat2x2<f32>,
+ f: mat2x2<f32>,
+ h: mat2x2<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main(_stageOut: ptr<function, FSOut>) {
+ {
(*_stageOut).sk_FragColor = (vec4<f32>(_globalUniforms.h[0], _globalUniforms.h[1]) + vec4<f32>(vec4<f32>(_globalUniforms.f[0], _globalUniforms.f[1]))) + vec4<f32>(vec4<f32>(vec4<f32>(_globalUniforms.h[0], _globalUniforms.h[1])) + vec4<f32>(_globalUniforms.f[0], _globalUniforms.f[1]));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- main(&_stageOut);
- return _stageOut;
+ var _stageOut: FSOut;
+ main(&_stageOut);
+ return _stageOut;
}
diff --git a/tests/sksl/wgsl/CastMat2x3ToMat4x4.wgsl b/tests/sksl/wgsl/CastMat2x3ToMat4x4.wgsl
index 9e269b8..56e777b 100644
--- a/tests/sksl/wgsl/CastMat2x3ToMat4x4.wgsl
+++ b/tests/sksl/wgsl/CastMat2x3ToMat4x4.wgsl
@@ -1,17 +1,19 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(front_facing) sk_Clockwise: bool,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
fn main(_stageOut: ptr<function, FSOut>) {
+ {
var a: mat4x4<f32> = mat4x4<f32>(6.0, 0.0, 0.0, 0.0, 0.0, 6.0, 0.0, 0.0, 0.0, 0.0, 6.0, 0.0, 0.0, 0.0, 0.0, 6.0);
let _skTemp0 = mat2x3<f32>(7.0, 0.0, 0.0, 0.0, 7.0, 0.0);
var b: mat4x4<f32> = mat4x4<f32>(_skTemp0[0][0], _skTemp0[0][1], _skTemp0[0][2], 0.0, _skTemp0[1][0], _skTemp0[1][1], _skTemp0[1][2], 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0);
(*_stageOut).sk_FragColor.x = f32(select(1, 0, all(a[1] == b[1])));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- main(&_stageOut);
- return _stageOut;
+ var _stageOut: FSOut;
+ main(&_stageOut);
+ return _stageOut;
}
diff --git a/tests/sksl/wgsl/CastMat4x4ToMat3x4.wgsl b/tests/sksl/wgsl/CastMat4x4ToMat3x4.wgsl
index e9bbe3e..7bd416d 100644
--- a/tests/sksl/wgsl/CastMat4x4ToMat3x4.wgsl
+++ b/tests/sksl/wgsl/CastMat4x4ToMat3x4.wgsl
@@ -1,17 +1,19 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(front_facing) sk_Clockwise: bool,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
fn main(_stageOut: ptr<function, FSOut>) {
+ {
var a: mat3x4<f32> = mat3x4<f32>(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
let _skTemp0 = mat4x4<f32>(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0);
var b: mat3x4<f32> = mat3x4<f32>(_skTemp0[0][0], _skTemp0[0][1], _skTemp0[0][2], _skTemp0[0][3], _skTemp0[1][0], _skTemp0[1][1], _skTemp0[1][2], _skTemp0[1][3], _skTemp0[2][0], _skTemp0[2][1], _skTemp0[2][2], _skTemp0[2][3]);
(*_stageOut).sk_FragColor.x = f32(select(1, 0, all(a[0] == b[0])));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- main(&_stageOut);
- return _stageOut;
+ var _stageOut: FSOut;
+ main(&_stageOut);
+ return _stageOut;
}
diff --git a/tests/sksl/wgsl/CastMat4x4ToMat4x3.wgsl b/tests/sksl/wgsl/CastMat4x4ToMat4x3.wgsl
index 0cc41dd..e90cf35 100644
--- a/tests/sksl/wgsl/CastMat4x4ToMat4x3.wgsl
+++ b/tests/sksl/wgsl/CastMat4x4ToMat4x3.wgsl
@@ -1,17 +1,19 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(front_facing) sk_Clockwise: bool,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
fn main(_stageOut: ptr<function, FSOut>) {
+ {
var a: mat4x3<f32> = mat4x3<f32>(1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0);
let _skTemp0 = mat4x4<f32>(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0);
var b: mat4x3<f32> = mat4x3<f32>(_skTemp0[0][0], _skTemp0[0][1], _skTemp0[0][2], _skTemp0[1][0], _skTemp0[1][1], _skTemp0[1][2], _skTemp0[2][0], _skTemp0[2][1], _skTemp0[2][2], _skTemp0[3][0], _skTemp0[3][1], _skTemp0[3][2]);
(*_stageOut).sk_FragColor.x = f32(select(1, 0, all(a[0] == b[0])));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- main(&_stageOut);
- return _stageOut;
+ var _stageOut: FSOut;
+ main(&_stageOut);
+ return _stageOut;
}
diff --git a/tests/sksl/wgsl/CastVec4ToMat2x2.wgsl b/tests/sksl/wgsl/CastVec4ToMat2x2.wgsl
index ee794f5..f4c4bf9 100644
--- a/tests/sksl/wgsl/CastVec4ToMat2x2.wgsl
+++ b/tests/sksl/wgsl/CastVec4ToMat2x2.wgsl
@@ -1,18 +1,20 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(front_facing) sk_Clockwise: bool,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
fn main(_stageOut: ptr<function, FSOut>) {
+ {
var m1: mat2x2<f32> = mat2x2<f32>(1.0, 2.0, 3.0, 4.0);
var m2: mat2x2<f32> = mat2x2<f32>(1.0, 2.0, 3.0, 4.0);
var m3: mat2x2<f32> = mat2x2<f32>(1.0, 2.0, 3.0, 4.0);
var m4: mat2x2<f32> = mat2x2<f32>(1.0, 2.0, 3.0, 4.0);
(*_stageOut).sk_FragColor = ((m1 * m2) * mat2x2<f32>(m3 * m4)[0]).xyxy;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- main(&_stageOut);
- return _stageOut;
+ var _stageOut: FSOut;
+ main(&_stageOut);
+ return _stageOut;
}
diff --git a/tests/sksl/wgsl/Equality.wgsl b/tests/sksl/wgsl/Equality.wgsl
index a32eadf..7c8873d 100644
--- a/tests/sksl/wgsl/Equality.wgsl
+++ b/tests/sksl/wgsl/Equality.wgsl
@@ -1,33 +1,34 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(front_facing) sk_Clockwise: bool,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- f1: f32,
- f2: f32,
- f3: f32,
- h1: f32,
- h2: f32,
- h3: f32,
- v1: vec2<f32>,
- v2: vec2<f32>,
- v3: vec2<f32>,
- hv1: vec2<f32>,
- hv2: vec2<f32>,
- hv3: vec2<f32>,
- m1: mat2x2<f32>,
- m2: mat2x2<f32>,
- m3: mat2x2<f32>,
- hm1: mat2x2<f32>,
- hm2: mat2x2<f32>,
- hm3: mat2x2<f32>,
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
+ f1: f32,
+ f2: f32,
+ f3: f32,
+ h1: f32,
+ h2: f32,
+ h3: f32,
+ v1: vec2<f32>,
+ v2: vec2<f32>,
+ v3: vec2<f32>,
+ hv1: vec2<f32>,
+ hv2: vec2<f32>,
+ hv3: vec2<f32>,
+ m1: mat2x2<f32>,
+ m2: mat2x2<f32>,
+ m3: mat2x2<f32>,
+ hm1: mat2x2<f32>,
+ hm2: mat2x2<f32>,
+ hm3: mat2x2<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main() -> vec4<f32> {
+ {
var ok: bool = true;
ok = ok && _globalUniforms.f1 == _globalUniforms.f2;
ok = ok && _globalUniforms.h1 == _globalUniforms.h2;
@@ -70,9 +71,10 @@
let _skTemp15 = _globalUniforms.m3;
ok = ok && !(all(_skTemp14[0] == _skTemp15[0]) && all(_skTemp14[1] == _skTemp15[1]));
return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>(ok));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main();
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main();
+ return _stageOut;
}
diff --git a/tests/sksl/wgsl/FunctionCallDependencies.wgsl b/tests/sksl/wgsl/FunctionCallDependencies.wgsl
index aeb3636..8e1c077 100644
--- a/tests/sksl/wgsl/FunctionCallDependencies.wgsl
+++ b/tests/sksl/wgsl/FunctionCallDependencies.wgsl
@@ -1,34 +1,46 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
fn getColor_h4h(c: f32) -> vec4<f32> {
+ {
return vec4<f32>(c);
+ }
}
fn getFragCoordAugmentedColor_h4h(_stageIn: FSIn, c: f32) -> vec4<f32> {
+ {
let _skTemp0 = getColor_h4h(c);
return vec4<f32>(_stageIn.sk_FragCoord.xyxy * vec4<f32>(_skTemp0));
+ }
}
fn writeColorToOutput_vh(_stageOut: ptr<function, FSOut>, c: f32) {
+ {
let _skTemp1 = getColor_h4h(c);
(*_stageOut).sk_FragColor = _skTemp1;
+ }
}
fn writeToOutput_v(_stageOut: ptr<function, FSOut>) {
+ {
writeColorToOutput_vh(_stageOut, 1.0);
+ }
}
fn modifyOutputColor_v(_stageIn: FSIn, _stageOut: ptr<function, FSOut>) {
+ {
let _skTemp2 = getFragCoordAugmentedColor_h4h(_stageIn, 2.0);
(*_stageOut).sk_FragColor = (*_stageOut).sk_FragColor + _skTemp2;
+ }
}
fn main(_stageIn: FSIn, _stageOut: ptr<function, FSOut>) {
+ {
writeToOutput_v(_stageOut);
modifyOutputColor_v(_stageIn, _stageOut);
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- main(_stageIn, &_stageOut);
- return _stageOut;
+ var _stageOut: FSOut;
+ main(_stageIn, &_stageOut);
+ return _stageOut;
}
diff --git a/tests/sksl/wgsl/GlobalUniforms.wgsl b/tests/sksl/wgsl/GlobalUniforms.wgsl
index 75c6d3f..5aee95e 100644
--- a/tests/sksl/wgsl/GlobalUniforms.wgsl
+++ b/tests/sksl/wgsl/GlobalUniforms.wgsl
@@ -1,20 +1,22 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(front_facing) sk_Clockwise: bool,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
- _array: array<vec4<f32>, 5>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
+ _array: array<vec4<f32>, 5>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main() -> vec4<f32> {
+ {
return vec4<f32>(_globalUniforms.colorGreen.x, _globalUniforms.colorRed.x, 0.0, 1.0);
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main();
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main();
+ return _stageOut;
}
diff --git a/tests/sksl/wgsl/IfStatement.wgsl b/tests/sksl/wgsl/IfStatement.wgsl
index 1c180ce..8468618 100644
--- a/tests/sksl/wgsl/IfStatement.wgsl
+++ b/tests/sksl/wgsl/IfStatement.wgsl
@@ -1,60 +1,66 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(front_facing) sk_Clockwise: bool,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn unbraced_v(_stageOut: ptr<function, FSOut>) {
+ {
if (_globalUniforms.colorGreen.y == 1.0) {
- (*_stageOut).sk_FragColor = _globalUniforms.colorGreen;
+ (*_stageOut).sk_FragColor = _globalUniforms.colorGreen;
} else {
- if (_globalUniforms.colorRed.x == 1.0) {
- if (_globalUniforms.colorRed.y == 0.0) {
- (*_stageOut).sk_FragColor = _globalUniforms.colorGreen;
- } else {
- (*_stageOut).sk_FragColor = _globalUniforms.colorRed;
- }
+ if (_globalUniforms.colorRed.x == 1.0) {
+ if (_globalUniforms.colorRed.y == 0.0) {
+ (*_stageOut).sk_FragColor = _globalUniforms.colorGreen;
} else {
- (*_stageOut).sk_FragColor = _globalUniforms.colorRed;
+ (*_stageOut).sk_FragColor = _globalUniforms.colorRed;
}
+ } else {
+ (*_stageOut).sk_FragColor = _globalUniforms.colorRed;
+ }
}
+ }
}
fn braced_v(_stageOut: ptr<function, FSOut>) {
+ {
if (_globalUniforms.colorGreen.y == 1.0) {
- {
- (*_stageOut).sk_FragColor = _globalUniforms.colorGreen;
- }
+ {
+ (*_stageOut).sk_FragColor = _globalUniforms.colorGreen;
+ }
} else {
- if (_globalUniforms.colorRed.x == 1.0) {
+ if (_globalUniforms.colorRed.x == 1.0) {
+ {
+ if (_globalUniforms.colorRed.y == 0.0) {
{
- if (_globalUniforms.colorRed.y == 0.0) {
- {
- (*_stageOut).sk_FragColor = _globalUniforms.colorGreen;
- }
- } else {
- {
- (*_stageOut).sk_FragColor = _globalUniforms.colorRed;
- }
- }
+ (*_stageOut).sk_FragColor = _globalUniforms.colorGreen;
}
- } else {
+ } else {
{
- (*_stageOut).sk_FragColor = _globalUniforms.colorRed;
+ (*_stageOut).sk_FragColor = _globalUniforms.colorRed;
}
+ }
}
+ } else {
+ {
+ (*_stageOut).sk_FragColor = _globalUniforms.colorRed;
+ }
+ }
}
+ }
}
fn main(_stageOut: ptr<function, FSOut>) {
+ {
unbraced_v(_stageOut);
braced_v(_stageOut);
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- main(&_stageOut);
- return _stageOut;
+ var _stageOut: FSOut;
+ main(&_stageOut);
+ return _stageOut;
}
diff --git a/tests/sksl/wgsl/IndexExpression.wgsl b/tests/sksl/wgsl/IndexExpression.wgsl
index 92d9efa..dec4943 100644
--- a/tests/sksl/wgsl/IndexExpression.wgsl
+++ b/tests/sksl/wgsl/IndexExpression.wgsl
@@ -1,23 +1,25 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(front_facing) sk_Clockwise: bool,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- _array: array<vec4<f32>, 5>,
- vector: vec2<f32>,
- matrix: mat2x2<f32>,
- idx: i32,
+ _array: array<vec4<f32>, 5>,
+ vector: vec2<f32>,
+ matrix: mat2x2<f32>,
+ idx: i32,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main() -> vec4<f32> {
+ {
let _skTemp0 = _globalUniforms.idx + 1;
let _skTemp1 = _globalUniforms.idx + 1;
return vec4<f32>(f32(_globalUniforms._array[_globalUniforms.idx][_globalUniforms.idx]), f32(_globalUniforms.vector[_skTemp0]), f32(_globalUniforms.matrix[_globalUniforms.idx][_skTemp1]), 1.0);
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main();
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main();
+ return _stageOut;
}
diff --git a/tests/sksl/wgsl/MainDoesNotHaveFragCoordParameter.wgsl b/tests/sksl/wgsl/MainDoesNotHaveFragCoordParameter.wgsl
index 447de17..0568402 100644
--- a/tests/sksl/wgsl/MainDoesNotHaveFragCoordParameter.wgsl
+++ b/tests/sksl/wgsl/MainDoesNotHaveFragCoordParameter.wgsl
@@ -1,15 +1,17 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
fn main(_stageIn: FSIn) -> vec4<f32> {
+ {
return vec4<f32>(f32(_stageIn.sk_FragCoord.x), 0.0, 0.0, 1.0);
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn);
+ return _stageOut;
}
diff --git a/tests/sksl/wgsl/MainHasFragCoordParameter.wgsl b/tests/sksl/wgsl/MainHasFragCoordParameter.wgsl
index 63d3be6..a98f8f4 100644
--- a/tests/sksl/wgsl/MainHasFragCoordParameter.wgsl
+++ b/tests/sksl/wgsl/MainHasFragCoordParameter.wgsl
@@ -1,15 +1,17 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
return vec4<f32>(f32(coords.x), f32(coords.y), 1.0, 1.0);
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/wgsl/MainHasVoidReturn.wgsl b/tests/sksl/wgsl/MainHasVoidReturn.wgsl
index 68e0702..04abbcb 100644
--- a/tests/sksl/wgsl/MainHasVoidReturn.wgsl
+++ b/tests/sksl/wgsl/MainHasVoidReturn.wgsl
@@ -1,14 +1,16 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(front_facing) sk_Clockwise: bool,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
fn main(_stageOut: ptr<function, FSOut>) {
+ {
(*_stageOut).sk_FragColor = vec4<f32>(1.0);
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- main(&_stageOut);
- return _stageOut;
+ var _stageOut: FSOut;
+ main(&_stageOut);
+ return _stageOut;
}
diff --git a/tests/sksl/wgsl/MatrixConstructorDiagonal.wgsl b/tests/sksl/wgsl/MatrixConstructorDiagonal.wgsl
index 66778c5..7cbb2a8 100644
--- a/tests/sksl/wgsl/MatrixConstructorDiagonal.wgsl
+++ b/tests/sksl/wgsl/MatrixConstructorDiagonal.wgsl
@@ -1,24 +1,26 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(front_facing) sk_Clockwise: bool,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
- h: f32,
- f: f32,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
+ h: f32,
+ f: f32,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn main() -> vec4<f32> {
+ {
var ok: bool = true;
ok = ok && all(mat2x2<f32>(2.0, 0.0, 0.0, 2.0) * vec2<f32>(_globalUniforms.f) == vec2<f32>(2.0 * _globalUniforms.f));
ok = ok && all(mat4x4<f32>(2.0, 0.0, 0.0, 0.0, 0.0, 2.0, 0.0, 0.0, 0.0, 0.0, 2.0, 0.0, 0.0, 0.0, 0.0, 2.0) * vec4<f32>(_globalUniforms.h) == vec4<f32>(2.0 * _globalUniforms.h));
return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>(ok));
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main();
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main();
+ return _stageOut;
}
diff --git a/tests/sksl/wgsl/OutParams.wgsl b/tests/sksl/wgsl/OutParams.wgsl
index 386f3a7..2370c5d 100644
--- a/tests/sksl/wgsl/OutParams.wgsl
+++ b/tests/sksl/wgsl/OutParams.wgsl
@@ -1,30 +1,37 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(front_facing) sk_Clockwise: bool,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- uFloat: f32,
+ uFloat: f32,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn various_parameter_types_vhhh(_stageOut: ptr<function, FSOut>, a: f32, b: ptr<function, f32>, c: ptr<function, f32>) {
+ {
(*_stageOut).sk_FragColor = vec4<f32>(a, (*b), (*c), _globalUniforms.uFloat);
(*b) = a;
(*c) = _globalUniforms.uFloat;
+ }
}
fn one_out_param_vh(h: ptr<function, f32>) {
+ {
(*h) = 2.0;
+ }
}
fn one_out_param_indirect_vh(h: ptr<function, f32>) {
+ {
var _skTemp0: f32;
one_out_param_vh(&_skTemp0);
(*h) = _skTemp0;
+ }
}
struct S {
- v: vec4<f32>,
+ v: vec4<f32>,
};
fn main(_stageOut: ptr<function, FSOut>) {
+ {
var x: f32 = 1.0;
var _skTemp1: f32;
one_out_param_vh(&_skTemp1);
@@ -64,9 +71,10 @@
various_parameter_types_vhhh(_stageOut, x + 1.0, &_skTemp13, &_skTemp14);
s.v.y = _skTemp13;
x = _skTemp14;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- main(&_stageOut);
- return _stageOut;
+ var _stageOut: FSOut;
+ main(&_stageOut);
+ return _stageOut;
}
diff --git a/tests/sksl/wgsl/TernaryThenShortCircuit.wgsl b/tests/sksl/wgsl/TernaryThenShortCircuit.wgsl
index a942537..d2c5419 100644
--- a/tests/sksl/wgsl/TernaryThenShortCircuit.wgsl
+++ b/tests/sksl/wgsl/TernaryThenShortCircuit.wgsl
@@ -1,168 +1,182 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @builtin(position) sk_FragCoord: vec4<f32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @builtin(position) sk_FragCoord: vec4<f32>,
};
struct FSOut {
- @location(0) sk_FragColor: vec4<f32>,
+ @location(0) sk_FragColor: vec4<f32>,
};
struct _GlobalUniforms {
- colorGreen: vec4<f32>,
- colorRed: vec4<f32>,
+ colorGreen: vec4<f32>,
+ colorRed: vec4<f32>,
};
@binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
fn Increment_ii(y: ptr<function, i32>) -> i32 {
+ {
(*y) = (*y) + 1;
return (*y);
+ }
}
fn True_b() -> bool {
+ {
return true;
+ }
}
fn False_b() -> bool {
+ {
return false;
+ }
}
fn TrueFalse_b() -> bool {
+ {
var x: i32 = 1;
var y: i32 = 1;
var _skTemp0: bool;
var _skTemp1: bool;
if x == 1 {
- let _skTemp2 = True_b();
- _skTemp1 = _skTemp2;
+ let _skTemp2 = True_b();
+ _skTemp1 = _skTemp2;
} else {
- let _skTemp3 = False_b();
- _skTemp1 = _skTemp3;
+ let _skTemp3 = False_b();
+ _skTemp1 = _skTemp3;
}
if _skTemp1 {
- _skTemp0 = true;
+ _skTemp0 = true;
} else {
- var _skTemp4: i32 = y;
- let _skTemp5 = Increment_ii(&_skTemp4);
- y = _skTemp4;
- _skTemp0 = _skTemp5 == 3;
+ var _skTemp4: i32 = y;
+ let _skTemp5 = Increment_ii(&_skTemp4);
+ y = _skTemp4;
+ _skTemp0 = _skTemp5 == 3;
}
if (_skTemp0) {
- {
- return x == 1 && y == 1;
- }
+ {
+ return x == 1 && y == 1;
+ }
} else {
- {
- return false;
- }
+ {
+ return false;
+ }
}
+ }
}
fn FalseTrue_b() -> bool {
+ {
var x: i32 = 1;
var y: i32 = 1;
var _skTemp6: bool;
var _skTemp7: bool;
if x == 2 {
- let _skTemp8 = True_b();
- _skTemp7 = _skTemp8;
+ let _skTemp8 = True_b();
+ _skTemp7 = _skTemp8;
} else {
- let _skTemp9 = False_b();
- _skTemp7 = _skTemp9;
+ let _skTemp9 = False_b();
+ _skTemp7 = _skTemp9;
}
if _skTemp7 {
- _skTemp6 = true;
+ _skTemp6 = true;
} else {
- var _skTemp10: i32 = y;
- let _skTemp11 = Increment_ii(&_skTemp10);
- y = _skTemp10;
- _skTemp6 = _skTemp11 == 2;
+ var _skTemp10: i32 = y;
+ let _skTemp11 = Increment_ii(&_skTemp10);
+ y = _skTemp10;
+ _skTemp6 = _skTemp11 == 2;
}
if (_skTemp6) {
- {
- return x == 1 && y == 2;
- }
+ {
+ return x == 1 && y == 2;
+ }
} else {
- {
- return false;
- }
+ {
+ return false;
+ }
}
+ }
}
fn FalseFalse_b() -> bool {
+ {
var x: i32 = 1;
var y: i32 = 1;
var _skTemp12: bool;
var _skTemp13: bool;
if x == 2 {
- let _skTemp14 = True_b();
- _skTemp13 = _skTemp14;
+ let _skTemp14 = True_b();
+ _skTemp13 = _skTemp14;
} else {
- let _skTemp15 = False_b();
- _skTemp13 = _skTemp15;
+ let _skTemp15 = False_b();
+ _skTemp13 = _skTemp15;
}
if _skTemp13 {
- _skTemp12 = true;
+ _skTemp12 = true;
} else {
- var _skTemp16: i32 = y;
- let _skTemp17 = Increment_ii(&_skTemp16);
- y = _skTemp16;
- _skTemp12 = _skTemp17 == 3;
+ var _skTemp16: i32 = y;
+ let _skTemp17 = Increment_ii(&_skTemp16);
+ y = _skTemp16;
+ _skTemp12 = _skTemp17 == 3;
}
if (_skTemp12) {
- {
- return false;
- }
+ {
+ return false;
+ }
} else {
- {
- return x == 1 && y == 2;
- }
+ {
+ return x == 1 && y == 2;
+ }
}
+ }
}
fn main(coords: vec2<f32>) -> vec4<f32> {
+ {
var _0_TrueTrue: bool;
var _2_y: i32 = 1;
var _skTemp18: bool;
let _skTemp19 = True_b();
if _skTemp19 {
- _skTemp18 = true;
+ _skTemp18 = true;
} else {
- var _skTemp20: i32 = _2_y;
- let _skTemp21 = Increment_ii(&_skTemp20);
- _2_y = _skTemp20;
- _skTemp18 = _skTemp21 == 2;
+ var _skTemp20: i32 = _2_y;
+ let _skTemp21 = Increment_ii(&_skTemp20);
+ _2_y = _skTemp20;
+ _skTemp18 = _skTemp21 == 2;
}
if (_skTemp18) {
- {
- _0_TrueTrue = _2_y == 1;
- }
+ {
+ _0_TrueTrue = _2_y == 1;
+ }
} else {
- {
- _0_TrueTrue = false;
- }
+ {
+ _0_TrueTrue = false;
+ }
}
var _skTemp22: vec4<f32>;
var _skTemp23: bool;
var _skTemp24: bool;
var _skTemp25: bool;
if _0_TrueTrue {
- let _skTemp26 = TrueFalse_b();
- _skTemp25 = _skTemp26;
+ let _skTemp26 = TrueFalse_b();
+ _skTemp25 = _skTemp26;
} else {
- _skTemp25 = false;
+ _skTemp25 = false;
}
if _skTemp25 {
- let _skTemp27 = FalseTrue_b();
- _skTemp24 = _skTemp27;
+ let _skTemp27 = FalseTrue_b();
+ _skTemp24 = _skTemp27;
} else {
- _skTemp24 = false;
+ _skTemp24 = false;
}
if _skTemp24 {
- let _skTemp28 = FalseFalse_b();
- _skTemp23 = _skTemp28;
+ let _skTemp28 = FalseFalse_b();
+ _skTemp23 = _skTemp28;
} else {
- _skTemp23 = false;
+ _skTemp23 = false;
}
if _skTemp23 {
- _skTemp22 = _globalUniforms.colorGreen;
+ _skTemp22 = _globalUniforms.colorGreen;
} else {
- _skTemp22 = _globalUniforms.colorRed;
+ _skTemp22 = _globalUniforms.colorRed;
}
return _skTemp22;
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
- return _stageOut;
+ var _stageOut: FSOut;
+ _stageOut.sk_FragColor = main(_stageIn.sk_FragCoord.xy);
+ return _stageOut;
}
diff --git a/tests/sksl/wgsl/UserDefinedPipelineIO.wgsl b/tests/sksl/wgsl/UserDefinedPipelineIO.wgsl
index f140a1d..7dcf218 100644
--- a/tests/sksl/wgsl/UserDefinedPipelineIO.wgsl
+++ b/tests/sksl/wgsl/UserDefinedPipelineIO.wgsl
@@ -1,22 +1,24 @@
struct FSIn {
- @builtin(front_facing) sk_Clockwise: bool,
- @location(1) input1: f32,
- @location(2) input2: f32,
- @location(3) input3: vec2<f32>,
- @location(4) @interpolate(flat) input4: i32,
- @location(5) @interpolate(flat) input5: vec2<i32>,
+ @builtin(front_facing) sk_Clockwise: bool,
+ @location(1) input1: f32,
+ @location(2) input2: f32,
+ @location(3) input3: vec2<f32>,
+ @location(4) @interpolate(flat) input4: i32,
+ @location(5) @interpolate(flat) input5: vec2<i32>,
};
struct FSOut {
- @location(1) output1: f32,
- @location(2) output2: f32,
- @location(3) output3: vec2<f32>,
- @location(4) @interpolate(flat) output4: i32,
- @location(5) @interpolate(flat) output5: vec2<i32>,
+ @location(1) output1: f32,
+ @location(2) output2: f32,
+ @location(3) output3: vec2<f32>,
+ @location(4) @interpolate(flat) output4: i32,
+ @location(5) @interpolate(flat) output5: vec2<i32>,
};
fn main() {
+ {
+ }
}
@fragment fn fragmentMain(_stageIn: FSIn) -> FSOut {
- var _stageOut: FSOut;
- main();
- return _stageOut;
+ var _stageOut: FSOut;
+ main();
+ return _stageOut;
}
diff --git a/tests/sksl/wgsl/VertexPositionOutputIsAlwaysDeclared.wgsl b/tests/sksl/wgsl/VertexPositionOutputIsAlwaysDeclared.wgsl
index 33b2f88..5472b50 100644
--- a/tests/sksl/wgsl/VertexPositionOutputIsAlwaysDeclared.wgsl
+++ b/tests/sksl/wgsl/VertexPositionOutputIsAlwaysDeclared.wgsl
@@ -1,10 +1,12 @@
struct VSOut {
- @builtin(position) sk_Position: vec4<f32>,
+ @builtin(position) sk_Position: vec4<f32>,
};
fn main() {
+ {
+ }
}
@vertex fn vertexMain() -> VSOut {
- var _stageOut: VSOut;
- main();
- return _stageOut;
+ var _stageOut: VSOut;
+ main();
+ return _stageOut;
}
