diff options
Diffstat (limited to 'src/render')
| -rw-r--r-- | src/render/OpenGL.cpp | 225 | ||||
| -rw-r--r-- | src/render/OpenGL.hpp | 65 | ||||
| -rw-r--r-- | src/render/Renderer.cpp | 18 | ||||
| -rw-r--r-- | src/render/Shader.cpp | 0 | ||||
| -rw-r--r-- | src/render/Shader.hpp | 20 | ||||
| -rw-r--r-- | src/render/Shaders.hpp | 69 | ||||
| -rw-r--r-- | src/render/Texture.cpp | 22 | ||||
| -rw-r--r-- | src/render/Texture.hpp | 21 |
8 files changed, 430 insertions, 10 deletions
diff --git a/src/render/OpenGL.cpp b/src/render/OpenGL.cpp new file mode 100644 index 00000000..b86a69d7 --- /dev/null +++ b/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); +}
\ No newline at end of file diff --git a/src/render/OpenGL.hpp b/src/render/OpenGL.hpp new file mode 100644 index 00000000..c3e1b987 --- /dev/null +++ b/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;
\ No newline at end of file diff --git a/src/render/Renderer.cpp b/src/render/Renderer.cpp index 974ab663..864a678e 100644 --- a/src/render/Renderer.cpp +++ b/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) { diff --git a/src/render/Shader.cpp b/src/render/Shader.cpp new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/src/render/Shader.cpp diff --git a/src/render/Shader.hpp b/src/render/Shader.hpp new file mode 100644 index 00000000..630dd32f --- /dev/null +++ b/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; +};
\ No newline at end of file diff --git a/src/render/Shaders.hpp b/src/render/Shaders.hpp new file mode 100644 index 00000000..a9140aca --- /dev/null +++ b/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; +})#"; diff --git a/src/render/Texture.cpp b/src/render/Texture.cpp new file mode 100644 index 00000000..6d47c4a8 --- /dev/null +++ b/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); +}
\ No newline at end of file diff --git a/src/render/Texture.hpp b/src/render/Texture.hpp new file mode 100644 index 00000000..dbdf715a --- /dev/null +++ b/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; +};
\ No newline at end of file |