Added --desktop flag with presets, added setclickthrough option, removed kde previous kde changes, updated readme

Stray letter

CHANGELOG.md

@@ -1,33 +0,0 @@
-## 1.4
-
-* Added window creation backends. GLava automatically uses the appropriate backend, currently `"glx"` and `"glfw"` are available. The GLX window creation code nicely supports transparent windows so that users do not need to use GLFW 3.3 for native transparency, which remains unstable and unreleased.
-* Added a `--backend` (or `-b`) flag that can be used to manually select window creation backends.
-* Fixed alpha blending with `"native"` transparency. GLava now correctly uses premultiplied alpha to provide alpha blending with other X windows, where a compositor is available.
-* Fixed a segmentation fault that occurs with uncommon window managers, see #19
-* Fixed various other issues with alpha blending in shader code.
-
-## 1.3
-
-* Added RGBA color parsing for GLSL code and directives (does not work within `#request` directives). The behaviour converts `#3ef708ff` -> `vec4(0.243, 0.967, 0.031, 1.0)`. If the alpha component is omitted, it is assumed to be `1.0`. The parsing occurs during compile time, so it does not incurr any performance penalty.
-* Fixed stray `[DEBUG]` messages that were errornously being printed
-* _Actually_ added support for GLFW 3.1, see issue #13
-* Fixed issue with some WMs not responding to GLava's window types and hints, see #17
-* Fixed alpha blending not working, `radial` and `circle` image quality should be drastically improved on `xroot` and `none` opacity settings.
-* Added `--version` command line flag
-
-## 1.2
-
-* Attempted to add support for GLFW 3.1, see issue #13
-* Added configurable solid background color, see #16
-* Fixed issue with excessive file reads from `~/.Xauthority` see #15
-
-## 1.1
-
-* Added `circle` module
-* Added anti-aliasing to the `radial` module, written into the shader itself
-* Default configuration values should create more appealing visualizers now
-* Massive performance improvements, see issue #10
-
-## 1.0
-
-* All versions of GLava with `1.0` version numbers are older development releases.

LICENSE

@@ -1,7 +1,7 @@
                     GNU GENERAL PUBLIC LICENSE
                        Version 3, 29 June 2007
 
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 
@@ -645,7 +645,7 @@ the "copyright" line and a pointer to where the full notice is found.
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 Also add information on how to contact you by electronic and paper mail.
 
@@ -664,11 +664,11 @@ might be different; for a GUI interface, you would use an "about box".
   You should also get your employer (if you work as a programmer) or school,
 if any, to sign a "copyright disclaimer" for the program, if necessary.
 For more information on this, and how to apply and follow the GNU GPL, see
-<https://www.gnu.org/licenses/>.
+<http://www.gnu.org/licenses/>.
 
   The GNU General Public License does not permit incorporating your program
 into proprietary programs.  If your program is a subroutine library, you
 may consider it more useful to permit linking proprietary applications with
 the library.  If this is what you want to do, use the GNU Lesser General
 Public License instead of this License.  But first, please read
-<https://www.gnu.org/licenses/why-not-lgpl.html>.
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

Makefile

@@ -4,11 +4,11 @@ obj = $(src:.c=.o)
 # Build type parameter
 
 ifeq ($(BUILD),debug)
-    CFLAGS_BUILD = -O0 -ggdb -Wall -fsanitize=address -fno-omit-frame-pointer -fno-optimize-sibling-calls
+    CFLAGS_BUILD = -O0 -ggdb -Wall #-fsanitize=address -fno-omit-frame-pointer -fno-optimize-sibling-calls
     GLAD_GEN = c-debug
-    ASAN = -lasan
+#    ASAN = -lasan
 else
-    CFLAGS_BUILD = -O2 -march=native
+    CFLAGS_BUILD = -O2 -march=native -Wstringop-overflow=0
     GLAD_GEN = c
 endif
 
@@ -32,20 +32,20 @@ endif
 ifeq ($(INSTALL),unix)
     CFLAGS_INSTALL = -DGLAVA_UNIX
     ifdef XDG_CONFIG_DIRS
-        SHADER_DIR = $(firstword $(subst :, ,$XDG_CONFIG_DIR))/glava
+        SHADER_DIR = $(firstword $(subst :, ,$(XDG_CONFIG_DIRS)))/glava
     else
         SHADER_DIR = etc/xdg/glava
     endif
 endif
 
-ifndef DISABLE_GLFW
+ifdef ENABLE_GLFW
     CFLAGS_GLFW = -DGLAVA_GLFW
     LDFLAGS_GLFW = -lglfw
 endif
 
 ifndef DISABLE_GLX
     CFLAGS_GLX = -DGLAVA_GLX
-    LDFLAGS_GLX = -lGLX -lXrender
+    LDFLAGS_GLX = -lXrender
 endif
 
 ifeq ($(INSTALL),osx)
@@ -53,14 +53,19 @@ ifeq ($(INSTALL),osx)
     SHADER_DIR = Library/glava
 endif
 
-LDFLAGS = $(ASAN) -lpulse -lpulse-simple -pthread $(LDFLAGS_GLFW) -ldl -lm -lX11 -lXext $(LDFLAGS_GLX)
+LDFLAGS += $(ASAN) -lpulse -lpulse-simple -pthread $(LDFLAGS_GLFW) -ldl -lm -lX11 -lXext $(LDFLAGS_GLX)
 
 PYTHON = python
 
+GLAVA_VERSION = \"$(shell git describe --tags 2>/dev/null)\"
+ifeq ($(GLAVA_VERSION),\"\")
+    GLAVA_VERSION = \"unknown\"
+endif
+
 GLAD_INSTALL_DIR = glad
 GLAD_SRCFILE = ./glad/src/glad.c
 GLAD_ARGS = --generator=$(GLAD_GEN) --extensions=GL_EXT_framebuffer_multisample,GL_EXT_texture_filter_anisotropic
-CFLAGS_COMMON = -I glad/include
+CFLAGS_COMMON = -I glad/include -DGLAVA_VERSION="$(GLAVA_VERSION)"
 CFLAGS_USE = $(CFLAGS_COMMON) $(CFLAGS_GLX) $(CFLAGS_GLFW) $(CFLAGS_BUILD) $(CFLAGS_INSTALL) $(CFLAGS)
 
 all: glava

README.md

@@ -1,7 +1,7 @@
-## GLava
+
 <img align="left" width="200" height="200" src="https://thumbs.gfycat.com/DefiantInformalIndianspinyloach-size_restricted.gif" />
 
-GLava is an OpenGL audio spectrum visualizer. Its primary use case is for desktop windows or backgrounds. Displayed to the left is the `radial` shader module, and [here is a demonstration video](https://streamable.com/dgpj8). Development is active, and reporting issues is encouranged.
+**GLava** is an OpenGL audio spectrum visualizer. Its primary use case is for desktop windows or backgrounds. Displayed to the left is the `radial` shader module, and [here is a demonstration video](https://streamable.com/dgpj8). Development is active, and reporting issues is encouranged.
 
 **Compiling** (Or use the [`glava-git` AUR package](https://aur.archlinux.org/packages/glava-git/))**:**
 
@@ -19,7 +19,6 @@ You can pass `BUILD=debug` to the makefile for debug builds of both glad and gla
 
 - X11
 - PulseAudio
-- GLFW 3.1+ (optional, disable with `DISABLE_GLFW=1`)
 - Linux or BSD
 
 **Additional compile time requirements:**
@@ -27,11 +26,14 @@ You can pass `BUILD=debug` to the makefile for debug builds of both glad and gla
 - glad (included as a submodule)
 - python (required to generate bindings with glad)
 - GCC (this program uses GNU C features)
-- GLX headers (optional, disable direct GLX support with `DISABLE_GLX=1`), usually the development packages for `libgl` include this on your distro
+
+**Optional requirements:**
+
+- GLFW 3.1+ (optional, enable with `ENABLE_GLFW=1`)
 
 **Ubuntu/Debian users:** the following command ensures you have all the needed packages and headers to compile GLava:
 ```bash
-sudo apt-get install libpulse libpulse-dev libglfw3 libglfw3-dev libxext6 libxext6-dev python make gcc
+sudo apt-get install libpulse0 libpulse-dev libglfw3 libglfw3-dev libxext6 libxext-dev libxcomposite-dev python make gcc 
 ```
 
 ## [Configuration](https://github.com/wacossusca34/glava/wiki)
@@ -40,9 +42,9 @@ GLava will start by looking for an entry point in the user configuration folder
 
 You should start by running `glava --copy-config`. This will copy over default configuration files and create symlinks to modules in your user config folder. GLava will either load system configuration files or the user provided ones, so it's not advised to copy these files selectively.
 
-To embed GLava in your desktop (for EWMH compliant window managers), use `#request setxwintype "desktop"` and then position it accordingly with `#request setgeometry x y width height`. You may want to also use `#request setforcegeometry true` for some window managers.
+To embed GLava in your desktop (for EWMH compliant window managers), run it with the `--desktop` flag and then position it accordingly with `#request setgeometry x y width height` in your `rc.glsl`.
 
-\* On an XDG compliant Linux or BSD system. OSX will use `/Library/glava` and `~/Library/Preferences/glava` instead.
+\* On an XDG compliant Linux or BSD system.
 
 ## Desktop window compatibility
 
@@ -51,21 +53,23 @@ GLava aims to be compatible with _most_ EWMH compliant window managers. Below is
 | WM | ! | Details
 | :---: | --- | --- |
 | Mutter (GNOME, Budgie) | ![-](https://placehold.it/15/118932/000000?text=+) | `"native"` (default) opacity should be used
-| Openbox (LXDE or standalone) | ![-](https://placehold.it/15/118932/000000?text=+) | [Some tweaks may be required](https://www.reddit.com/r/unixporn/comments/7vcgi4/oc_after_receiving_positive_feedback_here_i/dtrkvja/)
-| Xfwm (XFCE) | ![-](https://placehold.it/15/118932/000000?text=+) | Untested, but should work without issues
-| Fluxbox | ![-](https://placehold.it/15/118932/000000?text=+) | Untested, but should work without issues
-| iceWM | ![-](https://placehold.it/15/118932/000000?text=+) | No notable issues
+| KWin (KDE) | ![-](https://placehold.it/15/118932/000000?text=+) | No issues
+| Openbox (LXDE or standalone) | ![-](https://placehold.it/15/118932/000000?text=+) | No issues
+| Xfwm (XFCE) | ![-](https://placehold.it/15/118932/000000?text=+) | No issues
+| Fluxbox | ![-](https://placehold.it/15/118932/000000?text=+) | No issues
+| IceWM | ![-](https://placehold.it/15/118932/000000?text=+) | No issues
+| Bspwm | ![-](https://placehold.it/15/118932/000000?text=+) | No issues
 | Herbstluftwm | ![-](https://placehold.it/15/118932/000000?text=+) | `hc rule windowtype~'_NET_WM_WINDOW_TYPE_DESKTOP' manage=off` can be used to unmanage desktop windows
+| Unity | ![-](https://placehold.it/15/118932/000000?text=+) | No issues
 | AwesomeWM | ![-](https://placehold.it/15/f09c00/000000?text=+) | Can still be focused, may require other changes to config depending on layout
-| kwin (KDE) | ![-](https://placehold.it/15/f09c00/000000?text=+) | [Issues with workspaces and stacking](https://github.com/wacossusca34/glava/issues/4), needs further testing
 | i3 (and i3-gaps) | ![-](https://placehold.it/15/f03c15/000000?text=+) | [i3 does not respect the `"desktop"` window type](https://github.com/wacossusca34/glava/issues/6)
 | EXWM | ![-](https://placehold.it/15/f03c15/000000?text=+) | EXWM does not have a desktop, and forces window decorations
-| Unity | ![-](https://placehold.it/15/1589F0/000000?text=+) | Needs testing
 | Enlightenment | ![-](https://placehold.it/15/1589F0/000000?text=+) | Needs testing
-| Bspwm | ![-](https://placehold.it/15/1589F0/000000?text=+) | Needs testing
-| xmonad | ![-](https://placehold.it/15/1589F0/000000?text=+) | Needs testing
+| Xmonad | ![-](https://placehold.it/15/1589F0/000000?text=+) | Needs testing
 | Any non EWMH-compliant WM | ![-](https://placehold.it/15/f03c15/000000?text=+) | Window types and hints will not work if the window manager does not support the EWMH standards.
 
+Note that some WMs listed without issues have specific overrides when using the `--desktop` flag. See `shaders/env_*.glsl` files for details.
+
 ## Licensing
 
 GLava is licensed under the terms of the GPLv3. GLava includes some (heavily modified) source code that originated from [cava](https://github.com/karlstav/cava), which was initially provided under the MIT license. The source files that originated from cava are the following:
@@ -87,4 +91,4 @@ The below copyright applies for the modifications to the files listed above, and
 
 ## Porting
 
-GLava was built with GLFW, making the graphics frontend mostly compatible if it were to be ported to Windows, and I have taken all the Xlib-specific code and placed it into `xwin.c` if anyone decides they wish to attempt at a port.
+GLava was built with GLFW, making the graphics frontend mostly compatible if it were to be ported to Windows, and I have taken most of the Xlib-specific code and placed it into `xwin.c` if anyone decides they wish to attempt at a port.

glava.c

@@ -18,7 +18,6 @@
 #include "render.h"
 #include "xwin.h"
 
-#define GLAVA_VERSION "1.4"
 #ifdef GLAD_DEBUG
 #define GLAVA_RELEASE_TYPE_PREFIX "debug, "
 #else
@@ -160,6 +159,9 @@ static const char* help_str =
     "Available arguments:\n"
     "-h, --help              show this help and exit\n"
     "-v, --verbose           enables printing of detailed information about execution\n"
+    "-d, --desktop           enables running glava as a desktop window by detecting the\n"
+    "                          desktop environment and setting the appropriate properties\n"
+    "                          automatically. Can override properties in \"rc.glsl\".\n"
     "-m, --force-mod=NAME    forces the specified module to load instead, ignoring any\n"
     "                          `#request mod` instances in the entry point.\n"
     "-e, --entry=NAME        specifies the name of the file to look for when loading shaders,\n"
@@ -175,10 +177,11 @@ static const char* help_str =
     GLAVA_VERSION_STRING "\n"
     " -- Copyright (C) 2017 Levi Webb\n";
 
-static const char* opt_str = "hvVe:Cm:b:";
+static const char* opt_str = "dhvVe:Cm:b:";
 static struct option p_opts[] = {
     {"help",        no_argument,       0, 'h'},
     {"verbose",     no_argument,       0, 'v'},
+    {"desktop",     no_argument,       0, 'd'},
     {"entry",       required_argument, 0, 'e'},
     {"force-mod",   required_argument, 0, 'm'},
     {"copy-config", no_argument,       0, 'C'},
@@ -196,14 +199,14 @@ int main(int argc, char** argv) {
     const char* force        = NULL;
     const char* backend      = NULL;
     const char* system_shader_paths[] = { user_path, install_path, NULL };
-    bool verbose = false;
-    bool copy_mode = false;
+    bool verbose = false, copy_mode = false, desktop = false;
     
-    int c, idx, n = 0;
+    int c, idx;
     while ((c = getopt_long(argc, argv, opt_str, p_opts, &idx)) != -1) {
         switch (c) {
         case 'v': verbose   = true;   break;
         case 'C': copy_mode = true;   break;
+        case 'd': desktop   = true;   break;
         case 'e': entry     = optarg; break;
         case 'm': force     = optarg; break;
         case 'b': backend   = optarg; break;
@@ -225,7 +228,7 @@ int main(int argc, char** argv) {
         exit(EXIT_SUCCESS);
     }
 
-    renderer* r = rd_new(system_shader_paths, entry, force, backend);
+    renderer* r = rd_new(system_shader_paths, entry, force, backend, desktop);
 
     float b0[r->bufsize_request], b1[r->bufsize_request];
     size_t t;
@@ -245,7 +248,7 @@ int main(int argc, char** argv) {
         .rate         = (unsigned int) r->rate_request,
         .format       = -1,
         .terminate    = 0,
-        .channels     = 2,
+        .channels     = r->mirror_input ? 1 : 2,
         .audio_out_r  = b0,
         .audio_out_l  = b1,
         .mutex        = PTHREAD_MUTEX_INITIALIZER,
@@ -259,7 +262,7 @@ int main(int argc, char** argv) {
     }
     
     pthread_t thread;
-    int thread_id = pthread_create(&thread, NULL, input_pulse, (void*) &audio);
+    pthread_create(&thread, NULL, input_pulse, (void*) &audio);
     
     float lb[r->bufsize_request], rb[r->bufsize_request];
     while (r->alive) {
@@ -272,17 +275,15 @@ int main(int argc, char** argv) {
         pthread_mutex_lock(&audio.mutex);
         modified = audio.modified;
         if (modified) {
-            /* create our own copies of the audio buffers, so the streaming thread can continue to append to it */
+            /* create our own copies of the audio buffers, so the streaming
+               thread can continue to append to it */
             memcpy(lb, (void*) audio.audio_out_l, r->bufsize_request * sizeof(float));
             memcpy(rb, (void*) audio.audio_out_r, r->bufsize_request * sizeof(float));
             audio.modified = false; /* set this flag to false until the next time we read */
         }
         pthread_mutex_unlock(&audio.mutex);
         
-        /* Only render if needed (ie. stop rendering when fullscreen windows are focused) */
-        if (xwin_should_render(r)) {
-            rd_update(r, lb, rb, r->bufsize_request, modified);
-        } else {
+        if (!rd_update(r, lb, rb, r->bufsize_request, modified)) {
             /* Sleep for 50ms and then attempt to render again */
             struct timespec tv = {
                 .tv_sec = 0, .tv_nsec = 50 * 1000000

glfw_wcb.c

@@ -70,7 +70,8 @@ static void* create_and_bind(const char* name, const char* class,
                              size_t states_sz,
                              int d, int h,
                              int x, int y,
-                             int version_major, int version_minor) {
+                             int version_major, int version_minor,
+                             bool clickthrough) {
 
     GLFWwindow* w;
     
@@ -119,7 +120,7 @@ static void set_visible(GLFWwindow* w, bool visible) {
     else         glfwHideWindow(w);
 }
 
-static bool swap_buffers(GLFWwindow* w) {
+static void swap_buffers(GLFWwindow* w) {
     glfwSwapBuffers(w);
     glfwPollEvents();
 }
@@ -132,6 +133,9 @@ static void     get_pos        (GLFWwindow* w, int* x, int* y) { glfwGetWindowPo
 static double   get_time       (GLFWwindow* w)                 { return glfwGetTime();            }
 static void     set_time       (GLFWwindow* w, double time)    { glfwSetTime(time);               }
 static void     set_swap       (int i)                         { glfwSwapInterval(i); }
+static void     raise          (GLFWwindow* w)                 { glfwShowWindow(w); }
+
+static const char* get_environment(void) { return xwin_detect_wm(&wcb_glfw); }
 
 WCB_ATTACH("glfw", wcb_glfw);
 

glx_wcb.c

@@ -13,21 +13,154 @@
 #include <math.h>
 #include <time.h>
 
+#include <dlfcn.h>
+
 #include <X11/Xlib.h>
 #include <X11/extensions/Xrender.h>
+#include <X11/extensions/shape.h>
 #include <X11/Xatom.h>
 
 #include <glad/glad.h>
-#include <GL/glx.h>
 
 #include "render.h"
 #include "xwin.h"
 
+typedef struct __GLXcontextRec *GLXContext;
+typedef XID GLXPixmap;
+typedef XID GLXDrawable;
+
+typedef void (*__GLXextFuncPtr)(void);
+
+/* GLX 1.3 and later */
+typedef struct __GLXFBConfigRec *GLXFBConfig;
+typedef XID GLXFBConfigID;
+typedef XID GLXContextID;
+typedef XID GLXWindow;
+typedef XID GLXPbuffer;
+
+/*
+ * Tokens for glXChooseVisual and glXGetConfig:
+ */
+#define GLX_USE_GL		1
+#define GLX_BUFFER_SIZE		2
+#define GLX_LEVEL		3
+#define GLX_RGBA		4
+#define GLX_DOUBLEBUFFER	5
+#define GLX_STEREO		6
+#define GLX_AUX_BUFFERS		7
+#define GLX_RED_SIZE		8
+#define GLX_GREEN_SIZE		9
+#define GLX_BLUE_SIZE		10
+#define GLX_ALPHA_SIZE		11
+#define GLX_DEPTH_SIZE		12
+#define GLX_STENCIL_SIZE	13
+#define GLX_ACCUM_RED_SIZE	14
+#define GLX_ACCUM_GREEN_SIZE	15
+#define GLX_ACCUM_BLUE_SIZE	16
+#define GLX_ACCUM_ALPHA_SIZE	17
+
+
+/*
+ * Error codes returned by glXGetConfig:
+ */
+#define GLX_BAD_SCREEN		1
+#define GLX_BAD_ATTRIBUTE	2
+#define GLX_NO_EXTENSION	3
+#define GLX_BAD_VISUAL		4
+#define GLX_BAD_CONTEXT		5
+#define GLX_BAD_VALUE       	6
+#define GLX_BAD_ENUM		7
+
+/*
+ * GLX 1.1 and later:
+ */
+#define GLX_VENDOR		1
+#define GLX_VERSION		2
+#define GLX_EXTENSIONS 		3
+
+
+/*
+ * GLX 1.3 and later:
+ */
+#define GLX_CONFIG_CAVEAT		0x20
+#define GLX_DONT_CARE			0xFFFFFFFF
+#define GLX_X_VISUAL_TYPE		0x22
+#define GLX_TRANSPARENT_TYPE		0x23
+#define GLX_TRANSPARENT_INDEX_VALUE	0x24
+#define GLX_TRANSPARENT_RED_VALUE	0x25
+#define GLX_TRANSPARENT_GREEN_VALUE	0x26
+#define GLX_TRANSPARENT_BLUE_VALUE	0x27
+#define GLX_TRANSPARENT_ALPHA_VALUE	0x28
+#define GLX_WINDOW_BIT			0x00000001
+#define GLX_PIXMAP_BIT			0x00000002
+#define GLX_PBUFFER_BIT			0x00000004
+#define GLX_AUX_BUFFERS_BIT		0x00000010
+#define GLX_FRONT_LEFT_BUFFER_BIT	0x00000001
+#define GLX_FRONT_RIGHT_BUFFER_BIT	0x00000002
+#define GLX_BACK_LEFT_BUFFER_BIT	0x00000004
+#define GLX_BACK_RIGHT_BUFFER_BIT	0x00000008
+#define GLX_DEPTH_BUFFER_BIT		0x00000020
+#define GLX_STENCIL_BUFFER_BIT		0x00000040
+#define GLX_ACCUM_BUFFER_BIT		0x00000080
+#define GLX_NONE			0x8000
+#define GLX_SLOW_CONFIG			0x8001
+#define GLX_TRUE_COLOR			0x8002
+#define GLX_DIRECT_COLOR		0x8003
+#define GLX_PSEUDO_COLOR		0x8004
+#define GLX_STATIC_COLOR		0x8005
+#define GLX_GRAY_SCALE			0x8006
+#define GLX_STATIC_GRAY			0x8007
+#define GLX_TRANSPARENT_RGB		0x8008
+#define GLX_TRANSPARENT_INDEX		0x8009
+#define GLX_VISUAL_ID			0x800B
+#define GLX_SCREEN			0x800C
+#define GLX_NON_CONFORMANT_CONFIG	0x800D
+#define GLX_DRAWABLE_TYPE		0x8010
+#define GLX_RENDER_TYPE			0x8011
+#define GLX_X_RENDERABLE		0x8012
+#define GLX_FBCONFIG_ID			0x8013
+#define GLX_RGBA_TYPE			0x8014
+#define GLX_COLOR_INDEX_TYPE		0x8015
+#define GLX_MAX_PBUFFER_WIDTH		0x8016
+#define GLX_MAX_PBUFFER_HEIGHT		0x8017
+#define GLX_MAX_PBUFFER_PIXELS		0x8018
+#define GLX_PRESERVED_CONTENTS		0x801B
+#define GLX_LARGEST_PBUFFER		0x801C
+#define GLX_WIDTH			0x801D
+#define GLX_HEIGHT			0x801E
+#define GLX_EVENT_MASK			0x801F
+#define GLX_DAMAGED			0x8020
+#define GLX_SAVED			0x8021
+#define GLX_WINDOW			0x8022
+#define GLX_PBUFFER			0x8023
+#define GLX_PBUFFER_HEIGHT              0x8040
+#define GLX_PBUFFER_WIDTH               0x8041
+#define GLX_RGBA_BIT			0x00000001
+#define GLX_COLOR_INDEX_BIT		0x00000002
+#define GLX_PBUFFER_CLOBBER_MASK	0x08000000
+
+/*
+ * GLX 1.4 and later:
+ */
+#define GLX_SAMPLE_BUFFERS              0x186a0 /*100000*/
+#define GLX_SAMPLES                     0x186a1 /*100001*/
+
+/* glXCreateContextAttribsARB extension definitions */
+
 #define GLX_CONTEXT_MAJOR_VERSION_ARB       0x2091
 #define GLX_CONTEXT_MINOR_VERSION_ARB       0x2092
+
 typedef GLXContext (*glXCreateContextAttribsARBProc)(Display*, GLXFBConfig, GLXContext, Bool, const int*);
 typedef void       (*glXSwapIntervalEXTProc)        (Display*, GLXDrawable, int);
 
+GLXFBConfig*    (*glXChooseFBConfig)       (Display* dpy, int screen, const int* attribList, int* nitems);
+XVisualInfo*    (*glXGetVisualFromFBConfig)(Display* dpy, GLXFBConfig config);
+int             (*glXGetFBConfigAttrib)    (Display* dpy, GLXFBConfig config, int attribute, int *value );
+Bool            (*glXMakeCurrent)          (Display* dpy, GLXDrawable drawable, GLXContext ctx);
+GLXDrawable     (*glXGetCurrentDrawable)   (void);
+__GLXextFuncPtr (*glXGetProcAddressARB)    (const GLubyte *);
+void            (*glXSwapBuffers)          (Display* dpy, GLXDrawable drawable);
+
 extern struct gl_wcb wcb_glx;
 
 static Display* display;
@@ -43,6 +176,8 @@ struct glxwin {
     bool should_close;
 };
 
+static Atom ATOM__MOTIF_WM_HINTS, ATOM_WM_DELETE_WINDOW, ATOM_WM_PROTOCOLS, ATOM__NET_ACTIVE_WINDOW;
+
 static void init(void) {
     display = XOpenDisplay(NULL);
     if (!display) {
@@ -54,6 +189,47 @@ static void init(void) {
     focused     = false;
     maximized   = false;
     transparent = false;
+
+    void* hgl  = dlopen("libGL.so", RTLD_LAZY);
+    void* hglx = dlopen("libGLX.so", RTLD_LAZY);
+
+    if (!hgl && !hglx) {
+        fprintf(stderr, "Failed to load GLX functions (libGL and libGLX do not exist!)\n");
+        exit(EXIT_FAILURE);
+    }
+
+    /* Depending on the graphics driver, the GLX functions that we need may either be in libGL or
+       libGLX. */
+    void* resolve_f(const char* symbol) {
+        void* s = NULL;
+        if (hgl)        s = dlsym(hgl,  symbol);
+        if (!s && hglx) s = dlsym(hglx, symbol);
+        if (!s) {
+            fprintf(stderr, "Failed to resolve GLX symbol: `%s`\n", symbol);
+            exit(EXIT_FAILURE);
+        }
+        return s;
+    }
+
+    #define resolve(name) do { name = (typeof(name)) resolve_f(#name); } while (0)
+    #define intern(name, only_if_exists) \
+        do { ATOM_##name = XInternAtom(display, #name, only_if_exists); } while (0)
+
+    resolve(glXChooseFBConfig);
+    resolve(glXGetVisualFromFBConfig);
+    resolve(glXGetFBConfigAttrib);
+    resolve(glXMakeCurrent);
+    resolve(glXGetCurrentDrawable);
+    resolve(glXGetProcAddressARB);
+    resolve(glXSwapBuffers);
+
+    intern(_MOTIF_WM_HINTS,    false);
+    intern(WM_DELETE_WINDOW,   true);
+    intern(WM_PROTOCOLS,       true);
+    intern(_NET_ACTIVE_WINDOW, false);
+
+    #undef intern
+    #undef resolve
 }
 
 static void apply_decorations(Window w) {
@@ -67,9 +243,7 @@ static void apply_decorations(Window w) {
         hints.flags       = 2;
         hints.decorations = 0;
 
-        Atom motif = XInternAtom(display, "_MOTIF_WM_HINTS", false);
-
-        XChangeProperty(display, w, motif, motif, 32, PropModeReplace,
+        XChangeProperty(display, w, ATOM__MOTIF_WM_HINTS, ATOM__MOTIF_WM_HINTS, 32, PropModeReplace,
                         (unsigned char*) &hints, sizeof(hints) / sizeof(long));
     }
 }
@@ -79,7 +253,8 @@ static void* create_and_bind(const char* name, const char* class,
                              size_t states_sz,
                              int d, int h,
                              int x, int y,
-                             int version_major, int version_minor) {
+                             int version_major, int version_minor,
+                             bool clickthrough) {
     struct glxwin* w = malloc(sizeof(struct glxwin));
     w->time         = 0.0D;
     w->should_close = false;
@@ -126,7 +301,7 @@ static void* create_and_bind(const char* name, const char* class,
             if (!fmt || (transparent ? fmt->direct.alphaMask == 0 : fmt->direct.alphaMask != 0))
                 continue;
             
-            if (best < 0 || samp_buf && samples > samp) {
+            if (best < 0 || (samp_buf && samples > samp)) {
                 best = t;
                 samp = samples;
             }
@@ -145,11 +320,11 @@ static void* create_and_bind(const char* name, const char* class,
     vi = glXGetVisualFromFBConfig(display, config);
     
     attr.colormap          = XCreateColormap(display, DefaultRootWindow(display), vi->visual, AllocNone);
-    attr.event_mask        = ExposureMask | KeyPressMask | StructureNotifyMask;
+    attr.event_mask        = ExposureMask | KeyPressMask | StructureNotifyMask | PropertyChangeMask;
     attr.background_pixmap = None;
     attr.border_pixel      = 0;
     
-    if (!(w->w = XCreateWindow(display, DefaultRootWindow(display),
+    if (!(w->w = XCreateWindow(display, DefaultRootWindow(display)/**xwin_get_desktop_layer(&wcb_glx)*/,
                                x, y, d, h, 0,
                                vi->depth, InputOutput, vi->visual,
                                CWColormap | CWEventMask | CWBackPixmap | CWBorderPixel,
@@ -158,8 +333,10 @@ static void* create_and_bind(const char* name, const char* class,
         abort();
     }
 
+    bool desktop = false;
+    
     if (type)
-        xwin_settype(&wcb_glx, w, type);
+        desktop = xwin_settype(&wcb_glx, w, type);
 
     for (size_t t = 0; t < states_sz; ++t)
         xwin_addstate(&wcb_glx, w, states[t]);
@@ -178,8 +355,19 @@ static void* create_and_bind(const char* name, const char* class,
     
     XStoreName(display, w->w, name);
     
-    Atom dwin = XInternAtom(display, "WM_DELETE_WINDOW", false);
-    XSetWMProtocols(display, w->w, &dwin, 1);
+    XSetWMProtocols(display, w->w, &ATOM_WM_DELETE_WINDOW, 1);
+    
+    /* Eliminate the window's effective region */
+    if (desktop || clickthrough) {
+        int ignored;
+        if (XShapeQueryExtension(display, &ignored, &ignored)) {
+            Region region;
+            if ((region = XCreateRegion())) {
+                XShapeCombineRegion(display, w->w, ShapeInput, 0, 0, region, ShapeSet);
+                XDestroyRegion(region);
+            }
+        }
+    }
 
     glXCreateContextAttribsARBProc glXCreateContextAttribsARB = NULL;
     glXSwapIntervalEXTProc glXSwapIntervalEXT = NULL;
@@ -207,9 +395,34 @@ static void* create_and_bind(const char* name, const char* class,
     
     if (glXSwapIntervalEXT) glXSwapIntervalEXT(display, drawable, swap);
 
+    // XSelectInput(display, DefaultRootWindow(display), VisibilityChangeMask | PropertyChangeMask);
+
     return w;
 }
 
+static void raise(struct glxwin* w) {
+    XClientMessageEvent ev = {
+        .type = ClientMessage,
+        .serial = 0,
+        .send_event = true,
+        .display = display,
+        .window = w->w,
+        .message_type = ATOM__NET_ACTIVE_WINDOW,
+        .format = 32,
+        .data = { .l = {
+                [0] = 1, /* source indication -- `1` when coming from an application */
+                [1] = 0, /* timestamp -- `0` to (attempt to) ignore */
+                [2] = w->w  /* requestor's currently active window -- `0` for none */
+            }
+        }
+    };
+    /* Send the client message as defined by EWMH standards (usually works) */
+    XSendEvent(display, DefaultRootWindow(display), false, StructureNotifyMask, (XEvent*) &ev);
+    /* Raise the client in the X11 stacking order (sometimes works, can be blocked by the WM) */
+    XRaiseWindow(display, w->w);
+    XFlush(display);
+}
+
 static void set_swap       (int  _swap)        { swap        = _swap;        }
 static void set_floating   (bool _floating)    { floating    = _floating;    }
 static void set_decorated  (bool _decorated)   { decorated   = _decorated;   }
@@ -238,10 +451,11 @@ static void swap_buffers(struct glxwin* w) {
         XNextEvent(display, &ev);
         switch (ev.type) {
         case ClientMessage:
-            if (ev.xclient.message_type  == XInternAtom(display, "WM_PROTOCOLS", 1)
-                && ev.xclient.data.l[0]  == XInternAtom(display, "WM_DELETE_WINDOW", 1)) {
+            if (ev.xclient.message_type  == ATOM_WM_PROTOCOLS
+                && ev.xclient.data.l[0]  == ATOM_WM_DELETE_WINDOW) {
                 w->should_close = true;
             }
+            break;
         default: break;
         }
     }
@@ -255,7 +469,6 @@ static void get_fbsize(struct glxwin* w, int* d, int* h) {
 }
 
 static void get_pos(struct glxwin* w, int* x, int* y) {
-    XWindowAttributes a;
     Window _ignored;
     XTranslateCoordinates(display, w->w, DefaultRootWindow(display), 0, 0, x, y, &_ignored);
 }
@@ -273,6 +486,8 @@ static void     set_time       (struct glxwin* w, double time) { w->time = get_t
 static Display* get_x11_display(struct glxwin* w)              { return display; }
 static Window   get_x11_window (struct glxwin* w)              { return w->w;    }
 
+static const char* get_environment(void) { return xwin_detect_wm(&wcb_glx); }
+
 WCB_ATTACH("glx", wcb_glx);
 
 #endif /* GLAVA_GLX */

pulse_input.c

@@ -9,22 +9,22 @@
 
 #include "fifo.h"
 
-static pa_mainloop *m_pulseaudio_mainloop;
+static pa_mainloop* m_pulseaudio_mainloop;
 
-static void cb(__attribute__((unused)) pa_context *pulseaudio_context,
-               const pa_server_info *i,
-               void *userdata) {
+static void cb(__attribute__((unused)) pa_context* pulseaudio_context,
+               const pa_server_info* i,
+               void* userdata) {
 
-	//getting default sink name
-    struct audio_data *audio = (struct audio_data *)userdata;
+	/* Obtain default sink name */
+    struct audio_data* audio = (struct audio_data*) userdata;
 	audio->source = malloc(sizeof(char) * 1024);
 
 	strcpy(audio->source,i->default_sink_name);
 
-	//appending .monitor suffix
+	/* Append `.monitor` suffix */
 	audio->source = strcat(audio->source, ".monitor");
 
-	//quiting mainloop
+	/* Quiting mainloop */
     pa_context_disconnect(pulseaudio_context);
     pa_context_unref(pulseaudio_context);
 	pa_mainloop_quit(m_pulseaudio_mainloop, 0);
@@ -32,10 +32,9 @@ static void cb(__attribute__((unused)) pa_context *pulseaudio_context,
 }
 
 
-static void pulseaudio_context_state_callback(pa_context *pulseaudio_context,
-                                       void *userdata) {
+static void pulseaudio_context_state_callback(pa_context* pulseaudio_context, void* userdata) {
 
-	// make sure loop is ready	
+	/* Ensure loop is ready	*/
 	switch (pa_context_get_state(pulseaudio_context))
         {
         case PA_CONTEXT_UNCONNECTED:
@@ -54,7 +53,6 @@ static void pulseaudio_context_state_callback(pa_context *pulseaudio_context,
             exit(EXIT_FAILURE);
             break;
         case PA_CONTEXT_TERMINATED:
-            // printf("PulseAudio context terminated!\n");
             pa_mainloop_quit(m_pulseaudio_mainloop, 0);
             break;	  
         }
@@ -63,29 +61,29 @@ static void pulseaudio_context_state_callback(pa_context *pulseaudio_context,
 
 void get_pulse_default_sink(struct audio_data* audio) {
     
-	pa_mainloop_api *mainloop_api;
-	pa_context *pulseaudio_context;
+	pa_mainloop_api* mainloop_api;
+	pa_context* pulseaudio_context;
 	int ret;
 
-	// Create a mainloop API and connection to the default server
+	/* Create a mainloop API and connection to the default server */
 	m_pulseaudio_mainloop = pa_mainloop_new();
 
 	mainloop_api = pa_mainloop_get_api(m_pulseaudio_mainloop);
 	pulseaudio_context = pa_context_new(mainloop_api, "glava device list");
 
 
-	// This function connects to the pulse server
+	/* Connect to the PA server */
 	pa_context_connect(pulseaudio_context, NULL, PA_CONTEXT_NOFLAGS,
                        NULL);
 
-	// This function defines a callback so the server will tell us its state.
+	/* Define a callback so the server will tell us its state */
 	pa_context_set_state_callback(pulseaudio_context,
                                   pulseaudio_context_state_callback,
                                   (void*)audio);
 
-	// starting a mainloop to get default sink
+	/* Start mainloop to get default sink */
 
-	// starting with one non blokng iteration in case pulseaudio is not able to run
+	/* Start with one non blocking iteration in case pulseaudio is not able to run */
 	if (!(ret = pa_mainloop_iterate(m_pulseaudio_mainloop, 0, &ret))){
         printf("Could not open pulseaudio mainloop to "
                "find default device name: %d\n"
@@ -114,12 +112,11 @@ void get_pulse_default_sink(struct audio_data* audio) {
 #endif
 
 void* input_pulse(void* data) {
-    struct audio_data *audio = (struct audio_data *)data;
+    struct audio_data* audio = (struct audio_data*) data;
     int i, n;
     size_t ssz = audio->sample_sz;
 	float buf[ssz / 2];
     
-	/* The sample type to use */
 	const pa_sample_spec ss = {
 		.format   = FSAMPLE_FORMAT,
 		.rate     = audio->rate,
@@ -130,7 +127,7 @@ void* input_pulse(void* data) {
         .fragsize  = ssz
 	};
     
-	pa_simple *s = NULL;
+	pa_simple* s = NULL;
 	int error;
     
 	if (!(s = pa_simple_new(NULL, "glava", PA_STREAM_RECORD,
@@ -163,17 +160,21 @@ void* input_pulse(void* data) {
         memmove(bl, &bl[ssz / 4], (fsz - (ssz / 4)) * sizeof(float));
         memmove(br, &br[ssz / 4], (fsz - (ssz / 4)) * sizeof(float)); 
 
-        // sorting out channelss
+        /* sorting out channels */
         
         for (n = 0, i = 0; i < ssz / 2; i += 2) {
 
-            // size_t idx = (i / 2) + (at * (BUFSIZE / 2));
+            /* size_t idx = (i / 2) + (at * (BUFSIZE / 2)); */
 
             int idx = (fsz - (ssz / 4)) + n;
 
-            if (audio->channels == 1) bl[idx] = (buf[i] + buf[i + 1]) / 2;
+            if (audio->channels == 1) {
+                float sample = (buf[i] + buf[i + 1]) / 2;
+                bl[idx] = sample;
+                br[idx] = sample;
+            }
 
-            // stereo storing channels in buffer
+            /* stereo storing channels in buffer */
             if (audio->channels == 2) {
                 bl[idx] = buf[i];
                 br[idx] = buf[i + 1];

render.c

@@ -108,8 +108,9 @@ struct gl_data {
     int rate; /* framerate */
     double tcounter;
     int fcounter, ucounter, kcounter;
-    bool print_fps, avg_window, interpolate, force_geometry, copy_desktop,
-        smooth_pass, premultiply_alpha;
+    bool print_fps, avg_window, interpolate, force_geometry, force_raised,
+        copy_desktop, smooth_pass, premultiply_alpha, check_fullscreen,
+        clickthrough;
     void** t_data;
     float gravity_step, target_spu, fr, ur, smooth_distance, smooth_ratio,
         smooth_factor, fft_scale, fft_cutoff;
@@ -326,10 +327,8 @@ static GLuint create_1d_tex() {
 }
 
 static void update_1d_tex(GLuint tex, size_t w, float* data) {
-    float buf[w];
-    memcpy(buf, data, w * sizeof(float));
     glBindTexture(GL_TEXTURE_1D, tex);
-    glTexImage1D(GL_TEXTURE_1D, 0, GL_R16, w, 0, GL_RED, GL_FLOAT, buf);
+    glTexImage1D(GL_TEXTURE_1D, 0, GL_R16, w, 0, GL_RED, GL_FLOAT, data);
 }
 
 #define BIND_VEC2 0
@@ -508,7 +507,6 @@ void transform_smooth(struct gl_data* d, void** udaa, void* data) {
     for (int t = 0; t < asz; ++t) {
         float
             db  = log(t), /* buffer index on log scale */
-            v   = b[t],   /* value at this position */
             avg = 0;      /* adj value averages (weighted) */
         /* Calculate real indexes for sampling at this position, since the
            distance is specified in scalar values */
@@ -594,7 +592,7 @@ void transform_wrange(struct gl_data* d, void** _, void* data) {
 
 void transform_window(struct gl_data* d, void** _, void* data) {
     struct gl_sampler_data* s = (struct gl_sampler_data*) data;
-    float* b = s->buf, w;
+    float* b = s->buf;
     size_t sz = s->sz, t;
     
     for (t = 0; t < sz; ++t) {
@@ -683,11 +681,15 @@ static struct gl_bind_src* lookup_bind_src(const char* str) {
 }
 
 struct renderer* rd_new(const char** paths, const char* entry,
-                        const char* force_mod, const char* force_backend) {
+                        const char* force_mod, const char* force_backend,
+                        bool auto_desktop) {
+
+    xwin_wait_for_wm();
     
     renderer* r = malloc(sizeof(struct renderer));
     *r = (struct renderer) {
         .alive                = true,
+        .mirror_input         = false,
         .gl                   = malloc(sizeof(struct gl_data)),
         .bufsize_request      = 8192,
         .rate_request         = 22000,
@@ -714,6 +716,7 @@ struct renderer* rd_new(const char** paths, const char* entry,
         .gravity_step      = 4.2,
         .interpolate       = true,
         .force_geometry    = false,
+        .force_raised      = false,
         .smooth_factor     = 0.025,
         .smooth_distance   = 0.01,
         .smooth_ratio      = 4,
@@ -721,11 +724,13 @@ struct renderer* rd_new(const char** paths, const char* entry,
         .sm_prog           = 0,
         .copy_desktop      = true,
         .premultiply_alpha = true,
+        .check_fullscreen  = true,
         .smooth_pass       = true,
         .fft_scale         = 10.2F,
         .fft_cutoff        = 0.3F,
         .geometry          = { 0, 0, 500, 400 },
-        .clear_color       = { 0.0F, 0.0F, 0.0F, 0.0F }
+        .clear_color       = { 0.0F, 0.0F, 0.0F, 0.0F },
+        .clickthrough      = false
     };
 
     bool forced = force_backend != NULL;
@@ -739,7 +744,7 @@ struct renderer* rd_new(const char** paths, const char* entry,
 
     #ifdef GLAVA_GLX
     DECL_WCB(wcb_glx);
-    if (!forced && !getenv("WAYLAND_DISPLAY") && getenv("DISPLAY")) {
+    if (!forced && getenv("DISPLAY")) {
         backend = "glx";
     }
     #endif
@@ -767,7 +772,7 @@ struct renderer* rd_new(const char** paths, const char* entry,
     };
 
     if (!gl->wcb) {
-        fprintf(stderr, "Invalid window creation backend selected: '%s'\n", gl->wcb);
+        fprintf(stderr, "Invalid window creation backend selected: '%s'\n", backend);
         abort();
     }
     
@@ -789,7 +794,7 @@ struct renderer* rd_new(const char** paths, const char* entry,
     char* xwintype = NULL, * wintitle = "GLava";
     char** xwinstates = malloc(1);
     size_t xwinstates_sz = 0;
-    bool loading_module = true, loading_smooth_pass = false;
+    bool loading_module = true, loading_smooth_pass = false, loading_presets = false;;
     struct gl_sfbo* current = NULL;
     size_t t_count = 0;
 
@@ -819,6 +824,14 @@ struct renderer* rd_new(const char** paths, const char* entry,
                     }
                 })
         },
+        {
+            .name = "setmirror", .fmt = "b",
+            .handler = RHANDLER(name, args, { r->mirror_input = *(bool*) args[0]; })
+        },
+        {
+            .name = "setfullscreencheck", .fmt = "b",
+            .handler = RHANDLER(name, args, { gl->check_fullscreen = *(bool*) args[0]; })
+        },
         {
             .name = "setbg", .fmt = "s",
             .handler = RHANDLER(name, args, {
@@ -848,7 +861,7 @@ struct renderer* rd_new(const char** paths, const char* entry,
             .handler = RHANDLER(name, args, {
                     if (loading_module && !force_mod) {
                         size_t len = strlen((char*) args[0]);
-                        char* str = malloc(sizeof(char) * (strlen((char*) args[0]) + 1));
+                        char* str = malloc(sizeof(char) * (len + 1));
                         strncpy(str, (char*) args[0], len + 1);
                         module = str;
                     }
@@ -888,16 +901,22 @@ struct renderer* rd_new(const char** paths, const char* entry,
         {
             .name = "addxwinstate", .fmt = "s",
             .handler = RHANDLER(name, args, {
+                    if (!auto_desktop || loading_presets) {
                         ++xwinstates_sz;
                         xwinstates = realloc(xwinstates, sizeof(*xwinstates) * xwinstates_sz);
                         xwinstates[xwinstates_sz - 1] = strdup((char*) args[0]);
+                    }
                 })
         },
         {   .name = "setsource", .fmt = "s",
             .handler = RHANDLER(name, args, {
                     r->audio_source_request = strdup((char*) args[0]); })                    },
+        {   .name = "setclickthrough", .fmt = "b",
+            .handler = RHANDLER(name, args, { gl->clickthrough = *(bool*) args[0]; })        },
         {   .name = "setforcegeometry", .fmt = "b",
             .handler = RHANDLER(name, args, { gl->force_geometry = *(bool*) args[0]; })      },
+        {   .name = "setforceraised", .fmt = "b",
+            .handler = RHANDLER(name, args, { gl->force_raised = *(bool*) args[0]; })        },
         {   .name = "setxwintype", .fmt = "s",
             .handler = RHANDLER(name, args, { xwintype = strdup((char*) args[0]); })         },
         {   .name = "setshaderversion", .fmt = "i",
@@ -1026,12 +1045,18 @@ struct renderer* rd_new(const char** paths, const char* entry,
        directories will be populated with symlinks to the installed modules. */
     
     const char* data;
-    size_t d_len;
+    const char* env = gl->wcb->get_environment();
+    size_t d_len, e_len;
     
     for (const char** i = paths; (data = *i) != NULL; ++i) {
         d_len = strlen(data);
+        e_len = env ? strlen(env) : 0;
         size_t se_len = strlen(entry);
-        size_t bsz = se_len + d_len + 2;
+        /* '/' + \0 + "env_" + ".glsl" = 11 char padding, min 7 for "default" */
+        size_t bsz = se_len + 11;
+        if (d_len > e_len && d_len >= 7) bsz += d_len;
+        else if (e_len >= 7) bsz += e_len;
+        else bsz += 7;
         char se_buf[bsz];
         snprintf(se_buf, bsz, "%s/%s", data, entry);
 
@@ -1043,7 +1068,7 @@ struct renderer* rd_new(const char** paths, const char* entry,
             if (errno != ENOENT  &&
                 errno != ENOTDIR &&
                 errno != ELOOP     ) {
-                fprintf(stderr, "failed to load entry '%s': %s\n", se_buf, strerror(errno));
+                fprintf(stderr, "Failed to load entry '%s': %s\n", se_buf, strerror(errno));
                 exit(EXIT_FAILURE);
             } else continue;
         }
@@ -1062,6 +1087,42 @@ struct renderer* rd_new(const char** paths, const char* entry,
         
         munmap((void*) map, st.st_size);
 
+        if (auto_desktop) {
+            if (env) {
+                snprintf(se_buf, bsz, "%s/env_%s.glsl", data, env);
+                fd = open(se_buf, O_RDONLY);
+                if (fd == -1) {
+                    if (errno != ENOENT  &&
+                        errno != ENOTDIR &&
+                        errno != ELOOP) {
+                        fprintf(stderr, "Failed to load desktop environment specific presets at '%s': %s\n", se_buf, strerror(errno));
+                        exit(EXIT_FAILURE);
+                    } else {
+                        printf("No presets for current desktop environment (\"%s\"), using default presets for embedding\n", env);
+                        snprintf(se_buf, bsz, "%s/env_default.glsl", data);
+                        fd = open(se_buf, O_RDONLY);
+                        if (fd == -1) {
+                            fprintf(stderr, "Failed to load default presets at '%s': %s\n", se_buf, strerror(errno));
+                            exit(EXIT_FAILURE);
+                        }
+                    }
+                }
+                fstat(fd, &st);
+                map = mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
+
+                ext.source = map;
+                ext.source_len = st.st_size;
+
+                loading_presets = true;
+                ext_process(&ext, se_buf);
+                loading_presets = false;
+
+                munmap((void*) map, st.st_size);
+            } else {
+                fprintf(stderr, "Failed to detect the desktop environment! Is the window manager EWMH compliant?");
+            }
+        }
+        
         break;
     }
     
@@ -1073,13 +1134,10 @@ struct renderer* rd_new(const char** paths, const char* entry,
         exit(EXIT_FAILURE);
     }
     
-    if (!(gl->w = gl->wcb->create_and_bind(wintitle, "GLava", xwintype,
-                                           (const char**) xwinstates, xwinstates_sz,
-                                           gl->geometry[2], gl->geometry[3],
-                                           gl->geometry[0], gl->geometry[1],
-                                           context_version_major, context_version_minor))) {
-        abort();
-    }
+    gl->w = gl->wcb->create_and_bind(wintitle, "GLava", xwintype, (const char**) xwinstates, xwinstates_sz,
+                                     gl->geometry[2], gl->geometry[3], gl->geometry[0], gl->geometry[1],
+                                     context_version_major, context_version_minor, gl->clickthrough);
+    if (!gl->w) abort();
     
     if (xwintype)   free(xwintype);
     if (xwinstates) free(xwinstates);
@@ -1272,13 +1330,17 @@ void rd_time(struct renderer* r) {
     gl->wcb->set_time(gl->w, 0.0D); /* reset time for measuring this frame */
 }
 
-void rd_update(struct renderer* r, float* lb, float* rb, size_t bsz, bool modified) {
+bool rd_update(struct renderer* r, float* lb, float* rb, size_t bsz, bool modified) {
     struct gl_data* gl = r->gl;
     size_t t, a, fbsz = bsz * sizeof(float);
     
     r->alive = !gl->wcb->should_close(gl->w);
     if (!r->alive)
-        return;
+        return true;
+    
+    /* Stop rendering when fullscreen windows are focused */
+    if (gl->check_fullscreen && !xwin_should_render(r))
+        return false;
 
     /* Force disable interpolation if the update rate is close to or higher than the frame rate */
     float uratio = (gl->ur / gl->fr); /* update : framerate ratio */
@@ -1361,7 +1423,7 @@ void rd_update(struct renderer* r, float* lb, float* rb, size_t bsz, bool modifi
     
     for (t = 0; t < gl->stages_sz; ++t) {
 
-        bool needed[64] = { [ 0 ... 63 ] = false }; /* Load flags for each texture position */
+        bool load_flags[64] = { [ 0 ... 63 ] = false }; /* Load flags for each texture position */
         
         /* Current shader program */
         struct gl_sfbo* current = &gl->stages[t];
@@ -1429,6 +1491,10 @@ void rd_update(struct renderer* r, float* lb, float* rb, size_t bsz, bool modifi
             /* Handle transformations and bindings for 1D samplers */
             void handle_1d_tex(GLuint tex, float* buf, float* ubuf, size_t sz, int offset, bool audio) {
                 
+                if (load_flags[offset])
+                    goto bind_uniform;
+                load_flags[offset] = true;
+
                 /* Only apply transformations if the buffers we
                    were given are newly copied from PA */
                 if (modified) {
@@ -1443,6 +1509,7 @@ void rd_update(struct renderer* r, float* lb, float* rb, size_t bsz, bool modifi
                                 transform types are added) */
                     }
                 }
+                glActiveTexture(GL_TEXTURE0 + offset);
 
                 /* Update texture with our data */
                 update_1d_tex(tex, sz, gl->interpolate ? (ubuf ? ubuf : buf) : buf);
@@ -1526,11 +1593,9 @@ void rd_update(struct renderer* r, float* lb, float* rb, size_t bsz, bool modifi
                     tex = sm->tex; /* replace input texture with our processed one */
                 }
                 
-                if (!needed[offset]) {
                 glActiveTexture(GL_TEXTURE0 + offset);
                 glBindTexture(GL_TEXTURE_1D, tex);
-                    needed[offset] = true;
-                }
+            bind_uniform:
                 glUniform1i(bind->uniform, offset);
             }
 
@@ -1617,10 +1682,16 @@ void rd_update(struct renderer* r, float* lb, float* rb, size_t bsz, bool modifi
                                   gl->geometry[0], gl->geometry[1],
                                   gl->geometry[2], gl->geometry[3]);
         }
+        
+        if (gl->force_raised) {
+            gl->wcb->raise(gl->w);
+        }
     }
 
     /* Restore interpolation settings */
     gl->interpolate = old_interpolate;
+    
+    return true;
 }
 
 void*          rd_get_impl_window (struct renderer* r)  { return r->gl->w;   }

render.h

@@ -5,15 +5,16 @@
 struct gl_data;
 
 typedef struct renderer {
-    bool    alive;
+    bool    alive, mirror_input;
     size_t  bufsize_request, rate_request, samplesize_request;
     char*   audio_source_request;
     struct gl_data* gl;
 } renderer;
 
 struct renderer* rd_new            (const char** paths, const char* entry,
-                                    const char* force_mod, const char* force_backend);
-void             rd_update         (struct renderer*, float* lb, float* rb,
+                                    const char* force_mod, const char* force_backend,
+                                    bool auto_desktop);
+bool             rd_update         (struct renderer*, float* lb, float* rb,
                                     size_t bsz, bool modified);
 void             rd_destroy        (struct renderer*);
 void             rd_time           (struct renderer*);
@@ -29,9 +30,11 @@ struct gl_wcb {
                                 size_t states_sz,
                                 int w, int h,
                                 int x, int y,
-                                int version_major, int version_minor);
+                                int version_major, int version_minor,
+                                bool clickthrough);
     bool     (*should_close)   (void* ptr);
-    bool     (*swap_buffers)   (void* ptr);
+    void     (*swap_buffers)   (void* ptr);
+    void     (*raise)          (void* ptr);
     void     (*get_pos)        (void* ptr, int* x, int* y);
     void     (*get_fbsize)     (void* ptr, int* w, int* h);
     void     (*set_geometry)   (void* ptr, int x, int y, int w, int h);
@@ -44,6 +47,7 @@ struct gl_wcb {
     double   (*get_time)       (void* ptr);
     void     (*set_time)       (void* ptr, double time);
     void     (*set_visible)    (void* ptr, bool visible);
+    const char* (*get_environment) (void);
     #ifdef GLAVA_RDX11
     Display* (*get_x11_display)(void);
     Window   (*get_x11_window) (void* ptr);
@@ -63,6 +67,7 @@ struct gl_wcb {
         WCB_FUNC(create_and_bind),              \
         WCB_FUNC(should_close),                 \
         WCB_FUNC(swap_buffers),                 \
+        WCB_FUNC(raise),                        \
         WCB_FUNC(set_swap),                     \
         WCB_FUNC(get_pos),                      \
         WCB_FUNC(get_fbsize),                   \
@@ -75,6 +80,7 @@ struct gl_wcb {
         WCB_FUNC(set_time),                     \
         WCB_FUNC(get_time),                     \
         WCB_FUNC(set_visible),                  \
+        WCB_FUNC(get_environment),              \
         WCB_FUNC(get_x11_display),              \
         WCB_FUNC(get_x11_window)                \
     }

shaders/env_KWin.glsl

@@ -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
+

shaders/env_Openbox.glsl

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

shaders/env_Xfwm4.glsl

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

shaders/env_awesome.glsl

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

shaders/env_default.glsl

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

shaders/rc.glsl

@@ -21,11 +21,6 @@
 #request setfocused   false
 #request setmaximized false
 
-/* Force window geometry (locking the window in place), useful
-   for some pesky WMs that try to reposition the window when
-   embedding in the desktop. */
-#request setforcegeometry false
-
 /* Set window background opacity mode. Possible values are:
    
    "native" - True transparency provided by the compositor. Can
@@ -41,6 +36,9 @@
    "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
@@ -63,10 +61,7 @@
    
    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). More information can be found at:
-   
-   https://standards.freedesktop.org/wm-spec/wm-spec-1.3.html#idm140130317606816
-*/
+   converted to uppercase). */
 #request setxwintype "normal"
 
 /* (X11 only) EWMH Window state atoms (multiple can be specified).
@@ -74,7 +69,7 @@
    
    "modal", "sticky", "maximized_vert", "maximized_horz",
    "shaded", "skip_taskbar", "skip_pager", "hidden", "fullscreen",
-   "above", "below", "demands_attention", "focused"
+   "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
@@ -89,6 +84,13 @@
 // #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
 
 /* PulseAudio source. Can be a number or a name of an audio
    sink or device to record from. Set to "auto" to use the
@@ -120,6 +122,12 @@
    simple set to zero (or lower) to disable the frame limiter. */
 #request setframerate 0
 
+/* Enable/disable fullscreen checks. This looks at the currently
+   focused window and halts GLava's rendering if it is
+   fullscreen. This prevents rendering from interfering with
+   other graphically intensive tasks. */
+#request setfullscreencheck true
+
 /* 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
@@ -175,6 +183,21 @@
    value unless you have a strange PulseAudio configuration. */
 #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.

xwin.c

@@ -8,6 +8,8 @@
 #include <limits.h>
 #include <errno.h>
 
+#include <time.h>
+
 #include <sys/ipc.h>
 #include <sys/shm.h>
 
@@ -23,11 +25,13 @@
 #include "render.h"
 #include "xwin.h"
 
-static Window find_desktop(struct renderer* r) {
+/* Note: currently unused */
+Window* xwin_get_desktop_layer(struct gl_wcb* wcb) {
     static Window desktop;
     static bool searched = false;
     if (!searched) {
-        Display* d = rd_get_wcb(r)->get_x11_display();
+        Display* d = wcb->get_x11_display();
+        Atom class = XInternAtom(d, "WM_CLASS", false);
         desktop = DefaultRootWindow(d);
         Window _ignored, * children;
         unsigned int nret;
@@ -39,18 +43,102 @@ static Window find_desktop(struct renderer* r) {
                 if (name) {
                     /* Mutter-based window managers */
                     if (!strcmp(name, "mutter guard window")) {
-                        printf("Using mutter guard window instead of root window\n");
-                        // desktop = children[t];
+                        printf("Reparenting to mutter guard window instead of root window\n");
+                        desktop = children[t];
                         t = nret; /* break after */
                     }
                     XFree(name);
                 }
+                unsigned long bytes;
+                XTextProperty text = {};
+                char** list;
+                int list_sz;
+                /* Get WM_CLASS property */
+                if (Success == XGetWindowProperty(d, children[t], class, 0, 512, false, AnyPropertyType,
+                                                  &text.encoding, &text.format, &text.nitems, &bytes,
+                                                  &text.value)) {
+                    /* decode string array */
+                    if (Success == XmbTextPropertyToTextList(d, &text, &list, &list_sz)) {
+                        if (list_sz >= 1 && !strcmp(list[0], "plasmashell")) {
+                            desktop = children[t];
+                            t = nret;
+                        }
+                        XFreeStringList(list);
+                    }
+                    XFree(text.value);
+                }
             }
             XFree(children);
         }
         searched = true;
     }
-    return desktop;
+    return &desktop;
+}
+
+void xwin_wait_for_wm(void) {
+    Display* d = XOpenDisplay(0);
+
+    Atom check = None;
+    bool exists = false;
+    struct timespec tv = { .tv_sec = 0, .tv_nsec = 50 * 1000000 };
+    
+     do {
+        if (check == None) {
+            check = XInternAtom(d, "_NET_SUPPORTING_WM_CHECK", true);
+        }
+        if (check) {
+            int num_prop, idx;
+            Atom* props = XListProperties(d, DefaultRootWindow(d), &num_prop);
+            for (idx = 0; idx < num_prop; ++idx) {
+                if (props[idx] == check) {
+                    exists = true;
+                    break;
+                }
+            }
+            XFree(props);
+        }
+        if (!exists) nanosleep(&tv, NULL);
+    } while (!exists);
+
+    XCloseDisplay(d);
+}
+
+const char* xwin_detect_wm(struct gl_wcb* wcb) {
+    Display* d = wcb->get_x11_display();
+    Atom check = XInternAtom(d, "_NET_SUPPORTING_WM_CHECK", false);
+    Atom name = XInternAtom(d, "_NET_WM_NAME", false);
+    Atom type = XInternAtom(d, "UTF8_STRING", false);
+    union {
+        Atom a;
+        int i;
+        long unsigned int lui;
+    } ignored;
+    
+    unsigned long nitems = 0;
+    unsigned char* wm_name = NULL;
+    Window* wm_check;
+    if (Success != XGetWindowProperty(d, DefaultRootWindow(d), check, 0, 1024, false, XA_WINDOW,
+                                      &ignored.a, &ignored.i, &nitems, &ignored.lui, (unsigned char**) &wm_check)) {
+        return NULL;
+    }
+    
+    if (nitems > 0 && Success == XGetWindowProperty(d, *wm_check, name, 0, 1024, false, type,
+                                                    &ignored.a, &ignored.i, &nitems, &ignored.lui, &wm_name)) {
+        if (nitems > 0) {
+            static const char* wm_name_store = NULL;
+            if (wm_name_store) XFree((unsigned char*) wm_name_store);
+            wm_name_store = (const char*) wm_name;
+        } else {
+            XFree(wm_name);
+            wm_name = NULL;
+        }
+    }
+    
+    XFree(wm_check);
+    printf("wm_name: \"%s\"\n", wm_name);
+    
+    return (const char*) wm_name;
+    
 }
 
 bool xwin_should_render(struct renderer* rd) {
@@ -67,7 +155,7 @@ bool xwin_should_render(struct renderer* rd) {
     Atom actual_type;
     int actual_format, t;
     unsigned long nitems, bytes_after;
-    unsigned char* data;
+    unsigned char* data = NULL;
 
     int handler(Display* d, XErrorEvent* e) { return 0; }
     
@@ -85,6 +173,11 @@ bool xwin_should_render(struct renderer* rd) {
 
     prop = XInternAtom(d, "_NET_WM_STATE", true);
 
+    if (data) {
+        XFree(data);
+        data = NULL;
+    }
+
     if (Success != XGetWindowProperty(d, active, prop, 0, LONG_MAX, false, AnyPropertyType,
                                       &actual_type, &actual_format, &nitems, &bytes_after, &data)) {
         goto close; /* some WMs are a little slow on creating _NET_WM_STATE, so errors may occur here */
@@ -95,39 +188,58 @@ bool xwin_should_render(struct renderer* rd) {
         }
     }
  close:
+    if (data)
+        XFree(data);
     if (should_close)
         XCloseDisplay(d);
     return ret;
 }
 
-/* Set window types defined by the EWMH standard, possible values:
-   -> "desktop", "dock", "toolbar", "menu", "utility", "splash", "dialog", "normal" */
+/* Create string copy on stack with upcase chars */
+#define S_UPPER(in, out) char out[strlen(in) + 1];                  \
+    do {                                                            \
+        for (size_t t = 0; t < sizeof(out) / sizeof(char); ++t) {   \
+            char c = in[t];                                         \
+            switch (c) {                                            \
+            case 'a' ... 'z': c -= 'a' - 'A';                       \
+            default:          out[t] = c;                           \
+            }                                                       \
+        }                                                           \
+    } while (0)
+
 static void xwin_changeatom(struct gl_wcb* wcb, void* impl, const char* type,
                             const char* atom, const char* fmt, int mode) {
     Window w = wcb->get_x11_window(impl);
     Display* d = wcb->get_x11_display();
     Atom wtype = XInternAtom(d, atom, false);
-    size_t len = strlen(type), t;
-    char formatted[len + 1];
-    for (t = 0; t < len + 1; ++t) {
-        char c = type[t];
-        switch (c) {
-        case 'a' ... 'z': c -= 'a' - 'A';
-        default:          formatted[t] = c;
-        }
-    }
     char buf[256];
-    snprintf(buf, sizeof(buf), fmt, formatted);
+    snprintf(buf, sizeof(buf), fmt, type);
     Atom desk = XInternAtom(d, buf, false);
     XChangeProperty(d, w, wtype, XA_ATOM, 32, mode, (unsigned char*) &desk, 1);
 }
 
-void xwin_settype(struct gl_wcb* wcb, void* impl, const char* type) {
-    xwin_changeatom(wcb, impl, type, "_NET_WM_WINDOW_TYPE", "_NET_WM_WINDOW_TYPE_%s", PropModeReplace); 
+/* Set window types defined by the EWMH standard, possible values:
+   -> "desktop", "dock", "toolbar", "menu", "utility", "splash", "dialog", "normal" */
+bool xwin_settype(struct gl_wcb* wcb, void* impl, const char* rtype) {
+    S_UPPER(rtype, type);
+    xwin_changeatom(wcb, impl, type, "_NET_WM_WINDOW_TYPE",
+                    "_NET_WM_WINDOW_TYPE_%s", PropModeReplace);
+    return !strcmp(type, "DESKTOP");
 }
 
-void xwin_addstate(struct gl_wcb* wcb, void* impl, const char* state) {
+void xwin_addstate(struct gl_wcb* wcb, void* impl, const char* rstate) {
+    S_UPPER(rstate, state);
+    if (strcmp(state, "PINNED"))
         xwin_changeatom(wcb, impl, state, "_NET_WM_STATE", "_NET_WM_STATE_%s", PropModeAppend);
+    else
+        xwin_setdesktop(wcb, impl, XWIN_ALL_DESKTOPS);
+}
+
+void xwin_setdesktop(struct gl_wcb* wcb, void* impl, unsigned long desktop) {
+    Window w = wcb->get_x11_window(impl);
+    Display* d = wcb->get_x11_display();
+    Atom wtype = XInternAtom(d, "_NET_WM_DESKTOP", false);
+    XChangeProperty(d, w, wtype, XA_CARDINAL, 32, PropModeReplace, (unsigned char*) &desktop, 1);
 }
 
 static Drawable get_drawable(Display* d, Window w) {
@@ -160,14 +272,13 @@ unsigned int xwin_copyglbg(struct renderer* rd, unsigned int tex) {
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     
-    bool use_shm = true;
-    
     int x, y, w, h;
     rd_get_wcb(rd)->get_fbsize(rd_get_impl_window(rd), &w, &h);
     rd_get_wcb(rd)->get_pos(rd_get_impl_window(rd), &x, &y);
     XColor c;
     Display* d = rd_get_wcb(rd)->get_x11_display();
-    Drawable src = get_drawable(d, find_desktop(rd));
+    Drawable src = get_drawable(d, DefaultRootWindow(d));
+    bool use_shm = XShmQueryExtension(d);
 
     /* Obtain section of root pixmap */
     
@@ -191,7 +302,7 @@ unsigned int xwin_copyglbg(struct renderer* rd, unsigned int tex) {
         XShmGetImage(d, src, image, x, y, AllPlanes);
     } else {
         image = XGetImage(d, src, x, y, (unsigned int) w, (unsigned int) h,
-                  ZPixmap, AllPlanes);
+                          AllPlanes, ZPixmap);
     }
 
     /* Try to convert pixel bit depth to OpenGL storage format. The following formats\

xwin.h

@@ -1,5 +1,18 @@
 
+#define XWIN_ALL_DESKTOPS 0xFFFFFFFF
+
+#ifndef XWIN_H
+#define XWIN_H
+
+typedef unsigned long int Window;
+
 bool xwin_should_render(struct renderer* rd);
-void xwin_settype(struct gl_wcb* wcb, void* impl, const char* type);
+void xwin_wait_for_wm(void);
+bool xwin_settype(struct gl_wcb* wcb, void* impl, const char* type);
+void xwin_setdesktop(struct gl_wcb* wcb, void* impl, unsigned long desktop);
 void xwin_addstate(struct gl_wcb* wcb, void* impl, const char* state);
 unsigned int xwin_copyglbg(struct renderer* rd, unsigned int texture);
+Window* xwin_get_desktop_layer(struct gl_wcb* wcb);
+const char* xwin_detect_wm(struct gl_wcb* wcb);
+
+#endif