vbalien/newdotfiles
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

enable hidpi

Browse Source
This commit is contained in:
Jisu Kim
2020-08-20 12:09:10 +09:00
parent 7846fdae50
commit 4010759be5
32 changed files with 1468 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

164
linux-hidpi/conkyrc Normal file
View File

@@ -0,0 +1,164 @@
conky.config = {
-------------------------------------
-- Generic Settings
-------------------------------------
background=true,
update_interval=1,
double_buffer=true,
no_buffers=true,
draw_shades=false,
draw_outline=false,
draw_borders=false,
-------------------------------------
-- Window Specifications
-------------------------------------
gap_x=800,
gap_y=550,
minimum_height=250,
minimum_width=360,
own_window=true,
own_window_type="normal",
own_window_transparent=true,
own_window_hints="undecorated,below,sticky,skip_taskbar,skip_pager",
own_window_argb_visual=true,
own_window_argb_value=0,
-------------------------------------
-- Text Settings
-------------------------------------
use_xft=true,
xftalpha=1,
font="Droid Sans:size=10",
text_buffer_size=256,
override_utf8_locale=true,
-------------------------------------
-- Color Scheme
-------------------------------------
default_color="FFFFFF",
color0="FFFFFF", -- hours
color1="FFFFFF", -- clock dots
color2="FFFFFF", -- minutes
color3="FFFFFF", -- week day
color4="FFFFFF", -- month day
color5="FFFFFF", -- month
color6="FFFFFF", -- current temp
color7="FFFFFF", -- min temp
color8="FFFFFF", -- max temp
color9="FFFFFF", -- current conditions
-------------------------------------
-- Icon Sources
-------------------------------------
template0="~/.jelly-conky/#fff__64",
-------------------------------------
-- API Key
-------------------------------------
template6="$OWM_KEY",
-------------------------------------
-- City ID
-------------------------------------
template7="1846918",
-------------------------------------
-- Temp Unit (default, metric, imperial)
-------------------------------------
template8="metric",
-------------------------------------
-- Locale (e.g. "es_ES.UTF-8")
-- Leave empty for default
-------------------------------------
template9="$LANG"
}
-------------------------------------
-------------------------------------
conky.text = [[
\
\
${execi 300 ~/.jelly-conky/get_weather ${template6} ${template7} ${template8} ${template9}}\
\
\
\
\
${font Roboto:size=64}${color0}\
${alignc}${time %H}\
\
\
\
\
${font Roboto:thin:size=64}${color1}:\
\
\
\
\
${font Roboto:thin:size=64}${color2}\
${time %M}${font}${color}
\
\
\
\
${font Noto Sans CJK JP:light:size=16}${color3}\
${voffset 12}${alignc}${execi 300 LANG=${template9} LC_TIME=${template9} date +"%A"}${color}, \
\
\
\
\
${font Noto Sans CJK JP:light:size=16}${color5}\
${alignc}${execi 300 LANG=${template9} LC_TIME=${template9} date +"%B"}${color} \
\
\
\
\
${font Noto Sans CJK JP:size=16}${color4}\
${alignc}${execi 300 LANG=${template9} LC_TIME=${template9} date +"%d"}${color}日
\
\
\
\
${font Roboto:light:size=24}${color6}\
${goto 70}${voffset 18}\
${execi 300 jq ".main.temp" ~/.cache/jelly-conky/weather.json | awk '{print int($1+0.5)}' # round num}°${font}${color}
\
\
\
\
${font Roboto:light:size=12}\
${goto 70}${voffset 5}\
${color7}${execi 300 ~/.jelly-conky/parse_weather 'avg' '.main.temp_min' '0'}° ${color}| \
${color8}${execi 300 ~/.jelly-conky/parse_weather 'avg' '.main.temp_max' '0'}°${font}${color}
\
\
\
\
${font Noto Sans CJK JP:light:size=12}${color9}\
${goto 70}${voffset 5}\
${execi 300 jq -r ".weather[0].description" ~/.cache/jelly-conky/weather.json}${font}${color}
\
\
\
\
${execi 300 cp -f ${template0}/$(jq .weather[0].id ~/.cache/jelly-conky/weather.json).png ~/.cache/jelly-conky/current.png}${image ~/.cache/jelly-conky/current.png -p 236,270 -s 128x128}\
]]

BIN
linux-hidpi/dconf/user
View File

Binary file not shown.

33
linux-hidpi/glava/bars.glsl Executable file
View File

@@ -0,0 +1,33 @@
/* Center line thickness (pixels) */
#define C_LINE 1
/* Width (in pixels) of each bar */
#define BAR_WIDTH 4
/* Width (in pixels) of each bar gap */
#define BAR_GAP 2
/* Outline color */
#define BAR_OUTLINE #262626
/* Outline width (in pixels, set to 0 to disable outline drawing) */
#define BAR_OUTLINE_WIDTH 0
/* Amplify magnitude of the results each bar displays */
#define AMPLIFY 300
/* Whether the current settings use the alpha channel;
enabling this is required for alpha to function
correctly on X11 with `"native"` transparency. */
#define USE_ALPHA 0
/* How strong the gradient changes */
#define GRADIENT_POWER 60
/* Bar color changes with height */
#define GRADIENT (d / GRADIENT_POWER + 1)
/* Bar color */
#define COLOR (#3366b2 * GRADIENT)
/* Direction that the bars are facing, 0 for inward, 1 for outward */
#define DIRECTION 0
/* Whether to switch left/right audio buffers */
#define INVERT 0
/* Whether to flip the output vertically */
#define FLIP 0
/* Whether to mirror output along `Y = X`, causing output to render on the left side of the window */
/* Use with `FLIP 1` to render on the right side */
#define MIRROR_YX 0

114
linux-hidpi/glava/bars/1.frag Normal file
View File

@@ -0,0 +1,114 @@
in vec4 gl_FragCoord;
#request uniform "screen" screen
uniform ivec2 screen;
#request uniform "audio_sz" audio_sz
uniform int audio_sz;
#include "@bars.glsl"
#include ":bars.glsl"
#request uniform "audio_l" audio_l
#request transform audio_l "window"
#request transform audio_l "fft"
#request transform audio_l "gravity"
#request transform audio_l "avg"
uniform sampler1D audio_l;
#request uniform "audio_r" audio_r
#request transform audio_r "window"
#request transform audio_r "fft"
#request transform audio_r "gravity"
#request transform audio_r "avg"
uniform sampler1D audio_r;
out vec4 fragment;
#include ":util/smooth.glsl"
#define TWOPI 6.28318530718
#define PI 3.14159265359
void main() {
#if MIRROR_YX == 0
#define AREA_WIDTH screen.x
#define AREA_HEIGHT screen.y
#define AREA_X gl_FragCoord.x
#define AREA_Y gl_FragCoord.y
#else
#define AREA_WIDTH screen.y
#define AREA_HEIGHT screen.x
#define AREA_X gl_FragCoord.y
#define AREA_Y gl_FragCoord.x
#endif
float dx = (AREA_X - (AREA_WIDTH / 2));
#if FLIP == 0
float d = AREA_Y;
#else
float d = AREA_HEIGHT - AREA_Y;
#endif
float section = BAR_WIDTH + BAR_GAP; /* size of section for each bar (including gap) */
float center = section / 2.0F; /* half section, distance to center */
float m = abs(mod(dx, section)); /* position in section */
float md = m - center; /* position in section from center line */
float nbars = floor((AREA_WIDTH * 0.5F) / section) * 2;
float p, s;
if (md < ceil(float(BAR_WIDTH) / 2) && md >= -floor(float(BAR_WIDTH) / 2)) { /* if not in gap */
s = dx / section;
p = (sign(s) == 1.0 ? ceil(s) : floor(s)) / float(nbars / 2); /* position, (-1.0F, 1.0F)) */
p += sign(p) * ((0.5F + center) / AREA_WIDTH); /* index center of bar position */
/* Apply smooth function and index texture */
#define smooth_f(tex, p) smooth_audio(tex, audio_sz, p)
float v;
/* ignore out of bounds values */
if (p > 1.0F || p < -1.0F) {
fragment = vec4(0, 0, 0, 0);
return;
}
/* handle user options and store result of indexing in 'v' */
if (p > 0.0F) {
#if DIRECTION == 1
p = 1.0F - p;
#endif
#if INVERT > 0
v = smooth_f(audio_l, p);
#else
v = smooth_f(audio_r, p);
#endif
} else {
p = abs(p);
#if DIRECTION == 1
p = 1.0F - p;
#endif
#if INVERT > 0
v = smooth_f(audio_r, p);
#else
v = smooth_f(audio_l, p);
#endif
}
#undef smooth_f
v *= AMPLIFY; /* amplify result */
if (d < v - BAR_OUTLINE_WIDTH) { /* if within range of the reported frequency, draw */
#if BAR_OUTLINE_WIDTH > 0
if (md < (BAR_WIDTH / 2) - BAR_OUTLINE_WIDTH)
fragment = COLOR;
else
fragment = BAR_OUTLINE;
#else
fragment = COLOR;
#endif
return;
}
#if BAR_OUTLINE_WIDTH > 0
if (d <= v) {
fragment = BAR_OUTLINE;
return;
}
#endif
}
fragment = vec4(0, 0, 0, 0); /* default frag color */
}

24
linux-hidpi/glava/circle.glsl Executable file
View File

@@ -0,0 +1,24 @@
/* center radius (pixels) */
#define C_RADIUS 128
/* center line thickness (pixels) */
#define C_LINE 1.5
/* outline color */
#define OUTLINE #333333
/* Amplify magnitude of the results each bar displays */
#define AMPLIFY 150
/* Angle (in radians) for how much to rotate the visualizer */
#define ROTATE (PI / 2)
/* Whether to switch left/right audio buffers */
#define INVERT 0
/* Whether to fill in the space between the line and inner circle */
#define C_FILL 0
/* Whether to apply a post-processing image smoothing effect
1 to enable, 0 to disable. Only works with `xroot` transparency,
and improves performance if disabled. */
#define C_SMOOTH 1
/* Gravity step, overrude frin `smooth_parameters.glsl` */
#request setgravitystep 6.0
/* Smoothing factor, override from `smooth_parameters.glsl` */
#request setsmoothfactor 0.01

84
linux-hidpi/glava/circle/1.frag Normal file
View File

@@ -0,0 +1,84 @@
layout(pixel_center_integer) in vec4 gl_FragCoord;
#request uniform "screen" screen
uniform ivec2 screen;
#request uniform "audio_sz" audio_sz
uniform int audio_sz;
#include ":util/smooth.glsl"
#include "@circle.glsl"
#include ":circle.glsl"
#request uniform "audio_l" audio_l
#request transform audio_l "window"
#request transform audio_l "fft"
#request transform audio_l "gravity"
#request transform audio_l "avg"
uniform sampler1D audio_l;
#request uniform "audio_r" audio_r
#request transform audio_r "window"
#request transform audio_r "fft"
#request transform audio_r "gravity"
#request transform audio_r "avg"
uniform sampler1D audio_r;
out vec4 fragment;
#define TWOPI 6.28318530718
#define PI 3.14159265359
/* This shader is based on radial.glsl, refer to it for more commentary */
float apply_smooth(float theta) {
float idx = theta + ROTATE;
float dir = mod(abs(idx), TWOPI);
if (dir > PI)
idx = -sign(idx) * (TWOPI - dir);
if (INVERT > 0)
idx = -idx;
float pos = abs(idx) / (PI + 0.001F);
#define smooth_f(tex) smooth_audio(tex, audio_sz, pos)
float v;
if (idx > 0) v = smooth_f(audio_l);
else v = smooth_f(audio_r);
v *= AMPLIFY;
#undef smooth_f
return v;
}
void main() {
fragment = vec4(0, 0, 0, 0);
float
dx = gl_FragCoord.x - (screen.x / 2),
dy = gl_FragCoord.y - (screen.y / 2);
float theta = atan(dy, dx);
float d = sqrt((dx * dx) + (dy * dy));
float adv = (1.0F / d) * (C_LINE * 0.5);
float
adj0 = theta + adv,
adj1 = theta - adv;
d -= C_RADIUS;
if (d >= -(float(C_LINE) / 2.0F)) {
float v = apply_smooth(theta);
adj0 = apply_smooth(adj0) - v;
adj1 = apply_smooth(adj1) - v;
float
dmax = max(adj0, adj1),
dmin = min(adj0, adj1);
d -= v;
#if C_FILL > 0
#define BOUNDS (d < (float(C_LINE) / 2.0F))
#else
#define BOUNDS (d > -(float(C_LINE) / 2.0F) && d < (float(C_LINE) / 2.0F)) || (d <= dmax && d >= dmin)
#endif
if (BOUNDS) {
fragment = OUTLINE;
}
}
}

33
linux-hidpi/glava/circle/2.frag Normal file
View File

@@ -0,0 +1,33 @@
in vec4 gl_FragCoord;
#request uniform "prev" tex
uniform sampler2D tex; /* screen texture */
out vec4 fragment; /* output */
#include "@circle.glsl"
#include ":circle.glsl"
void main() {
fragment = texelFetch(tex, ivec2(gl_FragCoord.x, gl_FragCoord.y), 0);
#if C_SMOOTH > 0
#if USE_ALPHA
vec4
a0 = texelFetch(tex, ivec2((gl_FragCoord.x + 1), (gl_FragCoord.y + 0)), 0),
a1 = texelFetch(tex, ivec2((gl_FragCoord.x + 1), (gl_FragCoord.y + 1)), 0),
a2 = texelFetch(tex, ivec2((gl_FragCoord.x + 0), (gl_FragCoord.y + 1)), 0),
a3 = texelFetch(tex, ivec2((gl_FragCoord.x + 1), (gl_FragCoord.y + 0)), 0),
a4 = texelFetch(tex, ivec2((gl_FragCoord.x - 1), (gl_FragCoord.y - 0)), 0),
a5 = texelFetch(tex, ivec2((gl_FragCoord.x - 1), (gl_FragCoord.y - 1)), 0),
a6 = texelFetch(tex, ivec2((gl_FragCoord.x - 0), (gl_FragCoord.y - 1)), 0),
a7 = texelFetch(tex, ivec2((gl_FragCoord.x - 1), (gl_FragCoord.y - 0)), 0);
vec4 avg = (a0 + a1 + a2 + a3 + a4 + a5 + a6 + a7) / 8.0;
if (fragment.a == 0) {
fragment = avg;
}
#endif
#endif
}

1
linux-hidpi/glava/circle/3.frag Normal file
View File

@@ -0,0 +1 @@
#include ":util/premultiply.frag"

8
linux-hidpi/glava/env_KWin.glsl Executable file
View File

@@ -0,0 +1,8 @@
#request setdecorated false
#request setxwintype "normal"
#request addxwinstate "below"
#request addxwinstate "skip_taskbar"
#request addxwinstate "skip_pager"
#request addxwinstate "pinned"
#request setclickthrough true

2
linux-hidpi/glava/env_Openbox.glsl Executable file
View File

@@ -0,0 +1,2 @@
#request setxwintype "desktop"
#request addxwinstate "pinned"

3
linux-hidpi/glava/env_Xfwm4.glsl Executable file
View File

@@ -0,0 +1,3 @@
#request setxwintype "desktop"
#request addxwinstate "pinned"
#request addxwinstate "below"

1
linux-hidpi/glava/env_awesome.glsl Executable file
View File

@@ -0,0 +1 @@
#request setxwintype "!-"

1
linux-hidpi/glava/env_default.glsl Executable file
View File

@@ -0,0 +1 @@
#request setxwintype "desktop"

1
linux-hidpi/glava/env_i3.glsl Executable file
View File

@@ -0,0 +1 @@
#request setxwintype "!-"

31
linux-hidpi/glava/graph.glsl Executable file
View File

@@ -0,0 +1,31 @@
/* Vertical scale, larger values will amplify output */
#define VSCALE 300
/* Rendering direction, either -1 (outwards) or 1 (inwards). */
#define DIRECTION 1
/* Color gradient scale, (optionally) used in `COLOR` macro */
#define GRADIENT_SCALE 75
/* Color definition. By default this is a gradient formed by mixing two colors.
`pos` represents the pixel position relative to the visualizer baseline. */
#define COLOR mix(#802A2A, #4F4F92, clamp(pos / GRADIENT_SCALE, 0, 1))
/* 1 to draw outline, 0 to disable */
#define DRAW_OUTLINE 0
/* 1 to draw edge highlight, 0 to disable */
#define DRAW_HIGHLIGHT 1
/* Whether to anti-alias the border of the graph, creating a smoother curve.
This may have a small impact on performance.
Note: requires `xroot` or `none` opacity to be set */
#define ANTI_ALIAS 0
/* outline color */
#define OUTLINE #262626
/* 1 to join the two channels together in the middle, 0 to clamp both down to zero */
#define JOIN_CHANNELS 0
/* 1 to invert (vertically), 0 otherwise */
#define INVERT 0
/* Gravity step, overrude from `smooth_parameters.glsl` */
#request setgravitystep 2.4
/* Smoothing factor, override from `smooth_parameters.glsl` */
#request setsmoothfactor 0.015

132
linux-hidpi/glava/graph/1.frag Normal file
View File

@@ -0,0 +1,132 @@
layout(pixel_center_integer) in vec4 gl_FragCoord;
#request uniform "screen" screen
uniform ivec2 screen; /* screen dimensions */
#request uniform "audio_sz" audio_sz
uniform int audio_sz;
/* When we transform our audio, we need to go through the following steps:
transform -> "window"
First, apply a window function to taper off the ends of the spectrum, helping
avoid artifacts in the FFT output.
transform -> "fft"
Apply the Fast Fourier Transform algorithm to separate raw audio data (waves)
into their respective spectrums.
transform -> "fft"
As part of the FFT process, we return spectrum magnitude on a log(n) scale,
as this is how the (decibel) dB scale functions.
transform -> "gravity"
To help make our data more pleasing to look at, we apply our data received over
time to a buffer, taking the max of either the existing value in the buffer or
the data from the input. We then reduce the data by the 'gravity step', and
return the storage buffer.
This makes frequent and abrupt changes in frequency less distracting, and keeps
short frequency responses on the screen longer.
transform -> "avg"
As a final step, we take the average of several data frames (specified by
'setavgframes') and return the result to further help smooth the resulting
animation. In order to mitigate abrupt changes to the average, the values
at each end of the average buffer can be weighted less with a window function
(the same window function used at the start of this step!). It can be disabled
with 'setavgwindow'.
*/
#include ":util/smooth.glsl"
#include "@graph.glsl"
#include ":graph.glsl"
#request uniform "audio_l" audio_l
#request transform audio_l "window"
#request transform audio_l "fft"
#request transform audio_l "gravity"
#request transform audio_l "avg"
uniform sampler1D audio_l;
#request uniform "audio_r" audio_r
#request transform audio_r "window"
#request transform audio_r "fft"
#request transform audio_r "gravity"
#request transform audio_r "avg"
uniform sampler1D audio_r;
out vec4 fragment;
/* distance from center */
#define CDIST (abs((screen.x / 2) - gl_FragCoord.x) / screen.x)
/* distance from sides (far) */
#define FDIST (min(gl_FragCoord.x, screen.x - gl_FragCoord.x) / screen.x)
#if DIRECTION < 0
#define LEFT_IDX (gl_FragCoord.x)
#define RIGHT_IDX (-gl_FragCoord.x + screen.x)
/* distance from base frequencies */
#define BDIST FDIST
/* distance from high frequencies */
#define HDIST CDIST
#else
#define LEFT_IDX (half_w - gl_FragCoord.x)
#define RIGHT_IDX (gl_FragCoord.x - half_w)
#define BDIST CDIST
#define HDIST FDIST
#endif
#define TWOPI 6.28318530718
float half_w;
float middle;
highp float pixel = 1.0F / float(screen.x);
float get_line_height(in sampler1D tex, float idx) {
float s = smooth_audio_adj(tex, audio_sz, idx / half_w, pixel);
/* scale the data upwards so we can see it */
s *= VSCALE;
/* clamp far ends of the screen down to make the ends of the graph smoother */
float fact = clamp((abs((screen.x / 2) - gl_FragCoord.x) / screen.x) * 48, 0.0F, 1.0F);
#if JOIN_CHANNELS > 0
fact = -2 * pow(fact, 3) + 3 * pow(fact, 2); /* To avoid spikes */
s = fact * s + (1 - fact) * middle;
#else
s *= fact;
#endif
s *= clamp((min(gl_FragCoord.x, screen.x - gl_FragCoord.x) / screen.x) * 48, 0.0F, 1.0F);
return s;
}
void render_side(in sampler1D tex, float idx) {
float s = get_line_height(tex, idx);
/* and finally set fragment color if we are in range */
#if INVERT > 0
float pos = float(screen.y) - gl_FragCoord.y;
#else
float pos = gl_FragCoord.y;
#endif
if (pos + 1.5 <= s) {
fragment = COLOR;
} else {
fragment = vec4(0, 0, 0, 0);
}
}
void main() {
half_w = (screen.x / 2);
middle = VSCALE * (smooth_audio_adj(audio_l, audio_sz, 1, pixel) + smooth_audio_adj(audio_r, audio_sz, 0, pixel)) / 2;
if (gl_FragCoord.x < half_w) {
render_side(audio_l, LEFT_IDX);
} else {
render_side(audio_r, RIGHT_IDX);
}
}

44
linux-hidpi/glava/graph/2.frag Normal file
View File

@@ -0,0 +1,44 @@
in vec4 gl_FragCoord;
#request uniform "prev" tex
uniform sampler2D tex; /* screen texture */
out vec4 fragment; /* output */
#include "@graph.glsl"
#include ":graph.glsl"
#if DRAW_OUTLINE == 0 && DRAW_HIGHLIGHT == 0
#error __disablestage
#endif
void main() {
fragment = texelFetch(tex, ivec2(gl_FragCoord.x, gl_FragCoord.y), 0);
vec4
a0 = texelFetch(tex, ivec2((gl_FragCoord.x + 1), (gl_FragCoord.y + 0)), 0),
a1 = texelFetch(tex, ivec2((gl_FragCoord.x + 1), (gl_FragCoord.y + 1)), 0),
a2 = texelFetch(tex, ivec2((gl_FragCoord.x + 0), (gl_FragCoord.y + 1)), 0),
a3 = texelFetch(tex, ivec2((gl_FragCoord.x + 1), (gl_FragCoord.y + 0)), 0),
a4 = texelFetch(tex, ivec2((gl_FragCoord.x - 1), (gl_FragCoord.y - 0)), 0),
a5 = texelFetch(tex, ivec2((gl_FragCoord.x - 1), (gl_FragCoord.y - 1)), 0),
a6 = texelFetch(tex, ivec2((gl_FragCoord.x - 0), (gl_FragCoord.y - 1)), 0),
a7 = texelFetch(tex, ivec2((gl_FragCoord.x - 1), (gl_FragCoord.y - 0)), 0);
vec4 avg = (a0 + a1 + a2 + a3 + a4 + a5 + a6 + a7) / 8.0;
if (avg.a > 0){
if (fragment.a <= 0) {
/* outline */
#if DRAW_OUTLINE > 0
fragment = OUTLINE;
#endif
} else if (avg.a < 1) {
/* creates a highlight along the edge of the spectrum */
#if DRAW_HIGHLIGHT > 0
fragment.rgb *= avg.a * 2;
#endif
}
}
}

104
linux-hidpi/glava/graph/3.frag Normal file
View File

@@ -0,0 +1,104 @@
in vec4 gl_FragCoord;
#request uniform "screen" screen
uniform ivec2 screen; /* screen dimensions */
#request uniform "prev" tex
uniform sampler2D tex; /* screen texture */
out vec4 fragment; /* output */
#include "@graph.glsl"
#include ":graph.glsl"
#if ANTI_ALIAS == 0
#error __disablestage
#endif
/* Moves toward the border of the graph, gives the
y coordinate of the last colored pixel */
float get_col_height_up(float x, float oy) {
float y = oy;
#if INVERT > 0
while (y >= 0) {
#else
while (y < screen.y) {
#endif
vec4 f = texelFetch(tex, ivec2(x, y), 0);
if (f.a <= 0) {
#if INVERT > 0
y += 1;
#else
y -= 1;
#endif
break;
}
#if INVERT > 0
y -= 1;
#else
y += 1;
#endif
}
return y;
}
/* Moves toward the base of the graph, gives the
y coordinate of the first colored pixel */
float get_col_height_down(float x, float oy) {
float y = oy;
#if INVERT > 0
while (y < screen.y) {
#else
while (y >= 0) {
#endif
vec4 f = texelFetch(tex, ivec2(x, y), 0);
if (f.a > 0) {
break;
}
#if INVERT > 0
y += 1;
#else
y -= 1;
#endif
}
return y;
}
void main() {
fragment = texelFetch(tex, ivec2(gl_FragCoord.x, gl_FragCoord.y), 0);
#if ANTI_ALIAS > 0
if (fragment.a <= 0) {
bool left_done = false;
float h2;
float a_fact = 0;
if (texelFetch(tex, ivec2(gl_FragCoord.x - 1, gl_FragCoord.y), 0).a > 0) {
float h1 = get_col_height_up(gl_FragCoord.x - 1, gl_FragCoord.y);
h2 = get_col_height_down(gl_FragCoord.x, gl_FragCoord.y);
fragment = texelFetch(tex, ivec2(gl_FragCoord.x, h2), 0);
a_fact = clamp(abs((h1 - gl_FragCoord.y) / (h2 - h1)), 0.0, 1.0);
left_done = true;
}
if (texelFetch(tex, ivec2(gl_FragCoord.x + 1, gl_FragCoord.y), 0).a > 0) {
if (!left_done) {
h2 = get_col_height_down(gl_FragCoord.x, gl_FragCoord.y);
fragment = texelFetch(tex, ivec2(gl_FragCoord.x, h2), 0);
}
float h3 = get_col_height_up(gl_FragCoord.x + 1, gl_FragCoord.y);
a_fact = max(a_fact, clamp(abs((h3 - gl_FragCoord.y) / (h2 - h3)), 0.0, 1.0));
}
fragment.a *= a_fact;
}
#endif
}

39
linux-hidpi/glava/radial.glsl Executable file
View File

@@ -0,0 +1,39 @@
/* center radius (pixels) */
#define C_RADIUS 720
/* center line thickness (pixels) */
#define C_LINE 0
/* outline color */
#define OUTLINE #ffffff
/* number of bars (use even values for best results) */
#define NBARS 360
/* width (in pixels) of each bar*/
#define BAR_WIDTH 8
/* outline color */
#define BAR_OUTLINE OUTLINE
/* outline width (in pixels, set to 0 to disable outline drawing) */
#define BAR_OUTLINE_WIDTH 0
/* Amplify magnitude of the results each bar displays */
#define AMPLIFY 200
/* Bar color */
#define COLOR #ffffff
/* Angle (in radians) for how much to rotate the visualizer */
#define ROTATE (PI / 2)
/* Whether to switch left/right audio buffers */
#define INVERT 0
/* Aliasing factors. Higher values mean more defined and jagged lines.
Note: aliasing does not have a notable impact on performance, but requires
`xroot` transparency to be enabled since it relies on alpha blending with
the background. */
#define BAR_ALIAS_FACTOR 1.2
#define C_ALIAS_FACTOR 1.8
/* Offset (Y) of the visualization */
#define CENTER_OFFSET_Y 0
/* Offset (X) of the visualization */
#define CENTER_OFFSET_X 0
/* Gravity step, override from `smooth_parameters.glsl` */
#request setgravitystep 5.0
/* Smoothing factor, override from `smooth_parameters.glsl` */
#request setsmoothfactor 0.02

115
linux-hidpi/glava/radial/1.frag Normal file
View File

@@ -0,0 +1,115 @@
in vec4 gl_FragCoord;
#request uniform "screen" screen
uniform ivec2 screen;
#request uniform "audio_sz" audio_sz
uniform int audio_sz;
#include ":util/smooth.glsl"
#include "@radial.glsl"
#include ":radial.glsl"
#request uniform "audio_l" audio_l
#request transform audio_l "window"
#request transform audio_l "fft"
#request transform audio_l "gravity"
#request transform audio_l "avg"
uniform sampler1D audio_l;
#request uniform "audio_r" audio_r
#request transform audio_r "window"
#request transform audio_r "fft"
#request transform audio_r "gravity"
#request transform audio_r "avg"
uniform sampler1D audio_r;
out vec4 fragment;
#define TWOPI 6.28318530718
#define PI 3.14159265359
void main() {
#if USE_ALPHA > 0
#define APPLY_FRAG(f, c) f = vec4(f.rgb * f.a + c.rgb * (1 - clamp(f.a, 0, 1)), max(c.a, f.a))
fragment = #00000000;
#else
#define APPLY_FRAG(f, c) f = c
#endif
/* To handle jagged edges, we alias in the shader by using alpha layer blending.
Alpha layer blending is only applied when `xroot` transparency is enabled. */
float /* translate (x, y) to use (0, 0) as the center of the screen */
dx = gl_FragCoord.x - (screen.x / 2) + CENTER_OFFSET_X,
dy = gl_FragCoord.y - (screen.y / 2) + CENTER_OFFSET_Y;
float theta = atan(dy, dx); /* fragment angle with the center of the screen as the origin */
float d = sqrt((dx * dx) + (dy * dy)); /* distance */
if (d > C_RADIUS - (float(C_LINE) / 2.0F) && d < C_RADIUS + (float(C_LINE) / 2.0F)) {
APPLY_FRAG(fragment, OUTLINE);
#if USE_ALPHA > 0
fragment.a *= clamp(((C_LINE / 2) - abs(C_RADIUS - d)) * C_ALIAS_FACTOR, 0, 1);
#else
return; /* return immediately if there is no alpha blending available */
#endif
}
if (d > C_RADIUS) {
const float section = (TWOPI / NBARS); /* range (radians) for each bar */
const float center = ((TWOPI / NBARS) / 2.0F); /* center line angle */
float m = mod(theta, section); /* position in section (radians) */
float ym = d * sin(center - m); /* distance from center line (cartesian coords) */
if (abs(ym) < BAR_WIDTH / 2) { /* if within width, draw audio */
float idx = theta + ROTATE; /* position (radians) in texture */
float dir = mod(abs(idx), TWOPI); /* absolute position, [0, 2pi) */
if (dir > PI)
idx = -sign(idx) * (TWOPI - dir); /* Re-correct position values to [-pi, pi) */
if (INVERT > 0)
idx = -idx; /* Invert if needed */
float pos = int(abs(idx) / section) / float(NBARS / 2); /* bar position, [0, 1) */
#define smooth_f(tex) smooth_audio(tex, audio_sz, pos) /* smooth function format */
float v;
if (idx > 0) v = smooth_f(audio_l); /* left buffer */
else v = smooth_f(audio_r); /* right buffer */
v *= AMPLIFY; /* amplify */
#undef smooth_f
/* offset to fragment distance from inner circle */
#if USE_ALPHA > 0
#define ALIAS_FACTOR (((BAR_WIDTH / 2) - abs(ym)) * BAR_ALIAS_FACTOR)
d -= C_RADIUS; /* start bar overlapping the inner circle for blending */
#else
#define ALIAS_FACTOR 1
d -= C_RADIUS + (float(C_LINE) / 2.0F); /* start bar after circle */
#endif
if (d <= v - BAR_OUTLINE_WIDTH) {
vec4 r;
#if BAR_OUTLINE_WIDTH > 0
if (abs(ym) < (BAR_WIDTH / 2) - BAR_OUTLINE_WIDTH)
r = COLOR;
else
r = BAR_OUTLINE;
#else
r = COLOR;
#endif
#if USE_ALPHA > 0
r.a *= ALIAS_FACTOR;
#endif
APPLY_FRAG(fragment, r);
return;
}
#if BAR_OUTLINE_WIDTH > 0
if (d <= v) {
#if USE_ALPHA > 0
vec4 r = BAR_OUTLINE;
r.a *= ALIAS_FACTOR;
APPLY_FRAG(fragment, r);
#else
APPLY_FRAG(fragment, BAR_OUTLINE);
#endif
return;
}
#endif
}
}
fragment = APPLY_FRAG(fragment, vec4(0, 0, 0, 0)); /* default frag color */
}

1
linux-hidpi/glava/radial/2.frag Normal file
View File

@@ -0,0 +1 @@
#include ":util/premultiply.frag"

227
linux-hidpi/glava/rc.glsl Executable file
View File

@@ -0,0 +1,227 @@
/* The module to use. A module is a set of shaders used to produce
the visualizer. The structure for a module is the following:
module_name [directory]
1.frag [file: fragment shader],
2.frag [file: fragment shader],
...
Shaders are loaded in numerical order, starting at '1.frag',
continuing indefinitely. The results of each shader (except
for the final pass) is given to the next shader in the list
as a 2D sampler.
See documentation for more details. */
#request mod radial
/* Window hints */
#request setfloating false
#request setdecorated true
#request setfocused false
#request setmaximized false
/* Set window background opacity mode. Possible values are:
"native" - True transparency provided by the compositor. Can
reduce performance on some systems, depending on
the compositor used.
"xroot" - Maintain a copy of the root window's pixmap
(usually the desktop background) to provide a
pseudo-transparent effect. Useful when no compositor
is available or native transparency isn't nessecary.
Has very little performance impact.
"none" - Disable window opacity completely. */
#request setopacity "native"
/* Whether to mirror left and right audio input channels from PulseAudio.*/
#request setmirror false
/* OpenGL context and GLSL shader versions, do not change unless
you *absolutely* know what you are doing. */
#request setversion 3 3
#request setshaderversion 330
/* Window title */
#request settitle "GLava"
/* Window geometry (x, y, width, height) */
#request setgeometry 0 0 2880 1800
/* Window background color (RGB format).
Does not work with `setopacity "xroot"` */
#request setbg 00000000
/* (X11 only) EWMH Window type. Possible values are:
"desktop", "dock", "toolbar", "menu",
"utility", "splash", "dialog", "normal"
This will set _NET_WM_WINDOW_TYPE to _NET_WM_WINDOW_TYPE_(TYPE),
where (TYPE) is the one of the window types listed (after being
converted to uppercase).
Alternatively, you can set this value to "!", which will cause
the window to be unmanaged. If this is set, then `addxwinstate`
will do nothing, but you can use "!+" and "!-" to stack on top
or below other windows.
*/
#request setxwintype "normal"
/* (X11 only) EWMH Window state atoms (multiple can be specified).
Possible values are:
"modal", "sticky", "maximized_vert", "maximized_horz",
"shaded", "skip_taskbar", "skip_pager", "hidden", "fullscreen",
"above", "below", "demands_attention", "focused", "pinned"
This will add _NET_WM_STATE_(TYPE) atoms to _NET_WM_STATE,
where (TYPE) is one of the window states listed (after being
converted to uppercase).
The lines below (commented out by default) are of relevance
if you are trying to get GLava to behave as a desktop widget
and your WM is not correctly responding to the "desktop" value
for `setxwintype`.
*/
// #request addxwinstate "sticky"
// #request addxwinstate "skip_taskbar"
// #request addxwinstate "skip_pager"
// #request addxwinstate "above"
// #request addxwinstate "pinned"
/* (X11 only) Use the XShape extension to support clicking through
the GLava window. Useful when you want to interact with other
desktop windows (icons, menus, desktop shells). Enabled by
default when GLava itself is a desktop window. */
#request setclickthrough false
/* Audio source
When the "pulseaudio" backend is set, this can be a number or
a name of an audio sink or device to record from. Set to "auto"
to use the default output device.
When the "fifo" backend is set, "auto" is interpreted as
"/tmp/mpd.fifo". Otherwise, a valid path should be provided. */
#request setsource "auto"
/* Buffer swap interval (vsync), set to '0' to prevent
waiting for refresh, '1' (or more) to wait for the specified
amount of frames. */
#request setswap 1
/* Linear interpolation for audio data frames. Drastically
improves smoothness with configurations that yield low UPS
(`setsamplerate` and `setsamplesize`), or monitors that have
high refresh rates.
This feature itself, however, will effect performance as it
will have to interpolate data every frame on the CPU. It will
automatically (and temporarily) disable itself if the update
rate is close to, or higher than the framerate:
if (update_rate / frame_rate > 0.9) disable_interpolation;
This will delay data output by one update frame, so it can
desync audio with visual effects on low UPS configs. */
#request setinterpolate true
/* Frame limiter, set to the frames per second (FPS) desired or
simply set to zero (or lower) to disable the frame limiter. */
#request setframerate 0
/* Suspends rendering if a fullscreen window is focused while
GLava is still visible (ie. on another monitor). This prevents
rendering from interfering with other graphically intensive
tasks.
If GLava is minimized or completely obscured, it will not
render regardless of this option. */
#request setfullscreencheck false
/* Enable/disable printing framerate every second. 'FPS' stands
for 'Frames Per Second', and 'UPS' stands for 'Updates Per
Second'. Updates are performed when new data is submitted
by pulseaudio, and require transformations to be re-applied
(thus being a good measure of how much work your CPU has to
perform over time) */
#request setprintframes true
/* PulseAudio sample buffer size. Lower values result in more
frequent audio updates (also depends on sampling rate), but
will also require all transformations to be applied much
more frequently (CPU intensive).
High (>2048, with 22050 Hz) values will decrease accuracy
(as some signals can be missed by transformations like FFT)
The following settings (@22050 Hz) produce the listed rates:
Sample UPS Description
- 2048 -> 43.0 (low accuracy, cheap), use with < 60 FPS
- 1024 -> 86.1 (high accuracy, expensive), use with >= 60 FPS
- 512 -> 172.3 (extreme accuracy, very expensive), use only
for graphing accurate spectrum data with
custom modules.
If the framerate drops below the update rate, the update rate
will be locked to the framerate (to prevent wasting CPU time).
This behaviour means you can use a 1024 sample size on a 60Hz
monitor with vsync enabled to get 60FPS and 60UPS.
For high refresh rate monitors (120+ Hz), it's recommended to
also stick with the 1024 sample size and use interpolation to
smooth the data, as accuracy beyond this setting is mostly
meaningless for visual purposes.
*/
#request setsamplesize 1024
/* Audio buffer size to be used for processing and shaders.
Increasing this value can have the effect of adding 'gravity'
to FFT output, as the audio signal will remain in the buffer
longer.
This value has a _massive_ effect on FFT performance and
quality for some modules. */
#request setbufsize 4096
/* PulseAudio sample rate. Lower values can add 'gravity' to
FFT output, but can also reduce accuracy. Most hardware
samples at 44100Hz.
Lower sample rates also can make output more choppy, when
not using interpolation. It's generally OK to leave this
value unless you have a strange PulseAudio configuration.
This option does nothing when using the "fifo" audio
backend. Instead, an ideal rate should be be configured
in the application generating the output. */
#request setsamplerate 22050
/* ** DEPRECATED **
Force window geometry (locking the window in place), useful
for some pesky WMs that try to reposition the window when
embedding in the desktop.
This routinely sends X11 events and should be avoided. */
#request setforcegeometry false
/* ** DEPRECATED **
Force window to be raised (focused in some WMs), useful for
WMs that have their own stacking order for desktop windows.
This routinely sends X11 events and should be avoided. */
#request setforceraised false
/* ** DEPRECATED **
Scale down the audio buffer before any operations are
performed on the data. Higher values are faster.
This value can affect the output of various transformations,
since it applies (crude) averaging to the data when shrinking
the buffer. It is reccommended to use `setsamplerate` and
`setsamplesize` to improve performance or accuracy instead. */
#request setbufscale 1

78
linux-hidpi/glava/smooth_parameters.glsl Executable file
View File

@@ -0,0 +1,78 @@
/* Settings for smoothing functions and transformations commonly
used to display FFT output.
IMPORTANT: THESE VALUES CAN BE OVERRIDDEN IN MODULE CONFIG
FILES, IF CHANGING VALUES HERE DOES NOT WORK, CHECK
TO MAKE SURE THEY ARE NOT BEING SET ELSEWHERE.
*/
/* The type of formula to use for weighting values when smoothing.
Possible values:
- circular heavily rounded points
- sinusoidal rounded at both low and high weighted values
like a sine wave
- linear not rounded at all; linear distance
*/
#define ROUND_FORMULA sinusoidal
/* The sampling mode for processing raw FFT input:
- average averages all the inputs in the sample range for
a given point. Produces smooth output, but peaks
are not well represented
- maximum obtains the best value from the closest peak in
the sample range. Very accurate peaks, but
output is jagged and sporadic.
- hybrid uses the results from both `average` and `maximum`
with the weight provided in `SAMPLE_HYBRID_WEIGHT` */
#define SAMPLE_MODE average
/* Weight should be provided in the range (0, 1). Higher values favour
averaged results. `hybrid` mode only. */
#define SAMPLE_HYBRID_WEIGHT 0.65
/* Factor used to scale frequencies. Lower values allows lower
frequencies to occupy more space. */
#define SAMPLE_SCALE 8
/* The frequency range to sample. 1.0 would be the entire FFT output,
and lower values reduce the displayed frequencies in a log-like
scale. */
#define SAMPLE_RANGE 0.9
/* Factor for how to scale higher frequencies. Used in a linear equation
which is multiplied by the result of the fft transformation. */
#request setfftscale 10.2
/* Cutoff for the bass end of the audio data when scaling frequencies.
Higher values cause more of the bass frequencies to be skipped when
scaling. */
#request setfftcutoff 0.3
/* How many frames to queue and run through the average function.
Increasing this value will create latency between the audio and the
animation, but will make for much smoother results. */
#request setavgframes 6
/* Whether to window frames ran through the average function (new & old
frames are weighted less). This massively helps smoothing out
spontaneous values in the animation. */
#request setavgwindow true
/* Gravity step, higher values means faster drops. The step is applied
in a rate independant method like so:
val -= (gravitystep) * (seconds per update) */
#request setgravitystep 4.2
/* Smoothing factor. Larger values mean more smoothing in the output,
however high values can be expensive to compute. Values are in
normalized width: [0.0, 1.0) */
#request setsmoothfactor 0.025
/* Whether to use a separate pass for audio data while smoothing. On
most hardware, this will improve performance, but involves doing a
separate render step for each audio texture and will add some driver
(CPU) overhead. */
#request setsmoothpass true

17
linux-hidpi/glava/util/premultiply.frag Normal file
View File

@@ -0,0 +1,17 @@
#if PREMULTIPLY_ALPHA == 0
#error __disablestage
#endif
#request uniform "prev" tex
uniform sampler2D tex;
out vec4 fragment;
in vec4 gl_FragCoord;
void main() {
fragment = texelFetch(tex, ivec2(gl_FragCoord.x, gl_FragCoord.y), 0);
#if PREMULTIPLY_ALPHA > 0
fragment.rgb *= fragment.a;
#endif
}

97
linux-hidpi/glava/util/smooth.glsl Normal file
View File

@@ -0,0 +1,97 @@
#ifndef _SMOOTH_GLSL /* include gaurd */
#define _SMOOTH_GLSL
#ifndef TWOPI
#define TWOPI 6.28318530718
#endif
#ifndef PI
#define PI 3.14159265359
#endif
#include "@smooth_parameters.glsl"
#include ":smooth_parameters.glsl"
/* window value t that resides in range [0, sz)*/
#define window(t, sz) (0.53836 - (0.46164 * cos(TWOPI * t / (sz - 1))))
/* this does nothing, but we keep it as an option for config */
#define linear(x) (x)
/* take value x that scales linearly between [0, 1) and return its sinusoidal curve */
#define sinusoidal(x) ((0.5 * sin((PI * (x)) - (PI / 2))) + 0.5)
/* take value x that scales linearly between [0, 1) and return its circlar curve */
#define circular(x) sqrt(1 - (((x) - 1) * ((x) - 1)))
#define average 0
#define maximum 1
#define hybrid 2
float scale_audio(float idx) {
return -log((-(SAMPLE_RANGE) * idx) + 1) / (SAMPLE_SCALE);
}
float iscale_audio(float idx) {
return -log((SAMPLE_RANGE) * idx) / (SAMPLE_SCALE);
}
/* Note: the SMOOTH_FACTOR macro is defined by GLava itself, from `#request setsmoothfactor`*/
float smooth_audio(in sampler1D tex, int tex_sz, highp float idx) {
#if PRE_SMOOTHED_AUDIO < 1
float
smin = scale_audio(clamp(idx - SMOOTH_FACTOR, 0, 1)) * tex_sz,
smax = scale_audio(clamp(idx + SMOOTH_FACTOR, 0, 1)) * tex_sz;
float m = ((smax - smin) / 2.0F), s, w;
float rm = smin + m; /* middle */
#if SAMPLE_MODE == average
float avg = 0, weight = 0;
for (s = smin; s <= smax; s += 1.0F) {
w = ROUND_FORMULA(clamp((m - abs(rm - s)) / m, 0, 1));
weight += w;
avg += texelFetch(tex, int(round(s)), 0).r * w;
}
avg /= weight;
return avg;
#elif SAMPLE_MODE == hybrid
float vmax = 0, avg = 0, weight = 0, v;
for (s = smin; s < smax; s += 1.0F) {
w = ROUND_FORMULA(clamp((m - abs(rm - s)) / m, 0, 1));
weight += w;
v = texelFetch(tex, int(round(s)), 0).r * w;
avg += v;
if (vmax < v)
vmax = v;
}
return (vmax * (1 - SAMPLE_HYBRID_WEIGHT)) + ((avg / weight) * SAMPLE_HYBRID_WEIGHT);
#elif SAMPLE_MODE == maximum
float vmax = 0, v;
for (s = smin; s < smax; s += 1.0F) {
w = texelFetch(tex, int(round(s)), 0).r * ROUND_FORMULA(clamp((m - abs(rm - s)) / m, 0, 1));
if (vmax < w)
vmax = w;
}
return vmax;
#endif
#else
return texelFetch(tex, int(round(idx * tex_sz)), 0).r;
#endif
}
/* Applies the audio smooth sampling function three times to the adjacent values */
float smooth_audio_adj(in sampler1D tex, int tex_sz, highp float idx, highp float pixel) {
float
al = smooth_audio(tex, tex_sz, max(idx - pixel, 0.0F)),
am = smooth_audio(tex, tex_sz, idx),
ar = smooth_audio(tex, tex_sz, min(idx + pixel, 1.0F));
return (al + am + ar) / 3.0F;
}
#ifdef TWOPI
#undef TWOPI
#endif
#ifdef PI
#undef PI
#endif
#endif /* _SMOOTH_GLSL */

16
linux-hidpi/glava/util/smooth_pass.frag Normal file
View File

@@ -0,0 +1,16 @@
uniform sampler1D tex;
uniform int sz;
uniform int w;
out vec4 fragment;
in vec4 gl_FragCoord;
#undef PRE_SMOOTHED_AUDIO
#define PRE_SMOOTHED_AUDIO 0
#include ":util/smooth.glsl"
void main() {
fragment = vec4(smooth_audio(tex, sz, gl_FragCoord.x / w), 0, 0, 0);
}

14
linux-hidpi/glava/wave.glsl Executable file
View File

@@ -0,0 +1,14 @@
/* min (vertical) line thickness */
#define MIN_THICKNESS 1
/* max (vertical) line thickness */
#define MAX_THICKNESS 6
/* base color to use, distance from center will multiply the RGB components */
#define BASE_COLOR vec4(0.7, 0.2, 0.45, 1)
/* amplitude */
#define AMPLIFY 500
/* outline color */
#define OUTLINE vec4(0.15, 0.15, 0.15, 1)

39
linux-hidpi/glava/wave/1.frag Normal file
View File

@@ -0,0 +1,39 @@
layout(pixel_center_integer) in vec4 gl_FragCoord;
#request uniform "screen" screen
uniform ivec2 screen; /* screen dimensions */
#request uniform "audio_l" audio_l
#request transform audio_l "window"
#request transform audio_l "wrange"
uniform sampler1D audio_l;
out vec4 fragment;
#include "@wave.glsl"
#include ":wave.glsl"
#define index(offset) ((texture(audio_l, (gl_FragCoord.x + offset) / screen.x).r - 0.5) * AMPLIFY) + 0.5F
void main() {
float
os = index(0),
adj0 = index(-1),
adj1 = index(1);
float
s0 = adj0 - os,
s1 = adj1 - os;
float
dmax = max(s0, s1),
dmin = min(s0, s1);
float s = (os + (screen.y * 0.5F) - 0.5F); /* center to screen coords */
float diff = gl_FragCoord.y - s;
if (abs(diff) < clamp(abs(s - (screen.y * 0.5)) * 6, MIN_THICKNESS, MAX_THICKNESS)
|| (diff <= dmax && diff >= dmin)) {
fragment = BASE_COLOR + (abs((screen.y * 0.5F) - s) * 0.02);
} else {
fragment = vec4(0, 0, 0, 0);
}
}

33
linux-hidpi/glava/wave/2.frag Normal file
View File

@@ -0,0 +1,33 @@
layout(pixel_center_integer) in vec4 gl_FragCoord;
#request uniform "prev" tex
uniform sampler2D tex; /* screen texture */
#request uniform "screen" screen
uniform ivec2 screen; /* screen dimensions */
out vec4 fragment; /* output */
#include "@wave.glsl"
#include ":wave.glsl"
void main() {
fragment = texelFetch(tex, ivec2(gl_FragCoord.x, gl_FragCoord.y), 0);
vec4
a0 = texelFetch(tex, ivec2((gl_FragCoord.x + 1), (gl_FragCoord.y + 0)), 0),
a1 = texelFetch(tex, ivec2((gl_FragCoord.x + 1), (gl_FragCoord.y + 1)), 0),
a2 = texelFetch(tex, ivec2((gl_FragCoord.x + 0), (gl_FragCoord.y + 1)), 0),
a3 = texelFetch(tex, ivec2((gl_FragCoord.x + 1), (gl_FragCoord.y + 0)), 0),
a4 = texelFetch(tex, ivec2((gl_FragCoord.x - 1), (gl_FragCoord.y - 0)), 0),
a5 = texelFetch(tex, ivec2((gl_FragCoord.x - 1), (gl_FragCoord.y - 1)), 0),
a6 = texelFetch(tex, ivec2((gl_FragCoord.x - 0), (gl_FragCoord.y - 1)), 0),
a7 = texelFetch(tex, ivec2((gl_FragCoord.x - 1), (gl_FragCoord.y - 0)), 0);
vec4 avg = (a0 + a1 + a2 + a3 + a4 + a5 + a6 + a7) / 8.0;
if (avg.a > 0){
if (fragment.a <= 0 || gl_FragCoord.x == 0 || gl_FragCoord.x == screen.x - 1)
fragment = OUTLINE;
}
}

2
linux-hidpi/pam_environment
View File

@@ -3,7 +3,7 @@ QT_IM_MODULE DEFAULT=fcitx
XMODIFIERS DEFAULT=\@im=fcitx XMODIFIERS DEFAULT=\@im=fcitx
GTK_THEME DEFAULT=Lumiere GTK_THEME DEFAULT=Lumiere
GTK2_RC_FILES DEFAULT=/usr/share/themes/Lumiere/gtk-2.0/gtkrc GTK2_RC_FILES DEFAULT=/home/vbalien/.themes/Lumiere/gtk-2.0/gtkrc
BROWSER DEFAULT=google-chrome-stable BROWSER DEFAULT=google-chrome-stable
BACKLIGHT DEFAULT=gmux_backlight BACKLIGHT DEFAULT=gmux_backlight

9
linux-hidpi/picom/picom.conf
View File

@@ -36,8 +36,9 @@ shadow-exclude = [
"class_g = 'Cairo-clock'", "class_g = 'Cairo-clock'",
"class_g = 'slop'", "class_g = 'slop'",
"class_g = 'Polybar'", "class_g = 'Polybar'",
"_GTK_FRAME_EXTENTS@:c", "class_g = 'conky'",
"_PICOM_ROUNDED@:32c = 0" "class_g = 'GLava'",
"_GTK_FRAME_EXTENTS@:c"
]; ];
# Avoid drawing shadow on all shaped windows (see also: --detect-rounded-corners) # Avoid drawing shadow on all shaped windows (see also: --detect-rounded-corners)
@@ -124,6 +125,8 @@ focus-exclude = [
# opacity-rule = [] # opacity-rule = []
opacity-rule = [ opacity-rule = [
"100:class_g = 'Polybar'", "100:class_g = 'Polybar'",
"100:class_g = 'conky'",
"100:class_g = 'GLava'",
"100:class_g = 'Rofi'", "100:class_g = 'Rofi'",
"100:name = 'Picture in picture'", "100:name = 'Picture in picture'",
"100:class_g = 'baka-mplayer'", "100:class_g = 'baka-mplayer'",
@@ -186,6 +189,8 @@ blur-background-exclude = [
# prevents picom from blurring the background # prevents picom from blurring the background
# when taking selection screenshot with `main` # when taking selection screenshot with `main`
# https://github.com/naelstrof/maim/issues/130 # https://github.com/naelstrof/maim/issues/130
"class_g = 'conky'",
"class_g = 'GLava'",
"class_g = 'slop'", "class_g = 'slop'",
"_GTK_FRAME_EXTENTS@:c", "_GTK_FRAME_EXTENTS@:c",
]; ];

6
mapping.ts
View File

@@ -37,7 +37,7 @@ const linux: DotOption = {
kcm-fcitx5 numix-gtk-theme-git numix-circle-icon-theme-git kcm-fcitx5 numix-gtk-theme-git numix-circle-icon-theme-git
telegram-desktop nautilus eog smplayer smplayer-skins transgui-qt telegram-desktop nautilus eog smplayer smplayer-skins transgui-qt
qt5-styleplugins xdg-user-dirs slim network-manager-applet bc qt5-styleplugins xdg-user-dirs slim network-manager-applet bc
glava conky` glava conky jq xdo ttf-roboto`
], ],
link: { link: {
...common.link, ...common.link,
@@ -74,7 +74,9 @@ const linuxHiDPI: DotOption = {
".config/dunst": "linux-hidpi/dunst", ".config/dunst": "linux-hidpi/dunst",
".config/picom": "linux-hidpi/picom", ".config/picom": "linux-hidpi/picom",
".pam_environment": "linux-hidpi/pam_environment", ".pam_environment": "linux-hidpi/pam_environment",
".Xresources": "linux-hidpi/Xresources" ".Xresources": "linux-hidpi/Xresources",
".config/glava": "linux-hidpi/glava",
".conkyrc": "linux-hidpi/conkyrc"
} }
}; };