gl-transitions 1.74.0 → 1.76.0

package/wgsl/StereoViewer.wgsl

@@ -0,0 +1,625 @@
+// StereoViewer — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/StereoViewer.glsl
+// Author: Ted Schundler
+// License: BSD 2 Clause
+// Description: Both images shrink into rounded cards that swap, like a stereo viewer toy
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    zoom: f32,
+    corner_radius: 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 _e32 = (*uv)[0u];
+    let _e34 = (*uv)[1u];
+    let _e37 = textureSampleLevel(_to, _sampler, vec2<f32>(_e32, (1f - _e34)), 0f);
+    return _e37;
+}
+
+fn in_corner(p: ptr<function, vec2<f32>>, corner: ptr<function, vec2<f32>>, radius: ptr<function, vec2<f32>>) -> bool {
+    var axis: vec2<f32>;
+    var phi_156_: bool;
+    var phi_168_: bool;
+    var phi_169_: bool;
+    var phi_177_: bool;
+
+    let _e34 = (*corner);
+    let _e36 = (*corner);
+    axis = ((vec2<f32>(1f, 1f) - _e34) - _e36);
+    let _e38 = (*p);
+    let _e39 = (*corner);
+    let _e40 = axis;
+    let _e41 = (*radius);
+    (*p) = (_e38 - (_e39 + (_e40 * _e41)));
+    let _e45 = axis;
+    let _e46 = (*radius);
+    let _e48 = (*p);
+    (*p) = (_e48 * (_e45 / _e46));
+    let _e51 = (*p)[0u];
+    let _e52 = (_e51 > 0f);
+    phi_156_ = _e52;
+    if _e52 {
+        let _e54 = (*p)[1u];
+        phi_156_ = (_e54 > -1f);
+    }
+    let _e57 = phi_156_;
+    phi_169_ = _e57;
+    if !(_e57) {
+        let _e60 = (*p)[1u];
+        let _e61 = (_e60 > 0f);
+        phi_168_ = _e61;
+        if _e61 {
+            let _e63 = (*p)[0u];
+            phi_168_ = (_e63 > -1f);
+        }
+        let _e66 = phi_168_;
+        phi_169_ = _e66;
+    }
+    let _e68 = phi_169_;
+    phi_177_ = _e68;
+    if !(_e68) {
+        let _e70 = (*p);
+        let _e71 = (*p);
+        phi_177_ = (dot(_e70, _e71) < 1f);
+    }
+    let _e75 = phi_177_;
+    return _e75;
+}
+
+fn test_rounded_mask(p_1: ptr<function, vec2<f32>>, corner_size: ptr<function, vec2<f32>>) -> bool {
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+    var param_2: vec2<f32>;
+    var param_3: vec2<f32>;
+    var param_4: vec2<f32>;
+    var param_5: vec2<f32>;
+    var param_6: vec2<f32>;
+    var param_7: vec2<f32>;
+    var param_8: vec2<f32>;
+    var param_9: vec2<f32>;
+    var param_10: vec2<f32>;
+    var param_11: vec2<f32>;
+    var phi_196_: bool;
+    var phi_206_: bool;
+    var phi_215_: bool;
+
+    let _e44 = (*p_1);
+    param = _e44;
+    param_1 = vec2<f32>(0f, 0f);
+    let _e45 = (*corner_size);
+    param_2 = _e45;
+    let _e46 = in_corner((&param), (&param_1), (&param_2));
+    phi_196_ = _e46;
+    if _e46 {
+        let _e47 = (*p_1);
+        param_3 = _e47;
+        param_4 = vec2<f32>(0f, 1f);
+        let _e48 = (*corner_size);
+        param_5 = _e48;
+        let _e49 = in_corner((&param_3), (&param_4), (&param_5));
+        phi_196_ = _e49;
+    }
+    let _e51 = phi_196_;
+    phi_206_ = _e51;
+    if _e51 {
+        let _e52 = (*p_1);
+        param_6 = _e52;
+        param_7 = vec2<f32>(1f, 0f);
+        let _e53 = (*corner_size);
+        param_8 = _e53;
+        let _e54 = in_corner((&param_6), (&param_7), (&param_8));
+        phi_206_ = _e54;
+    }
+    let _e56 = phi_206_;
+    phi_215_ = _e56;
+    if _e56 {
+        let _e57 = (*p_1);
+        param_9 = _e57;
+        param_10 = vec2<f32>(1f, 1f);
+        let _e58 = (*corner_size);
+        param_11 = _e58;
+        let _e59 = in_corner((&param_9), (&param_10), (&param_11));
+        phi_215_ = _e59;
+    }
+    let _e61 = phi_215_;
+    return _e61;
+}
+
+fn simple_sample_with_corners_to(p_2: ptr<function, vec2<f32>>, corner_size_1: ptr<function, vec2<f32>>, zoom_amt: ptr<function, f32>) -> vec4<f32> {
+    var param_12: vec2<f32>;
+    var param_13: vec2<f32>;
+    var param_14: vec2<f32>;
+
+    let _e36 = (*p_2);
+    let _e39 = (*zoom_amt);
+    let _e42 = uniforms.zoom;
+    let _e43 = (*zoom_amt);
+    (*p_2) = (((_e36 - vec2(0.5f)) / vec2(((1f - _e39) + (_e42 * _e43)))) + vec2(0.5f));
+    let _e50 = (*p_2);
+    param_12 = _e50;
+    let _e51 = (*corner_size_1);
+    param_13 = _e51;
+    let _e52 = test_rounded_mask((&param_12), (&param_13));
+    if !(_e52) {
+        return vec4<f32>(0f, 0f, 0f, 1f);
+    }
+    let _e54 = (*p_2);
+    param_14 = _e54;
+    let _e55 = getToColor((&param_14));
+    return _e55;
+}
+
+fn screen(a: ptr<function, vec4<f32>>, b: ptr<function, vec4<f32>>) -> vec4<f32> {
+    let _e32 = (*a);
+    let _e35 = (*b);
+    return (vec4(1f) - ((vec4(1f) - _e32) * (vec4(1f) - _e35)));
+}
+
+fn unscreen(c: ptr<function, vec4<f32>>) -> vec4<f32> {
+    let _e31 = (*c);
+    return (vec4(1f) - sqrt((vec4(1f) - _e31)));
+}
+
+fn sample_with_corners_to(p_3: ptr<function, vec2<f32>>, corner_size_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var param_15: vec2<f32>;
+    var param_16: vec2<f32>;
+    var param_17: vec2<f32>;
+    var param_18: vec4<f32>;
+
+    let _e36 = (*p_3);
+    let _e40 = uniforms.zoom;
+    (*p_3) = (((_e36 - vec2(0.5f)) / vec2(_e40)) + vec2(0.5f));
+    let _e45 = (*p_3);
+    param_15 = _e45;
+    let _e46 = (*corner_size_2);
+    param_16 = _e46;
+    let _e47 = test_rounded_mask((&param_15), (&param_16));
+    if !(_e47) {
+        return vec4<f32>(0f, 0f, 0f, 1f);
+    }
+    let _e49 = (*p_3);
+    param_17 = _e49;
+    let _e50 = getToColor((&param_17));
+    param_18 = _e50;
+    let _e51 = unscreen((&param_18));
+    return _e51;
+}
+
+fn rotate2d(angle: ptr<function, f32>, ratio: ptr<function, f32>) -> mat3x3<f32> {
+    var s: f32;
+    var c_1: f32;
+
+    let _e34 = (*angle);
+    s = sin(_e34);
+    let _e36 = (*angle);
+    c_1 = cos(_e36);
+    let _e38 = c_1;
+    let _e39 = s;
+    let _e40 = s;
+    let _e42 = c_1;
+    return mat3x3<f32>(vec3<f32>(_e38, _e39, 0f), vec3<f32>(-(_e40), _e42, 0f), vec3<f32>(0f, 0f, 1f));
+}
+
+fn scale2d(x: ptr<function, f32>, y: ptr<function, f32>) -> mat3x3<f32> {
+    let _e32 = (*x);
+    let _e33 = (*y);
+    return mat3x3<f32>(vec3<f32>(_e32, 0f, 0f), vec3<f32>(0f, _e33, 0f), vec3<f32>(0f, 0f, 1f));
+}
+
+fn translate2d(x_1: ptr<function, f32>, y_1: ptr<function, f32>) -> mat3x3<f32> {
+    let _e32 = (*x_1);
+    let _e34 = (*y_1);
+    return mat3x3<f32>(vec3<f32>(1f, 0f, 0f), vec3<f32>(0f, 1f, 0f), vec3<f32>(-(_e32), -(_e34), 1f));
+}
+
+fn get_cross_masked(p3_: ptr<function, vec3<f32>>, angle_1: ptr<function, f32>, corner_size_3: ptr<function, vec2<f32>>, ratio_1: ptr<function, f32>) -> vec4<f32> {
+    var center_and_scale: mat3x3<f32>;
+    var param_19: f32;
+    var param_20: f32;
+    var param_21: f32;
+    var param_22: f32;
+    var unscale_and_uncenter: mat3x3<f32>;
+    var param_23: f32;
+    var param_24: f32;
+    var param_25: f32;
+    var param_26: f32;
+    var slide_left: mat3x3<f32>;
+    var param_27: f32;
+    var param_28: f32;
+    var slide_right: mat3x3<f32>;
+    var param_29: f32;
+    var param_30: f32;
+    var rotate: mat3x3<f32>;
+    var param_31: f32;
+    var param_32: f32;
+    var op_a: mat3x3<f32>;
+    var op_b: mat3x3<f32>;
+    var mask_a: bool;
+    var param_33: vec2<f32>;
+    var param_34: vec2<f32>;
+    var mask_b: bool;
+    var param_35: vec2<f32>;
+    var param_36: vec2<f32>;
+    var img: vec4<f32>;
+    var param_37: vec2<f32>;
+    var param_38: vec2<f32>;
+    var param_39: vec4<f32>;
+    var param_40: vec4<f32>;
+
+    let _e66 = (*angle_1);
+    (*angle_1) = (1f - _e66);
+    let _e68 = (*angle_1);
+    let _e69 = (*angle_1);
+    (*angle_1) = (_e68 * _e69);
+    let _e71 = (*angle_1);
+    (*angle_1) = (_e71 / 2.4f);
+    param_19 = -0.5f;
+    param_20 = -0.5f;
+    let _e73 = translate2d((&param_19), (&param_20));
+    param_21 = 1f;
+    let _e74 = (*ratio_1);
+    param_22 = _e74;
+    let _e75 = scale2d((&param_21), (&param_22));
+    center_and_scale = (_e73 * _e75);
+    let _e78 = uniforms.zoom;
+    let _e81 = uniforms.zoom;
+    let _e82 = (*ratio_1);
+    param_23 = (1f / _e78);
+    param_24 = (1f / (_e81 * _e82));
+    let _e85 = scale2d((&param_23), (&param_24));
+    param_25 = 0.5f;
+    param_26 = 0.5f;
+    let _e86 = translate2d((&param_25), (&param_26));
+    unscale_and_uncenter = (_e85 * _e86);
+    param_27 = -2f;
+    param_28 = 0f;
+    let _e88 = translate2d((&param_27), (&param_28));
+    slide_left = _e88;
+    param_29 = 2f;
+    param_30 = 0f;
+    let _e89 = translate2d((&param_29), (&param_30));
+    slide_right = _e89;
+    let _e90 = (*angle_1);
+    param_31 = _e90;
+    let _e91 = (*ratio_1);
+    param_32 = _e91;
+    let _e92 = rotate2d((&param_31), (&param_32));
+    rotate = _e92;
+    let _e93 = center_and_scale;
+    let _e94 = slide_right;
+    let _e96 = rotate;
+    let _e98 = slide_left;
+    let _e100 = unscale_and_uncenter;
+    op_a = ((((_e93 * _e94) * _e96) * _e98) * _e100);
+    let _e102 = center_and_scale;
+    let _e103 = slide_left;
+    let _e105 = rotate;
+    let _e107 = slide_right;
+    let _e109 = unscale_and_uncenter;
+    op_b = ((((_e102 * _e103) * _e105) * _e107) * _e109);
+    let _e111 = op_a;
+    let _e112 = (*p3_);
+    param_33 = (_e111 * _e112).xy;
+    let _e115 = (*corner_size_3);
+    param_34 = _e115;
+    let _e116 = test_rounded_mask((&param_33), (&param_34));
+    mask_a = _e116;
+    let _e117 = op_b;
+    let _e118 = (*p3_);
+    param_35 = (_e117 * _e118).xy;
+    let _e121 = (*corner_size_3);
+    param_36 = _e121;
+    let _e122 = test_rounded_mask((&param_35), (&param_36));
+    mask_b = _e122;
+    let _e123 = mask_a;
+    let _e124 = mask_b;
+    if (_e123 || _e124) {
+        let _e126 = (*p3_);
+        param_37 = _e126.xy;
+        let _e128 = (*corner_size_3);
+        param_38 = _e128;
+        let _e129 = sample_with_corners_to((&param_37), (&param_38));
+        img = _e129;
+        let _e130 = mask_a;
+        let _e131 = img;
+        let _e134 = mask_b;
+        let _e135 = img;
+        param_39 = select(vec4<f32>(0f, 0f, 0f, 1f), _e131, vec4(_e130));
+        param_40 = select(vec4<f32>(0f, 0f, 0f, 1f), _e135, vec4(_e134));
+        let _e138 = screen((&param_39), (&param_40));
+        return _e138;
+    } else {
+        return vec4<f32>(0f, 0f, 0f, 1f);
+    }
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e32 = (*uv_1)[0u];
+    let _e34 = (*uv_1)[1u];
+    let _e37 = textureSampleLevel(_from, _sampler, vec2<f32>(_e32, (1f - _e34)), 0f);
+    return _e37;
+}
+
+fn sample_with_corners_from(p_4: ptr<function, vec2<f32>>, corner_size_4: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var param_41: vec2<f32>;
+    var param_42: vec2<f32>;
+    var param_43: vec2<f32>;
+    var param_44: vec4<f32>;
+
+    let _e36 = (*p_4);
+    let _e40 = uniforms.zoom;
+    (*p_4) = (((_e36 - vec2(0.5f)) / vec2(_e40)) + vec2(0.5f));
+    let _e45 = (*p_4);
+    param_41 = _e45;
+    let _e46 = (*corner_size_4);
+    param_42 = _e46;
+    let _e47 = test_rounded_mask((&param_41), (&param_42));
+    if !(_e47) {
+        return vec4<f32>(0f, 0f, 0f, 1f);
+    }
+    let _e49 = (*p_4);
+    param_43 = _e49;
+    let _e50 = getFromColor((&param_43));
+    param_44 = _e50;
+    let _e51 = unscreen((&param_44));
+    return _e51;
+}
+
+fn get_cross_rotated(p3_1: ptr<function, vec3<f32>>, angle_2: ptr<function, f32>, corner_size_5: ptr<function, vec2<f32>>, ratio_2: ptr<function, f32>) -> vec4<f32> {
+    var center_and_scale_1: mat3x3<f32>;
+    var param_45: f32;
+    var param_46: f32;
+    var param_47: f32;
+    var param_48: f32;
+    var unscale_and_uncenter_1: mat3x3<f32>;
+    var param_49: f32;
+    var param_50: f32;
+    var param_51: f32;
+    var param_52: f32;
+    var slide_left_1: mat3x3<f32>;
+    var param_53: f32;
+    var param_54: f32;
+    var slide_right_1: mat3x3<f32>;
+    var param_55: f32;
+    var param_56: f32;
+    var rotate_1: mat3x3<f32>;
+    var param_57: f32;
+    var param_58: f32;
+    var op_a_1: mat3x3<f32>;
+    var op_b_1: mat3x3<f32>;
+    var a_1: vec4<f32>;
+    var param_59: vec2<f32>;
+    var param_60: vec2<f32>;
+    var b_1: vec4<f32>;
+    var param_61: vec2<f32>;
+    var param_62: vec2<f32>;
+    var param_63: vec4<f32>;
+    var param_64: vec4<f32>;
+
+    let _e63 = (*angle_2);
+    let _e64 = (*angle_2);
+    (*angle_2) = (_e63 * _e64);
+    let _e66 = (*angle_2);
+    (*angle_2) = (_e66 / 2.4f);
+    param_45 = -0.5f;
+    param_46 = -0.5f;
+    let _e68 = translate2d((&param_45), (&param_46));
+    param_47 = 1f;
+    let _e69 = (*ratio_2);
+    param_48 = _e69;
+    let _e70 = scale2d((&param_47), (&param_48));
+    center_and_scale_1 = (_e68 * _e70);
+    let _e72 = (*ratio_2);
+    param_49 = 1f;
+    param_50 = (1f / _e72);
+    let _e74 = scale2d((&param_49), (&param_50));
+    param_51 = 0.5f;
+    param_52 = 0.5f;
+    let _e75 = translate2d((&param_51), (&param_52));
+    unscale_and_uncenter_1 = (_e74 * _e75);
+    param_53 = -2f;
+    param_54 = 0f;
+    let _e77 = translate2d((&param_53), (&param_54));
+    slide_left_1 = _e77;
+    param_55 = 2f;
+    param_56 = 0f;
+    let _e78 = translate2d((&param_55), (&param_56));
+    slide_right_1 = _e78;
+    let _e79 = (*angle_2);
+    param_57 = _e79;
+    let _e80 = (*ratio_2);
+    param_58 = _e80;
+    let _e81 = rotate2d((&param_57), (&param_58));
+    rotate_1 = _e81;
+    let _e82 = center_and_scale_1;
+    let _e83 = slide_right_1;
+    let _e85 = rotate_1;
+    let _e87 = slide_left_1;
+    let _e89 = unscale_and_uncenter_1;
+    op_a_1 = ((((_e82 * _e83) * _e85) * _e87) * _e89);
+    let _e91 = center_and_scale_1;
+    let _e92 = slide_left_1;
+    let _e94 = rotate_1;
+    let _e96 = slide_right_1;
+    let _e98 = unscale_and_uncenter_1;
+    op_b_1 = ((((_e91 * _e92) * _e94) * _e96) * _e98);
+    let _e100 = op_a_1;
+    let _e101 = (*p3_1);
+    param_59 = (_e100 * _e101).xy;
+    let _e104 = (*corner_size_5);
+    param_60 = _e104;
+    let _e105 = sample_with_corners_from((&param_59), (&param_60));
+    a_1 = _e105;
+    let _e106 = op_b_1;
+    let _e107 = (*p3_1);
+    param_61 = (_e106 * _e107).xy;
+    let _e110 = (*corner_size_5);
+    param_62 = _e110;
+    let _e111 = sample_with_corners_from((&param_61), (&param_62));
+    b_1 = _e111;
+    let _e112 = a_1;
+    param_63 = _e112;
+    let _e113 = b_1;
+    param_64 = _e113;
+    let _e114 = screen((&param_63), (&param_64));
+    return _e114;
+}
+
+fn simple_sample_with_corners_from(p_5: ptr<function, vec2<f32>>, corner_size_6: ptr<function, vec2<f32>>, zoom_amt_1: ptr<function, f32>) -> vec4<f32> {
+    var param_65: vec2<f32>;
+    var param_66: vec2<f32>;
+    var param_67: vec2<f32>;
+
+    let _e36 = (*p_5);
+    let _e39 = (*zoom_amt_1);
+    let _e42 = uniforms.zoom;
+    let _e43 = (*zoom_amt_1);
+    (*p_5) = (((_e36 - vec2(0.5f)) / vec2(((1f - _e39) + (_e42 * _e43)))) + vec2(0.5f));
+    let _e50 = (*p_5);
+    param_65 = _e50;
+    let _e51 = (*corner_size_6);
+    param_66 = _e51;
+    let _e52 = test_rounded_mask((&param_65), (&param_66));
+    if !(_e52) {
+        return vec4<f32>(0f, 0f, 0f, 1f);
+    }
+    let _e54 = (*p_5);
+    param_67 = _e54;
+    let _e55 = getFromColor((&param_67));
+    return _e55;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var p_6: vec2<f32>;
+    var p3_2: vec3<f32>;
+    var corner_size_7: vec2<f32>;
+    var param_68: vec2<f32>;
+    var a_2: f32;
+    var param_69: vec2<f32>;
+    var param_70: vec2<f32>;
+    var param_71: f32;
+    var param_72: vec3<f32>;
+    var param_73: f32;
+    var param_74: vec2<f32>;
+    var param_75: f32;
+    var param_76: vec3<f32>;
+    var param_77: f32;
+    var param_78: vec2<f32>;
+    var param_79: f32;
+    var param_80: vec2<f32>;
+    var param_81: vec2<f32>;
+    var param_82: f32;
+    var param_83: vec2<f32>;
+
+    let _e51 = (*uv_2);
+    p_6 = (_e51 / vec2<f32>(1f, 1f));
+    let _e53 = p_6;
+    p3_2 = vec3<f32>(_e53.x, _e53.y, 1f);
+    let _e58 = uniforms.corner_radius;
+    let _e60 = uniforms.ratio;
+    let _e63 = uniforms.corner_radius;
+    corner_size_7 = vec2<f32>((_e58 / _e60), _e63);
+    let _e66 = uniforms.progress;
+    if (_e66 <= 0f) {
+        let _e68 = p_6;
+        param_68 = _e68;
+        let _e69 = getFromColor((&param_68));
+        return _e69;
+    } else {
+        let _e71 = uniforms.progress;
+        if (_e71 < 0.1f) {
+            let _e74 = uniforms.progress;
+            a_2 = (_e74 / 0.1f);
+            let _e76 = corner_size_7;
+            let _e77 = a_2;
+            let _e79 = p_6;
+            param_69 = _e79;
+            param_70 = (_e76 * _e77);
+            let _e80 = a_2;
+            param_71 = _e80;
+            let _e81 = simple_sample_with_corners_from((&param_69), (&param_70), (&param_71));
+            return _e81;
+        } else {
+            let _e83 = uniforms.progress;
+            if (_e83 < 0.48f) {
+                let _e86 = uniforms.progress;
+                a_2 = ((_e86 - 0.1f) / 0.38f);
+                let _e89 = p3_2;
+                param_72 = _e89;
+                let _e90 = a_2;
+                param_73 = _e90;
+                let _e91 = corner_size_7;
+                param_74 = _e91;
+                let _e93 = uniforms.ratio;
+                param_75 = _e93;
+                let _e94 = get_cross_rotated((&param_72), (&param_73), (&param_74), (&param_75));
+                return _e94;
+            } else {
+                let _e96 = uniforms.progress;
+                if (_e96 < 0.9f) {
+                    let _e99 = uniforms.progress;
+                    let _e102 = p3_2;
+                    param_76 = _e102;
+                    param_77 = ((_e99 - 0.52f) / 0.38f);
+                    let _e103 = corner_size_7;
+                    param_78 = _e103;
+                    let _e105 = uniforms.ratio;
+                    param_79 = _e105;
+                    let _e106 = get_cross_masked((&param_76), (&param_77), (&param_78), (&param_79));
+                    return _e106;
+                } else {
+                    let _e108 = uniforms.progress;
+                    if (_e108 < 1f) {
+                        let _e111 = uniforms.progress;
+                        a_2 = ((1f - _e111) / 0.1f);
+                        let _e114 = corner_size_7;
+                        let _e115 = a_2;
+                        let _e117 = p_6;
+                        param_80 = _e117;
+                        param_81 = (_e114 * _e115);
+                        let _e118 = a_2;
+                        param_82 = _e118;
+                        let _e119 = simple_sample_with_corners_to((&param_80), (&param_81), (&param_82));
+                        return _e119;
+                    } else {
+                        let _e120 = p_6;
+                        param_83 = _e120;
+                        let _e121 = getToColor((&param_83));
+                        return _e121;
+                    }
+                }
+            }
+        }
+    }
+}
+
+fn main_1() {
+    var param_84: vec2<f32>;
+
+    let _e31 = _uv_1;
+    param_84 = _e31;
+    let _e32 = transition((&param_84));
+    _fragColor = _e32;
+    return;
+}
+
+@fragment 
+fn main(@location(0) _uv: vec2<f32>) -> @location(0) vec4<f32> {
+    _uv_1 = _uv;
+    main_1();
+    let _e3 = _fragColor;
+    return _e3;
+}