diff --git a/scripts/wlbg/src/bg_frag.glsl b/scripts/wlbg/src/bg_frag.glsl index 17510a7..2faa732 100644 --- a/scripts/wlbg/src/bg_frag.glsl +++ b/scripts/wlbg/src/bg_frag.glsl @@ -6,45 +6,163 @@ in vec2 fragCoord; out vec4 fragColor; -// shader: https://www.shadertoy.com/view/fljSDW +// shader: https://www.shadertoy.com/view/XfXXWj -float sq(float x) { - return x*x; +#define iResolution vec3(1.) + +#define R(p,a,r)mix(a*dot(p,a),p,cos(r))+sin(r)*cross(p,a) +#define H(h)(cos((h)*6.3+vec3(23,43,21))*.5+.5) + +#define OCTAVES 6 + +float random(vec2 p) { + return fract(sin(dot(p.xy, vec2(12.9898, 78.233))) * 43758.5453123); +} + +float cheap_star(vec2 uv, float anim) { + uv = abs(uv); + vec2 pos = min(uv.xy / uv.yx, anim); + float p = (2.0 - pos.x - pos.y); + return (2.0 + p * (p * p - 1.5)) / (uv.x + uv.y); +} + +float noise(vec2 p) { + vec2 s = floor(p); + + float a = random(s); + float b = random(s + vec2(1.0, 0.0)); + float c = random(s + vec2(0.0, 1.0)); + float d = random(s + vec2(1.0, 1.0)); + + vec2 f = smoothstep(0.0, 1.0, fract(p)); + + float ab = mix(a, b, f.x); + float cd = mix(c, d, f.x); + + float o = mix(ab, cd, f.y); + + return o; +} +#define pi 3.14159265358 +#define tpi (2.0*pi) +#define pi_6 pi/6.0 + +vec3 sebs_colors(float offset, float speed) { + return 1.0 - sin(offset + speed * time * vec3(3.0, 7.0, 11.0) / pi_6); +} + +float circle(vec2 uv, float angle, float radius, vec2 wiggle) { + return 0.0025 / abs(length(uv) - radius + wiggle[0] * sin(time * 0.1) * sin(10.0 * (angle - 0.5 * time) + wiggle[1])); +} + +float fractal(vec2 p) { + float o = 0.0; + float strength = 0.5; + vec2 position = p; + + for (int i = 0; i < OCTAVES; i++) { + o += noise(position) * strength; + position *= 2.0; + strength *= 0.5; + } + + // attempt to fix darkness issues + o /= 1.0 - 0.5 * pow(0.5, float(OCTAVES - 1)); + + return o; +} + +vec2 computeNext(vec2 current, vec2 constant) { + float zr = (current.x * current.x) - (current.y * current.y); + float zi = 2.0 * current.x * current.y; + + return vec2(zr, zi) + constant; +} + +float mod2(vec2 z) { + return z.x * z.x + z.y * z.y; +} + +float computeIterations(vec2 z0, vec2 constant, float max_iterations) { + vec2 zn = z0; + float iteration = 0.; + while (length(zn) < 2. && iteration < max_iterations) { + zn = computeNext(zn, constant); + iteration++; + } + + float mod2 = length(zn); + float smoothf = float(iteration) - log2(max(1., log2(mod2))); + return smoothf; +} + +vec3 getColor(float it, float maxIt) { + return (vec3(it / maxIt)); } void main() { - vec2 u = fragCoord; - vec4 o = vec4(0); - vec2 R = vec2(1); - ivec4 b = ivec4(o -= o); // Initialize b=0 - float t = .1*time, B, h, z; - vec4 g = vec4(0); + vec2 C = fragCoord + vec2(.5); + vec4 O = vec4(0); + O = vec4(0); + vec2 uv = (2.0 * C - iResolution.xy) / iResolution.y; + uv *= .1; - u = - (5. + cos(t) * 1.5) * // * Camera push in/out - (u+u)/R.y // Center coordinates - * mat2( cos( vec4(0,33,55,0) - .1*t)) // * Rotate camera - ; + float max_Iterations = 80.; + float uTime = pow(sin(time * 0.2), 3.) * .03 - 1.313; + //float uTime = -1.313; + uv *= sin(time * 0.2) + 2.; + vec2 uConstant = (vec2(-abs(-sin(uTime)), (cos(uTime)))); + float color = computeIterations(uv, uConstant, max_Iterations); - z = (h = cos(B = floor(atan(u.x, u.y) * 2e2))) / dot(u,u); //Variables for Rain + vec3 col = vec3(getColor(color, max_Iterations)); + col = vec3(pow(col.x, .7)); + col.z = 0.; - for (; (b.x^b.y^b.z)%199 > b.z-16 ; ) // XOR function for towers - g += pow(vec4(0., 0., 0., .5*u + .1*sin(t/.1+(o.a*.03)+3.*u) ),g-g+18.), // * Ground ghosts - b = ivec4(u * o.a + 2e2 - + vec2(7,30)*t // * Move camera (x,y) - , o+=.1 ); // Increment layer + col += vec3(0, 0, .5); + col *= vec3(1.3, 1, 1); + vec3 color2 = vec3(0.0); - o = - //o.a < 8.1 ? .1+sin(t/.1)*vec4(b%32 & b.x%9 & b.z%9) : // * Blinking lights - o/80. - .02 * // * Distance fog - vec4(b%2) // * Building colors - + .2*(o.a > 17. ? vec4( int(.5+sin(float(b.x/2 + b.y + 2*b.z))) & b.x & b.y & int(.5+sin(4.*o.a-3.4)) ) : g-g) // * Windows - + (o.a > 50. ? g*vec4(.02,.1,1,0) : g-g) // * Ground ghosts - + vec4(1, 0, 0, .06)*sin(g) // * Moving fog - + .01*max(exp(fract(h * B - z + t+t) * -1e2) / z,0.) // * Rain - ; + float angle = pi * mod(atan(uv.x, uv.y) / tpi, 1.0); - o *= vec4(0.6, 0, 0, 1.0); + for (float i = 1.0; i < 10.0; i++) + { + color2 += sebs_colors(0.0, 25.0) * circle(uv, angle + 3.0 * pi_6, i / 7.0, vec2(i, i)); + } + vec3 natur, q, r = iResolution, + d = normalize(vec3((C * 2. - r.xy) / r.y, 1)); + for (float i = 0., a, s, e, g = 0.; + ++i < 110.; + O.xyz += mix(vec3(1), H(g * .1), sin(.8)) * 1. / e / 8e3 + ) + { + natur = g * d; + float c23 = fractal(natur.xy); + natur.z += time * 0.0; + a = 30. + c23; + natur = mod(natur - a, a * 2.) - a; + s = 3.; + for (int i = 0; i++ < 8; ) { + natur = .3 - abs(natur); - fragColor = o; + natur.x < natur.z ? natur = natur.zyx : natur; + + natur.y < natur.z ? natur = natur.zyx : natur; + natur.z < natur.x ? natur = natur.yxz : natur; + s *= e = 1.4 + sin(time * .234) * .1; + natur = abs(natur) * e - + vec3( + 5. + atan(time * .3 + .5 * +cos(time * .3)) * 3., + 80, + 3. + atan(time * .5) * 5. + ) * col; + } + g += e = length(natur.yz) / s; + } + uv *= 2.0 * (cos(time * 2.0) - 2.5); + + // anim between 0.9 - 1.1 + float anim = sin(time * 12.0) * 0.1 + 1.0; + + O *= vec4(cheap_star(uv, anim) * vec3(0.55, 0.5, 0.55) * 3., 1.0); + fragColor = O; } diff --git a/scripts/wlbg/src/main.zig b/scripts/wlbg/src/main.zig index b68544a..bdd896b 100644 --- a/scripts/wlbg/src/main.zig +++ b/scripts/wlbg/src/main.zig @@ -360,17 +360,19 @@ fn wlPollCb( }; const dpy: *wl.Display = @ptrCast(@alignCast(userdata)); - if (dpy.readEvents() != .SUCCESS or - dpy.dispatchPending() != .SUCCESS or - dpy.flush() != .SUCCESS) - { - std.log.err("error processing wayland events", .{}); + if (dpy.readEvents() != .SUCCESS) { + std.log.err("error reading wayland events", .{}); loop.stop(); return .disarm; } - // This is only false if the queue is not empty, but we just emptied the queue. - std.debug.assert(dpy.prepareRead()); + while (!dpy.prepareRead()) { + if (dpy.dispatchPending() != .SUCCESS or dpy.flush() != .SUCCESS) { + std.log.err("error processing wayland events", .{}); + loop.stop(); + return .disarm; + } + } return .rearm; } diff --git a/scripts/wlbg/src/main_frag.glsl b/scripts/wlbg/src/main_frag.glsl index ccc7bd6..df295be 100644 --- a/scripts/wlbg/src/main_frag.glsl +++ b/scripts/wlbg/src/main_frag.glsl @@ -17,4 +17,3 @@ void main() { vec2 zoomedUv = fragUv * .9 + (.1 / 2.0); fragColor = mix(texture(bg, zoomedUv + (cursorPos - .5) / 10.0), vec4(1.0), light * hasCursor); } - diff --git a/scripts/wlbg/src/options.zig b/scripts/wlbg/src/options.zig index 9cbbafd..47414ac 100644 --- a/scripts/wlbg/src/options.zig +++ b/scripts/wlbg/src/options.zig @@ -4,7 +4,7 @@ const std = @import("std"); pub const fps = 30; // Draw backgrounds aligned with same value or individually with different val. -pub const multihead_mode: enum { combined, individual } = .individual; +pub const multihead_mode: enum { combined, individual } = .combined; // Time between background changes pub const refresh_time = std.time.ms_per_min * 5;