Merge pull request #14 from vaxerski/custom-renderer-wlr

Added a custom wlr renderer

README.md

@@ -30,10 +30,11 @@ Nevertheless, REPORT any you find! Make an issue!
  - Moving/resizing windows
 
 # Major to-dos
- - Switch to fully custom OpenGL rendering
  - Damage tracking
  - Animations (better)
  - Rounded corners
+ - Fix XWayland focus
+ - Fix GDK popups on multimon
  - Blur
  - Fadein/out
  - Fix electron rendering issues

src/Compositor.cpp

@@ -17,14 +17,14 @@ CCompositor::CCompositor() {
         return;
     }
 
-    const auto DRMFD = wlr_backend_get_drm_fd(m_sWLRBackend);
-    if (DRMFD < 0) {
+    m_iDRMFD = wlr_backend_get_drm_fd(m_sWLRBackend);
+    if (m_iDRMFD < 0) {
         Debug::log(CRIT, "Couldn't query the DRM FD!");
         RIP("DRMFD NULL!");
         return;
     }
 
-    m_sWLRRenderer = wlr_gles2_renderer_create_with_drm_fd(DRMFD);
+    m_sWLRRenderer = wlr_gles2_renderer_create_with_drm_fd(m_iDRMFD);
 
     if (!m_sWLRRenderer) {
         Debug::log(CRIT, "m_sWLRRenderer was NULL!");
@@ -133,6 +133,9 @@ void CCompositor::startCompositor() {
     Debug::log(LOG, "Creating the InputManager!");
     g_pInputManager = std::make_unique<CInputManager>();
 
+    Debug::log(LOG, "Creating the CHyprOpenGLImpl!");
+    g_pHyprOpenGL = std::make_unique<CHyprOpenGLImpl>();
+
     Debug::log(LOG, "Creating the HyprRenderer!");
     g_pHyprRenderer = std::make_unique<CHyprRenderer>();
 

src/Compositor.hpp

@@ -18,6 +18,7 @@
 #include "helpers/Workspace.hpp"
 #include "Window.hpp"
 #include "render/Renderer.hpp"
+#include "render/OpenGL.hpp"
 
 class CCompositor {
 public:
@@ -46,6 +47,7 @@ public:
     wlr_input_inhibit_manager*       m_sWLRInhibitMgr;
     wlr_keyboard_shortcuts_inhibit_manager_v1* m_sWLRKbShInhibitMgr;
     wlr_egl*                         m_sWLREGL;
+    int                              m_iDRMFD;
     // ------------------------------------------------- //
 
 

src/debug/HyprCtl.cpp

@@ -12,19 +12,6 @@
 
 #include <string>
 
-std::string getFormat(const char* fmt, ...) {
-    char buf[2048] = "";
-
-    va_list args;
-    va_start(args, fmt);
-
-    vsprintf(buf, fmt , args);
-
-    va_end(args);
-
-    return std::string(buf);
-}
-
 std::string monitorsRequest() {
     std::string result = "";
     for (auto& m : g_pCompositor->m_lMonitors) {

src/debug/HyprCtl.hpp

@@ -2,6 +2,7 @@
 
 #include "../Compositor.hpp"
 #include <fstream>
+#include "../helpers/MiscFunctions.hpp"
 
 namespace HyprCtl {
     void            startHyprCtlSocket();

src/defines.hpp

@@ -31,13 +31,13 @@
 #define HYPRATOM(name) {name, 0}
 
 #ifndef __INTELLISENSE__
-#define RASSERT(expr, reason)                                                                                                                                                                                                                                                                                                                  \
+#define RASSERT(expr, reason, ...)                                                                                                                                                                                                                                                                                                                  \
     if (!expr) {                                                                                                                                                                                                                                                                                                                               \
-        Debug::log(CRIT, "\n==========================================================================================\nASSERTION FAILED! \n\n%s\n\nat: line %d in %s", std::string(reason).c_str(), __LINE__, ([]() constexpr->std::string { return std::string(__FILE__).substr(std::string(__FILE__).find_last_of('/') + 1); })().c_str()); \
+        Debug::log(CRIT, "\n==========================================================================================\nASSERTION FAILED! \n\n%s\n\nat: line %d in %s", getFormat(reason, ##__VA_ARGS__).c_str(), __LINE__, ([]() constexpr->std::string { return std::string(__FILE__).substr(std::string(__FILE__).find_last_of('/') + 1); })().c_str()); \
         RIP("Assertion failed! See the log in /tmp/hypr/hyprland.log for more info.");                                                                                                                                                                                                                                                         \
     }
 #else
-#define RASSERT(expr, reason)
+#define RASSERT(expr, reason, ...)
 #endif
 
 #define ASSERT(expr) RASSERT(expr, "?")

src/events/Monitors.cpp

@@ -108,20 +108,23 @@ void Events::listener_monitorFrame(void* owner, void* data) {
 
     timespec now;
     clock_gettime(CLOCK_MONOTONIC, &now);
-    const float bgcol[4] = {0.1f, 0.1f, 0.1f, 1.f};
 
     if (!wlr_output_attach_render(PMONITOR->output, nullptr))
         return;
 
-    wlr_renderer_begin(g_pCompositor->m_sWLRRenderer, PMONITOR->vecSize.x, PMONITOR->vecSize.y);
-    wlr_renderer_clear(g_pCompositor->m_sWLRRenderer, bgcol);
+    g_pHyprOpenGL->begin(PMONITOR);
+    g_pHyprOpenGL->clear(CColor(11, 11, 11, 255));
 
     g_pHyprRenderer->renderAllClientsForMonitor(PMONITOR->ID, &now);
 
+    wlr_renderer_begin(g_pCompositor->m_sWLRRenderer, PMONITOR->vecSize.x, PMONITOR->vecSize.y);
+
     wlr_output_render_software_cursors(PMONITOR->output, NULL);
 
     wlr_renderer_end(g_pCompositor->m_sWLRRenderer);
 
+    g_pHyprOpenGL->end();
+
     wlr_output_commit(PMONITOR->output);
 }
 

src/helpers/MiscFunctions.cpp

@@ -42,3 +42,16 @@ void wlr_signal_emit_safe(struct wl_signal *signal, void *data) {
     wl_list_remove(&cursor.link);
     wl_list_remove(&end.link);
 }
+
+std::string getFormat(const char *fmt, ...) {
+    char buf[2048] = "";
+
+    va_list args;
+    va_start(args, fmt);
+
+    vsprintf(buf, fmt, args);
+
+    va_end(args);
+
+    return std::string(buf);
+}

src/helpers/MiscFunctions.hpp

@@ -3,4 +3,5 @@
 #include "../includes.hpp"
 
 void addWLSignal(wl_signal*, wl_listener*, void* pOwner, std::string ownerString);
-void wlr_signal_emit_safe(struct wl_signal *signal, void *data);
+void wlr_signal_emit_safe(struct wl_signal *signal, void *data);
+std::string getFormat(const char *fmt, ...); // Basically Debug::log to a string

src/includes.hpp

@@ -84,5 +84,6 @@ extern "C" {
 #endif
 
 #include <GLES3/gl32.h>
+#include <GLES2/gl2ext.h>
 
 #include "helpers/Vector2D.hpp"

src/render/OpenGL.cpp

@@ -0,0 +1,225 @@
+#include "OpenGL.hpp"
+#include "../Compositor.hpp"
+
+CHyprOpenGLImpl::CHyprOpenGLImpl() {
+    RASSERT(eglMakeCurrent(g_pCompositor->m_sWLREGL->display, EGL_NO_SURFACE, EGL_NO_SURFACE, g_pCompositor->m_sWLREGL->context), "Couldn't make the EGL current!");
+
+    auto *const EXTENSIONS = (const char*)glGetString(GL_EXTENSIONS);
+
+    RASSERT(EXTENSIONS, "Couldn't retrieve openGL extensions!");
+
+    m_iDRMFD = g_pCompositor->m_iDRMFD;
+
+    m_szExtensions = EXTENSIONS;
+
+    Debug::log(LOG, "Creating the Hypr OpenGL Renderer!");
+    Debug::log(LOG, "Using: %s", glGetString(GL_VERSION));
+    Debug::log(LOG, "Vendor: %s", glGetString(GL_VENDOR));
+    Debug::log(LOG, "Renderer: %s", glGetString(GL_RENDERER));
+    Debug::log(LOG, "Supported extensions size: %d", std::count(m_szExtensions.begin(), m_szExtensions.end(), ' '));
+
+    // Init shaders
+
+    GLuint prog = createProgram(QUADVERTSRC, QUADFRAGSRC);
+    m_shQUAD.program = prog;
+    m_shQUAD.proj = glGetUniformLocation(prog, "proj");
+    m_shQUAD.color = glGetUniformLocation(prog, "color");
+    m_shQUAD.posAttrib = glGetAttribLocation(prog, "pos");
+
+    prog = createProgram(TEXVERTSRC, TEXFRAGSRCRGBA);
+    m_shRGBA.program = prog;
+    m_shRGBA.proj = glGetUniformLocation(prog, "proj");
+    m_shRGBA.tex = glGetUniformLocation(prog, "tex");
+    m_shRGBA.alpha = glGetUniformLocation(prog, "alpha");
+    m_shRGBA.texAttrib = glGetAttribLocation(prog, "texcoord");
+    m_shRGBA.posAttrib = glGetAttribLocation(prog, "pos");
+
+    prog = createProgram(TEXVERTSRC, TEXFRAGSRCRGBX);
+    m_shRGBX.program = prog;
+    m_shRGBX.tex = glGetUniformLocation(prog, "tex");
+    m_shRGBX.proj = glGetUniformLocation(prog, "proj");
+    m_shRGBX.alpha = glGetUniformLocation(prog, "alpha");
+    m_shRGBX.texAttrib = glGetAttribLocation(prog, "texcoord");
+    m_shRGBX.posAttrib = glGetAttribLocation(prog, "pos");
+
+    prog = createProgram(TEXVERTSRC, TEXFRAGSRCEXT);
+    m_shEXT.program = prog;
+    m_shEXT.tex = glGetUniformLocation(prog, "tex");
+    m_shEXT.proj = glGetUniformLocation(prog, "proj");
+    m_shEXT.alpha = glGetUniformLocation(prog, "alpha");
+    m_shEXT.posAttrib = glGetAttribLocation(prog, "pos");
+    m_shEXT.texAttrib = glGetAttribLocation(prog, "texcoord");
+
+    Debug::log(LOG, "Shaders initialized successfully.");
+
+    // End shaders
+
+    RASSERT(eglMakeCurrent(g_pCompositor->m_sWLREGL->display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT), "Couldn't unset current EGL!");
+
+    // Done!
+}
+
+GLuint CHyprOpenGLImpl::createProgram(const std::string& vert, const std::string& frag) {
+    auto vertCompiled = compileShader(GL_VERTEX_SHADER, vert);
+    RASSERT(vertCompiled, "Compiling shader failed. VERTEX NULL! Shader source:\n\n%s", vert.c_str());
+
+    auto fragCompiled = compileShader(GL_FRAGMENT_SHADER, frag);
+    RASSERT(fragCompiled, "Compiling shader failed. FRAGMENT NULL! Shader source:\n\n%s", frag.c_str());
+
+    auto prog = glCreateProgram();
+    glAttachShader(prog, vertCompiled);
+    glAttachShader(prog, fragCompiled);
+    glLinkProgram(prog);
+
+    glDetachShader(prog, vertCompiled);
+    glDetachShader(prog, fragCompiled);
+    glDeleteShader(vertCompiled);
+    glDeleteShader(fragCompiled);
+
+    GLint ok;
+    glGetProgramiv(prog, GL_LINK_STATUS, &ok);
+    RASSERT(ok != GL_FALSE, "createProgram() failed! GL_LINK_STATUS not OK!");
+
+    return prog;
+}
+
+GLuint CHyprOpenGLImpl::compileShader(const GLuint& type, std::string src) {
+    auto shader = glCreateShader(type);
+
+    auto shaderSource = src.c_str();
+
+    glShaderSource(shader, 1, (const GLchar**)&shaderSource, nullptr);
+    glCompileShader(shader);
+
+    GLint ok;
+    glGetShaderiv(shader, GL_COMPILE_STATUS, &ok);
+    RASSERT(ok != GL_FALSE, "compileShader() failed! GL_COMPILE_STATUS not OK!");
+
+    return shader;
+}
+
+void CHyprOpenGLImpl::begin(SMonitor* pMonitor) {
+    m_RenderData.pMonitor = pMonitor;
+
+    glViewport(0, 0, pMonitor->vecSize.x, pMonitor->vecSize.y);
+
+    wlr_matrix_projection(m_RenderData.projection, pMonitor->vecSize.x, pMonitor->vecSize.y, WL_OUTPUT_TRANSFORM_NORMAL); // TODO: this is deprecated
+
+    glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+}
+
+void CHyprOpenGLImpl::end() {
+    m_RenderData.pMonitor = nullptr;
+}
+
+void CHyprOpenGLImpl::clear(const CColor& color) {
+    RASSERT(m_RenderData.pMonitor, "Tried to render without begin()!");
+
+    glClearColor(color.r / 255.f, color.g / 255.f, color.b / 255.f, color.a / 255.f);
+    glClear(GL_COLOR_BUFFER_BIT);
+}
+
+void CHyprOpenGLImpl::scissor(const wlr_box* pBox) {
+    RASSERT(m_RenderData.pMonitor, "Tried to scissor without begin()!");
+
+    if (!pBox) {
+        glDisable(GL_SCISSOR_TEST);
+        return;
+    }
+
+    glScissor(pBox->x, pBox->y, pBox->width, pBox->height);
+    glEnable(GL_SCISSOR_TEST);
+}
+
+void CHyprOpenGLImpl::renderRect(wlr_box* box, const CColor& col) {
+    RASSERT((box->width > 0 && box->height > 0), "Tried to render rect with width/height < 0!");
+    RASSERT(m_RenderData.pMonitor, "Tried to render rect without begin()!");
+
+    float matrix[9];
+    wlr_matrix_project_box(matrix, box, WL_OUTPUT_TRANSFORM_NORMAL, 0, m_RenderData.pMonitor->output->transform_matrix);  // TODO: write own, don't use WLR here
+
+    float glMatrix[9];
+    wlr_matrix_multiply(glMatrix, m_RenderData.projection, matrix);
+    wlr_matrix_multiply(glMatrix, matrixFlip180, glMatrix);
+
+    wlr_matrix_transpose(glMatrix, glMatrix);
+
+    if (col.a == 255.f) 
+        glDisable(GL_BLEND);
+    else
+        glEnable(GL_BLEND);
+
+    glUseProgram(m_shQUAD.program);
+
+    glUniformMatrix3fv(m_shQUAD.proj, 1, GL_FALSE, glMatrix);
+    glUniform4f(m_shQUAD.color, col.r / 255.f, col.g / 255.f, col.b / 255.f, col.a / 255.f);
+
+    glVertexAttribPointer(m_shQUAD.posAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
+
+    glEnableVertexAttribArray(m_shQUAD.posAttrib);
+
+    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+
+    glDisableVertexAttribArray(m_shQUAD.posAttrib);
+}
+
+void CHyprOpenGLImpl::renderTexture(wlr_texture* tex,float matrix[9], float alpha) {
+    RASSERT(m_RenderData.pMonitor, "Tried to render texture without begin()!");
+
+    renderTexture(CTexture(tex), matrix, alpha);
+}
+
+void CHyprOpenGLImpl::renderTexture(const CTexture& tex, float matrix[9], float alpha) {
+    RASSERT(m_RenderData.pMonitor, "Tried to render texture without begin()!");
+    RASSERT((tex.m_iTexID > 0), "Attempted to draw NULL texture!");
+
+    float glMatrix[9];
+    wlr_matrix_multiply(glMatrix, m_RenderData.projection, matrix);
+    wlr_matrix_multiply(glMatrix, matrixFlip180, glMatrix);
+
+    wlr_matrix_transpose(glMatrix, glMatrix);
+
+    CShader* shader = nullptr;
+
+    switch (tex.m_iType) {
+        case TEXTURE_RGBA:
+            shader = &m_shRGBA;
+            glEnable(GL_BLEND);
+            break;
+        case TEXTURE_RGBX:
+            shader = &m_shRGBX;
+            if (alpha == 255.f)
+                glDisable(GL_BLEND);
+            break;
+        case TEXTURE_EXTERNAL:
+            shader = &m_shEXT;
+            glEnable(GL_BLEND);
+            break;
+        default:
+            RASSERT(false, "tex.m_iTarget unsupported!");
+    }
+
+    glActiveTexture(GL_TEXTURE0);
+    glBindTexture(tex.m_iTarget, tex.m_iTexID);
+
+    glTexParameteri(tex.m_iTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+
+    glUseProgram(shader->program);
+
+    glUniformMatrix3fv(shader->proj, 1, GL_FALSE, glMatrix);
+    glUniform1i(shader->tex, 0);
+    glUniform1f(shader->alpha, alpha / 255.f);
+
+    glVertexAttribPointer(shader->posAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
+    glVertexAttribPointer(shader->texAttrib, 2, GL_FLOAT, GL_FALSE, 0, fullVerts);
+
+    glEnableVertexAttribArray(shader->posAttrib);
+    glEnableVertexAttribArray(shader->texAttrib);
+
+    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+
+    glDisableVertexAttribArray(shader->posAttrib);
+    glDisableVertexAttribArray(shader->texAttrib);
+
+    glBindTexture(tex.m_iTarget, 0);
+}

src/render/OpenGL.hpp

@@ -0,0 +1,65 @@
+#pragma once
+
+#include "../defines.hpp"
+#include "../helpers/Monitor.hpp"
+#include "../helpers/Color.hpp"
+#include <wlr/render/egl.h>
+#include <list>
+
+#include "Shaders.hpp"
+#include "Shader.hpp"
+#include "Texture.hpp"
+
+inline const float matrixFlip180[] = {
+	1.0f, 0.0f, 0.0f,
+	0.0f, -1.0f, 0.0f,
+	0.0f, 0.0f, 1.0f,
+};
+inline const float fullVerts[] = {
+    1, 0,  // top right
+    0, 0,  // top left
+    1, 1,  // bottom right
+    0, 1,  // bottom left
+};
+
+struct SCurrentRenderData {
+    SMonitor*   pMonitor = nullptr;
+    float       projection[9];
+};
+
+class CHyprOpenGLImpl {
+public:
+
+    CHyprOpenGLImpl();
+
+    void    begin(SMonitor*);
+    void    end();
+
+    void    renderRect(wlr_box*, const CColor&);
+    void    renderTexture(wlr_texture*, float matrix[9], float a);
+    void    renderTexture(const CTexture&, float matrix[9], float a);
+
+    void    clear(const CColor&);
+    void    scissor(const wlr_box*);
+
+    SCurrentRenderData m_RenderData;
+
+private:
+    std::list<GLuint>       m_lBuffers;
+    std::list<GLuint>       m_lTextures;
+
+    int                     m_iDRMFD;
+    std::string             m_szExtensions;
+
+    // Shaders
+    SQuad                   m_shQUAD;
+    CShader                 m_shRGBA;
+    CShader                 m_shRGBX;
+    CShader                 m_shEXT;
+    //
+
+    GLuint                  createProgram(const std::string&, const std::string&);
+    GLuint                  compileShader(const GLuint&, std::string);
+};
+
+inline std::unique_ptr<CHyprOpenGLImpl> g_pHyprOpenGL;

src/render/Renderer.cpp

@@ -21,7 +21,7 @@ void renderSurface(struct wlr_surface* surface, int x, int y, void* data) {
     wlr_box windowBox;
     if (RDATA->surface && surface == RDATA->surface) {
         windowBox = {(int)outputX + RDATA->x + x, (int)outputY + RDATA->y + y, RDATA->w, RDATA->h};
-        wlr_renderer_scissor(g_pCompositor->m_sWLRRenderer, &windowBox);
+        g_pHyprOpenGL->scissor(&windowBox);
     } else {
         windowBox = {(int)outputX + RDATA->x + x, (int)outputY + RDATA->y + y, surface->current.width, surface->current.height};
     }
@@ -31,13 +31,13 @@ void renderSurface(struct wlr_surface* surface, int x, int y, void* data) {
     float matrix[9];
     wlr_matrix_project_box(matrix, &windowBox, TRANSFORM, 0, RDATA->output->transform_matrix);
 
-    wlr_render_texture_with_matrix(g_pCompositor->m_sWLRRenderer, TEXTURE, matrix, 1); // TODO: fadein/out
+    g_pHyprOpenGL->renderTexture(TEXTURE, matrix, 255.f); // TODO: fadeinout
 
     wlr_surface_send_frame_done(surface, RDATA->when);
 
     wlr_presentation_surface_sampled_on_output(g_pCompositor->m_sWLRPresentation, surface, RDATA->output);
 
-    wlr_renderer_scissor(g_pCompositor->m_sWLRRenderer, nullptr);
+    g_pHyprOpenGL->scissor(nullptr);
 }
 
 bool shouldRenderWindow(CWindow* pWindow, SMonitor* pMonitor) {
@@ -395,29 +395,27 @@ void CHyprRenderer::arrangeLayersForMonitor(const int& monitor) {
 
 void CHyprRenderer::drawBorderForWindow(CWindow* pWindow, SMonitor* pMonitor) {
     const auto BORDERSIZE = g_pConfigManager->getInt("general:border_size");
-    const auto BORDERCOL = pWindow->m_cRealBorderColor.getAsHex();
-
-    const float BORDERWLRCOL[4] = {RED(BORDERCOL), GREEN(BORDERCOL), BLUE(BORDERCOL), ALPHA(BORDERCOL)};
+    const auto BORDERCOL = pWindow->m_cRealBorderColor;
 
     Vector2D correctPos = pWindow->m_vRealPosition - pMonitor->vecPosition;
 
     // top
     wlr_box border = {correctPos.x - BORDERSIZE, correctPos.y - BORDERSIZE, pWindow->m_vRealSize.x + 2 * BORDERSIZE, BORDERSIZE};
-    wlr_render_rect(g_pCompositor->m_sWLRRenderer, &border, BORDERWLRCOL, pMonitor->output->transform_matrix);
+    g_pHyprOpenGL->renderRect(&border, BORDERCOL);
 
     // bottom
     border.y = correctPos.y + pWindow->m_vRealSize.y;
-    wlr_render_rect(g_pCompositor->m_sWLRRenderer, &border, BORDERWLRCOL, pMonitor->output->transform_matrix);
+    g_pHyprOpenGL->renderRect(&border, BORDERCOL);
 
     // left
     border.y = correctPos.y;
     border.width = BORDERSIZE;
     border.height = pWindow->m_vRealSize.y;
-    wlr_render_rect(g_pCompositor->m_sWLRRenderer, &border, BORDERWLRCOL, pMonitor->output->transform_matrix);
+    g_pHyprOpenGL->renderRect(&border, BORDERCOL);
 
     // right
     border.x = correctPos.x + pWindow->m_vRealSize.x;
-    wlr_render_rect(g_pCompositor->m_sWLRRenderer, &border, BORDERWLRCOL, pMonitor->output->transform_matrix);
+    g_pHyprOpenGL->renderRect(&border, BORDERCOL);
 }
 
 void damageSurfaceIter(struct wlr_surface* surface, int x, int y, void* data) {

src/render/Shader.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "../defines.hpp"
+
+struct SQuad {
+    GLuint program;
+    GLint proj;
+    GLint color;
+    GLint posAttrib;
+};
+
+class CShader {
+public:
+    GLuint program;
+    GLint proj;
+    GLint tex;
+    GLint alpha;
+    GLint posAttrib;
+    GLint texAttrib;
+};

src/render/Shaders.hpp

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <string>
+
+inline const std::string QUADVERTSRC = R"#(
+uniform mat3 proj;
+uniform vec4 color;
+attribute vec2 pos;
+attribute vec2 texcoord;
+varying vec4 v_color;
+varying vec2 v_texcoord;
+
+void main() {
+    gl_Position = vec4(proj * vec3(pos, 1.0), 1.0);
+    v_color = color;
+    v_texcoord = texcoord;
+})#";
+
+inline const std::string QUADFRAGSRC = R"#(
+precision mediump float;
+varying vec4 v_color;
+varying vec2 v_texcoord;
+
+void main() {
+    gl_FragColor = v_color;
+})#";
+
+inline const std::string TEXVERTSRC = R"#(
+uniform mat3 proj;
+attribute vec2 pos;
+attribute vec2 texcoord;
+varying vec2 v_texcoord;
+
+void main() {
+	gl_Position = vec4(proj * vec3(pos, 1.0), 1.0);
+	v_texcoord = texcoord;
+})#";
+
+inline const std::string TEXFRAGSRCRGBA = R"#(
+precision mediump float;
+varying vec2 v_texcoord;
+uniform sampler2D tex;
+uniform float alpha;
+
+void main() {
+	gl_FragColor = texture2D(tex, v_texcoord) * alpha;
+})#";
+
+inline const std::string TEXFRAGSRCRGBX = R"#(
+precision mediump float;
+varying vec2 v_texcoord;
+uniform sampler2D tex;
+uniform float alpha;
+
+void main() {
+	gl_FragColor = vec4(texture2D(tex, v_texcoord).rgb, 1.0) * alpha;
+})#";
+
+inline const std::string TEXFRAGSRCEXT = R"#(
+#extension GL_OES_EGL_image_external : require
+
+precision mediump float;
+varying vec2 v_texcoord;
+uniform samplerExternalOES texture0;
+uniform float alpha;
+
+void main() {
+	gl_FragColor = texture2D(texture0, v_texcoord) * alpha;
+})#";

src/render/Texture.cpp

@@ -0,0 +1,22 @@
+#include "Texture.hpp"
+
+CTexture::CTexture() {
+    // naffin'
+}
+
+CTexture::CTexture(wlr_texture* tex) {
+    RASSERT(wlr_texture_is_gles2(tex), "wlr_texture provided to CTexture that isn't GLES2!");
+    wlr_gles2_texture_attribs attrs;
+    wlr_gles2_texture_get_attribs(tex, &attrs);
+
+    m_iTarget = attrs.target;
+    m_iTexID = attrs.tex;
+
+    if (m_iTarget == GL_TEXTURE_2D) {
+        m_iType = attrs.has_alpha ? TEXTURE_RGBA : TEXTURE_RGBX;
+    } else {
+        m_iType = TEXTURE_EXTERNAL;
+    }
+
+    m_vSize = Vector2D(tex->width, tex->height);
+}

src/render/Texture.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "../defines.hpp"
+
+enum TEXTURETYPE {
+    TEXTURE_INVALID,    // Invalid
+    TEXTURE_RGBA,       // 4 channels
+    TEXTURE_RGBX,       // discard A
+    TEXTURE_EXTERNAL,   // EGLImage
+};
+
+class CTexture {
+public:
+    CTexture();
+    CTexture(wlr_texture*);
+
+    TEXTURETYPE         m_iType = TEXTURE_RGBA;
+    GLenum              m_iTarget = GL_TEXTURE_2D;
+    GLuint              m_iTexID = 0;
+    Vector2D            m_vSize;
+};