gl-transitions 1.74.0 → 1.76.0

package/wgsl/rotate_scale_fade.wgsl

@@ -0,0 +1,138 @@
+// rotate_scale_fade — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/rotate_scale_fade.glsl
+// Author: Fernando Kuteken
+// License: MIT
+// Description: The outgoing image spins and zooms while fading to the incoming one, over a background color
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    center: vec2<f32>,
+    rotations: f32,
+    scale: f32,
+    backColor: vec4<f32>,
+}
+
+@group(0) @binding(2) 
+var _from: texture_2d<f32>;
+@group(0) @binding(1) 
+var _sampler: sampler;
+@group(0) @binding(3) 
+var _to: texture_2d<f32>;
+@group(0) @binding(0) 
+var<uniform> uniforms: Uniforms;
+var<private> _fragColor: vec4<f32>;
+var<private> _uv_1: vec2<f32>;
+
+fn getToColor(uv: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e20 = (*uv)[0u];
+    let _e22 = (*uv)[1u];
+    let _e25 = textureSampleLevel(_to, _sampler, vec2<f32>(_e20, (1f - _e22)), 0f);
+    return _e25;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e20 = (*uv_1)[0u];
+    let _e22 = (*uv_1)[1u];
+    let _e25 = textureSampleLevel(_from, _sampler, vec2<f32>(_e20, (1f - _e22)), 0f);
+    return _e25;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var difference: vec2<f32>;
+    var dir: vec2<f32>;
+    var dist: f32;
+    var angle: f32;
+    var c: f32;
+    var s: f32;
+    var currentScale: f32;
+    var rotatedDir: vec2<f32>;
+    var rotatedUv: vec2<f32>;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+    var phi_144_: bool;
+    var phi_151_: bool;
+    var phi_158_: bool;
+
+    let _e30 = (*uv_2);
+    let _e32 = uniforms.center;
+    difference = (_e30 - _e32);
+    let _e34 = difference;
+    dir = normalize(_e34);
+    let _e36 = difference;
+    dist = length(_e36);
+    let _e39 = uniforms.rotations;
+    let _e42 = uniforms.progress;
+    angle = ((6.2831855f * _e39) * _e42);
+    let _e44 = angle;
+    c = cos(_e44);
+    let _e46 = angle;
+    s = sin(_e46);
+    let _e49 = uniforms.scale;
+    let _e51 = uniforms.progress;
+    currentScale = mix(_e49, 1f, (2f * abs((_e51 - 0.5f))));
+    let _e57 = dir[0u];
+    let _e58 = c;
+    let _e61 = dir[1u];
+    let _e62 = s;
+    let _e66 = dir[0u];
+    let _e67 = s;
+    let _e70 = dir[1u];
+    let _e71 = c;
+    rotatedDir = vec2<f32>(((_e57 * _e58) - (_e61 * _e62)), ((_e66 * _e67) + (_e70 * _e71)));
+    let _e76 = uniforms.center;
+    let _e77 = rotatedDir;
+    let _e78 = dist;
+    let _e80 = currentScale;
+    rotatedUv = (_e76 + ((_e77 * _e78) / vec2(_e80)));
+    let _e85 = rotatedUv[0u];
+    let _e86 = (_e85 < 0f);
+    phi_144_ = _e86;
+    if !(_e86) {
+        let _e89 = rotatedUv[0u];
+        phi_144_ = (_e89 > 1f);
+    }
+    let _e92 = phi_144_;
+    phi_151_ = _e92;
+    if !(_e92) {
+        let _e95 = rotatedUv[1u];
+        phi_151_ = (_e95 < 0f);
+    }
+    let _e98 = phi_151_;
+    phi_158_ = _e98;
+    if !(_e98) {
+        let _e101 = rotatedUv[1u];
+        phi_158_ = (_e101 > 1f);
+    }
+    let _e104 = phi_158_;
+    if _e104 {
+        let _e106 = uniforms.backColor;
+        return _e106;
+    }
+    let _e107 = rotatedUv;
+    param = _e107;
+    let _e108 = getFromColor((&param));
+    let _e109 = rotatedUv;
+    param_1 = _e109;
+    let _e110 = getToColor((&param_1));
+    let _e112 = uniforms.progress;
+    return mix(_e108, _e110, vec4(_e112));
+}
+
+fn main_1() {
+    var param_2: vec2<f32>;
+
+    let _e19 = _uv_1;
+    param_2 = _e19;
+    let _e20 = transition((&param_2));
+    _fragColor = _e20;
+    return;
+}
+
+@fragment 
+fn main(@location(0) _uv: vec2<f32>) -> @location(0) vec4<f32> {
+    _uv_1 = _uv;
+    main_1();
+    let _e3 = _fragColor;
+    return _e3;
+}

package/wgsl/scale-in.wgsl

@@ -0,0 +1,79 @@
+// scale-in — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/scale-in.glsl
+// Author: haiyoucuv
+// License: MIT
+// Description: The incoming image scales in from the center while fading in
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+}
+
+@group(0) @binding(2) 
+var _from: texture_2d<f32>;
+@group(0) @binding(1) 
+var _sampler: sampler;
+@group(0) @binding(3) 
+var _to: texture_2d<f32>;
+@group(0) @binding(0) 
+var<uniform> uniforms: Uniforms;
+var<private> _fragColor: vec4<f32>;
+var<private> _uv_1: vec2<f32>;
+
+fn getToColor(uv: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e14 = (*uv)[0u];
+    let _e16 = (*uv)[1u];
+    let _e19 = textureSampleLevel(_to, _sampler, vec2<f32>(_e14, (1f - _e16)), 0f);
+    return _e19;
+}
+
+fn scale(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var param: vec2<f32>;
+
+    let _e14 = (*uv_1);
+    let _e18 = uniforms.progress;
+    (*uv_1) = (vec2(0.5f) + ((_e14 - vec2(0.5f)) * _e18));
+    let _e22 = (*uv_1);
+    param = _e22;
+    let _e23 = getToColor((&param));
+    return _e23;
+}
+
+fn getFromColor(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e14 = (*uv_2)[0u];
+    let _e16 = (*uv_2)[1u];
+    let _e19 = textureSampleLevel(_from, _sampler, vec2<f32>(_e14, (1f - _e16)), 0f);
+    return _e19;
+}
+
+fn transition(uv_3: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var param_1: vec2<f32>;
+    var param_2: vec2<f32>;
+
+    let _e15 = (*uv_3);
+    param_1 = _e15;
+    let _e16 = getFromColor((&param_1));
+    let _e17 = (*uv_3);
+    param_2 = _e17;
+    let _e18 = scale((&param_2));
+    let _e20 = uniforms.progress;
+    return mix(_e16, _e18, vec4(_e20));
+}
+
+fn main_1() {
+    var param_3: vec2<f32>;
+
+    let _e13 = _uv_1;
+    param_3 = _e13;
+    let _e14 = transition((&param_3));
+    _fragColor = _e14;
+    return;
+}
+
+@fragment 
+fn main(@location(0) _uv: vec2<f32>) -> @location(0) vec4<f32> {
+    _uv_1 = _uv;
+    main_1();
+    let _e3 = _fragColor;
+    return _e3;
+}

package/wgsl/splitSlideInHorizontal.wgsl

@@ -0,0 +1,118 @@
+// splitSlideInHorizontal — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/splitSlideInHorizontal.glsl
+// Author: OllyOllyOlly
+// License: MIT
+// Description: The incoming image slides in as two halves moving horizontally in opposite directions
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    reverse: i32,
+}
+
+@group(0) @binding(2) 
+var _from: texture_2d<f32>;
+@group(0) @binding(1) 
+var _sampler: sampler;
+@group(0) @binding(3) 
+var _to: texture_2d<f32>;
+@group(0) @binding(0) 
+var<uniform> uniforms: Uniforms;
+var<private> _fragColor: vec4<f32>;
+var<private> _uv_1: vec2<f32>;
+
+fn getFromColor(uv: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e18 = (*uv)[0u];
+    let _e20 = (*uv)[1u];
+    let _e23 = textureSampleLevel(_from, _sampler, vec2<f32>(_e18, (1f - _e20)), 0f);
+    return _e23;
+}
+
+fn getToColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e18 = (*uv_1)[0u];
+    let _e20 = (*uv_1)[1u];
+    let _e23 = textureSampleLevel(_to, _sampler, vec2<f32>(_e18, (1f - _e20)), 0f);
+    return _e23;
+}
+
+fn inBounds(p: ptr<function, vec2<f32>>) -> bool {
+    var phi_74_: bool;
+
+    let _e17 = (*p);
+    let _e19 = all((vec2<f32>(0f, 0f) < _e17));
+    phi_74_ = _e19;
+    if _e19 {
+        let _e20 = (*p);
+        phi_74_ = all((_e20 < vec2<f32>(1f, 1f)));
+    }
+    let _e24 = phi_74_;
+    return _e24;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var modifier: f32;
+    var toP: vec2<f32>;
+    var local: vec2<f32>;
+    var fromP: vec2<f32>;
+    var param: vec2<f32>;
+    var local_1: vec4<f32>;
+    var param_1: vec2<f32>;
+    var param_2: vec2<f32>;
+
+    let _e26 = uniforms.reverse;
+    modifier = select(1f, -1f, (_e26 != 0i));
+    let _e30 = (*uv_2)[1u];
+    if (_e30 > 0.5f) {
+        let _e33 = (*uv_2)[0u];
+        let _e35 = uniforms.progress;
+        let _e36 = modifier;
+        let _e39 = modifier;
+        let _e42 = (*uv_2)[1u];
+        local = vec2<f32>(((_e33 - (_e35 * _e36)) + _e39), _e42);
+    } else {
+        let _e45 = (*uv_2)[0u];
+        let _e47 = uniforms.progress;
+        let _e48 = modifier;
+        let _e51 = modifier;
+        let _e54 = (*uv_2)[1u];
+        local = vec2<f32>(((_e45 + (_e47 * _e48)) - _e51), _e54);
+    }
+    let _e56 = local;
+    toP = _e56;
+    let _e57 = (*uv_2);
+    fromP = _e57;
+    let _e58 = toP;
+    param = _e58;
+    let _e59 = inBounds((&param));
+    if _e59 {
+        let _e60 = toP;
+        param_1 = _e60;
+        let _e61 = getToColor((&param_1));
+        local_1 = _e61;
+    } else {
+        let _e62 = fromP;
+        param_2 = _e62;
+        let _e63 = getFromColor((&param_2));
+        local_1 = _e63;
+    }
+    let _e64 = local_1;
+    return _e64;
+}
+
+fn main_1() {
+    var param_3: vec2<f32>;
+
+    let _e17 = _uv_1;
+    param_3 = _e17;
+    let _e18 = transition((&param_3));
+    _fragColor = _e18;
+    return;
+}
+
+@fragment 
+fn main(@location(0) _uv: vec2<f32>) -> @location(0) vec4<f32> {
+    _uv_1 = _uv;
+    main_1();
+    let _e3 = _fragColor;
+    return _e3;
+}

package/wgsl/splitSlideInOutHorizontal.wgsl

@@ -0,0 +1,109 @@
+// splitSlideInOutHorizontal — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/splitSlideInOutHorizontal.glsl
+// Author: OllyOllyOlly
+// License: MIT
+// Description: The halves of both images slide horizontally in opposite directions, out and in at once
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    reverse: i32,
+}
+
+@group(0) @binding(2) 
+var _from: texture_2d<f32>;
+@group(0) @binding(1) 
+var _sampler: sampler;
+@group(0) @binding(3) 
+var _to: texture_2d<f32>;
+@group(0) @binding(0) 
+var<uniform> uniforms: Uniforms;
+var<private> _fragColor: vec4<f32>;
+var<private> _uv_1: vec2<f32>;
+
+fn getToColor(uv: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e18 = (*uv)[0u];
+    let _e20 = (*uv)[1u];
+    let _e23 = textureSampleLevel(_to, _sampler, vec2<f32>(_e18, (1f - _e20)), 0f);
+    return _e23;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e18 = (*uv_1)[0u];
+    let _e20 = (*uv_1)[1u];
+    let _e23 = textureSampleLevel(_from, _sampler, vec2<f32>(_e18, (1f - _e20)), 0f);
+    return _e23;
+}
+
+fn inBounds(p: ptr<function, vec2<f32>>) -> bool {
+    var phi_74_: bool;
+
+    let _e17 = (*p);
+    let _e19 = all((vec2<f32>(0f, 0f) < _e17));
+    phi_74_ = _e19;
+    if _e19 {
+        let _e20 = (*p);
+        phi_74_ = all((_e20 < vec2<f32>(1f, 1f)));
+    }
+    let _e24 = phi_74_;
+    return _e24;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var modifier: f32;
+    var fromP: vec2<f32>;
+    var toP: vec2<f32>;
+    var param: vec2<f32>;
+    var local: vec4<f32>;
+    var param_1: vec2<f32>;
+    var param_2: vec2<f32>;
+
+    let _e25 = (*uv_2)[1u];
+    let _e29 = uniforms.reverse;
+    modifier = (select(-1f, 1f, (_e25 > 0.5f)) * select(1f, -1f, (_e29 != 0i)));
+    let _e34 = (*uv_2)[0u];
+    let _e36 = uniforms.progress;
+    let _e37 = modifier;
+    let _e41 = (*uv_2)[1u];
+    fromP = vec2<f32>((_e34 + (_e36 * _e37)), _e41);
+    let _e44 = (*uv_2)[0u];
+    let _e46 = uniforms.progress;
+    let _e47 = modifier;
+    let _e50 = modifier;
+    let _e53 = (*uv_2)[1u];
+    toP = vec2<f32>(((_e44 + (_e46 * _e47)) - _e50), _e53);
+    let _e55 = fromP;
+    param = _e55;
+    let _e56 = inBounds((&param));
+    if _e56 {
+        let _e57 = fromP;
+        param_1 = _e57;
+        let _e58 = getFromColor((&param_1));
+        local = _e58;
+    } else {
+        let _e59 = toP;
+        param_2 = _e59;
+        let _e60 = getToColor((&param_2));
+        local = _e60;
+    }
+    let _e61 = local;
+    return _e61;
+}
+
+fn main_1() {
+    var param_3: vec2<f32>;
+
+    let _e17 = _uv_1;
+    param_3 = _e17;
+    let _e18 = transition((&param_3));
+    _fragColor = _e18;
+    return;
+}
+
+@fragment 
+fn main(@location(0) _uv: vec2<f32>) -> @location(0) vec4<f32> {
+    _uv_1 = _uv;
+    main_1();
+    let _e3 = _fragColor;
+    return _e3;
+}

package/wgsl/splitSlideInOutVertical.wgsl

@@ -0,0 +1,109 @@
+// splitSlideInOutVertical — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/splitSlideInOutVertical.glsl
+// Author: OllyOllyOlly
+// License: MIT
+// Description: The halves of both images slide vertically in opposite directions, out and in at once
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    reverse: i32,
+}
+
+@group(0) @binding(2) 
+var _from: texture_2d<f32>;
+@group(0) @binding(1) 
+var _sampler: sampler;
+@group(0) @binding(3) 
+var _to: texture_2d<f32>;
+@group(0) @binding(0) 
+var<uniform> uniforms: Uniforms;
+var<private> _fragColor: vec4<f32>;
+var<private> _uv_1: vec2<f32>;
+
+fn getToColor(uv: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e18 = (*uv)[0u];
+    let _e20 = (*uv)[1u];
+    let _e23 = textureSampleLevel(_to, _sampler, vec2<f32>(_e18, (1f - _e20)), 0f);
+    return _e23;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e18 = (*uv_1)[0u];
+    let _e20 = (*uv_1)[1u];
+    let _e23 = textureSampleLevel(_from, _sampler, vec2<f32>(_e18, (1f - _e20)), 0f);
+    return _e23;
+}
+
+fn inBounds(p: ptr<function, vec2<f32>>) -> bool {
+    var phi_74_: bool;
+
+    let _e17 = (*p);
+    let _e19 = all((vec2<f32>(0f, 0f) < _e17));
+    phi_74_ = _e19;
+    if _e19 {
+        let _e20 = (*p);
+        phi_74_ = all((_e20 < vec2<f32>(1f, 1f)));
+    }
+    let _e24 = phi_74_;
+    return _e24;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var modifier: f32;
+    var fromP: vec2<f32>;
+    var toP: vec2<f32>;
+    var param: vec2<f32>;
+    var local: vec4<f32>;
+    var param_1: vec2<f32>;
+    var param_2: vec2<f32>;
+
+    let _e25 = (*uv_2)[0u];
+    let _e29 = uniforms.reverse;
+    modifier = (select(-1f, 1f, (_e25 > 0.5f)) * select(1f, -1f, (_e29 != 0i)));
+    let _e34 = (*uv_2)[0u];
+    let _e36 = (*uv_2)[1u];
+    let _e38 = uniforms.progress;
+    let _e39 = modifier;
+    fromP = vec2<f32>(_e34, (_e36 + (_e38 * _e39)));
+    let _e44 = (*uv_2)[0u];
+    let _e46 = (*uv_2)[1u];
+    let _e48 = uniforms.progress;
+    let _e49 = modifier;
+    let _e52 = modifier;
+    toP = vec2<f32>(_e44, ((_e46 + (_e48 * _e49)) - _e52));
+    let _e55 = fromP;
+    param = _e55;
+    let _e56 = inBounds((&param));
+    if _e56 {
+        let _e57 = fromP;
+        param_1 = _e57;
+        let _e58 = getFromColor((&param_1));
+        local = _e58;
+    } else {
+        let _e59 = toP;
+        param_2 = _e59;
+        let _e60 = getToColor((&param_2));
+        local = _e60;
+    }
+    let _e61 = local;
+    return _e61;
+}
+
+fn main_1() {
+    var param_3: vec2<f32>;
+
+    let _e17 = _uv_1;
+    param_3 = _e17;
+    let _e18 = transition((&param_3));
+    _fragColor = _e18;
+    return;
+}
+
+@fragment 
+fn main(@location(0) _uv: vec2<f32>) -> @location(0) vec4<f32> {
+    _uv_1 = _uv;
+    main_1();
+    let _e3 = _fragColor;
+    return _e3;
+}

package/wgsl/splitSlideInVertical.wgsl

@@ -0,0 +1,115 @@
+// splitSlideInVertical — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/splitSlideInVertical.glsl
+// Author: OllyOllyOlly
+// License: MIT
+// Description: The incoming image slides in as two halves moving vertically in opposite directions
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    reverse: i32,
+}
+
+@group(0) @binding(2) 
+var _from: texture_2d<f32>;
+@group(0) @binding(1) 
+var _sampler: sampler;
+@group(0) @binding(3) 
+var _to: texture_2d<f32>;
+@group(0) @binding(0) 
+var<uniform> uniforms: Uniforms;
+var<private> _fragColor: vec4<f32>;
+var<private> _uv_1: vec2<f32>;
+
+fn getFromColor(uv: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e18 = (*uv)[0u];
+    let _e20 = (*uv)[1u];
+    let _e23 = textureSampleLevel(_from, _sampler, vec2<f32>(_e18, (1f - _e20)), 0f);
+    return _e23;
+}
+
+fn getToColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e18 = (*uv_1)[0u];
+    let _e20 = (*uv_1)[1u];
+    let _e23 = textureSampleLevel(_to, _sampler, vec2<f32>(_e18, (1f - _e20)), 0f);
+    return _e23;
+}
+
+fn inBounds(p: ptr<function, vec2<f32>>) -> bool {
+    var phi_74_: bool;
+
+    let _e17 = (*p);
+    let _e19 = all((vec2<f32>(0f, 0f) < _e17));
+    phi_74_ = _e19;
+    if _e19 {
+        let _e20 = (*p);
+        phi_74_ = all((_e20 < vec2<f32>(1f, 1f)));
+    }
+    let _e24 = phi_74_;
+    return _e24;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var modifier: f32;
+    var p_1: vec2<f32>;
+    var local: vec2<f32>;
+    var param: vec2<f32>;
+    var local_1: vec4<f32>;
+    var param_1: vec2<f32>;
+    var param_2: vec2<f32>;
+
+    let _e25 = uniforms.reverse;
+    modifier = select(1f, -1f, (_e25 != 0i));
+    let _e29 = (*uv_2)[0u];
+    if (_e29 > 0.5f) {
+        let _e32 = (*uv_2)[0u];
+        let _e34 = (*uv_2)[1u];
+        let _e36 = uniforms.progress;
+        let _e37 = modifier;
+        let _e40 = modifier;
+        local = vec2<f32>(_e32, ((_e34 - (_e36 * _e37)) + _e40));
+    } else {
+        let _e44 = (*uv_2)[0u];
+        let _e46 = (*uv_2)[1u];
+        let _e48 = uniforms.progress;
+        let _e49 = modifier;
+        let _e52 = modifier;
+        local = vec2<f32>(_e44, ((_e46 + (_e48 * _e49)) - _e52));
+    }
+    let _e55 = local;
+    p_1 = _e55;
+    let _e56 = p_1;
+    param = _e56;
+    let _e57 = inBounds((&param));
+    if _e57 {
+        let _e58 = p_1;
+        param_1 = _e58;
+        let _e59 = getToColor((&param_1));
+        local_1 = _e59;
+    } else {
+        let _e60 = (*uv_2);
+        param_2 = _e60;
+        let _e61 = getFromColor((&param_2));
+        local_1 = _e61;
+    }
+    let _e62 = local_1;
+    return _e62;
+}
+
+fn main_1() {
+    var param_3: vec2<f32>;
+
+    let _e17 = _uv_1;
+    param_3 = _e17;
+    let _e18 = transition((&param_3));
+    _fragColor = _e18;
+    return;
+}
+
+@fragment 
+fn main(@location(0) _uv: vec2<f32>) -> @location(0) vec4<f32> {
+    _uv_1 = _uv;
+    main_1();
+    let _e3 = _fragColor;
+    return _e3;
+}