gl-transitions
Version:
The open collection of GL Transitions
231 lines (218 loc) • 7.07 kB
text/wgsl
// 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,
}
var _from: texture_2d<f32>;
var _sampler: sampler;
var _to: texture_2d<f32>;
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((¶m));
let _e59 = uniforms.dividerWidth;
if (_e57 < _e59) {
let _e61 = currentProg;
a = (1f - _e61);
}
let _e63 = (*uv_2);
param_1 = _e63;
let _e64 = getFromColor((¶m_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((¶m_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((¶m_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((¶m_4));
a_1 = _e129;
let _e130 = p_1;
param_5 = _e130;
let _e131 = getToColor((¶m_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((¶m_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((¶m_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((¶m_8));
_fragColor = _e24;
return;
}
fn main( _uv: vec2<f32>) -> vec4<f32> {
_uv_1 = _uv;
main_1();
let _e3 = _fragColor;
return _e3;
}