gl-transitions
Version:
The open collection of GL Transitions
251 lines (236 loc) • 7.86 kB
text/wgsl
// GridFlip — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/GridFlip.glsl
// Author: TimDonselaar
// 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,
bgcolor: vec4<f32>,
randomness: 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 getDividerSize_u0028_() -> f32 {
var rectangleSize: vec2<f32>;
let _e24 = uniforms.size;
let _e29 = uniforms.size;
rectangleSize = vec2<f32>((1f / vec2<f32>(_e24).x), (1f / vec2<f32>(_e29).y));
let _e35 = rectangleSize[0u];
let _e37 = rectangleSize[1u];
let _e40 = uniforms.dividerWidth;
return (min(_e35, _e37) * _e40);
}
fn getDelta(p: ptr<function, vec2<f32>>) -> f32 {
var rectanglePos: vec2<f32>;
var rectangleSize_1: vec2<f32>;
var top: f32;
var bottom: f32;
var left: f32;
var right: f32;
var minX: f32;
var minY: f32;
let _e32 = uniforms.size;
let _e34 = (*p);
rectanglePos = floor((vec2<f32>(_e32) * _e34));
let _e38 = uniforms.size;
let _e43 = uniforms.size;
rectangleSize_1 = vec2<f32>((1f / vec2<f32>(_e38).x), (1f / vec2<f32>(_e43).y));
let _e49 = rectangleSize_1[1u];
let _e51 = rectanglePos[1u];
top = (_e49 * (_e51 + 1f));
let _e55 = rectangleSize_1[1u];
let _e57 = rectanglePos[1u];
bottom = (_e55 * _e57);
let _e60 = rectangleSize_1[0u];
let _e62 = rectanglePos[0u];
left = (_e60 * _e62);
let _e65 = rectangleSize_1[0u];
let _e67 = rectanglePos[0u];
right = (_e65 * (_e67 + 1f));
let _e71 = (*p)[0u];
let _e72 = left;
let _e76 = (*p)[0u];
let _e77 = right;
minX = min(abs((_e71 - _e72)), abs((_e76 - _e77)));
let _e82 = (*p)[1u];
let _e83 = top;
let _e87 = (*p)[1u];
let _e88 = bottom;
minY = min(abs((_e82 - _e83)), abs((_e87 - _e88)));
let _e92 = minX;
let _e93 = minY;
return min(_e92, _e93);
}
fn transition(p_1: 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 q: vec2<f32>;
var rectanglePos_1: vec2<f32>;
var r: f32;
var param_3: vec2<f32>;
var cp: f32;
var rectangleSize_2: f32;
var delta: f32;
var offset: 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 = (*p_1);
param = _e56;
let _e57 = getDelta((¶m));
let _e58 = getDividerSize_u0028_();
if (_e57 < _e58) {
let _e60 = currentProg;
a = (1f - _e60);
}
let _e63 = uniforms.bgcolor;
let _e64 = (*p_1);
param_1 = _e64;
let _e65 = getFromColor((¶m_1));
let _e66 = a;
return mix(_e63, _e65, vec4(_e66));
} else {
let _e70 = uniforms.progress;
let _e72 = uniforms.pause;
if (_e70 < (1f - _e72)) {
let _e75 = (*p_1);
param_2 = _e75;
let _e76 = getDelta((¶m_2));
let _e77 = getDividerSize_u0028_();
if (_e76 < _e77) {
let _e80 = uniforms.bgcolor;
return _e80;
} else {
let _e82 = uniforms.progress;
let _e84 = uniforms.pause;
let _e87 = uniforms.pause;
currentProg_1 = ((_e82 - _e84) / (1f - (_e87 * 2f)));
let _e91 = (*p_1);
q = _e91;
let _e93 = uniforms.size;
let _e95 = q;
rectanglePos_1 = floor((vec2<f32>(_e93) * _e95));
let _e98 = rectanglePos_1;
param_3 = _e98;
let _e99 = rand((¶m_3));
let _e101 = uniforms.randomness;
r = (_e99 - _e101);
let _e103 = r;
let _e105 = currentProg_1;
cp = smoothstep(0f, (1f - _e103), _e105);
let _e108 = uniforms.size;
rectangleSize_2 = (1f / vec2<f32>(_e108).x);
let _e113 = rectanglePos_1[0u];
let _e114 = rectangleSize_2;
delta = (_e113 * _e114);
let _e116 = rectangleSize_2;
let _e118 = delta;
offset = ((_e116 / 2f) + _e118);
let _e121 = (*p_1)[0u];
let _e122 = offset;
let _e124 = cp;
let _e129 = offset;
(*p_1)[0u] = ((((_e121 - _e122) / abs((_e124 - 0.5f))) * 0.5f) + _e129);
let _e132 = (*p_1);
param_4 = _e132;
let _e133 = getFromColor((¶m_4));
a_1 = _e133;
let _e134 = (*p_1);
param_5 = _e134;
let _e135 = getToColor((¶m_5));
b = _e135;
let _e137 = uniforms.size;
let _e141 = q[0u];
let _e142 = delta;
let _e147 = cp;
s = step(abs(((vec2<f32>(_e137).x * (_e141 - _e142)) - 0.5f)), abs((_e147 - 0.5f)));
let _e152 = uniforms.bgcolor;
let _e153 = b;
let _e154 = a_1;
let _e155 = cp;
let _e159 = s;
return mix(_e152, mix(_e153, _e154, vec4(step(_e155, 0.5f))), vec4(_e159));
}
} else {
let _e163 = uniforms.progress;
let _e166 = uniforms.pause;
let _e169 = uniforms.pause;
currentProg_2 = (((_e163 - 1f) + _e166) / _e169);
a_2 = 1f;
let _e171 = (*p_1);
param_6 = _e171;
let _e172 = getDelta((¶m_6));
let _e173 = getDividerSize_u0028_();
if (_e172 < _e173) {
let _e175 = currentProg_2;
a_2 = _e175;
}
let _e177 = uniforms.bgcolor;
let _e178 = (*p_1);
param_7 = _e178;
let _e179 = getToColor((¶m_7));
let _e180 = a_2;
return mix(_e177, _e179, vec4(_e180));
}
}
}
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;
}