summaryrefslogtreecommitdiff
path: root/picom
diff options
context:
space:
mode:
Diffstat (limited to 'picom')
-rw-r--r--picom/default.glsl19
-rw-r--r--picom/default_anim.glsl70
-rw-r--r--picom/glass.glsl165
-rw-r--r--picom/lock.glsl458
-rw-r--r--picom/matrix_dissolve.glsl78
-rw-r--r--picom/picom.conf766
-rw-r--r--picom/pixelize.glsl71
-rw-r--r--picom/sdf_mask.glsl131
8 files changed, 1438 insertions, 320 deletions
diff --git a/picom/default.glsl b/picom/default.glsl
new file mode 100644
index 0000000..e433f4b
--- /dev/null
+++ b/picom/default.glsl
@@ -0,0 +1,19 @@
+#version 330
+in vec2 texcoord; // texture coordinate of the fragment
+
+uniform sampler2D tex; // texture of the window
+
+// Default window post-processing:
+// 1) invert color
+// 2) opacity / transparency
+// 3) max-brightness clamping
+// 4) rounded corners
+vec4 default_post_processing(vec4 c);
+
+// Default window shader:
+// 1) fetch the specified pixel
+// 2) apply default post-processing
+vec4 window_shader() {
+ vec4 c = texelFetch(tex, ivec2(texcoord), 0);
+ return default_post_processing(c);
+}
diff --git a/picom/default_anim.glsl b/picom/default_anim.glsl
new file mode 100644
index 0000000..e4f43ed
--- /dev/null
+++ b/picom/default_anim.glsl
@@ -0,0 +1,70 @@
+#version 330
+
+in vec2 texcoord; // texture coordinate of the fragment
+
+uniform sampler2D tex; // texture of the window
+
+
+ivec2 window_size = textureSize(tex, 0); // Size of the window
+ivec2 window_center = ivec2(window_size.x/2, window_size.y/2);
+
+/*
+These shaders use a sorta hacky way to use the changing
+window opacity you might set on picom.conf animation rules
+to perform animations.
+
+Basically, when a window get's mapped, we make it's alpha
+go from 0 to 1, so, using the default_post_processing to get that alpha
+we can get a variable going from 0 (start of mapping animation)
+to 1 (end of mapping animation)
+
+You can also set up your alpha value to go from 1 to 0 in picom when
+a window is closed, effectively reversing the animations described here
+*/
+
+// Default window post-processing:
+// 1) invert color
+// 2) opacity / transparency
+// 3) max-brightness clamping
+// 4) rounded corners
+vec4 default_post_processing(vec4 c);
+
+// If you have semitransparent windows (like a terminal)
+// You can use the below function to add an opacity threshold where the
+// animation won't apply. For example, if you had your terminal
+// configured to have 0.8 opacity, you'd set the below variable to 0.8
+float max_opacity = 1;
+float opacity_threshold(float opacity)
+{
+ // if statement jic?
+ if (opacity >= max_opacity)
+ {
+ return 1.0;
+ }
+ else
+ {
+ return min(1, opacity/max_opacity);
+ }
+
+}
+
+vec4 anim(float time) {
+ vec4 c = texelFetch(tex, ivec2(texcoord), 0);
+ return c;
+}
+
+// Default window shader:
+// 1) fetch the specified pixel
+// 2) apply default post-processing
+vec4 window_shader() {
+ vec4 c = texelFetch(tex, ivec2(texcoord), 0);
+ c = default_post_processing(c);
+ float opacity = opacity_threshold(c.w);
+ if (opacity == 0.0)
+ {
+ return c;
+ }
+ vec4 anim_c = anim(opacity);
+ return default_post_processing(anim_c);
+}
+
diff --git a/picom/glass.glsl b/picom/glass.glsl
new file mode 100644
index 0000000..a37972e
--- /dev/null
+++ b/picom/glass.glsl
@@ -0,0 +1,165 @@
+#version 330
+
+in vec2 texcoord; // texture coordinate of the fragment
+
+uniform sampler2D tex; // texture of the window
+
+
+ivec2 window_size = textureSize(tex, 0); // Size of the window
+ivec2 window_center = ivec2(window_size.x/2, window_size.y/2);
+
+/*
+These shaders use a sorta hacky way to use the changing
+window opacity you might set on picom.conf animation rules
+to perform animations.
+
+Basically, when a window get's mapped, we make it's alpha
+go from 0 to 1, so, using the default_post_processing to get that alpha
+we can get a variable going from 0 (start of mapping animation)
+to 1 (end of mapping animation)
+
+You can also set up your alpha value to go from 1 to 0 in picom when
+a window is closed, effectively reversing the animations described here
+*/
+
+// Default window post-processing:
+// 1) invert color
+// 2) opacity / transparency
+// 3) max-brightness clamping
+// 4) rounded corners
+vec4 default_post_processing(vec4 c);
+
+// If you have semitransparent windows (like a terminal)
+// You can use the below function to add an opacity threshold where the
+// animation won't apply. For example, if you had your terminal
+// configured to have 0.8 opacity, you'd set the below variable to 0.8
+float max_opacity = 0.8;
+float opacity_threshold(float opacity)
+{
+ // if statement jic?
+ if (opacity >= max_opacity)
+ {
+ return 1.0;
+ }
+ else
+ {
+ return min(1, opacity/max_opacity);
+ }
+
+}
+
+// Pseudo-random function (from original shader)
+float random(vec2 st) {
+ return fract(sin(dot(st.xy, vec2(12.9898,78.233))) * 43758.5453123);
+}
+
+float PI = 3.1415926535;
+float TWO_PI = 2.0 * PI;
+
+// NEW anim function: Glass-Shard Shatter
+vec4 anim(float animation_progress) {
+ vec4 out_color = vec4(0.0); // Default to transparent
+
+ // --- Shard Parameters ---
+ float num_shards = 20.0; // Number of angular shards
+ vec2 impact_point = window_center;
+
+ // --- Fragment's Relation to Impact Point & Shard ID ---
+ vec2 vec_frag_to_impact = texcoord - impact_point;
+ float dist_frag_to_impact = length(vec_frag_to_impact);
+ float angle_frag = atan(vec_frag_to_impact.y, vec_frag_to_impact.x); // Range: -PI to PI
+ if (angle_frag < 0.0) {
+ angle_frag += TWO_PI; // Normalize to 0 to 2*PI
+ }
+ float shard_id = floor(angle_frag / (TWO_PI / num_shards));
+
+ // --- Staggered Animation Timing for each Shard ---
+ // Use random for a less ordered shatter
+ float shard_delay_normalized = random(vec2(shard_id, shard_id * 0.31));
+ // float shard_delay_normalized = shard_id / num_shards; // For a sweep
+
+ float individual_shard_anim_duration = 0.7; // How long each shard takes to animate
+ float ripple_spread_factor = 1.0 - individual_shard_anim_duration;
+
+ float stagger_start_progress = shard_delay_normalized * ripple_spread_factor;
+ float stagger_end_progress = stagger_start_progress + individual_shard_anim_duration;
+
+ // shard_anim_progress: 0.0 (shard starts moving in) -> 1.0 (shard is in place)
+ float shard_anim_progress = smoothstep(stagger_start_progress, stagger_end_progress, animation_progress);
+
+ if (shard_anim_progress < 0.001) { // Shard is not yet visible or fully shattered away
+ return vec4(0.0); // Fully transparent
+ }
+
+ // --- Shard Transformation Parameters ---
+ // current_displacement_factor: 1.0 (max shatter) -> 0.0 (assembled)
+ float current_displacement_factor = 1.0 - shard_anim_progress;
+
+ // Max translation (e.g., 30% of half window width)
+ float max_translation_dist = length(vec2(window_size) * 0.5) * 0.3;
+ // Max rotation (e.g., 25 degrees)
+ float max_rotation_angle_rad = (PI / 180.0) * 25.0 * random(vec2(shard_id * 0.7, shard_id)); // Add some randomness to rotation
+
+ // Direction for this shard (center angle of the shard sector)
+ float shard_center_angle = (shard_id + 0.5) * (TWO_PI / num_shards);
+ vec2 shard_radial_dir = vec2(cos(shard_center_angle), sin(shard_center_angle));
+
+ vec2 translation_offset = shard_radial_dir * max_translation_dist * current_displacement_factor;
+ float current_rotation = max_rotation_angle_rad * current_displacement_factor;
+
+ // --- Inverse Transformation for Sampling ---
+ // We are at `texcoord` on screen. Find where this point came from on the original texture.
+ // 1. Undo translation
+ vec2 p1_translated_back = texcoord - translation_offset;
+
+ // 2. Undo rotation around impact_point
+ vec2 p1_rel_to_impact = p1_translated_back - impact_point;
+ float cos_rot = cos(current_rotation); // Rotate by +angle to undo shatter rotation by -angle
+ float sin_rot = sin(current_rotation); // (or vice-versa, depends on convention)
+ // Let's assume shatter rotates by -current_rotation
+ // So to undo, rotate by +current_rotation
+ mat2 rot_matrix = mat2(cos_rot, -sin_rot, sin_rot, cos_rot);
+ vec2 p2_rotated_back = rot_matrix * p1_rel_to_impact;
+ vec2 sample_coord = p2_rotated_back + impact_point;
+
+ // --- Boundary Check & Texture Fetch ---
+ if (sample_coord.x >= 0.0 && sample_coord.x < float(window_size.x) &&
+ sample_coord.y >= 0.0 && sample_coord.y < float(window_size.y)) {
+
+ // --- Chromatic Aberration ---
+ float ca_strength = 0.008 * current_displacement_factor; // Stronger when more shattered
+ vec2 ca_offset_dir = shard_radial_dir; // Radial aberration
+ // vec2 ca_offset_dir = vec2(-shard_radial_dir.y, shard_radial_dir.x); // Tangential
+
+ vec2 r_sample = sample_coord + ca_offset_dir * ca_strength * float(window_size.x);
+ vec2 b_sample = sample_coord - ca_offset_dir * ca_strength * float(window_size.x);
+
+ out_color.r = texelFetch(tex, ivec2(r_sample), 0).r;
+ out_color.g = texelFetch(tex, ivec2(sample_coord), 0).g; // Green channel from center
+ out_color.b = texelFetch(tex, ivec2(b_sample), 0).b;
+ out_color.a = texelFetch(tex, ivec2(sample_coord), 0).a; // Base alpha from original texture
+
+ } else {
+ out_color.a = 0.0; // Sampled point is outside original texture
+ }
+
+ // Modulate final alpha by shard's animation progress
+ out_color.a *= shard_anim_progress;
+ return out_color;
+}
+
+
+// Default window shader:
+// 1) fetch the specified pixel
+// 2) apply default post-processing
+vec4 window_shader() {
+ vec4 c = texelFetch(tex, ivec2(texcoord), 0);
+ c = default_post_processing(c);
+ float opacity = opacity_threshold(c.w);
+ if (opacity == 0.0)
+ {
+ return c;
+ }
+ vec4 anim_c = anim(opacity);
+ return default_post_processing(anim_c);
+}
diff --git a/picom/lock.glsl b/picom/lock.glsl
new file mode 100644
index 0000000..76d47ad
--- /dev/null
+++ b/picom/lock.glsl
@@ -0,0 +1,458 @@
+#version 330
+#define PI 3.14159265
+#define BORDER 200
+#define WAVE_SPEED 1.0
+#define WAVE_FREQUENCY 1.0
+#define WAVE_AMPLITUDE 10.0
+#define BASE_COLOR vec4(0.216, 0.337, 0.373, 1)
+#define BG_COLOR vec4(0, 0, 0, 1)
+
+
+in vec2 texcoord; // texture coordinate of the fragment
+uniform sampler2D tex; // texture of the window
+
+uniform float time; // Time in miliseconds.
+ivec2 window_size = textureSize(tex, 0); // Size of the window
+ivec2 window_center = ivec2(window_size.x/2, window_size.y/2);
+uniform float icon_factor = 12.0;
+float icon_radius = window_size.y/icon_factor;
+uniform float shadow_cutoff = 1; // How "early" the shadow starts affecting
+ // pixels close to the edges
+ // I'd keep this value very close to 1
+uniform int shadow_intensity = 3; // Intensity level of the shadow effect (from 1 to 5)
+float window_diagonal = length(window_size); // Diagonal of the window
+int wss = min(window_size.x, window_size.y); // Window smallest side, useful when squaring windows
+
+uniform float flash_speed = 300.0; // Speed of the flash line in pixels per second
+uniform float bright_line_intensity = 0.9; // Max brightness added by the sharp line (can be > 1 for HDR look)
+uniform float bright_line_sharpness = 0.5; // Controls how narrow the bright line is (smaller = sharper)
+uniform float falloff_intensity = 0.3; // Max brightness added by the falloff glow
+uniform float falloff_height = 80.0; // How many pixels above the line the falloff extends
+
+// These shaders work by using a pinhole camera and raycasting
+// The window 3d objects will always be (somewhat) centered at (0, 0, 0)
+struct pinhole_camera
+{
+ float focal_offset; // Distance along the Z axis between the camera
+ // center and the focal point. Use negative values
+ // so the image doesn't flip
+ // This kinda works like FOV in games
+
+ // Transformations
+ // Use these to modify the coordinate system of the camera plane
+ vec3 rotations; // Rotations in radians around each axis
+ // The camera plane rotates around
+ // its center point, not the origin
+
+ vec3 translations; // Translations in pixels along each axis
+
+ vec3 deformations; // Deforms the camera. Higher values on each axis
+ // means the window will be squashed in that axis
+
+ // ---------------------------------------------------------------//
+
+ // "Aftervalues"
+ // These will be set later with setup_camera(), leave them as 0
+ vec3 base_x;
+ vec3 base_y;
+ vec3 base_z;
+ vec3 center_point;
+ vec3 focal_point;
+};
+
+
+// Sets up a camera by applying transformations and
+// calculating xyz vector basis
+pinhole_camera setup_camera(pinhole_camera camera, float ppa)
+{
+ // Apply translations
+ camera.center_point += camera.translations;
+
+ // Apply rotations
+ // We initialize our vector basis as normalized vectors
+ // in each axis * our deformations vector
+ camera.base_x = vec3(camera.deformations.x, 0, 0);
+ camera.base_y = vec3(0, camera.deformations.y, 0);
+ camera.base_z = vec3(0, 0, camera.deformations.z);
+
+
+ // Then we rotate them around following our rotations vector:
+ // First save these values to avoid redundancy
+ float cosx = cos(camera.rotations.x);
+ float cosy = cos(camera.rotations.y);
+ float cosz = cos(camera.rotations.z);
+ float sinx = sin(camera.rotations.x);
+ float siny = sin(camera.rotations.y);
+ float sinz = sin(camera.rotations.z);
+
+ // Declare a buffer vector we will use to apply multiple changes at once
+ vec3 tmp = vec3(0);
+
+ // Rotations for base_x:
+ tmp = camera.base_x;
+ // X axis:
+ tmp.y = camera.base_x.y * cosx - camera.base_x.z * sinx;
+ tmp.z = camera.base_x.y * sinx + camera.base_x.z * cosx;
+ camera.base_x = tmp;
+ // Y axis:
+ tmp.x = camera.base_x.x * cosy + camera.base_x.z * siny;
+ tmp.z = -camera.base_x.x * siny + camera.base_x.z * cosy;
+ camera.base_x = tmp;
+ // Z axis:
+ tmp.x = camera.base_x.x * cosz - camera.base_x.y * sinz;
+ tmp.y = camera.base_x.x * sinz + camera.base_x.y * cosz;
+ camera.base_x = tmp;
+
+ // Rotations for base_y:
+ tmp = camera.base_y;
+ // X axis:
+ tmp.y = camera.base_y.y * cosx - camera.base_y.z * sinx;
+ tmp.z = camera.base_y.y * sinx + camera.base_y.z * cosx;
+ camera.base_y = tmp;
+ // Y axis:
+ tmp.x = camera.base_y.x * cosy + camera.base_y.z * siny;
+ tmp.z = -camera.base_y.x * siny + camera.base_y.z * cosy;
+ camera.base_y = tmp;
+ // Z axis:
+ tmp.x = camera.base_y.x * cosz - camera.base_y.y * sinz;
+ tmp.y = camera.base_y.x * sinz + camera.base_y.y * cosz;
+ camera.base_y = tmp;
+
+ // Rotations for base_z:
+ tmp = camera.base_z;
+ // X axis:
+ tmp.y = camera.base_z.y * cosx - camera.base_z.z * sinx;
+ tmp.z = camera.base_z.y * sinx + camera.base_z.z * cosx;
+ camera.base_z = tmp;
+ // Y axis:
+ tmp.x = camera.base_z.x * cosy + camera.base_z.z * siny;
+ tmp.z = -camera.base_z.x * siny + camera.base_z.z * cosy;
+ camera.base_z = tmp;
+ // Z axis:
+ tmp.x = camera.base_z.x * cosz - camera.base_z.y * sinz;
+ tmp.y = camera.base_z.x * sinz + camera.base_z.y * cosz;
+ camera.base_z = tmp;
+
+ // Now that we have our transformed 3d orthonormal base
+ // we can calculate our focal point
+ camera.focal_point = camera.center_point + camera.base_z * camera.focal_offset;
+
+ // Return our set up camera
+ return camera;
+}
+// Helper function for the RGB shift (chromatic aberration)
+vec2 curve(vec2 uv)
+{
+ uv = (uv - 0.5) * 2.0;
+ uv *= 1.1;
+ uv.x *= 1.0 + pow((abs(uv.y) / 5.0), 2.0);
+ uv.y *= 1.0 + pow((abs(uv.x) / 4.0), 2.0);
+ uv = (uv / 2.0) + 0.5;
+ return uv;
+}
+
+
+vec4 apply_flash_effect(vec4 color, vec2 coords) {
+ // 1. Calculate the current vertical position of the flash line
+ // Convert speed from pixels/sec to pixels/ms for use with 'time'
+ float flash_y = mod(time * (flash_speed / 1000.0), float(window_size.y));
+
+ // 2. Calculate the brightness contribution from the sharp bright line
+ float distance_from_line = abs(coords.y - flash_y);
+ // This creates a very sharp peak at distance 0, falling off quickly.
+ // The max value is bright_line_intensity.
+ // The '+ 1.0' prevents division by zero and normalizes the peak.
+ float bright_line_factor = bright_line_intensity / (pow(distance_from_line / bright_line_sharpness, 2.0) + 1.0);
+
+ // 3. Calculate the brightness contribution from the falloff (above the line)
+ float falloff_factor = 0.0;
+ float distance_above_line = flash_y - coords.y; // Positive if current pixel is above the line
+
+ if (distance_above_line > 0.0) {
+ // Use smoothstep for a gradual fade from falloff_intensity at the line (distance_above_line = 0)
+ // down to 0 brightness at falloff_height pixels above the line.
+ falloff_factor = falloff_intensity * (1.0 - smoothstep(0.0, falloff_height, distance_above_line));
+ }
+
+ // 4. Combine the effects and apply to the color (additive brightness)
+ float total_flash_brightness = bright_line_factor + falloff_factor;
+ color.rgb += vec3(total_flash_brightness);
+
+ // Optional: Clamp the result if you want to prevent colors going significantly above 1.0
+ // color.rgb = clamp(color.rgb, 0.0, 1.0); // Hard clamp
+ // color.rgb = min(color.rgb, vec3(1.5)); // Allow some over-brightening
+
+ return color;
+}
+
+// CRT effect shader
+vec4 crt_shader(vec2 coords)
+{
+ // Parameters - feel free to adjust these
+ float scanline_intensity = 0.125; // How dark the scanlines are
+ float rgb_shift = 2.0; // How much RGB shifting occurs
+ float vignette_intensity = 0.2; // How dark the corners get
+ float screen_curve = 0.5; // How much screen curvature
+
+ // Convert coords to UV space (0 to 1)
+ vec2 uv = coords / vec2(window_size);
+
+ // Apply screen curvature
+ vec2 curved_uv = mix(uv, curve(uv), screen_curve);
+
+ // If UV is outside bounds, return black
+ if (curved_uv.x < 0.0 || curved_uv.x > 1.0 ||
+ curved_uv.y < 0.0 || curved_uv.y > 1.0)
+ return vec4(0.0, 0.0, 0.0, 1.0);
+
+ // Convert curved UV back to pixel coordinates
+ vec2 screen_pos = curved_uv * vec2(window_size);
+
+ // Chromatic aberration
+ vec4 color;
+ color.r = texelFetch(tex, ivec2(screen_pos + vec2(rgb_shift, 0.0)), 0).r;
+ color.g = texelFetch(tex, ivec2(screen_pos), 0).g;
+ color.b = texelFetch(tex, ivec2(screen_pos - vec2(rgb_shift, 0.0)), 0).b;
+ color.a = 1.0;
+
+ // Scanlines
+ float scanline = sin(screen_pos.y * 0.7) * 0.5 + 0.5;
+ color.rgb *= 1.0 - (scanline * scanline_intensity);
+
+ // Vertical sync lines (more subtle)
+ float vertical_sync = sin(screen_pos.x * 2.0) * 0.5 + 0.5;
+ color.rgb *= 1.0 - (vertical_sync * scanline_intensity * 0.5);
+
+ // Vignette (darker corners)
+ vec2 center_dist = curved_uv - vec2(0.5);
+ float vignette = 1.0 - (dot(center_dist, center_dist) * vignette_intensity);
+ color.rgb *= vignette;
+
+ // Brightness and contrast adjustments
+ color.rgb *= 1.2; // Brightness boost
+ color.rgb = pow(color.rgb, vec3(1.2)); // Contrast boost
+
+ // Add subtle noise to simulate CRT noise
+ float noise = fract(sin(dot(curved_uv, vec2(12.9898, 78.233))) * 43758.5453);
+ color.rgb += (noise * 0.02 - 0.01); // Very subtle noise
+
+ return color;
+}
+
+// Gets a pixel from the end of a ray projected to an axis
+vec4 get_pixel_from_projection(float t, pinhole_camera camera, vec3 focal_vector, float ppa)
+{
+ // If the point we end up in is behind our camera, don't "render" it
+ if (t < 1)
+ {
+ return BG_COLOR;
+ }
+
+ // Then we multiply our focal vector by t and add our focal point to it
+ // to end up in a point inside the window plane
+ vec3 intersection = focal_vector * t + camera.focal_point;
+
+
+ // Save necessary coordinates
+ vec2 cam_coords = intersection.xy;
+ float cam_coords_length = length(cam_coords);
+
+ // If pixel is outside of our icon region
+ // return an empty pixel
+ float local_icon_radius = icon_radius - 50 + 60 * ppa;
+ if (cam_coords_length > local_icon_radius)
+ {
+ return vec4(0);
+ }
+
+ // Fetch the pixel
+ cam_coords += window_center;
+ vec4 pixel = texelFetch(tex, ivec2(cam_coords), 0);
+ pixel = crt_shader(cam_coords);
+ pixel = apply_flash_effect(pixel, cam_coords);
+ if (pixel.xyz == vec3(0))
+ {
+ return BASE_COLOR;
+ }
+
+ pixel.w = 0.9;
+ return pixel;
+}
+
+// Combines colors using alpha
+// Got this from https://stackoverflow.com/questions/64701745/how-to-blend-colours-with-transparency
+// Not sure how it works honestly lol
+vec4 alpha_composite(vec4 color1, vec4 color2)
+{
+ float ar = color1.w + color2.w - (color1.w * color2.w);
+ float asr = color2.w / ar;
+ float a1 = 1 - asr;
+ float a2 = asr * (1 - color1.w);
+ float ab = asr * color1.w;
+ vec4 outcolor;
+ outcolor.xyz = color1.xyz * a1 + color2.xyz * a2 + color2.xyz * ab;
+ outcolor.w = ar;
+ return outcolor;
+}
+
+// Gets a pixel through the camera using coords as coordinates in
+// the camera plane
+vec4 get_pixel_through_camera(vec2 coords, pinhole_camera camera, float ppa)
+{
+ // Offset coords
+ coords -= window_center;
+
+ // Find the pixel 3d position using the camera vector basis
+ vec3 pixel_3dposition = camera.center_point
+ + coords.x * camera.base_x
+ + coords.y * camera.base_y;
+
+ // Get the vector going from the focal point to the pixel in 3d sapace
+ vec3 focal_vector = pixel_3dposition - camera.focal_point;
+
+ // Following the sphere EQ (with Y axis as center)
+ // x^2 + y^2 + z^2 = r^2
+ float r = icon_radius * 2 / PI + 33;
+
+ // Then there's a line going from our focal point to the sphere
+ // which we can describe as:
+ // x(t) = focal_point.x + focal_vector.x * t
+ // y(t) = focal_point.y + focal_vector.y * t
+ // z(t) = focal_point.z + focal_vector.z * t
+ // We substitute x, y and z with x(t) and z(t) in the sphere EQ
+ // Solving for t we get a cuadratic EQ which we solve with the
+ // cuadratic formula:
+
+ // We calculate focal vector and focal point values squared
+ // to avoid redundancy
+ vec3 fvsqr;
+ vec3 fpsqr;
+
+ fvsqr.x = pow(focal_vector.x,2);
+ fvsqr.y = pow(focal_vector.y,2);
+ fvsqr.z = pow(focal_vector.z,2);
+
+ fpsqr.x = pow(camera.focal_point.x,2);
+ fpsqr.y = pow(camera.focal_point.y,2);
+ fpsqr.z = pow(camera.focal_point.z,2);
+
+ // Coeficients of our EQ
+ float a = fvsqr.x + fvsqr.y + fvsqr.z;
+ float b = 2*(camera.focal_point.x*focal_vector.x
+ +camera.focal_point.y*focal_vector.y
+ +camera.focal_point.z*focal_vector.z);
+ float c = fpsqr.x + fpsqr.y + fpsqr.z - pow(r,2);
+
+ // If there are no real roots, then there's no intersection and we
+ // return an empty pixel
+ float formulasqrt = pow(b,2)-4*a*c;
+ if (formulasqrt < 0)
+ {
+ return vec4(0);
+ }
+
+ vec2 t[2]; // A float should be used for this instead, but the shader
+ // isn't rendered correctly when I use a float
+ // Cursed, but it works
+
+ // Solve with general formula
+ t[0].x = (-b + sqrt(formulasqrt))/(2*a);
+ t[1].x = (-b - sqrt(formulasqrt))/(2*a);
+ t[0].y = 0;
+ t[1].y = 0;
+
+
+ // Bubble sort to know which intersections happen first
+ for (int i = 0; i < t.length(); i++)
+ {
+ for (int j = 0; j < t.length(); j++)
+ {
+ if (t [j].x > t[j+1].x)
+ {
+ vec2 tmp = t[j];
+ t[j] = t[j+1];
+ t[j+1] = tmp;
+ }
+ }
+ }
+
+ // Then we go through each one of the intersections in order
+ // and mix pixels together using alpha
+ vec4 blended_pixels = vec4(0);
+ for (int i = 0; i < t.length(); i++)
+ {
+ // We get the pixel through projection
+ vec4 projection_pixel = get_pixel_from_projection(t[i].x,
+ camera,
+ focal_vector, ppa);
+ if (projection_pixel.w > 0.0)
+ {
+ // Blend the pixel using alpha
+ blended_pixels = alpha_composite(projection_pixel, blended_pixels);
+ }
+ }
+ return blended_pixels;
+}
+
+// Darkens a pixels near the edges
+vec4 calc_opacity(vec4 color, vec2 coords)
+{
+ // If shadow intensity is 0, change nothing
+ if (shadow_intensity == 0)
+ {
+ return color;
+ }
+
+ // Get how far the coords are from the center
+ vec2 distances_from_center = abs(window_center - coords);
+
+ // Darken pixels close to the edges of the screen in a polynomial fashion
+ float opacity = 1;
+ opacity *= -pow((distances_from_center.y/window_center.y)*shadow_cutoff,
+ (5/shadow_intensity)*2)+1;
+ opacity *= -pow((distances_from_center.x/window_center.x)*shadow_cutoff,
+ (5/shadow_intensity)*2)+1;
+ color.w *= opacity;
+ color.w = max(1 - color.w, 0.5);
+
+ return color;
+}
+
+// Default window post-processing:
+// 1) invert color
+// 2) opacity / transparency
+// 3) max-brightness clamping
+// 4) rounded corners
+vec4 default_post_processing(vec4 c);
+
+vec4 window_shader() {
+ vec4 c = texelFetch(tex, ivec2(texcoord), 0);
+ float post_proc_alpha = default_post_processing(c).w; // <-- Use that to animate things when window is destroyed
+ if (distance(texcoord, window_center) <=icon_radius)
+ {
+ float cam_offset = window_size.y*3;
+
+ float time_offset = pow((1-post_proc_alpha),2) ;
+ float time_cyclic = mod(4*(time/10000 - time_offset),2);
+ pinhole_camera rotate_around_origin =
+ pinhole_camera(-cam_offset,
+ vec3(0,-time_cyclic*PI-PI/2,0),
+ vec3(cos(time_cyclic*PI)*window_size.y*0.4,
+ 0,
+ sin(time_cyclic*PI)*window_size.y*0.4),
+ vec3(1,1,1),
+ vec3(0),
+ vec3(0),
+ vec3(0),
+ vec3(0),
+ vec3(0));
+ pinhole_camera transformed_cam = setup_camera(rotate_around_origin, post_proc_alpha);
+ c = get_pixel_through_camera(texcoord, transformed_cam, post_proc_alpha);
+ }
+ else if (c.x +c.y + c.z < 0.3)
+ {
+ c.w = 1;
+ c = calc_opacity(c,texcoord);
+ }
+ return default_post_processing(c);
+}
diff --git a/picom/matrix_dissolve.glsl b/picom/matrix_dissolve.glsl
new file mode 100644
index 0000000..d42eb71
--- /dev/null
+++ b/picom/matrix_dissolve.glsl
@@ -0,0 +1,78 @@
+#version 330
+
+in vec2 texcoord; // texture coordinate of the fragment
+
+uniform sampler2D tex; // texture of the window
+
+
+ivec2 window_size = textureSize(tex, 0); // Size of the window
+ivec2 window_center = ivec2(window_size.x/2, window_size.y/2);
+
+/*
+These shaders use a sorta hacky way to use the changing
+window opacity you might set on picom.conf animation rules
+to perform animations.
+
+Basically, when a window get's mapped, we make it's alpha
+go from 0 to 1, so, using the default_post_processing to get that alpha
+we can get a variable going from 0 (start of mapping animation)
+to 1 (end of mapping animation)
+
+You can also set up your alpha value to go from 1 to 0 in picom when
+a window is closed, effectively reversing the animations described here
+*/
+
+// Default window post-processing:
+// 1) invert color
+// 2) opacity / transparency
+// 3) max-brightness clamping
+// 4) rounded corners
+vec4 default_post_processing(vec4 c);
+// Pseudo-random function
+float random(vec2 st) {
+ return fract(sin(dot(st.xy, vec2(12.9898,78.233))) * 43758.5453123);
+}
+
+// Creates vertical scanlines
+float scanline(vec2 uv, float time) {
+ return sin(uv.y * 200.0 + time * 10.0) * 0.5 + 0.5;
+}
+
+vec4 anim(float time) {
+ vec2 uv = texcoord / vec2(window_size);
+
+ // Adjust square size (smaller number = more squares)
+ float square_size = 10.0;
+
+ // Calculate grid position
+ vec2 square_pos = floor(texcoord / square_size);
+
+ // Generate random value for this square
+ float index = random(square_pos);
+
+ // Get original color
+ vec4 c = texelFetch(tex, ivec2(texcoord), 0);
+
+ // Create threshold for dissolve
+ float threshold = (1.0 - time) * 1.2; // The 1.2 creates a slight overlap
+
+ // If the random index is greater than our threshold, make pixel transparent
+ if (index > threshold) {
+ c.a = 0.0;
+ }
+
+ return c;
+}
+
+// Default window shader:
+// 1) fetch the specified pixel
+// 2) apply default post-processing
+vec4 window_shader() {
+ vec4 c = texelFetch(tex, ivec2(texcoord), 0);
+ c = default_post_processing(c);
+ if (c.w != 1.0)
+ {
+ c = anim(1.0-c.w);
+ }
+ return default_post_processing(c);
+}
diff --git a/picom/picom.conf b/picom/picom.conf
index 4cf5b90..a5b45ec 100644
--- a/picom/picom.conf
+++ b/picom/picom.conf
@@ -1,136 +1,67 @@
#################################
-# Animations #
-#################################
-
-
-# fly-in: Windows fly in from random directions to the screen
-# maximize: Windows pop from center of the screen to their respective positions
-# minimize: Windows minimize from their position to the center of the screen
-# slide-in-center: Windows move from upper-center of the screen to their respective positions
-# slide-out-center: Windows move to the upper-center of the screen
-# slide-left: Windows are created from the right-most window position and slide leftwards
-# slide right: Windows are created from the left-most window position and slide rightwards
-# slide-down: Windows are moved from the top of the screen and slide downward
-# slide-up: Windows are moved from their position to top of the screen
-# squeeze: Windows are either closed or created to/from their center y-position (the animation is similar to a blinking eye)
-# squeeze-bottom: Similar to squeeze, but the animation starts from bottom-most y-position
-# zoom: Windows are either created or destroyed from/to their center (not the screen center)
-
-animations = true;
-animation-stiffness = 90;
-animation-window-mass = 0.5;
-animation-dampening = 10;
-animation-for-transient-window = "fly-in";
-animation-for-unmap-window = "fly-in";
-animation-for-open-window = "fly-in";
-
-# animating-rule-open = ["zoom:class_g = 'code'"];
-# animating-rule-unmap = ["zoom:class_g = 'code'"];
-
-#################################
# Shadows #
#################################
-
# Enabled client-side shadows on windows. Note desktop windows
# (windows with '_NET_WM_WINDOW_TYPE_DESKTOP') never get shadow,
# unless explicitly requested using the wintypes option.
#
-# shadow = false
+# Can be set per-window using rules.
+#
+# Default: false
shadow = false;
-# The blur radius for shadows, in pixels. (defaults to 12)
-# shadow-radius = 12
-shadow-radius = 7;
-
-# The opacity of shadows. (0.0 - 1.0, defaults to 0.75)
-# shadow-opacity = .75
-
-# The left offset for shadows, in pixels. (defaults to -15)
-# shadow-offset-x = -15
-shadow-offset-x = -7;
-
-# The top offset for shadows, in pixels. (defaults to -15)
-# shadow-offset-y = -15
-shadow-offset-y = -7;
-
-# Red color value of shadow (0.0 - 1.0, defaults to 0).
-# shadow-red = 0
-
-# Green color value of shadow (0.0 - 1.0, defaults to 0).
-# shadow-green = 0
-
-# Blue color value of shadow (0.0 - 1.0, defaults to 0).
-# shadow-blue = 0
-
-# Hex string color value of shadow (#000000 - #FFFFFF, defaults to #000000). This option will override options set shadow-(red/green/blue)
-# shadow-color = "#000000"
+# The blur radius for shadows, in pixels.
+#
+# Default: 12
+shadow-radius = 30;
-# Specify a list of conditions of windows that should have no shadow.
+# The opacity of shadows.
#
-# examples:
-# shadow-exclude = "n:e:Notification";
+# Range: 0.0 - 1.0
+# Default: 0.75
+shadow-opacity = .75
+
+# The left offset for shadows, in pixels.
#
-# shadow-exclude = []
-shadow-exclude = [
- "name = 'Notification'",
- "class_g = 'Conky'",
- "class_g ?= 'Notify-osd'",
- "class_g = 'Cairo-clock'",
- "_GTK_FRAME_EXTENTS@:c"
-];
+# Default: -15
+shadow-offset-x = -30;
-# Specify a list of conditions of windows that should have no shadow painted over, such as a dock window.
-# clip-shadow-above = []
+# The top offset for shadows, in pixels.
+#
+# Default: -15
+shadow-offset-y = -30;
-# Specify a X geometry that describes the region in which shadow should not
-# be painted in, such as a dock window region. Use
-# shadow-exclude-reg = "x10+0+0"
-# for example, if the 10 pixels on the bottom of the screen should not have shadows painted on.
+# Hex string color value of shadow. Formatted like "#RRGGBB", e.g. "#C0FFEE".
#
-# shadow-exclude-reg = ""
+# Default: #000000
+# shadow-color = "#000000"
# Crop shadow of a window fully on a particular monitor to that monitor. This is
# currently implemented using the X RandR extension.
+#
+# Default: false
# crop-shadow-to-monitor = false
-# shadow-color-rule = ["#FFFFFF:class_g = 'fly-term'"];
-# shadow-opacity-rule = ["20:class_g = 'fly-term'" ];
-# shadow-offset-x-rule = ["-100:class_g = 'fly-term'"];
-# shadow-offset-y-rule = ["-100:class_g = 'fly-term'"];
-# shadow-radius-rule = ["100:class_g = 'fly-term'"];
-
-# If shadow-active is 'true' the tweaks below will be applied to the currently focused window
-# shadow-active = true;
-# shadow-color-active = "#FFFFF";
-# shadow-opacity-active = 0.5;
-# shadow-radius-active = 50;
-# shadow-offset-x-active = -50;
-# shadow-offset-y-active = -50;
#################################
# Fading #
#################################
-
# Fade windows in/out when opening/closing and when opacity changes,
-# unless no-fading-openclose is used.
-# fading = false
+# unless no-fading-openclose is used. Can be set per-window using rules.
+#
+# Default: false
fading = true;
# Opacity change between steps while fading in. (0.01 - 1.0, defaults to 0.028)
-# fade-in-step = 0.028
fade-in-step = 0.03;
# Opacity change between steps while fading out. (0.01 - 1.0, defaults to 0.03)
-# fade-out-step = 0.03
fade-out-step = 0.03;
# The time between steps in fade step, in milliseconds. (> 0, defaults to 10)
-# fade-delta = 10
-
-# Specify a list of conditions of windows that should not be faded.
-# fade-exclude = []
+fade-delta = 8
# Do not fade on window open/close.
# no-fading-openclose = false
@@ -143,43 +74,16 @@ fade-out-step = 0.03;
# Transparency / Opacity #
#################################
-
-# Opacity of inactive windows. (0.1 - 1.0, defaults to 1.0)
-# inactive-opacity = 1
-# inactive-opacity = 0.8;
-
-# Opacity of window titlebars and borders. (0.1 - 1.0, disabled by default)
-# frame-opacity = 1.0
-# frame-opacity = 0.7;
-
-# Let inactive opacity set by -i override the '_NET_WM_WINDOW_OPACITY' values of windows.
-# inactive-opacity-override = true
-inactive-opacity-override = false;
-
-# Default opacity for active windows. (0.0 - 1.0, defaults to 1.0)
-# active-opacity = 1.0
-
-# Dim inactive windows. (0.0 - 1.0, defaults to 0.0)
-# inactive-dim = 0.0
-
-# Specify a list of conditions of windows that should never be considered focused.
-# focus-exclude = []
-focus-exclude = [ "class_g = 'Cairo-clock'" ];
+# Opacity of window titlebars and borders.
+#
+# Range: 0.1 - 1.0
+# Default: 1.0 (disabled)
+frame-opacity = 1.0;
# Use fixed inactive dim value, instead of adjusting according to window opacity.
-# inactive-dim-fixed = 1.0
-
-# Specify a list of opacity rules, in the format `PERCENT:PATTERN`,
-# like `50:name *= "Firefox"`. picom-trans is recommended over this.
-# Note we don't make any guarantee about possible conflicts with other
-# programs that set '_NET_WM_WINDOW_OPACITY' on frame or client windows.
-# example:
-opacity-rule = [
- "95:class_g = 'Polybar'",
-];
#
-# opacity-rule = []
-
+# Default: false
+# inactive-dim-fixed = true
#################################
# Corners #
@@ -188,136 +92,113 @@ opacity-rule = [
# Sets the radius of rounded window corners. When > 0, the compositor will
# round the corners of windows. Does not interact well with
# `transparent-clipping`.
-corner-radius = 5
-
-# Exclude conditions for rounded corners.
-rounded-corners-exclude = [
- "window_type = 'dock'",
- "window_type = 'desktop'",
- "class_g = 'Polybar'",
-];
-
-# corners-rounding-rule = [ "10:class_g = 'fly-term'" ];
+#
+# Default: 0 (disabled)
+corner-radius = 8
#################################
-# Background-Blurring #
+# Blur #
#################################
-
-# Parameters for background blurring, see the *BLUR* section for more information.
-# blur-method = "kawase"
+# Parameters for background blurring, see BLUR section in the man page for more information.
+# blur-method =
# blur-size = 12
-# # blur-deviation = false
-# blur-strength = 10
+#
+# blur-deviation = false
+#
+# blur-strength = 5
# Blur background of semi-transparent / ARGB windows.
-# Bad in performance, with driver-dependent behavior.
-# The name of the switch may change without prior notifications.
+# Can be set per-window using rules.
#
+# Default: false
# blur-background = false
# Blur background of windows when the window frame is not opaque.
# Implies:
# blur-background
-# Bad in performance, with driver-dependent behavior. The name may change.
#
-# blur-background-frame = true
-
+# Default: false
+# blur-background-frame = false
# Use fixed blur strength rather than adjusting according to window opacity.
+#
+# Default: false
# blur-background-fixed = false
# Specify the blur convolution kernel, with the following format:
# example:
# blur-kern = "5,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1";
+# Can also be a pre-defined kernel, see the man page.
#
-# blur-kern = ""
-# blur-kern = "3x3box";
-
-
-# Exclude conditions for background blur.
-# blur-background-exclude = []
-blur-background-exclude = [
- "window_type = 'dock'",
- "window_type = 'desktop'",
- "_GTK_FRAME_EXTENTS@:c"
-];
-
-# blur-method-rule = [ "kawase:class_g = 'fly-term'" ];
-# blur-size-rule = [ "10:class_g = 'fly-term'" ];
-# blur-strength-rule = [ "1:class_g = 'fly-term'" ];
-# blur-deviation-rule = [ "10:class_g = 'fly-term'" ];
+# Default: ""
+blur-kern = "3x3box";
#################################
# General Settings #
#################################
# Enable remote control via D-Bus. See the man page for more details.
+#
+# Default: false
# dbus = true
# Daemonize process. Fork to background after initialization. Causes issues with certain (badly-written) drivers.
# daemon = false
-# Specify the backend to use: `xrender`, `glx`, `egl` or `xr_glx_hybrid`.
-# `xrender` is the default one.
+# Specify the backend to use: `xrender`, `glx`, or `egl`.
#
-# backend = "glx"
-backend = "xrender";
+# Default: "xrender"
+backend = "glx"
# Use higher precision during rendering, and apply dither when presenting the
-# rendered screen. Reduces banding artifacts, but might cause performance
+# rendered screen. Reduces banding artifacts, but may cause performance
# degradation. Only works with OpenGL.
dithered-present = false;
# Enable/disable VSync.
-# vsync = false
-vsync = true;
-
-# Try to detect WM windows (a non-override-redirect window with no
-# child that has 'WM_STATE') and mark them as active.
#
-# mark-wmwin-focused = false
-mark-wmwin-focused = true;
-
-# Mark override-redirect windows that doesn't have a child window with 'WM_STATE' focused.
-# mark-ovredir-focused = false
-mark-ovredir-focused = true;
+# Default: false
+vsync = true;
# Try to detect windows with rounded corners and don't consider them
# shaped windows. The accuracy is not very high, unfortunately.
#
-# detect-rounded-corners = false
+# Has nothing to do with `corner-radius`.
+#
+# Default: false
detect-rounded-corners = true;
# Detect '_NET_WM_WINDOW_OPACITY' on client windows, useful for window managers
# not passing '_NET_WM_WINDOW_OPACITY' of client windows to frame windows.
#
-# detect-client-opacity = false
+# Default: false
detect-client-opacity = true;
# Use EWMH '_NET_ACTIVE_WINDOW' to determine currently focused window,
-# rather than listening to 'FocusIn'/'FocusOut' event. Might have more accuracy,
+# rather than listening to 'FocusIn'/'FocusOut' event. May be more accurate,
# provided that the WM supports it.
#
-# use-ewmh-active-win = false
+# Default: false
+use-ewmh-active-win = true
# Unredirect all windows if a full-screen opaque window is detected,
# to maximize performance for full-screen windows. Known to cause flickering
# when redirecting/unredirecting windows.
#
-# unredir-if-possible = false
+# Default: false
+unredir-if-possible = true
-# Delay before unredirecting the window, in milliseconds. Defaults to 0.
+# Delay before unredirecting the window, in milliseconds.
+#
+# Default: 0.
# unredir-if-possible-delay = 0
-# Conditions of windows that shouldn't be considered full-screen for unredirecting screen.
-# unredir-if-possible-exclude = []
-
# Use 'WM_TRANSIENT_FOR' to group windows, and consider windows
# in the same group focused at the same time.
#
-# detect-transient = false
+# Default: false
detect-transient = true;
# Use 'WM_CLIENT_LEADER' to group windows, and consider windows in the same
@@ -325,102 +206,67 @@ detect-transient = true;
# will be considered focused or unfocused at the same time.
# 'WM_TRANSIENT_FOR' has higher priority if detect-transient is enabled, too.
#
+# Default: false
# detect-client-leader = false
-# Resize damaged region by a specific number of pixels.
-# A positive value enlarges it while a negative one shrinks it.
-# If the value is positive, those additional pixels will not be actually painted
-# to screen, only used in blur calculation, and such. (Due to technical limitations,
-# with use-damage, those pixels will still be incorrectly painted to screen.)
-# Primarily used to fix the line corruption issues of blur,
-# in which case you should use the blur radius value here
-# (e.g. with a 3x3 kernel, you should use `--resize-damage 1`,
-# with a 5x5 one you use `--resize-damage 2`, and so on).
-# May or may not work with *--glx-no-stencil*. Shrinking doesn't function correctly.
-#
-# resize-damage = 1
-
-# Specify a list of conditions of windows that should be painted with inverted color.
-# Resource-hogging, and is not well tested.
-#
-# invert-color-include = []
-
-# GLX backend: Avoid using stencil buffer, useful if you don't have a stencil buffer.
-# Might cause incorrect opacity when rendering transparent content (but never
-# practically happened) and may not work with blur-background.
-# My tests show a 15% performance boost. Recommended.
-#
-# glx-no-stencil = false
-
-# GLX backend: Avoid rebinding pixmap on window damage.
-# Probably could improve performance on rapid window content changes,
-# but is known to break things on some drivers (LLVMpipe, xf86-video-intel, etc.).
-# Recommended if it works.
+# Use of damage information for rendering. This cause the only the part of the
+# screen that has actually changed to be redrawn, instead of the whole screen
+# every time. Should improve performance.
#
-# glx-no-rebind-pixmap = false
+# Default: false
+use-damage = true;
-# Disable the use of damage information.
-# This cause the whole screen to be redrawn every time, instead of the part of the screen
-# has actually changed. Potentially degrades the performance, but might fix some artifacts.
-# The opposing option is use-damage
+# Use X Sync fence to wait for the completion of rendering of other windows,
+# before using their content to render the current screen.
#
-# no-use-damage = false
-use-damage = false;
-
-# Use X Sync fence to sync clients' draw calls, to make sure all draw
-# calls are finished before picom starts drawing. Needed on nvidia-drivers
-# with GLX backend for some users.
+# Required for explicit sync drivers, such as nvidia.
#
+# Default: false
# xrender-sync-fence = false
# GLX backend: Use specified GLSL fragment shader for rendering window
# contents. Read the man page for a detailed explanation of the interface.
#
-# window-shader-fg = "default"
-
-# Use rules to set per-window shaders. Syntax is SHADER_PATH:PATTERN, similar
-# to opacity-rule. SHADER_PATH can be "default". This overrides window-shader-fg.
+# Can be set per-window using rules.
#
-# window-shader-fg-rule = [
-# "my_shader.frag:window_type != 'dock'"
-# ]
+# window-shader-fg = "default"
# Force all windows to be painted with blending. Useful if you
-# have a glx-fshader-win that could turn opaque pixels transparent.
+# have a `window-shader-fg` that could turn opaque pixels transparent.
#
+# Default: false
# force-win-blend = false
# Do not use EWMH to detect fullscreen windows.
# Reverts to checking if a window is fullscreen based only on its size and coordinates.
#
-# no-ewmh-fullscreen = false
+# Default: false
+no-ewmh-fullscreen = false
# Dimming bright windows so their brightness doesn't exceed this set value.
# Brightness of a window is estimated by averaging all pixels in the window,
# so this could comes with a performance hit.
-# Setting this to 1.0 disables this behaviour. Requires --use-damage to be disabled. (default: 1.0)
+# Setting this to 1.0 disables this behaviour. Requires --use-damage to be disabled.
#
+# Default: 1.0 (disabled)
# max-brightness = 1.0
# Make transparent windows clip other windows like non-transparent windows do,
-# instead of blending on top of them.
+# instead of blending on top of them. e.g. placing a transparent window on top
+# of another window will cut a "hole" in that window, and show the desktop background
+# underneath.
#
+# Default: false
# transparent-clipping = false
-# Specify a list of conditions of windows that should never have transparent
-# clipping applied. Useful for screenshot tools, where you need to be able to
-# see through transparent parts of the window.
-#
-# transparent-clipping-exclude = []
-
# Set the log level. Possible values are:
# "trace", "debug", "info", "warn", "error"
-# in increasing level of importance. Case doesn't matter.
+# in increasing level of importance. Case insensitive.
# If using the "TRACE" log level, it's better to log into a file
# using *--log-file*, since it can generate a huge stream of logs.
#
-# log-level = "debug"
-log-level = "warn";
+# Default: "warn"
+# log-level = "warn";
# Set the log file.
# If *--log-file* is never specified, logs will be written to stderr.
@@ -430,71 +276,351 @@ log-level = "warn";
#
# log-file = "/path/to/your/log/file"
-# Show all X errors (for debugging)
-# show-all-xerrors = false
-
# Write process ID to a file.
# write-pid-path = "/path/to/your/log/file"
-
-# Window type settings
-#
-# 'WINDOW_TYPE' is one of the 15 window types defined in EWMH standard:
-# "unknown", "desktop", "dock", "toolbar", "menu", "utility",
-# "splash", "dialog", "normal", "dropdown_menu", "popup_menu",
-# "tooltip", "notification", "combo", and "dnd".
-#
-# Following per window-type options are available: ::
-#
-# fade, shadow:::
-# Controls window-type-specific shadow and fade settings.
-#
-# opacity:::
-# Controls default opacity of the window type.
-#
-# focus:::
-# Controls whether the window of this type is to be always considered focused.
-# (By default, all window types except "normal" and "dialog" has this on.)
-#
-# full-shadow:::
-# Controls whether shadow is drawn under the parts of the window that you
-# normally won't be able to see. Useful when the window has parts of it
-# transparent, and you want shadows in those areas.
-#
-# clip-shadow-above:::
-# Controls whether shadows that would have been drawn above the window should
-# be clipped. Useful for dock windows that should have no shadow painted on top.
-#
-# redir-ignore:::
-# Controls whether this type of windows should cause screen to become
-# redirected again after been unredirected. If you have unredir-if-possible
-# set, and doesn't want certain window to cause unnecessary screen redirection,
-# you can set this to `true`.
-#
-
-wintypes :
-{
- tooltip :
- {
- animation = "squeeze";
- };
- popup_menu :
- {
- animation = "slide-up";
- };
- dropdown_menu :
- {
- animation = "slide-down";
- };
- dialog :
- {
- animation = "squeeze";
- };
- menu :
- {
- animation = "slide-down";
- };
- notification :
- {
- animation = "squeeze";
- };
-};
+# Rule-based per-window options.
+#
+# See WINDOW RULES section in the man page for how these work.
+rules: ({
+ match = "focused";
+}, {
+ match = "window_type = 'normal'";
+ shader = "/home/marcellus/.config/picom/pixelize.glsl";
+ animations = ({
+ # Pop in
+ # Options
+ duration = 0.5;
+ opacity-duration = 0.5;
+ initial-scale = 0.8;
+
+ triggers = ["open", "show"];
+ anim-curve = {
+ curve = "cubic-bezier(0, 1.5, 1, 1)";
+ start = 0;
+ end = 1;
+ duration = "duration";
+ }
+ opacity-curve = {
+ curve = "cubic-bezier(0.5, 0.5, 0.5, 0.5)";
+ start = 0;
+ end = 1;
+ duration = "opacity-duration";
+ }
+ scale-x = "anim-curve * (1 - initial-scale) + initial-scale";
+ scale-y = "anim-curve * (1 - initial-scale) + initial-scale";
+ offset-x = "(1 - scale-x) / 2 * window-width"
+ offset-y = "(1 - scale-y) / 2 * window-height"
+
+ opacity = "opacity-curve";
+ shadow-offset-x = "offset-x";
+ shadow-offset-y = "offset-y";
+ shadow-scale-x = "scale-x";
+ shadow-scale-y = "scale-y";
+})
+#}, {
+# match = "class_g = 'Polybar'";
+# shader = "/home/kz87/Code/picom-shaders/default.glsl";
+#}, {
+# match = "class_g = 'GLWall'";
+# shader = "/home/kz87/Code/picom-shaders/Practical/disable_post.glsl";
+}, {
+ match = "class_g = 'i3lock'";
+ shader = "/home/marcellus/.config/picom/lock.glsl";
+}, {
+ match = "class_g = 'i3lock'";
+ animations = ({
+ # Slow fade in
+ opacity-duration = 1;
+ initial-opacity = 0;
+
+ triggers = ["open", "show"];
+ opacity-curve = {
+ curve = "cubic-bezier(0.5, 0.5, 0.5, 0.5)";
+ start = 0;
+ end = 1;
+ duration = "opacity-duration";
+ }
+
+ opacity = "opacity-curve";
+ }, {
+ # Slow fade out
+ opacity-duration = 1;
+ initial-opacity = 0;
+
+ triggers = ["close", "hide"];
+ opacity-curve = {
+ curve = "cubic-bezier(0.5, 0.5, 0.5, 0.5)";
+ start = 1;
+ end = 0;
+ duration = "opacity-duration";
+ }
+
+ opacity = "opacity-curve";
+ })
+}, {
+ match = "class_g = 'librewolf' || "
+ "class_g = 'vlc' || "
+ "class_g = 'Pqiv' || "
+ "class_g = 'i3lock' || "
+ "class_g = 'mpv' || "
+ "class_g = 'sm64ex' || "
+ "class_g = 'Discord' || "
+ "class_g = 'love' || "
+ "class_g = 'MPlayer' || "
+ "name *= 'Eww'";
+ unredir = false;
+}, {
+ match = "window_type = 'unknown' || "
+ "window_type = 'desktop' || "
+ "window_type = 'toolbar' || "
+ "window_type = 'menu' || "
+ "window_type = 'utility' || "
+ "window_type = 'splash' || "
+ "window_type = 'dialog' || "
+ "window_type = 'dropdown_menu' || "
+ "window_type = 'popup_menu' || "
+ "window_type = 'tooltip' || "
+ "window_type = 'toolbar' || "
+ "window_type = 'combo' || "
+ "window_type = 'dnd' || "
+ "class_g = 'Pqiv' || "
+ "class_g = 'GLWall' || "
+ "class_g = 'mpv' || "
+ "class_g = 'Eww' || "
+ "class_g = 'eww' || "
+ "class_g = 'i3lock' || "
+ "fullscreen" ;
+ corner-radius = 0;
+}, {
+ match = "window_type = 'unknown' || "
+ "window_type = 'desktop' || "
+ "window_type = 'toolbar' || "
+ "window_type = 'normal ' || "
+ "window_type = 'notification' || "
+ "window_type = 'menu' || "
+ "window_type = 'utility' || "
+ "window_type = 'splash' || "
+ "window_type = 'dialog' || "
+ "window_type = 'dropdown_menu' || "
+ "window_type = 'popup_menu' || "
+ "window_type = 'tooltip' || "
+ "window_type = 'toolbar' || "
+ "window_type = 'combo' || "
+ "window_type = 'dnd' || "
+ "class_g = 'Pqiv' || "
+ "class_g = 'GLWall' || "
+ "class_g = 'mpv' || "
+ "class_g = 'Eww' || "
+ "class_g = 'eww' || "
+ "class_g = 'ghostty' || "
+ "class_g = 'librewolf'";
+ blur-background = false;
+ full-shadow = false;
+}, {
+ match = "window_type = 'tooltip' ||"
+ "window_type = 'dnd' ||"
+ "window_type = 'notification' ||"
+ "window_type = 'dock'";
+ full-shadow = false;
+}, {
+ match = "class_g = 'scrot'";
+ full-shadow = false;
+}, {
+ match = "class_g = 'ghostty'";
+ full-shadow = true;
+}, {
+ match = "class_g = 'i3lock'";
+ animations = ({
+ triggers = ["open", "show"];
+ anim-duration = 0.2;
+ offset-y = {
+ curve = "cubic-bezier(0, 1, 1, 1)";
+ start = "- window-height";
+ end = 0;
+ duration = "anim-duration";
+ };
+ opacity = {
+ end = 1;
+ start = 1;
+ duration = "anim-duration";
+ };
+ shadow-offset-y = "offset-y";
+ shadow-opacity = "opacity";
+ }, {
+ triggers = ["close", "hide"];
+ anim-duration = 0.4;
+ offset-y = {
+ curve = "cubic-bezier(1, 0, 1, 1)";
+ start = 0;
+ end = "- window-height";
+ duration = "anim-duration";
+ };
+ shadow-offset-y = "offset-y";
+ opacity = {
+ end = 1;
+ start = 1;
+ duration = "anim-duration";
+ };
+ shadow-opacity = "opacity";
+ });
+#}, {
+ match = "window_type = 'notification'";
+ animations = ({
+ triggers = ["close", "hide"];
+ preset = "disappear";
+ scale = 1.4;
+ duration = 0.2;
+ });
+}, {
+# match = "window_type = 'notification'";
+# animations = ({
+# triggers = ["close", "hide"];
+# });
+}, {
+ match = "class_g = 'dmenu'";
+ shader = "/home/marcellus/.config/picom/glass.glsl";
+
+ animations = ({
+ duration = 0.5;
+ triggers = ["open", "show"];
+ opacity-curve = {
+ curve = "cubic-bezier(0.5, 0.5, 0.5, 0.5)";
+ start = 0;
+ end = 1;
+ duration = "duration";
+ }
+ opacity="opacity-curve";
+ }, {
+ duration = 0.5;
+ triggers = ["close", "hide"];
+ opacity-curve = {
+ curve = "cubic-bezier(0.5, 0.5, 0.5, 0.5)";
+ start = 1;
+ end = 0;
+ duration = "duration";
+ }
+ opacity="opacity-curve";
+ });
+}, {
+ match = "window_type = 'popup_menu' ||"
+ "window_type = 'tooltip' ||"
+ "window_type = 'dropdown_menu'";
+ animations = ({
+ triggers = ["open", "show"];
+ preset = "slide-in";
+ direction = "up";
+ duration = 0.1;
+ }, {
+ triggers = ["close", "hide"];
+ preset = "slide-out";
+ direction = "up";
+ duration = 0.1;
+ });
+ opacity = 0.8;
+ shader = "/home/marcellus/.config/picom/default.glsl";
+})
+
+animations = ({
+ # Pop in
+ # Options
+ duration = 0.5;
+ opacity-duration = 0.5;
+ initial-scale = 0.8;
+
+ triggers = ["open", "show"];
+ anim-curve = {
+ curve = "cubic-bezier(0, 1.5, 1, 1)";
+ start = 0;
+ end = 1;
+ duration = "duration";
+ }
+ opacity-curve = {
+ curve = "cubic-bezier(0.5, 0.5, 0.5, 0.5)";
+ start = 0;
+ end = 1;
+ duration = "opacity-duration";
+ }
+ scale-x = "anim-curve * (1 - initial-scale) + initial-scale";
+ scale-y = "anim-curve * (1 - initial-scale) + initial-scale";
+ offset-x = "(1 - scale-x) / 2 * window-width"
+ offset-y = "(1 - scale-y) / 2 * window-height"
+
+ opacity = "opacity-curve";
+ shadow-offset-x = "offset-x";
+ shadow-offset-y = "offset-y";
+ shadow-scale-x = "scale-x";
+ shadow-scale-y = "scale-y";
+}, {
+ # Pop-out
+ # Options
+ duration = 0.5;
+ opacity-duration = 0.5;
+ initial-scale = 0.8;
+
+ triggers = ["hide"];
+ anim-curve = {
+ curve = "cubic-bezier(0, 0, 1, -0.5)";
+ start = 1;
+ end = 0;
+ duration = "duration";
+ }
+ opacity-curve = {
+ curve = "cubic-bezier(0.5, 0.5, 0.5, 0.5)";
+ start = 1;
+ end = 0;
+ duration = "opacity-duration";
+ }
+ scale-x = "anim-curve * (1 - initial-scale) + initial-scale";
+ scale-y = "anim-curve * (1 - initial-scale) + initial-scale";
+ offset-x = "(1-scale-x) / 2 * window-width"
+ offset-y = "(1-scale-y) / 2 * window-height"
+
+ opacity = "opacity-curve";
+ shadow-offset-x = "offset-x";
+ shadow-offset-y = "offset-y";
+ shadow-scale-x = "scale-x";
+ shadow-scale-y = "scale-y";
+}, {
+ triggers = ["close"];
+ preset = "disappear";
+ scale = 1.4;
+ duration = 0.5;
+}, {
+ triggers = ["geometry"];
+ duration = 0.3;
+ scale-x = {
+ curve = "cubic-bezier(0, 1, 1, 1)";
+ duration = "duration";
+ start = "window-width-before / window-width";
+ end = 1;
+ };
+ scale-y = {
+ curve = "cubic-bezier(0, 1, 1, 1)";
+ duration = "duration";
+ start = "window-height-before / window-height";
+ end = 1;
+ };
+ shadow-scale-x = "scale-x";
+ shadow-scale-y = "scale-y";
+ offset-x = {
+ curve = "cubic-bezier(0, 1, 1, 1)";
+ duration = "duration";
+ start = "window-x-before - window-x";
+ end = 0;
+ };
+ offset-y = {
+ curve = "cubic-bezier(0, 1, 1, 1)";
+ duration = "duration";
+ start = "window-y-before - window-y";
+ end = 0;
+ };
+ shadow-offset-x = "offset-x";
+ shadow-offset-y = "offset-y";
+})
+
+# `@include` directive can be used to include additional configuration files.
+# Relative paths are search either in the parent of this configuration file
+# (when the configuration is loaded through a symlink, the symlink will be
+# resolved first). Or in `$XDG_CONFIG_HOME/picom/include`.
+#
+# @include "extra.conf"
diff --git a/picom/pixelize.glsl b/picom/pixelize.glsl
new file mode 100644
index 0000000..6e6207e
--- /dev/null
+++ b/picom/pixelize.glsl
@@ -0,0 +1,71 @@
+#version 330
+
+in vec2 texcoord; // texture coordinate of the fragment
+
+uniform sampler2D tex; // texture of the window
+
+
+ivec2 window_size = textureSize(tex, 0); // Size of the window
+ivec2 window_center = ivec2(window_size.x/2, window_size.y/2);
+
+/*
+These shaders use a sorta hacky way to use the changing
+window opacity you might set on picom.conf animation rules
+to perform animations.
+
+Basically, when a window get's mapped, we make it's alpha
+go from 0 to 1, so, using the default_post_processing to get that alpha
+we can get a variable going from 0 (start of mapping animation)
+to 1 (end of mapping animation)
+
+You can also set up your alpha value to go from 1 to 0 in picom when
+a window is closed, effectively reversing the animations described here
+*/
+
+// Default window post-processing:
+// 1) invert color
+// 2) opacity / transparency
+// 3) max-brightness clamping
+// 4) rounded corners
+vec4 default_post_processing(vec4 c);
+
+// If you have semitransparent windows (like a terminal)
+// You can use the below function to add an opacity threshold where the
+// animation won't apply. For example, if you had your terminal
+// configured to have 0.8 opacity, you'd set the below variable to 0.8
+float max_opacity = 0.9;
+float opacity_threshold(float opacity)
+{
+ // if statement jic?
+ if (opacity >= max_opacity)
+ {
+ return 1.0;
+ }
+ else
+ {
+ return min(1, opacity/max_opacity);
+ }
+
+}
+
+vec4 anim(float time) {
+// block size shrinks from 40→1
+ float block = mix(40.0, 1.0, time);
+ vec2 uvb = floor(texcoord / block) * block + block/2;
+ vec4 c = texelFetch(tex, ivec2(uvb), 0);
+ return c;
+}
+
+// Default window shader:
+// 1) fetch the specified pixel
+// 2) apply default post-processing
+vec4 window_shader() {
+ vec4 c = texelFetch(tex, ivec2(texcoord), 0);
+ c = default_post_processing(c);
+ float opacity = opacity_threshold(c.w);
+ if (opacity != 1.0)
+ {
+ c = anim(opacity);
+ }
+ return default_post_processing(c);
+}
diff --git a/picom/sdf_mask.glsl b/picom/sdf_mask.glsl
new file mode 100644
index 0000000..3e73770
--- /dev/null
+++ b/picom/sdf_mask.glsl
@@ -0,0 +1,131 @@
+#version 330
+
+in vec2 texcoord; // texture coordinate of the fragment
+
+uniform sampler2D tex; // texture of the window
+
+
+ivec2 window_size = textureSize(tex, 0); // Size of the window
+ivec2 window_center = ivec2(window_size.x/2, window_size.y/2);
+
+/*
+These shaders use a sorta hacky way to use the changing
+window opacity you might set on picom.conf animation rules
+to perform animations.
+
+Basically, when a window get's mapped, we make it's alpha
+go from 0 to 1, so, using the default_post_processing to get that alpha
+we can get a variable going from 0 (start of mapping animation)
+to 1 (end of mapping animation)
+
+You can also set up your alpha value to go from 1 to 0 in picom when
+a window is closed, effectively reversing the animations described here
+*/
+
+// Default window post-processing:
+// 1) invert color
+// 2) opacity / transparency
+// 3) max-brightness clamping
+// 4) rounded corners
+vec4 default_post_processing(vec4 c);
+
+// If you have semitransparent windows (like a terminal)
+// You can use the below function to add an opacity threshold where the
+// animation won't apply. For example, if you had your terminal
+// configured to have 0.8 opacity, you'd set the below variable to 0.8
+float max_opacity = 0.8;
+float opacity_threshold(float opacity)
+{
+ // if statement jic?
+ if (opacity >= max_opacity)
+ {
+ return 1.0;
+ }
+ else
+ {
+ return min(1, opacity/max_opacity);
+ }
+
+}
+
+// NEW anim function: Morphing Distance-Field Mask (Wobbly Circle)
+vec4 anim(float progress) {
+
+ vec4 c = texelFetch(tex, ivec2(texcoord), 0);
+
+ // Early exit for fully transparent or fully opaque states
+ if (progress <= 0.001) { // Beginning of reveal / End of conceal
+ c.a = 0.0;
+ return c;
+ }
+ if (progress >= 0.999) { // End of reveal / Beginning of conceal
+ return c; // Original alpha, effect is complete
+ }
+
+ vec2 p_centered = texcoord - vec2(window_center); // Pixel coords relative to center
+
+ // --- SDF Parameters ---
+ // Max radius needed to cover the window from the center to a corner
+ float max_coverage_radius = length(vec2(window_size) * 0.5) * 1.05; // 5% margin
+
+ // Easing for progress (e.g., ease-in: starts slow, speeds up)
+ float eased_progress = progress * progress;
+ // float eased_progress = sqrt(progress); // Alternative: ease-out
+ // float eased_progress = progress; // Alternative: linear
+
+ float base_radius = eased_progress * max_coverage_radius;
+
+ // --- Wobble Parameters ---
+ float angle = atan(p_centered.y, p_centered.x); // Angle of pixel from center
+
+ float spatial_freq = 7.0; // Number of wobbles around circumference
+ float wobble_anim_speed = 10.0; // How fast wobbles change with progress
+ // Wobble amplitude (as a factor of base_radius), decreases as reveal completes
+ float wobble_amplitude_factor = 0.15 * (1.0 - eased_progress * 0.7);
+
+ // Wobble animation phase based on progress
+ float wobble_phase = progress * wobble_anim_speed;
+
+ float radius_offset = sin(angle * spatial_freq + wobble_phase) *
+ base_radius * wobble_amplitude_factor;
+
+ float effective_radius = base_radius + radius_offset;
+
+ // --- SDF Calculation (Circle) ---
+ // Distance from current pixel to the center of the coordinate system (p_centered)
+ float dist_from_center = length(p_centered);
+ // SDF value: negative inside the shape, positive outside
+ float sdf_value = dist_from_center - effective_radius;
+
+ // --- Alpha Masking ---
+ float edge_softness = 15.0; // Softness of the mask edge in pixels
+
+ // Create mask: 1.0 inside (visible), 0.0 outside (transparent)
+ // smoothstep transitions from 0 to 1 as sdf_value goes from 0 to edge_softness
+ // So, for sdf_value < 0 (inside), mask is 1.0.
+ // For sdf_value > edge_softness (far outside), mask is 0.0.
+ float mask = 1.0 - smoothstep(0.0, edge_softness, sdf_value);
+
+ c.a *= mask; // Apply the mask to the original alpha
+
+ return c;
+}
+
+// Default window shader:
+// 1) fetch the specified pixel
+// 2) apply default post-processing
+vec4 window_shader() {
+ vec4 c = texelFetch(tex, ivec2(texcoord), 0);
+ c = default_post_processing(c);
+ float opacity = opacity_threshold(c.w);
+ if (opacity == 0.0)
+ {
+ return c;
+ }
+ vec4 anim_c = anim(opacity);
+ if (anim_c.w < max_opacity)
+ {
+ return vec4(0);
+ }
+ return default_post_processing(anim_c);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2026-03-14 22:59:34 +0000