// PuzzleRight — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/PuzzleRight.glsl
// Author: JustKirillS
// License: MIT
// Description: The image splits into a grid of tiles that flip one by one to the incoming image
// Bindings and uniform layout: see the gl-transitions package README

struct Uniforms {
    progress: f32,
    ratio: f32,
    size: vec2<i32>,
    pause: f32,
    dividerWidth: 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 _e24 = (*uv)[0u];
    let _e26 = (*uv)[1u];
    let _e29 = textureSampleLevel(_to, _sampler, vec2<f32>(_e24, (1f - _e26)), 0f);
    return _e29;
}

fn rand(co: ptr<function, vec2<f32>>) -> f32 {
    let _e23 = (*co);
    return fract((sin(dot(_e23, vec2<f32>(12.9898f, 78.233f))) * 43758.547f));
}

fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
    let _e24 = (*uv_1)[0u];
    let _e26 = (*uv_1)[1u];
    let _e29 = textureSampleLevel(_from, _sampler, vec2<f32>(_e24, (1f - _e26)), 0f);
    return _e29;
}

fn getDelta(p: ptr<function, vec2<f32>>) -> f32 {
    var rectangleSize: vec2<f32>;
    var rectanglePos: vec2<f32>;
    var top: f32;
    var bottom: f32;
    var left: f32;
    var right: f32;
    var minX: f32;
    var minY: f32;

    let _e32 = uniforms.size;
    rectangleSize = (vec2(1f) / vec2<f32>(_e32));
    let _e37 = uniforms.size;
    let _e39 = (*p);
    rectanglePos = floor((vec2<f32>(_e37) * _e39));
    let _e43 = rectangleSize[1u];
    let _e45 = rectanglePos[1u];
    top = (_e43 * (_e45 + 1f));
    let _e49 = rectangleSize[1u];
    let _e51 = rectanglePos[1u];
    bottom = (_e49 * _e51);
    let _e54 = rectangleSize[0u];
    let _e56 = rectanglePos[0u];
    left = (_e54 * _e56);
    let _e59 = rectangleSize[0u];
    let _e61 = rectanglePos[0u];
    right = (_e59 * (_e61 + 1f));
    let _e65 = (*p)[0u];
    let _e66 = left;
    let _e70 = (*p)[0u];
    let _e71 = right;
    minX = min(abs((_e65 - _e66)), abs((_e70 - _e71)));
    let _e76 = (*p)[1u];
    let _e77 = top;
    let _e81 = (*p)[1u];
    let _e82 = bottom;
    minY = min(abs((_e76 - _e77)), abs((_e81 - _e82)));
    let _e86 = minX;
    let _e87 = minY;
    return min(_e86, _e87);
}

fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
    var currentProg: f32;
    var a: f32;
    var param: vec2<f32>;
    var param_1: vec2<f32>;
    var param_2: vec2<f32>;
    var currentProg_1: f32;
    var rectanglePos_1: vec2<f32>;
    var r: f32;
    var param_3: vec2<f32>;
    var cp: f32;
    var rectangleSize_1: f32;
    var delta: f32;
    var offset: f32;
    var p_1: vec2<f32>;
    var a_1: vec4<f32>;
    var param_4: vec2<f32>;
    var b: vec4<f32>;
    var param_5: vec2<f32>;
    var s: f32;
    var currentProg_2: f32;
    var a_2: f32;
    var param_6: vec2<f32>;
    var param_7: vec2<f32>;

    let _e47 = uniforms.progress;
    let _e49 = uniforms.pause;
    if (_e47 < _e49) {
        let _e52 = uniforms.progress;
        let _e54 = uniforms.pause;
        currentProg = (_e52 / _e54);
        a = 1f;
        let _e56 = (*uv_2);
        param = _e56;
        let _e57 = getDelta((&param));
        let _e59 = uniforms.dividerWidth;
        if (_e57 < _e59) {
            let _e61 = currentProg;
            a = (1f - _e61);
        }
        let _e63 = (*uv_2);
        param_1 = _e63;
        let _e64 = getFromColor((&param_1));
        let _e65 = a;
        return mix(vec4<f32>(0f, 0f, 0f, 1f), _e64, vec4(_e65));
    } else {
        let _e69 = uniforms.progress;
        let _e71 = uniforms.pause;
        if (_e69 < (1f - _e71)) {
            let _e74 = (*uv_2);
            param_2 = _e74;
            let _e75 = getDelta((&param_2));
            let _e77 = uniforms.dividerWidth;
            if (_e75 < _e77) {
                return vec4<f32>(0f, 0f, 0f, 1f);
            }
            let _e80 = uniforms.progress;
            let _e82 = uniforms.pause;
            let _e85 = uniforms.pause;
            currentProg_1 = ((_e80 - _e82) / (1f - (_e85 * 2f)));
            let _e90 = uniforms.size;
            let _e92 = (*uv_2);
            rectanglePos_1 = floor((vec2<f32>(_e90) * _e92));
            let _e95 = rectanglePos_1;
            param_3 = _e95;
            let _e96 = rand((&param_3));
            r = (_e96 - 0.1f);
            let _e98 = r;
            let _e100 = currentProg_1;
            cp = smoothstep(0f, (1f - _e98), _e100);
            let _e104 = uniforms.size[0u];
            rectangleSize_1 = (1f / f32(_e104));
            let _e108 = rectanglePos_1[0u];
            let _e109 = rectangleSize_1;
            delta = (_e108 * _e109);
            let _e111 = rectangleSize_1;
            let _e113 = delta;
            offset = ((_e111 / 2f) + _e113);
            let _e115 = (*uv_2);
            p_1 = _e115;
            let _e117 = p_1[0u];
            let _e118 = offset;
            let _e120 = cp;
            let _e125 = offset;
            p_1[0u] = ((((_e117 - _e118) / abs((_e120 - 0.5f))) * 0.5f) + _e125);
            let _e128 = p_1;
            param_4 = _e128;
            let _e129 = getFromColor((&param_4));
            a_1 = _e129;
            let _e130 = p_1;
            param_5 = _e130;
            let _e131 = getToColor((&param_5));
            b = _e131;
            let _e134 = uniforms.size[0u];
            let _e137 = (*uv_2)[0u];
            let _e138 = delta;
            let _e143 = cp;
            s = step(abs(((f32(_e134) * (_e137 - _e138)) - 0.5f)), abs((_e143 - 0.5f)));
            let _e147 = b;
            let _e148 = a_1;
            let _e149 = cp;
            let _e154 = s;
            let _e155 = (mix(_e147, _e148, vec4(step(_e149, 0.5f))).xyz * _e154);
            return vec4<f32>(_e155.x, _e155.y, _e155.z, 1f);
        } else {
            let _e161 = uniforms.progress;
            let _e164 = uniforms.pause;
            let _e167 = uniforms.pause;
            currentProg_2 = (((_e161 - 1f) + _e164) / _e167);
            a_2 = 1f;
            let _e169 = (*uv_2);
            param_6 = _e169;
            let _e170 = getDelta((&param_6));
            let _e172 = uniforms.dividerWidth;
            if (_e170 < _e172) {
                let _e174 = currentProg_2;
                a_2 = _e174;
            }
            let _e175 = (*uv_2);
            param_7 = _e175;
            let _e176 = getToColor((&param_7));
            let _e177 = a_2;
            return mix(vec4<f32>(0f, 0f, 0f, 1f), _e176, vec4(_e177));
        }
    }
}

fn main_1() {
    var param_8: vec2<f32>;

    let _e23 = _uv_1;
    param_8 = _e23;
    let _e24 = transition((&param_8));
    _fragColor = _e24;
    return;
}

@fragment 
fn main(@location(0) _uv: vec2<f32>) -> @location(0) vec4<f32> {
    _uv_1 = _uv;
    main_1();
    let _e3 = _fragColor;
    return _e3;
}