diff options
Diffstat (limited to 'config')
| -rw-r--r-- | config/picom/picom.conf | 504 | ||||
| -rw-r--r-- | config/picom/shaders/OldCRT.glsl | 190 | ||||
| -rw-r--r-- | config/picom/shaders/cross.glsl | 335 | ||||
| -rw-r--r-- | config/picom/shaders/cube.glsl | 373 | ||||
| -rw-r--r-- | config/picom/shaders/default_anim.glsl | 70 | ||||
| -rw-r--r-- | config/picom/shaders/dither.glsl | 127 | ||||
| -rw-r--r-- | config/picom/shaders/glass.glsl | 165 | ||||
| -rw-r--r-- | config/picom/shaders/glitch.glsl | 86 | ||||
| -rw-r--r-- | config/picom/shaders/glitch_animation.glsl | 119 | ||||
| -rw-r--r-- | config/picom/shaders/matrix_dissolve.glsl | 78 | ||||
| -rw-r--r-- | config/picom/shaders/pixelize.glsl | 72 | ||||
| -rwxr-xr-x | config/picom/shaders/pixelize_median.glsl | 85 | ||||
| -rw-r--r-- | config/picom/shaders/plane.glsl | 266 | ||||
| -rw-r--r-- | config/picom/shaders/sdf_mask.glsl | 131 | ||||
| -rw-r--r-- | config/picom/shaders/shiny.glsl | 33 | ||||
| -rw-r--r-- | config/picom/shaders/terminal_vignette.glsl | 58 |
16 files changed, 2375 insertions, 317 deletions
diff --git a/config/picom/picom.conf b/config/picom/picom.conf index 1179a80..d30d4eb 100644 --- a/config/picom/picom.conf +++ b/config/picom/picom.conf @@ -1,121 +1,67 @@ ################################# -# Corners # -################################# -# requires: https://github.com/sdhand/compton -corner-radius = 4; -round-borders = 0; - -# Specify a list of border width rules, in the format `PIXELS:PATTERN`, -# Note we don't make any guarantee about possible conflicts with the -# border_width set by the window manager. -# -# example: -# round-borders-rule = [ "2:class_g = 'URxvt'" ]; -# -round-borders-rule = [ -]; - -################################# # Shadows # ################################# - -# Enabled client-side shadows on windows. Note desktop windows -# (windows with '_NET_WM_WINDOW_TYPE_DESKTOP') never get shadow, +# 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 = true; -# The blur radius for shadows, in pixels. (defaults to 12) -# shadow-radius = 12 -shadow-radius = 20; - -# The opacity of shadows. (1.0 - 1.0, defaults to 0.75) -shadow-opacity = 0.7; - -# The left offset for shadows, in pixels. (defaults to -15) -# shadow-offset-x = -15 -shadow-offset-x = -20; - -# The top offset for shadows, in pixels. (defaults to -15) -# shadow-offset-y = -15 -shadow-offset-y = -20; - -# Don't draw shadows on drag-and-drop windows. This option is deprecated, -# you should use the *wintypes* option in your config file instead. +# The blur radius for shadows, in pixels. # -#no-dnd-shadow = true -#no-dock-shadow = false - -# Red color value of shadow (0.0 - 1.0, defaults to 0). -#shadow-red = 0.86328125 - -# Green color value of shadow (0.0 - 1.0, defaults to 0). -#shadow-green = 0.2109375 - -# Blue color value of shadow (0.0 - 1.0, defaults to 0). -#shadow-blue = 0.015625 +# Default: 12 +shadow-radius = 12; -# Do not paint shadows on shaped windows. Note shaped windows -# here means windows setting its shape through X Shape extension. -# Those using ARGB background is beyond our control. -# Deprecated, use -# shadow-exclude = 'bounding_shaped' -# or -# shadow-exclude = 'bounding_shaped && !rounded_corners' -# instead. +# The opacity of shadows. # -# shadow-ignore-shaped = '' +# Range: 0.0 - 1.0 +# Default: 0.75 +# shadow-opacity = .75 -# Specify a list of conditions of windows that should have no shadow. +# The left offset for shadows, in pixels. # -# examples: -# shadow-exclude = "n:e:Notification"; +# Default: -15 +shadow-offset-x = -7; + +# The top offset for shadows, in pixels. # -# shadow-exclude = [] -shadow-exclude = [ - "_GTK_FRAME_EXTENTS@:c", - #"_NET_WM_STATE@:32a" -]; +# Default: -15 +shadow-offset-y = -7; -# 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 Xinerama screen to the screen. -# xinerama-shadow-crop = false +# 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 ################################# # Fading # ################################# - # Fade windows in/out when opening/closing and when opacity changes, -# unless no-fading-openclose is used. -# fading = false -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; +fade-in-step = 0.01; # 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; +fade-out-step = 0.01; # The time between steps in fade step, in milliseconds. (> 0, defaults to 10) -fade-delta = 4 - -# Specify a list of conditions of windows that should not be faded. -# don't need this, we disable fading for all normal windows with wintypes: {} -fade-exclude = [ - "class_g = 'slop'" # maim -] +fade-delta = 2 # Do not fade on window open/close. # no-fading-openclose = false @@ -128,321 +74,245 @@ fade-exclude = [ # Transparency / Opacity # ################################# - -# Opacity of inactive windows. (0.1 - 1.0, defaults to 1.0) -# inactive-opacity = 1 - -# Opacity of window titlebars and borders. (0.1 - 1.0, disabled by default) -# frame-opacity = 1.0 - -# Default opacity for dropdown menus and popup menus. (0.0 - 1.0, defaults to 1.0) -# menu-opacity = 1.0 - -# Let inactive opacity set by -i override the '_NET_WM_OPACITY' values of windows. -# inactive-opacity-override = true -inactive-opacity-override = true; - -# 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 always be considered focused. -# focus-exclude = [] -focus-exclude = [ - "class_g = 'slop'" # maim -]; +# Opacity of window titlebars and borders. +# +# Range: 0.1 - 1.0 +# Default: 1.0 (disabled) +frame-opacity = 0.7; # 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 = [ "80:class_g = 'URxvt'" ]; # -# opacity-rule = [] -opacity-rule = [ - "100:class_g = 'slop'", # maim -]; - +# Default: false +# inactive-dim-fixed = true ################################# -# Background-Blurring # +# Corners # ################################# +# Sets the radius of rounded window corners. When > 0, the compositor will +# round the corners of windows. Does not interact well with +# `transparent-clipping`. +# +# Default: 0 (disabled) +corner-radius = 0 + +################################# +# Blur # +################################# -# Parameters for background blurring, see the *BLUR* section for more information. -# blur-method = gaussian +# Parameters for background blurring, see BLUR section in the man page for more information. +# blur-method = # blur-size = 12 # # 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. +# Blur background of semi-transparent / ARGB windows. +# Can be set per-window using rules. # -blur-background = true; +# Default: false +# blur-background = false -# Blur background of windows when the window frame is not opaque. +# 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 # -# blur-background-frame = false; - +# Default: false +# blur-background-frame = false # Use fixed blur strength rather than adjusting according to window opacity. -# blur-background-fixed = false; +# +# 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"; - -blur: { - # requires: https://github.com/ibhagwan/picom - #method = "none"; - method = "kawase"; - strength = 3; - deviation = 1.0; - background = true; - background-frame = false; - background-fixed = false; - kern = "3x3box"; -} - -# Exclude conditions for background blur. -blur-background-exclude = [ - "class_g != 'St'", - "_GTK_FRAME_EXTENTS@:c" -]; - +# 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 = true +# daemon = false -# Specify the backend to use: `xrender`, `glx`, or `xr_glx_hybrid`. -# `xrender` is the default one. +# Specify the backend to use: `xrender`, `glx`, or `egl`. # -experimental-backends = true; -backend = "glx"; - -vsync = false +# Default: "xrender" +backend = "glx" -# Enable remote control via D-Bus. See the *D-BUS API* section below for more details. -# dbus = false +# Use higher precision during rendering, and apply dither when presenting the +# rendered screen. Reduces banding artifacts, but may cause performance +# degradation. Only works with OpenGL. +dithered-present = false; -# Try to detect WM windows (a non-override-redirect window with no -# child that has 'WM_STATE') and mark them as active. +# Enable/disable VSync. # -# 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 +# Try to detect windows with rounded corners and don't consider them # shaped windows. The accuracy is not very high, unfortunately. # +# Has nothing to do with `corner-radius`. +# +# Default: false detect-rounded-corners = true; -# Detect '_NET_WM_OPACITY' on client windows, useful for window managers -# not passing '_NET_WM_OPACITY' of client windows to frame windows. +# 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; -# Specify refresh rate of the screen. If not specified or 0, picom will -# try detecting this with X RandR extension. -# -# refresh-rate = 60 -refresh-rate = 0 - -# Limit picom to repaint at most once every 1 / 'refresh_rate' second to -# boost performance. This should not be used with -# vsync drm/opengl/opengl-oml -# as they essentially does sw-opti's job already, -# unless you wish to specify a lower refresh rate than the actual value. -# -# sw-opti = - -# Use EWMH '_NET_ACTIVE_WINDOW' to determine currently focused window, -# rather than listening to 'FocusIn'/'FocusOut' event. Might have more accuracy, +# Use EWMH '_NET_ACTIVE_WINDOW' to determine currently focused window, +# rather than listening to 'FocusIn'/'FocusOut' event. May be more accurate, # provided that the WM supports it. # +# Default: false # use-ewmh-active-win = false -# 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. paint-on-overlay may make the flickering less obvious. +# 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 = true +# Default: false +# unredir-if-possible = false -# 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 +# Use 'WM_TRANSIENT_FOR' to group windows, and consider windows # in the same group focused at the same time. # -# detect-transient = false -detect-transient = true +# Default: false +detect-transient = true; -# Use 'WM_CLIENT_LEADER' to group windows, and consider windows in the same -# group focused at the same time. 'WM_TRANSIENT_FOR' has higher priority if -# detect-transient is enabled, too. +# Use 'WM_CLIENT_LEADER' to group windows, and consider windows in the same +# group focused at the same time. This usually means windows from the same application +# 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 -detect-client-leader = true -# 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. +# 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. # -# resize-damage = 1 +# Default: false +use-damage = false; -# Specify a list of conditions of windows that should be painted with inverted color. -# Resource-hogging, and is not well tested. +# Use X Sync fence to wait for the completion of rendering of other windows, +# before using their content to render the current screen. # -# 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. +# Required for explicit sync drivers, such as nvidia. # -# glx-no-stencil = false +# Default: false +# xrender-sync-fence = 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. +# GLX backend: Use specified GLSL fragment shader for rendering window +# contents. Read the man page for a detailed explanation of the interface. # -# glx-no-rebind-pixmap = false - -# Disable the use of damage information. -# This cause the whole screen to be redrawn everytime, 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 -# -# no-use-damage = false -use-damage = true - -# 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. +# Can be set per-window using rules. # -xrender-sync-fence = true +window-shader-fg = "~/.config/picom/shaders/glitch_animation.glsl" -# GLX backend: Use specified GLSL fragment shader for rendering window contents. -# See `compton-default-fshader-win.glsl` and `compton-fake-transparency-fshader-win.glsl` -# in the source tree for examples. -# -# glx-fshader-win = '' - -# Force all windows to be painted with blending. Useful if you -# have a glx-fshader-win that could turn opaque pixels transparent. +# Force all windows to be painted with blending. Useful if you +# 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. +# Do not use EWMH to detect fullscreen windows. # Reverts to checking if a window is fullscreen based only on its size and coordinates. # +# 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) +# 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 (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 # Set the log level. Possible values are: # "trace", "debug", "info", "warn", "error" -# in increasing level of importance. Case doesn't matter. -# If using the "TRACE" log level, it's better to log into a file +# 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 = "info"; +# Default: "warn" +# log-level = "warn"; # Set the log file. -# If *--log-file* is never specified, logs will be written to stderr. -# Otherwise, logs will to written to the given file, though some of the early -# logs might still be written to the stderr. +# If *--log-file* is never specified, logs will be written to stderr. +# Otherwise, logs will to written to the given file, though some of the early +# logs might still be written to the stderr. # When setting this option from the config file, it is recommended to use an absolute path. # -# log-file = '/path/to/your/log/file' - -# Show all X errors (for debugging) -# show-all-xerrors = false +# log-file = "/path/to/your/log/file" # 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. -# -# 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: -{ - normal = { fade = true; shadow = true;} - tooltip = { fade = true; shadow = true; opacity = 0.75; focus = true; full-shadow = false; }; - dock = { full-shadow = true; } - dnd = { shadow = true; } - popup_menu = { shadow = true; } - dropdown_menu = { shadow = true; } -}; -unredir-if-possible = false +# write-pid-path = "/path/to/your/log/file" + +# Rule-based per-window options. +# +# See WINDOW RULES section in the man page for how these work. +rules: ({ + match = "window_type = 'tooltip'"; + fade = false; + shadow = true; + opacity = 0.9; + full-shadow = false; +}, { + match = "window_type = 'dock' || " + "window_type = 'desktop' || " + "_GTK_FRAME_EXTENTS@"; + blur-background = false; +}, { + match = "window_type != 'dock'"; + # shader = "my_shader.frag"; +}, { + match = "window_type = 'dock' || " + "window_type = 'desktop'"; + corner-radius = 0; +}, { + match = "name = 'Notification' || " + "class_g = 'Conky' || " + "class_g ?= 'Notify-osd' || " + "class_g = 'Cairo-clock' || " + "_GTK_FRAME_EXTENTS@"; + shadow = false; +}) + +# `@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/config/picom/shaders/OldCRT.glsl b/config/picom/shaders/OldCRT.glsl new file mode 100644 index 0000000..6e02812 --- /dev/null +++ b/config/picom/shaders/OldCRT.glsl @@ -0,0 +1,190 @@ +#version 430 +#define PI 3.1415926538 +uniform float opacity; +uniform float time; + +// Works best with fullscreen windows +// Made this to play retro games the way god intended + +uniform float sc_freq = 0.2; // Frequency for the scanlines + +uniform float sc_intensity = 0.6; // Intensity of the scanline effect + +uniform bool grid = false; // Whether to also apply scanlines to x axis or not + +uniform int distortion_offset = 2; // Pixel offset for red/blue distortion + +uniform int downscale_factor = 2; // How many pixels of the window + // make an actual "pixel" (or block) + +uniform float sph_distance = 500; // Distance from the theoretical sphere + // we use for our curvature transform + +uniform float curvature = 1.5; // How much the window should "curve" + +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 = 1; // Intensity level of the shadow effect (from 1 to 5) + +vec4 outside_color = vec4(0 ,0 ,0, opacity); // Color for the outside of the window + +float flash_speed = 0; // Speed of flashing effect, set to 0 to deactivate + +float flash_intensity = 0.8; // Intensity of flashing effect + + +// You can play with different values for all the variables above + +in vec2 texcoord; // texture coordinate of the fragment + +uniform sampler2D tex; // texture of the window + +ivec2 window_size = textureSize(tex, 0); +ivec2 window_center = ivec2(window_size.x/2, window_size.y/2); +float radius = (window_size.x/curvature); +int flash = int(round(flash_speed*time/(10000/window_size.y))) % window_size.y; + +// Default window post-processing: +// 1) invert color +// 2) opacity / transparency +// 3) max-brightness clamping +// 4) rounded corners +vec4 default_post_processing(vec4 c); + +// Darkens a pixels near the edges +vec4 darken_color(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 brightness = 1; + brightness *= -pow((distances_from_center.y/window_center.y)*shadow_cutoff, + (5/shadow_intensity)*2)+1; + brightness *= -pow((distances_from_center.x/window_center.x)*shadow_cutoff, + (5/shadow_intensity)*2)+1; + color.xyz *= brightness; + + return color; +} + +// Applies a transformation to our window pixels to simulate +// a curved screen +ivec2 curve_coords_spheric(vec2 coords) +{ + // Offset coords + coords -= window_center; + vec2 curved_coords; + + // For this transform imagine a sphere in a 3d space with the + // window as a 2d plane tangent to that sphere + // For simplicity, we center the sphere at 0,0,0 + // The coordinates of the projection share x and y with our window pixel + // We find Z using the formula for a sphere + vec3 projection_coords3d = vec3(coords.x, coords.y, + sqrt(pow(radius+sph_distance,2)- + pow(coords.x,2)- + pow(coords.y,2))); + + // That vector goes from the center of the sphere to the projection of a pixel + // of our window onto the sphere's surface + // Let's scale it until it hits our window plane + projection_coords3d *= ((radius+sph_distance)/projection_coords3d.z); + curved_coords = projection_coords3d.xy; + + // Compensate for starting coords offset + curved_coords += window_center; + + return ivec2(curved_coords); +} + + +// Gets a color for a pixel with all the coordinate and +// downscale changes +vec4 get_pixel(vec2 coords) +{ + // If pixel is at the edge of the window, return a completely black color + if (coords.x >=window_size.x-1 || coords.y >=window_size.y-1 || + coords.x <=0 || coords.y <=0) + { + return outside_color; + } + vec4 color = texelFetch(tex, ivec2(coords), 0); + return default_post_processing(color); +} + +// Gets the color from a downscaled block +vec4 get_block_color(vec2 coords) +{ + // If downscale is set to 1, just return a pixel + if (downscale_factor < 2) + { + return get_pixel(coords); + } + + // Relative position of pixel inside the block + ivec2 relative_position; + relative_position.xy = ivec2(coords).xy % downscale_factor; + + // Average all colors from pixels inside the block + vec4 average = vec4(0, 0 , 0, 0); + for (int i = 0; i < downscale_factor; i++) + { + for (int j = 0; j < downscale_factor; j++) + { + average.xyzw += get_pixel(vec2(coords.x + i - relative_position.x, + coords.y + j - relative_position.y)); + } + } + average /= pow(downscale_factor, 2); + + return average; +} + + +// Main shader function +vec4 window_shader() { + + // Apply curvature transform to coords + vec2 curved_coords = curve_coords_spheric(texcoord); + + // Fetch the color + vec4 c = get_block_color(curved_coords); + + // Fetch colors from close pixels to apply color distortion + vec4 c_right = get_block_color(vec2(curved_coords.x+2, curved_coords.y)); + vec4 c_left = get_block_color(vec2(curved_coords.x-2, curved_coords.y)); + + // Mix red and blue colors + c = vec4(c_left.x, c.y, c_right.z, c.w); + + // Apply scanlines + c.xyz *= sin(2*PI*sc_freq*(texcoord).y)/(2/sc_intensity) + + 1 - sc_intensity/2; + + // Also apply scanlines to x axis if grid is enabled + if (grid == true) + { + c.xyz *= sin(2*PI*sc_freq*(texcoord).x)/(2/sc_intensity) + + 1 - sc_intensity/2; + } + + // Apply flash + if (curved_coords.y >=flash-(window_size.y/10) && curved_coords.y <=flash) + { + c.xyz *= flash_intensity*(pow(((flash-curved_coords.y)/(window_size.y/10))-1,2) + + 1/flash_intensity); + } + + // Darken pixel + c = darken_color(c, curved_coords); + return (c); +} diff --git a/config/picom/shaders/cross.glsl b/config/picom/shaders/cross.glsl new file mode 100644 index 0000000..2241508 --- /dev/null +++ b/config/picom/shaders/cross.glsl @@ -0,0 +1,335 @@ +#version 430 +#define PI 3.14159265 + +// 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; +}; + +in vec2 texcoord; // texture coordinate of the fragment + +uniform sampler2D tex; // texture of the window + + +uniform float time; // Time in miliseconds. + +float time_cyclic = mod(time/10000,2); // Like time, but in seconds and resets to + // 0 when it hits 2. Useful for using it in + // periodic functions like cos and sine +// Time variables can be used to change transformations over time + + +ivec2 window_size = textureSize(tex, 0); // Size of the window + +float window_diagonal = length(window_size); // Diagonal of the window +// Try to keep focal offset and translations proportional to window_size components +// or window_diagonal as you see fit + +pinhole_camera camera = +pinhole_camera(-window_size.y/2, // Focal offset + vec3(0,0,0), // Rotations + vec3(0,0,0), // Translations + vec3(1,1,1), // Deformations + // Leave the rest as 0 + vec3(0), + vec3(0), + vec3(0), + vec3(0), + vec3(0)); + +// Here are some presets you can use + +// Moves the camera up and down +pinhole_camera bobbing = +pinhole_camera(-window_size.y/2, + vec3(0,0,0), + vec3(0,cos(time_cyclic*PI)*window_size.y/16,-window_size.y/4), + vec3(1,1,1), + vec3(0), + vec3(0), + vec3(0), + vec3(0), + vec3(0)); + +// Rotates camera around the origin +// Makes the window rotate around the Y axis from the camera's POV +// (if the window is centered) +pinhole_camera rotate_around_origin = +pinhole_camera(-window_diagonal, + vec3(0,-time_cyclic*PI-PI/2,0), + vec3(cos(time_cyclic*PI)*window_diagonal, + 0, + sin(time_cyclic*PI)*window_diagonal), + vec3(1,1,1), + vec3(0), + vec3(0), + vec3(0), + vec3(0), + vec3(0)); + +// Rotate camera around its center +pinhole_camera rotate_around_itself = +pinhole_camera(-window_diagonal, + vec3(0,-time_cyclic*PI-PI/2,0), + vec3(0,0,-window_diagonal), + vec3(1,1,1), + vec3(0), + vec3(0), + vec3(0), + vec3(0), + vec3(0)); + +// Here you can select the preset to use +pinhole_camera window_cam = rotate_around_origin; + + + +ivec2 window_center = ivec2(window_size.x/2, window_size.y/2); + +// Default window post-processing: +// 1) invert color +// 2) opacity / transparency +// 3) max-brightness clamping +// 4) rounded corners +vec4 default_post_processing(vec4 c); + +// Sets up a camera by applying transformations and +// calculating xyz vector basis +pinhole_camera setup_camera(pinhole_camera camera) +{ + // 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; +} + +// Gets a pixel from the end of a ray projected to an axis +vec4 get_pixel_from_projection(float t, int face, pinhole_camera camera, vec3 focal_vector) +{ + // If the point we end up in is behind our camera, don't "render" it + if (t < 1) + { + return vec4(0); + } + + // 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 a the necessary coordinates and add back offset + vec2 cam_coords; + switch (face) + { + case 0: + cam_coords = intersection.xy + window_center; + break; + case 1: + cam_coords = intersection.zy + window_center; + break; + } + + // If pixel is outside of our window region + // return a completely transparent color + if (cam_coords.x >=window_size.x-1 || + cam_coords.y >=window_size.y-1 || + cam_coords.x <=0 || cam_coords.y <=0) + { + return vec4(0); + } + + // Fetch the pixel + vec4 pixel = texelFetch(tex, ivec2(cam_coords), 0); + 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) +{ + // 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; + + // We need 2 planes, one for each axis of the cross, they all follow the plane EQ + // ax + by + cz + d + float a[] = {0,1}; + float b[] = {0,0}; + float c[] = {1,0}; + float d[] = {0,0}; + // Then there's a line going from our focal point to each of the planes + // 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), y(t) and z(t) in the plane EQ + // Solving for t we get: + vec2 t[2]; // we use a vec2 to also store the plane that was hit + for (int i = 0; i < 2; i++) + { + t[i].x = (d[i] + - a[i]*camera.focal_point.x + - b[i]*camera.focal_point.y + - c[i]*camera.focal_point.z) + / (a[i]*focal_vector.x + + b[i]*focal_vector.y + + c[i]*focal_vector.z); + t[i].y = i; + } + + // 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 < 2; i++) + { + // We get the pixel through projection + vec4 projection_pixel = get_pixel_from_projection(t[i].x, + int(t[i].y), + camera, + focal_vector); + // Blend the pixel using alpha + blended_pixels = alpha_composite(projection_pixel, blended_pixels); + } + return blended_pixels; +} + +// Main function +vec4 window_shader() { + pinhole_camera transformed_cam = setup_camera(window_cam); + return(get_pixel_through_camera(texcoord, transformed_cam)); +} diff --git a/config/picom/shaders/cube.glsl b/config/picom/shaders/cube.glsl new file mode 100644 index 0000000..8988a7d --- /dev/null +++ b/config/picom/shaders/cube.glsl @@ -0,0 +1,373 @@ +#version 430 +#define PI 3.14159265 + +// 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; +}; + +in vec2 texcoord; // texture coordinate of the fragment + +uniform sampler2D tex; // texture of the window + + +uniform float time; // Time in miliseconds. + +float time_cyclic = mod(time/10000,2); // Like time, but in seconds and resets to + // 0 when it hits 2. Useful for using it in + // periodic functions like cos and sine + +// Time variables can be used to change transformations over time + + +ivec2 window_size = textureSize(tex, 0); // Size of the window + +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 +// Try to keep focal offset and translations proportional to window_size components +// or window_diagonal as you see fit + +pinhole_camera camera = +pinhole_camera(-window_size.y/2, // Focal offset + vec3(0,0,0), // Rotations + vec3(0,0,0), // Translations + vec3(1,1,1), // Deformations + // Leave the rest as 0 + vec3(0), + vec3(0), + vec3(0), + vec3(0), + vec3(0)); + +// Here are some presets you can use + +// Moves the camera up and down +pinhole_camera bobbing = +pinhole_camera(-window_size.y/2, + vec3(0,0,0), + vec3(0,cos(time_cyclic*PI)*window_size.y/16,-window_size.y/4), + vec3(1,1,1), + vec3(0), + vec3(0), + vec3(0), + vec3(0), + vec3(0)); + +// Rotates camera around the origin +// Makes the window rotate around the Y axis from the camera's POV +// (if the window is centered) +pinhole_camera rotate_around_origin = +pinhole_camera(-wss, + vec3(PI/6*sin(2*time_cyclic*PI),-time_cyclic*PI-PI/2,0), + vec3(cos(time_cyclic*PI)*wss, + wss/2*sin(2*time_cyclic*PI), + sin(time_cyclic*PI)*wss), + vec3(1,1,1), + vec3(0), + vec3(0), + vec3(0), + vec3(0), + vec3(0)); + +// Rotate camera around its center +pinhole_camera rotate_around_itself = +pinhole_camera(-wss, + vec3(0,-time_cyclic*PI-PI/2,0), + vec3(0,0,-wss), + vec3(1,1,1), + vec3(0), + vec3(0), + vec3(0), + vec3(0), + vec3(0)); + +// Here you can select the preset to use +pinhole_camera window_cam = rotate_around_origin; + + + +ivec2 window_center = ivec2(window_size.x/2, window_size.y/2); + +// Default window post-processing: +// 1) invert color +// 2) opacity / transparency +// 3) max-brightness clamping +// 4) rounded corners +vec4 default_post_processing(vec4 c); + +// Sets up a camera by applying transformations and +// calculating xyz vector basis +pinhole_camera setup_camera(pinhole_camera camera) +{ + // 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; +} + +// Gets a pixel from the end of a ray projected to an axis +vec4 get_pixel_from_projection(float t, int face, pinhole_camera camera, vec3 focal_vector) +{ + // If the point we end up in is behind our camera, don't "render" it + if (t < 1) + { + return vec4(0); + } + + // 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 + // (different cube faces need different coords) + vec2 cam_coords; + switch (face) + { + case 0: + cam_coords = intersection.xy; + break; + case 1: + cam_coords = intersection.xy; + break; + case 2: + cam_coords = intersection.zy; + break; + case 3: + cam_coords = intersection.zy; + break; + case 4: + cam_coords = intersection.zx; + break; + case 5: + cam_coords = intersection.zx; + break; + } + + if (window_size.x > window_size.y) + { + cam_coords.x /= window_size.y/float(window_size.x); + cam_coords.xy += window_center.xy; + } + else if (window_size.x < window_size.y) + { + cam_coords.y /= window_size.x/float(window_size.y); + cam_coords.xy += window_center.xy; + } + // If pixel is outside of our window region + // return a completely transparent color + if (cam_coords.x >=window_size.x-1 || + cam_coords.y >=window_size.y-1 || + cam_coords.x <=0 || cam_coords.y <=0) + { + return vec4(0); + } + + // Fetch the pixel + vec4 pixel = texelFetch(tex, ivec2(cam_coords), 0); + + 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) +{ + // 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; + + // We need 6 planes, one for each face of the cube, they all follow the plane EQ + // ax + by + cz + d + float a[] = {0,0, + 1,1, + 0,0}; + float b[] = {0,0, + 0,0, + 1,1}; + float c[] = {1,1, + 0,0, + 0,0}; + float d[] = {-wss/2.0,wss/2.0, + -wss/2.0,wss/2.0, + -wss/2.0,wss/2.0}; + + // Then there's a line going from our focal point to each of the planes + // 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), y(t) and z(t) in the plane EQ + // Solving for t we get: + vec2 t[6]; // we use a vec2 to also store the plane that was hit + for (int i = 0; i < t.length(); i++) + { + t[i].x = (d[i] + - a[i]*camera.focal_point.x + - b[i]*camera.focal_point.y + - c[i]*camera.focal_point.z) + / (a[i]*focal_vector.x + + b[i]*focal_vector.y + + c[i]*focal_vector.z); + t[i].y = i; + } + + // 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, + int(t[i].y), + camera, + focal_vector); + // Only blend non fully transparent pixels + if (projection_pixel.w > 0.0) + { + // Blend the pixel using alpha + blended_pixels = alpha_composite(projection_pixel, blended_pixels); + } + } + return blended_pixels; +} + +// Main function +vec4 window_shader() { + pinhole_camera transformed_cam = setup_camera(window_cam); + return(get_pixel_through_camera(texcoord, transformed_cam)); +} diff --git a/config/picom/shaders/default_anim.glsl b/config/picom/shaders/default_anim.glsl new file mode 100644 index 0000000..e4f43ed --- /dev/null +++ b/config/picom/shaders/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/config/picom/shaders/dither.glsl b/config/picom/shaders/dither.glsl new file mode 100644 index 0000000..6a2a285 --- /dev/null +++ b/config/picom/shaders/dither.glsl @@ -0,0 +1,127 @@ +#version 430 + +bool monochrome = false; // Whether to apply a black & white filter to the window + +// You can modify the list of patterns to whatever you like, the code will +// adapt to it as long as it is a list of equally sized 2D arrays +// This example shows a dither pattern list that uses numbers other than +// 0 and 1 for more color variation +// Dither patterns +float dither [][][] = { {{0 , 0 }, + {0 , 0 }}, + + {{0.5, 0 }, + {0 , 0 }}, + + {{0.5, 0 }, + {0 , 0.5}}, + + {{0.5, 0.5}, + {0 , 0.5}}, + + {{0.5, 0.5}, + {0.5, 0.5}}, + + {{1 , 0.5}, + {0.5,0.5}}, + + {{1 , 0.5}, + {0.5, 1 }}, + + {{1 , 1 }, + {0.5, 1 }}, + + {{1 , 1 }, + {1 , 1 }} }; + +// Some more props that depend on the dither patterns +float bit_depth = dither.length() - 1.0; +int block_size = dither[0].length(); + +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); + +// Returns a monochromatic pixel +vec4 to_monochrome (vec4 pixel) +{ + float brightness = (pixel.x + pixel.y + pixel.z)/3; + return vec4(vec3(brightness), pixel.w); +} + +vec4 window_shader() { + // Alpha for the current pixel + float alpha; + + // Relative block position + ivec2 block_pos; + block_pos.x = int(texcoord.x) % block_size; + block_pos.y = int(texcoord.y) % block_size; + + // Current block total color + vec3 block_color = vec3(0,0,0); + + // We will iterate over all the pixels in the block + // and save it to this variable + vec4 pixel; + for (int y = 0; y < block_size; y += 1) + { + for (int x = 0; x < block_size; x += 1) + { + // Apply default post processing picom things and + // add color values after. + pixel = texelFetch(tex, ivec2(texcoord.x+x-block_pos.x,texcoord.y+y-block_pos.y), 0); + pixel = default_post_processing(pixel); + if (monochrome) + { + pixel = to_monochrome(pixel); + block_color.x += pixel.x; + } + else + { + block_color.x += pixel.x; + block_color.y += pixel.y; + block_color.z += pixel.z; + } + + // If we are on the current pixel, save the alpha value + if (x == 0 && y == 0) + { + alpha = pixel.w; + } + } + } + // Normalize block colors and quantify them + block_color.x = block_color.x/float(block_size*block_size); + block_color.x = round(block_color.x*bit_depth); + + // Get the pixel colors using our dither pattern + block_color.x = dither[int(block_color.x)][block_pos.y][block_pos.x]; + + if (monochrome) + { + block_color.yz = block_color.xx; + } + else + { + block_color.y = block_color.y/float(block_size*block_size); + block_color.y = round(block_color.y*bit_depth); + + block_color.z = block_color.z/float(block_size*block_size); + block_color.z = round(block_color.z*bit_depth); + + block_color.y = dither[int(block_color.y)][block_pos.y][block_pos.x]; + block_color.z = dither[int(block_color.z)][block_pos.y][block_pos.x]; + } + + // Set the final value for our pixel + pixel = vec4(block_color.x, block_color.y, block_color.z, alpha); + return pixel; +} diff --git a/config/picom/shaders/glass.glsl b/config/picom/shaders/glass.glsl new file mode 100644 index 0000000..a37972e --- /dev/null +++ b/config/picom/shaders/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/config/picom/shaders/glitch.glsl b/config/picom/shaders/glitch.glsl new file mode 100644 index 0000000..be28f78 --- /dev/null +++ b/config/picom/shaders/glitch.glsl @@ -0,0 +1,86 @@ +#version 330 + + +int delta = 20; +float barh = 0.02; +float barw = 0.4; +int nbar = 16; + +float maxoff = 5; +float minoff = 2; + +in vec2 texcoord; // texture coordinate of the fragment + +uniform sampler2D tex; // texture of the window +ivec2 window_size = textureSize(tex, 0); +ivec2 window_center = ivec2(window_size.x/2, window_size.y/2); + +// Default window post-processing: +// 1) invert color +// 2) opacity / transparency +// 3) max-brightness clamping +// 4) rounded corners +vec4 default_post_processing(vec4 c); + +uniform float time; // Time in miliseconds. + +float alpha = round(time/delta); // Like time, but in seconds and resets to + +// Pseudo-random function (from original shader) +float random(float n) { + return fract(sin(n) * 43758.5453f); +} + +float get_box() { + float n = random(alpha)*(nbar); + + for(int i=0;i<n;i++){ + float y = random(mod(alpha, 2048)+i) * window_size.y; + float x = random(mod(alpha+128, 2048)+i) * window_size.x; + float w = random(mod(alpha+64, 2048)+i) * barw*window_size.x; + float h = random(mod(alpha+32, 2048)+i) * barh*window_size.y; + if (texcoord.y > y && texcoord.y < y + h + && texcoord.x > x && texcoord.x < x + w) { + return i*w*h*y*x*n; + } + } + return -1.0f; +} + +float rand_offset(float b) { + return (random(b*64) - 0.5) * (maxoff*2); +} + +vec4 window_shader() { + float b = get_box(); + + if (b == -1.0) { + vec4 c = texelFetch(tex, ivec2(texcoord), 0); + return default_post_processing(c); + } + //b = random(mod(alpha, 2000)); + + // Offsets in pixels for each color + vec2 uvr = vec2(rand_offset(b*1), rand_offset(b*6)); + vec2 uvg = vec2(rand_offset(b*2),rand_offset(b*7)); + vec2 uvb = vec2(rand_offset(b*3),rand_offset(b*8)); + + // Calculate offset coords + uvr += texcoord; + uvg += texcoord; + uvb += texcoord; + + // Fetch colors using offset coords + vec3 offset_color; + offset_color.x = texelFetch(tex, ivec2(uvr), 0).x; + offset_color.y = texelFetch(tex, ivec2(uvg), 0).y; + offset_color.z = texelFetch(tex, ivec2(uvb), 0).z; + + // Set the new color + vec4 c; + c.w = texelFetch(tex, ivec2(uvr), 0).w; + c.xyz = offset_color; + + return default_post_processing(c); +} + diff --git a/config/picom/shaders/glitch_animation.glsl b/config/picom/shaders/glitch_animation.glsl new file mode 100644 index 0000000..be1e16c --- /dev/null +++ b/config/picom/shaders/glitch_animation.glsl @@ -0,0 +1,119 @@ +#version 330 + +float maxoff = 10; +float minoff = 2; +float hue = 0.3; + +float block_max = 500; +float block_min = 200; + +in vec2 texcoord; // texture coordinate of the fragment +uniform sampler2D tex; // texture of the window + +vec4 default_post_processing(vec4 c); + +uniform float time; // Time in miliseconds. + +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); + } + +} + +// Pseudo-random function (from original shader) +float random(float n) { + return fract(sin(n) * 43758.5453f); +} + +float rand_offset(float b, float off) { + return (random(b*64) - 0.5) * (off*2); +} + +vec3 hueShift( vec3 color, float hueAdjust ){ + + const vec3 kRGBToYPrime = vec3 (0.299, 0.587, 0.114); + const vec3 kRGBToI = vec3 (0.596, -0.275, -0.321); + const vec3 kRGBToQ = vec3 (0.212, -0.523, 0.311); + + const vec3 kYIQToR = vec3 (1.0, 0.956, 0.621); + const vec3 kYIQToG = vec3 (1.0, -0.272, -0.647); + const vec3 kYIQToB = vec3 (1.0, -1.107, 1.704); + + float YPrime = dot (color, kRGBToYPrime); + float I = dot (color, kRGBToI); + float Q = dot (color, kRGBToQ); + float hue = atan (Q, I); + float chroma = sqrt (I * I + Q * Q); + + hue += hueAdjust; + + Q = chroma * sin (hue); + I = chroma * cos (hue); + + vec3 yIQ = vec3 (YPrime, I, Q); + + return vec3( dot (yIQ, kYIQToR), dot (yIQ, kYIQToG), dot (yIQ, kYIQToB) ); + +} + +vec4 anim(float alpha) { + float block = mix(block_max, block_min, alpha); + vec2 bs = floor(texcoord / block) * block + block/2; + + float b = random(bs.y) * random(mod(time/10000,2)); + + float off = mix(maxoff, minoff, alpha); + if (b > alpha) { + off = 0; + } + + // Offsets in pixels for each color + vec2 uvr = vec2(rand_offset(b*1, off), rand_offset(b*6, off)); + vec2 uvg = vec2(rand_offset(b*2, off), rand_offset(b*7, off)); + vec2 uvb = vec2(rand_offset(b*3, off), rand_offset(b*8, off)); + + // Calculate offset coords + uvr += texcoord; + uvg += texcoord; + uvb += texcoord; + + // Fetch colors using offset coords + vec3 offset_color; + offset_color.x = texelFetch(tex, ivec2(uvr), 0).x; + offset_color.y = texelFetch(tex, ivec2(uvg), 0).y; + + offset_color.x = hueShift(texelFetch(tex, ivec2(uvr), 0).xyz, hue).x; + offset_color.y = hueShift(texelFetch(tex, ivec2(uvg), 0).xyz, hue).y; + offset_color.z = hueShift(texelFetch(tex, ivec2(uvb), 0).xyz, hue).z; + + offset_color.xyz = hueShift(offset_color.xyz, -hue); + + // Set the new color + vec4 c; + c.w = texelFetch(tex, ivec2(uvr), 0).w; + c.xyz = offset_color; + + return default_post_processing(c); +} + +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); + } + //c = anim(opacity); + return default_post_processing(c); +} + diff --git a/config/picom/shaders/matrix_dissolve.glsl b/config/picom/shaders/matrix_dissolve.glsl new file mode 100644 index 0000000..aaa6c4b --- /dev/null +++ b/config/picom/shaders/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 = 4.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/config/picom/shaders/pixelize.glsl b/config/picom/shaders/pixelize.glsl new file mode 100644 index 0000000..8a9c72e --- /dev/null +++ b/config/picom/shaders/pixelize.glsl @@ -0,0 +1,72 @@ +#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/config/picom/shaders/pixelize_median.glsl b/config/picom/shaders/pixelize_median.glsl new file mode 100755 index 0000000..9d695aa --- /dev/null +++ b/config/picom/shaders/pixelize_median.glsl @@ -0,0 +1,85 @@ +#version 330 + +#define vec vec3 +#define toVec(x) x.rgb + +#define s2(a, b) temp = a; a = min(a, b); b = max(temp, b); +#define mn3(a, b, c) s2(a, b); s2(a, c); +#define mx3(a, b, c) s2(b, c); s2(a, c); + +#define mnmx3(a, b, c) mx3(a, b, c); s2(a, b); // 3 exchanges +#define mnmx4(a, b, c, d) s2(a, b); s2(c, d); s2(a, c); s2(b, d); // 4 exchanges +#define mnmx5(a, b, c, d, e) s2(a, b); s2(c, d); mn3(a, c, e); mx3(b, d, e); // 6 exchanges +#define mnmx6(a, b, c, d, e, f) s2(a, d); s2(b, e); s2(c, f); mn3(a, b, c); mx3(d, e, f); // 7 exchanges + + +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/config/picom/shaders/plane.glsl b/config/picom/shaders/plane.glsl new file mode 100644 index 0000000..b1c6885 --- /dev/null +++ b/config/picom/shaders/plane.glsl @@ -0,0 +1,266 @@ +#version 330 +#define PI 3.14159265 + +// 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; +}; + +in vec2 texcoord; // texture coordinate of the fragment + +uniform sampler2D tex; // texture of the window + + +uniform float time; // Time in miliseconds. + +float time_cyclic = mod(time/10000,2); // Like time, but in seconds and resets to + // 0 when it hits 2. Useful for using it in + // periodic functions like cos and sine +// Time variables can be used to change transformations over time + + +ivec2 window_size = textureSize(tex, 0); // Size of the window + +float window_diagonal = length(window_size); // Diagonal of the window +// Try to keep focal offset and translations proportional to window_size components +// or window_diagonal as you see fit + +pinhole_camera camera = +pinhole_camera(-window_size.y/2, // Focal offset + vec3(0,0,0), // Rotations + vec3(0), // Translations + vec3(1,1,1), // Deformations + // Leave the rest as 0 + vec3(0), + vec3(0), + vec3(0), + vec3(0), + vec3(0)); + +// Here are some presets you can use + +// Moves the camera up and down +pinhole_camera bobbing = +pinhole_camera(-window_size.y/2, + vec3(0,0,0), + vec3(0,cos(time_cyclic*PI)*window_size.y/16,-window_size.y/4), + vec3(1,1,1), + vec3(0), + vec3(0), + vec3(0), + vec3(0), + vec3(0)); + +// Rotates camera around the origin +// Makes the window rotate around the Y axis from the camera's POV +// (if the window is centered) +pinhole_camera rotate_around_origin = +pinhole_camera(-window_diagonal, + vec3(0,-time_cyclic*PI-PI/2,0), + vec3(cos(time_cyclic*PI)*window_diagonal, + 0, + sin(time_cyclic*PI)*window_diagonal), + vec3(1,1,1), + vec3(0), + vec3(0), + vec3(0), + vec3(0), + vec3(0)); + +// Rotate camera around its center +pinhole_camera rotate_around_itself = +pinhole_camera(-window_diagonal, + vec3(0,-time_cyclic*PI-PI/2,0), + vec3(0,0,-window_diagonal), + vec3(1,1,1), + vec3(0), + vec3(0), + vec3(0), + vec3(0), + vec3(0)); + +// Here you can select the preset to use +pinhole_camera window_cam = rotate_around_origin; + + + +ivec2 window_center = ivec2(window_size.x/2, window_size.y/2); + +// Default window post-processing: +// 1) invert color +// 2) opacity / transparency +// 3) max-brightness clamping +// 4) rounded corners +vec4 default_post_processing(vec4 c); + +// Sets up a camera by applying transformations and +// calculating xyz vector basis +pinhole_camera setup_camera(pinhole_camera camera) +{ + // 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; +} + +vec4 get_pixel_through_camera(vec2 coords, pinhole_camera camera) +{ + // 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; + + // Let's say we have a plane for our window following the plane equation + // ax + by + cz = d + float a = 0; + float b = 0; + float c = 1; + float d = 0; + // Then there's a line going from our focal point to the plane + // 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), y(t) and z(t) in our plane EQ + // Solving for t we get: + float t = (d + - a*camera.focal_point.x + - b*camera.focal_point.y + - c*camera.focal_point.z) + / (a*focal_vector.x + + b*focal_vector.y + + c*focal_vector.z); + + // If the point we end up in is behind our camera, don't "render" it + if (t < 1) + { + return vec4(0); + } + + // 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 x and y coordinates and add back our initial offset + vec2 cam_coords = intersection.xy + window_center; + + // If pixel is outside of our window region + // return a completely transparent color + if (cam_coords.x >=window_size.x-1 || + cam_coords.y >=window_size.y-1 || + cam_coords.x <=0 || cam_coords.y <=0) + { + return vec4(0); + } + + // Fetch the pixel + vec4 pixel = texelFetch(tex, ivec2(cam_coords), 0); + return pixel; +} + +vec4 window_shader() { + pinhole_camera transformed_cam = setup_camera(window_cam); + return(get_pixel_through_camera(texcoord, transformed_cam)); +} diff --git a/config/picom/shaders/sdf_mask.glsl b/config/picom/shaders/sdf_mask.glsl new file mode 100644 index 0000000..3e73770 --- /dev/null +++ b/config/picom/shaders/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); +} diff --git a/config/picom/shaders/shiny.glsl b/config/picom/shaders/shiny.glsl new file mode 100644 index 0000000..16636ac --- /dev/null +++ b/config/picom/shaders/shiny.glsl @@ -0,0 +1,33 @@ +#version 430 + +// Source: https://github.com/yshui/picom/issues/295#issuecomment-592077997 + +in vec2 texcoord; + +uniform float opacity; +uniform bool invert_color; +uniform sampler2D tex; +uniform float time; + +ivec2 window_size = textureSize(tex, 0); + +float amt = 10000.0; + +vec4 default_post_processing(vec4 c); + +vec4 window_shader() { + float pct = mod(time, amt) / amt * 1000; + float factor = float(max(window_size.x, window_size.y)); + pct *= factor / 150.0; + vec2 pos = texcoord; + vec4 c = texelFetch(tex, ivec2(texcoord), 0); + + if (pos.x + pos.y < pct * 4.0 && pos.x + pos.y > pct * 4.0 - .5 * pct + || pos.x + pos.y < pct * 4.0 - .8 * pct && pos.x + pos.y > pct * 3.0) + c *= vec4(2, 2, 2, 1); + if (invert_color) + c = vec4(vec3(c.a, c.a, c.a) - vec3(c), c.a); + + c *= opacity; + return default_post_processing(c); +} diff --git a/config/picom/shaders/terminal_vignette.glsl b/config/picom/shaders/terminal_vignette.glsl new file mode 100644 index 0000000..4e5aa21 --- /dev/null +++ b/config/picom/shaders/terminal_vignette.glsl @@ -0,0 +1,58 @@ +#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); +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) + + +// Default window post-processing: +// 1) invert color +// 2) opacity / transparency +// 3) max-brightness clamping +// 4) rounded corners +vec4 default_post_processing(vec4 c); + +// 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.8); + + return color; +} + + +// Default window shader: +// 1) fetch the specified pixel +// 2) apply default post-processing +vec4 window_shader() { + vec4 c = texelFetch(tex, ivec2(texcoord), 0); + if (c.x +c.y + c.z < 0.6) + { + c.w = 1; + c = calc_opacity(c,texcoord); + } + + return default_post_processing(c); +} |