gl-transitions 1.74.0 → 1.76.0

package/wgsl/InvertedPageCurl.wgsl

@@ -0,0 +1,690 @@
+// InvertedPageCurl — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/InvertedPageCurl.glsl
+// Author: Hewlett-Packard
+// License: BSD 3 Clause
+// Description: The outgoing image curls away like a page, revealing the incoming one
+// 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>;
+var<private> cylinderAngle: f32;
+var<private> amount: f32;
+@group(0) @binding(0) 
+var<uniform> uniforms: Uniforms;
+var<private> cylinderCenter: f32;
+var<private> _fragColor: vec4<f32>;
+var<private> _uv_1: vec2<f32>;
+
+fn distanceToEdge(point: ptr<function, vec3<f32>>) -> f32 {
+    var dx: f32;
+    var local: f32;
+    var dy: f32;
+    var local_1: f32;
+    var phi_222_: bool;
+    var phi_234_: bool;
+    var phi_235_: bool;
+
+    let _e51 = (*point)[0u];
+    if (_e51 > 0.5f) {
+        let _e54 = (*point)[0u];
+        local = (1f - _e54);
+    } else {
+        let _e57 = (*point)[0u];
+        local = _e57;
+    }
+    let _e58 = local;
+    dx = abs(_e58);
+    let _e61 = (*point)[1u];
+    if (_e61 > 0.5f) {
+        let _e64 = (*point)[1u];
+        local_1 = (1f - _e64);
+    } else {
+        let _e67 = (*point)[1u];
+        local_1 = _e67;
+    }
+    let _e68 = local_1;
+    dy = abs(_e68);
+    let _e71 = (*point)[0u];
+    if (_e71 < 0f) {
+        let _e74 = (*point)[0u];
+        dx = -(_e74);
+    }
+    let _e77 = (*point)[0u];
+    if (_e77 > 1f) {
+        let _e80 = (*point)[0u];
+        dx = (_e80 - 1f);
+    }
+    let _e83 = (*point)[1u];
+    if (_e83 < 0f) {
+        let _e86 = (*point)[1u];
+        dy = -(_e86);
+    }
+    let _e89 = (*point)[1u];
+    if (_e89 > 1f) {
+        let _e92 = (*point)[1u];
+        dy = (_e92 - 1f);
+    }
+    let _e95 = (*point)[0u];
+    let _e96 = (_e95 < 0f);
+    phi_222_ = _e96;
+    if !(_e96) {
+        let _e99 = (*point)[0u];
+        phi_222_ = (_e99 > 1f);
+    }
+    let _e102 = phi_222_;
+    phi_235_ = _e102;
+    if _e102 {
+        let _e104 = (*point)[1u];
+        let _e105 = (_e104 < 0f);
+        phi_234_ = _e105;
+        if !(_e105) {
+            let _e108 = (*point)[1u];
+            phi_234_ = (_e108 > 1f);
+        }
+        let _e111 = phi_234_;
+        phi_235_ = _e111;
+    }
+    let _e113 = phi_235_;
+    if _e113 {
+        let _e114 = dx;
+        let _e115 = dx;
+        let _e117 = dy;
+        let _e118 = dy;
+        return sqrt(((_e114 * _e115) + (_e117 * _e118)));
+    }
+    let _e122 = dx;
+    let _e123 = dy;
+    return min(_e122, _e123);
+}
+
+fn antiAlias(color1_: ptr<function, vec4<f32>>, color2_: ptr<function, vec4<f32>>, distanc: ptr<function, f32>) -> vec4<f32> {
+    var dd: f32;
+
+    let _e49 = (*distanc);
+    (*distanc) = (_e49 * 512f);
+    let _e51 = (*distanc);
+    if (_e51 < 0f) {
+        let _e53 = (*color2_);
+        return _e53;
+    }
+    let _e54 = (*distanc);
+    if (_e54 > 2f) {
+        let _e56 = (*color1_);
+        return _e56;
+    }
+    let _e57 = (*distanc);
+    dd = pow((1f - (_e57 / 2f)), 3f);
+    let _e61 = (*color2_);
+    let _e62 = (*color1_);
+    let _e64 = dd;
+    let _e66 = (*color1_);
+    return (((_e61 - _e62) * _e64) + _e66);
+}
+
+fn getFromColor(uv: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e47 = (*uv)[0u];
+    let _e49 = (*uv)[1u];
+    let _e52 = textureSampleLevel(_from, _sampler, vec2<f32>(_e47, (1f - _e49)), 0f);
+    return _e52;
+}
+
+fn backside(yc: ptr<function, f32>, point_1: ptr<function, vec3<f32>>) -> vec4<f32> {
+    var color: vec4<f32>;
+    var param: vec2<f32>;
+    var gray: f32;
+
+    let _e50 = (*point_1);
+    param = _e50.xy;
+    let _e52 = getFromColor((&param));
+    color = _e52;
+    let _e54 = color[0u];
+    let _e56 = color[2u];
+    let _e59 = color[1u];
+    gray = (((_e54 + _e56) + _e59) / 15f);
+    let _e62 = (*yc);
+    let _e71 = gray;
+    gray = (_e71 + (0.8f * ((pow(max(0f, (1f - abs((_e62 / 0.15915494f)))), 0.2f) / 2f) + 0.5f)));
+    let _e73 = gray;
+    let _e74 = vec3(_e73);
+    color[0u] = _e74.x;
+    color[1u] = _e74.y;
+    color[2u] = _e74.z;
+    let _e81 = color;
+    return _e81;
+}
+
+fn getToColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e47 = (*uv_1)[0u];
+    let _e49 = (*uv_1)[1u];
+    let _e52 = textureSampleLevel(_to, _sampler, vec2<f32>(_e47, (1f - _e49)), 0f);
+    return _e52;
+}
+
+fn hitPoint_u0028_f1_u003b_f1_u003b_vf3_u003b_mf33_u003b(hitAngle: ptr<function, f32>, yc_1: ptr<function, f32>, point_2: ptr<function, vec3<f32>>, rrotation: ptr<function, mat3x3<f32>>) -> vec3<f32> {
+    var hitPoint: f32;
+
+    let _e50 = (*hitAngle);
+    hitPoint = (_e50 / 6.2831855f);
+    let _e52 = hitPoint;
+    (*point_2)[1u] = _e52;
+    let _e54 = (*rrotation);
+    let _e55 = (*point_2);
+    return (_e54 * _e55);
+}
+
+fn seeThrough(yc_2: ptr<function, f32>, p: ptr<function, vec2<f32>>, rotation: ptr<function, mat3x3<f32>>, rrotation_1: ptr<function, mat3x3<f32>>) -> vec4<f32> {
+    var hitAngle_1: f32;
+    var point_3: vec3<f32>;
+    var param_1: f32;
+    var param_2: f32;
+    var param_3: vec3<f32>;
+    var param_4: mat3x3<f32>;
+    var param_5: vec2<f32>;
+    var param_6: vec2<f32>;
+    var color_1: vec4<f32>;
+    var param_7: vec2<f32>;
+    var tcolor: vec4<f32>;
+    var param_8: vec3<f32>;
+    var param_9: vec4<f32>;
+    var param_10: vec4<f32>;
+    var param_11: f32;
+    var phi_293_: bool;
+    var phi_300_: bool;
+    var phi_307_: bool;
+    var phi_308_: bool;
+
+    let _e64 = (*yc_2);
+    let _e68 = cylinderAngle;
+    hitAngle_1 = (3.1415927f - (acos(clamp((_e64 / 0.15915494f), -1f, 1f)) - _e68));
+    let _e71 = (*rotation);
+    let _e72 = (*p);
+    let _e77 = hitAngle_1;
+    param_1 = _e77;
+    let _e78 = (*yc_2);
+    param_2 = _e78;
+    param_3 = (_e71 * vec3<f32>(_e72.x, _e72.y, 1f));
+    let _e79 = (*rrotation_1);
+    param_4 = _e79;
+    let _e80 = hitPoint_u0028_f1_u003b_f1_u003b_vf3_u003b_mf33_u003b((&param_1), (&param_2), (&param_3), (&param_4));
+    point_3 = _e80;
+    let _e81 = (*yc_2);
+    let _e82 = (_e81 <= 0f);
+    phi_308_ = _e82;
+    if _e82 {
+        let _e84 = point_3[0u];
+        let _e85 = (_e84 < 0f);
+        phi_293_ = _e85;
+        if !(_e85) {
+            let _e88 = point_3[1u];
+            phi_293_ = (_e88 < 0f);
+        }
+        let _e91 = phi_293_;
+        phi_300_ = _e91;
+        if !(_e91) {
+            let _e94 = point_3[0u];
+            phi_300_ = (_e94 > 1f);
+        }
+        let _e97 = phi_300_;
+        phi_307_ = _e97;
+        if !(_e97) {
+            let _e100 = point_3[1u];
+            phi_307_ = (_e100 > 1f);
+        }
+        let _e103 = phi_307_;
+        phi_308_ = _e103;
+    }
+    let _e105 = phi_308_;
+    if _e105 {
+        let _e106 = (*p);
+        param_5 = _e106;
+        let _e107 = getToColor((&param_5));
+        return _e107;
+    }
+    let _e108 = (*yc_2);
+    if (_e108 > 0f) {
+        let _e110 = (*p);
+        param_6 = _e110;
+        let _e111 = getFromColor((&param_6));
+        return _e111;
+    }
+    let _e112 = point_3;
+    param_7 = _e112.xy;
+    let _e114 = getFromColor((&param_7));
+    color_1 = _e114;
+    tcolor = vec4<f32>(0f, 0f, 0f, 0f);
+    let _e115 = point_3;
+    param_8 = _e115;
+    let _e116 = distanceToEdge((&param_8));
+    let _e117 = color_1;
+    param_9 = _e117;
+    let _e118 = tcolor;
+    param_10 = _e118;
+    param_11 = _e116;
+    let _e119 = antiAlias((&param_9), (&param_10), (&param_11));
+    return _e119;
+}
+
+fn seeThroughWithShadow(yc_3: ptr<function, f32>, p_1: ptr<function, vec2<f32>>, point_4: ptr<function, vec3<f32>>, rotation_1: ptr<function, mat3x3<f32>>, rrotation_2: ptr<function, mat3x3<f32>>) -> vec4<f32> {
+    var shadow: f32;
+    var param_12: vec3<f32>;
+    var shadowColor: vec4<f32>;
+    var param_13: f32;
+    var param_14: vec2<f32>;
+    var param_15: mat3x3<f32>;
+    var param_16: mat3x3<f32>;
+
+    let _e57 = (*point_4);
+    param_12 = _e57;
+    let _e58 = distanceToEdge((&param_12));
+    shadow = (_e58 * 30f);
+    let _e60 = shadow;
+    shadow = ((1f - _e60) / 3f);
+    let _e63 = shadow;
+    if (_e63 < 0f) {
+        shadow = 0f;
+    } else {
+        let _e65 = amount;
+        let _e66 = shadow;
+        shadow = (_e66 * _e65);
+    }
+    let _e68 = (*yc_3);
+    param_13 = _e68;
+    let _e69 = (*p_1);
+    param_14 = _e69;
+    let _e70 = (*rotation_1);
+    param_15 = _e70;
+    let _e71 = (*rrotation_2);
+    param_16 = _e71;
+    let _e72 = seeThrough((&param_13), (&param_14), (&param_15), (&param_16));
+    shadowColor = _e72;
+    let _e73 = shadow;
+    let _e75 = shadowColor[0u];
+    shadowColor[0u] = (_e75 - _e73);
+    let _e78 = shadow;
+    let _e80 = shadowColor[1u];
+    shadowColor[1u] = (_e80 - _e78);
+    let _e83 = shadow;
+    let _e85 = shadowColor[2u];
+    shadowColor[2u] = (_e85 - _e83);
+    let _e88 = shadowColor;
+    return _e88;
+}
+
+fn behindSurface(p_2: ptr<function, vec2<f32>>, yc_4: ptr<function, f32>, point_5: ptr<function, vec3<f32>>, rrotation_3: ptr<function, mat3x3<f32>>) -> vec4<f32> {
+    var safeAmount: f32;
+    var local_2: f32;
+    var shado: f32;
+    var hitAngle_2: f32;
+    var param_17: f32;
+    var param_18: f32;
+    var param_19: vec3<f32>;
+    var param_20: mat3x3<f32>;
+    var dx_1: f32;
+    var dy_1: f32;
+    var nyc: f32;
+    var param_21: vec2<f32>;
+    var phi_487_: bool;
+    var phi_493_: bool;
+    var phi_499_: bool;
+    var phi_505_: bool;
+    var phi_513_: bool;
+
+    let _e61 = amount;
+    if (_e61 >= 0f) {
+        let _e63 = amount;
+        local_2 = max(_e63, 0.0001f);
+    } else {
+        let _e65 = amount;
+        local_2 = min(_e65, -0.0001f);
+    }
+    let _e67 = local_2;
+    safeAmount = _e67;
+    let _e68 = (*yc_4);
+    let _e70 = safeAmount;
+    shado = ((1f - (((-0.15915494f - _e68) / _e70) * 7f)) / 6f);
+    let _e76 = (*point_5)[0u];
+    let _e80 = shado;
+    shado = (_e80 * (1f - abs((_e76 - 0.5f))));
+    let _e82 = (*yc_4);
+    (*yc_4) = (-0.31830987f - _e82);
+    let _e84 = (*yc_4);
+    let _e88 = cylinderAngle;
+    hitAngle_2 = ((acos(clamp((_e84 / 0.15915494f), -1f, 1f)) + _e88) - 3.1415927f);
+    let _e91 = hitAngle_2;
+    param_17 = _e91;
+    let _e92 = (*yc_4);
+    param_18 = _e92;
+    let _e93 = (*point_5);
+    param_19 = _e93;
+    let _e94 = (*rrotation_3);
+    param_20 = _e94;
+    let _e95 = hitPoint_u0028_f1_u003b_f1_u003b_vf3_u003b_mf33_u003b((&param_17), (&param_18), (&param_19), (&param_20));
+    (*point_5) = _e95;
+    let _e96 = (*yc_4);
+    let _e97 = (_e96 < 0f);
+    phi_487_ = _e97;
+    if _e97 {
+        let _e99 = (*point_5)[0u];
+        phi_487_ = (_e99 >= 0f);
+    }
+    let _e102 = phi_487_;
+    phi_493_ = _e102;
+    if _e102 {
+        let _e104 = (*point_5)[1u];
+        phi_493_ = (_e104 >= 0f);
+    }
+    let _e107 = phi_493_;
+    phi_499_ = _e107;
+    if _e107 {
+        let _e109 = (*point_5)[0u];
+        phi_499_ = (_e109 <= 1f);
+    }
+    let _e112 = phi_499_;
+    phi_505_ = _e112;
+    if _e112 {
+        let _e114 = (*point_5)[1u];
+        phi_505_ = (_e114 <= 1f);
+    }
+    let _e117 = phi_505_;
+    phi_513_ = _e117;
+    if _e117 {
+        let _e118 = hitAngle_2;
+        let _e120 = amount;
+        phi_513_ = ((_e118 < 3.1415927f) || (_e120 > 0.5f));
+    }
+    let _e124 = phi_513_;
+    if _e124 {
+        let _e126 = (*point_5)[0u];
+        dx_1 = (_e126 - 0.5f);
+        let _e129 = (*point_5)[1u];
+        dy_1 = (_e129 - 0.5f);
+        let _e131 = dx_1;
+        let _e132 = dx_1;
+        let _e134 = dy_1;
+        let _e135 = dy_1;
+        shado = (1f - (sqrt(((_e131 * _e132) + (_e134 * _e135))) / 0.71f));
+        let _e141 = (*yc_4);
+        nyc = (-(_e141) / 0.15915494f);
+        let _e144 = nyc;
+        let _e145 = nyc;
+        let _e147 = nyc;
+        let _e149 = shado;
+        shado = (_e149 * ((_e144 * _e145) * _e147));
+        let _e151 = shado;
+        shado = (_e151 * 0.5f);
+    } else {
+        shado = 0f;
+    }
+    let _e153 = (*p_2);
+    param_21 = _e153;
+    let _e154 = getToColor((&param_21));
+    let _e156 = shado;
+    let _e158 = (_e154.xyz - vec3(_e156));
+    return vec4<f32>(_e158.x, _e158.y, _e158.z, 1f);
+}
+
+fn transition(p_3: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var c: f32;
+    var s: f32;
+    var rotation_2: mat3x3<f32>;
+    var rrotation_4: mat3x3<f32>;
+    var point_6: vec3<f32>;
+    var yc_5: f32;
+    var param_22: vec2<f32>;
+    var param_23: f32;
+    var param_24: vec3<f32>;
+    var param_25: mat3x3<f32>;
+    var param_26: vec2<f32>;
+    var hitAngle_3: f32;
+    var hitAngleMod: f32;
+    var param_27: f32;
+    var param_28: vec2<f32>;
+    var param_29: mat3x3<f32>;
+    var param_30: mat3x3<f32>;
+    var param_31: f32;
+    var param_32: f32;
+    var param_33: vec3<f32>;
+    var param_34: mat3x3<f32>;
+    var param_35: f32;
+    var param_36: vec2<f32>;
+    var param_37: vec3<f32>;
+    var param_38: mat3x3<f32>;
+    var param_39: mat3x3<f32>;
+    var color_2: vec4<f32>;
+    var param_40: f32;
+    var param_41: vec3<f32>;
+    var dx2_: f32;
+    var dy2_: f32;
+    var shado_1: f32;
+    var nyc2_: f32;
+    var otherColor: vec4<f32>;
+    var param_42: vec2<f32>;
+    var param_43: vec4<f32>;
+    var param_44: vec4<f32>;
+    var param_45: f32;
+    var cl: vec4<f32>;
+    var param_46: f32;
+    var param_47: vec2<f32>;
+    var param_48: vec3<f32>;
+    var param_49: mat3x3<f32>;
+    var param_50: mat3x3<f32>;
+    var dist: f32;
+    var param_51: vec3<f32>;
+    var param_52: vec4<f32>;
+    var param_53: vec4<f32>;
+    var param_54: f32;
+    var phi_665_: bool;
+    var phi_696_: bool;
+    var phi_703_: bool;
+    var phi_710_: bool;
+
+    let _e96 = uniforms.progress;
+    amount = ((_e96 * 1.66f) + -0.16f);
+    let _e99 = amount;
+    cylinderCenter = _e99;
+    let _e100 = amount;
+    cylinderAngle = (6.2831855f * _e100);
+    c = -0.17364818f;
+    s = -0.9848077f;
+    let _e102 = c;
+    let _e103 = s;
+    let _e104 = s;
+    let _e106 = c;
+    rotation_2 = mat3x3<f32>(vec3<f32>(_e102, _e103, 0f), vec3<f32>(-(_e104), _e106, 0f), vec3<f32>(-0.801f, 0.89f, 1f));
+    c = -0.17364818f;
+    s = 0.9848077f;
+    let _e111 = c;
+    let _e112 = s;
+    let _e113 = s;
+    let _e115 = c;
+    rrotation_4 = mat3x3<f32>(vec3<f32>(_e111, _e112, 0f), vec3<f32>(-(_e113), _e115, 0f), vec3<f32>(0.985f, 0.985f, 1f));
+    let _e120 = rotation_2;
+    let _e121 = (*p_3);
+    point_6 = (_e120 * vec3<f32>(_e121.x, _e121.y, 1f));
+    let _e127 = point_6[1u];
+    let _e128 = cylinderCenter;
+    yc_5 = (_e127 - _e128);
+    let _e130 = yc_5;
+    if (_e130 < -0.15915494f) {
+        let _e132 = (*p_3);
+        param_22 = _e132;
+        let _e133 = yc_5;
+        param_23 = _e133;
+        let _e134 = point_6;
+        param_24 = _e134;
+        let _e135 = rrotation_4;
+        param_25 = _e135;
+        let _e136 = behindSurface((&param_22), (&param_23), (&param_24), (&param_25));
+        return _e136;
+    }
+    let _e137 = yc_5;
+    if (_e137 > 0.15915494f) {
+        let _e139 = (*p_3);
+        param_26 = _e139;
+        let _e140 = getFromColor((&param_26));
+        return _e140;
+    }
+    let _e141 = yc_5;
+    let _e145 = cylinderAngle;
+    hitAngle_3 = ((acos(clamp((_e141 / 0.15915494f), -1f, 1f)) + _e145) - 3.1415927f);
+    let _e148 = hitAngle_3;
+    hitAngleMod = (_e148 - (floor((_e148 / 6.2831855f)) * 6.2831855f));
+    let _e153 = hitAngleMod;
+    let _e155 = amount;
+    let _e157 = ((_e153 > 3.1415927f) && (_e155 < 0.5f));
+    phi_665_ = _e157;
+    if !(_e157) {
+        let _e159 = hitAngleMod;
+        let _e161 = amount;
+        phi_665_ = ((_e159 > 1.5707964f) && (_e161 < 0f));
+    }
+    let _e165 = phi_665_;
+    if _e165 {
+        let _e166 = yc_5;
+        param_27 = _e166;
+        let _e167 = (*p_3);
+        param_28 = _e167;
+        let _e168 = rotation_2;
+        param_29 = _e168;
+        let _e169 = rrotation_4;
+        param_30 = _e169;
+        let _e170 = seeThrough((&param_27), (&param_28), (&param_29), (&param_30));
+        return _e170;
+    }
+    let _e171 = hitAngle_3;
+    param_31 = _e171;
+    let _e172 = yc_5;
+    param_32 = _e172;
+    let _e173 = point_6;
+    param_33 = _e173;
+    let _e174 = rrotation_4;
+    param_34 = _e174;
+    let _e175 = hitPoint_u0028_f1_u003b_f1_u003b_vf3_u003b_mf33_u003b((&param_31), (&param_32), (&param_33), (&param_34));
+    point_6 = _e175;
+    let _e177 = point_6[0u];
+    let _e178 = (_e177 < 0f);
+    phi_696_ = _e178;
+    if !(_e178) {
+        let _e181 = point_6[1u];
+        phi_696_ = (_e181 < 0f);
+    }
+    let _e184 = phi_696_;
+    phi_703_ = _e184;
+    if !(_e184) {
+        let _e187 = point_6[0u];
+        phi_703_ = (_e187 > 1f);
+    }
+    let _e190 = phi_703_;
+    phi_710_ = _e190;
+    if !(_e190) {
+        let _e193 = point_6[1u];
+        phi_710_ = (_e193 > 1f);
+    }
+    let _e196 = phi_710_;
+    if _e196 {
+        let _e197 = yc_5;
+        param_35 = _e197;
+        let _e198 = (*p_3);
+        param_36 = _e198;
+        let _e199 = point_6;
+        param_37 = _e199;
+        let _e200 = rotation_2;
+        param_38 = _e200;
+        let _e201 = rrotation_4;
+        param_39 = _e201;
+        let _e202 = seeThroughWithShadow((&param_35), (&param_36), (&param_37), (&param_38), (&param_39));
+        return _e202;
+    }
+    let _e203 = yc_5;
+    param_40 = _e203;
+    let _e204 = point_6;
+    param_41 = _e204;
+    let _e205 = backside((&param_40), (&param_41));
+    color_2 = _e205;
+    let _e206 = yc_5;
+    if (_e206 < 0f) {
+        let _e209 = point_6[0u];
+        dx2_ = (_e209 - 0.5f);
+        let _e212 = point_6[1u];
+        dy2_ = (_e212 - 0.5f);
+        let _e214 = dx2_;
+        let _e215 = dx2_;
+        let _e217 = dy2_;
+        let _e218 = dy2_;
+        shado_1 = (1f - (sqrt(((_e214 * _e215) + (_e217 * _e218))) / 0.71f));
+        let _e224 = yc_5;
+        nyc2_ = (-(_e224) / 0.15915494f);
+        let _e227 = nyc2_;
+        let _e228 = nyc2_;
+        let _e230 = nyc2_;
+        let _e232 = shado_1;
+        shado_1 = (_e232 * ((_e227 * _e228) * _e230));
+        let _e234 = shado_1;
+        shado_1 = (_e234 * 0.5f);
+        let _e236 = shado_1;
+        otherColor = vec4<f32>(0f, 0f, 0f, _e236);
+    } else {
+        let _e238 = (*p_3);
+        param_42 = _e238;
+        let _e239 = getFromColor((&param_42));
+        otherColor = _e239;
+    }
+    let _e240 = yc_5;
+    let _e243 = color_2;
+    param_43 = _e243;
+    let _e244 = otherColor;
+    param_44 = _e244;
+    param_45 = (0.15915494f - abs(_e240));
+    let _e245 = antiAlias((&param_43), (&param_44), (&param_45));
+    color_2 = _e245;
+    let _e246 = yc_5;
+    param_46 = _e246;
+    let _e247 = (*p_3);
+    param_47 = _e247;
+    let _e248 = point_6;
+    param_48 = _e248;
+    let _e249 = rotation_2;
+    param_49 = _e249;
+    let _e250 = rrotation_4;
+    param_50 = _e250;
+    let _e251 = seeThroughWithShadow((&param_46), (&param_47), (&param_48), (&param_49), (&param_50));
+    cl = _e251;
+    let _e252 = point_6;
+    param_51 = _e252;
+    let _e253 = distanceToEdge((&param_51));
+    dist = _e253;
+    let _e254 = color_2;
+    param_52 = _e254;
+    let _e255 = cl;
+    param_53 = _e255;
+    let _e256 = dist;
+    param_54 = _e256;
+    let _e257 = antiAlias((&param_52), (&param_53), (&param_54));
+    return _e257;
+}
+
+fn main_1() {
+    var param_55: vec2<f32>;
+
+    let _e46 = _uv_1;
+    param_55 = _e46;
+    let _e47 = transition((&param_55));
+    _fragColor = _e47;
+    return;
+}
+
+@fragment 
+fn main(@location(0) _uv: vec2<f32>) -> @location(0) vec4<f32> {
+    _uv_1 = _uv;
+    main_1();
+    let _e3 = _fragColor;
+    return _e3;
+}