diff options
Diffstat (limited to 'src')
28 files changed, 880 insertions, 901 deletions
diff --git a/src/debug/HyprDebugOverlay.cpp b/src/debug/HyprDebugOverlay.cpp index 6c5d8000..45b11de9 100644 --- a/src/debug/HyprDebugOverlay.cpp +++ b/src/debug/HyprDebugOverlay.cpp @@ -260,11 +260,11 @@ void CHyprDebugOverlay::draw() { // copy the data to an OpenGL texture we have const auto DATA = cairo_image_surface_get_data(m_cairoSurface); m_texture->allocate(); - glBindTexture(GL_TEXTURE_2D, m_texture->m_texID); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_BLUE); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED); + m_texture->bind(); + m_texture->setTexParameter(GL_TEXTURE_MAG_FILTER, GL_NEAREST); + m_texture->setTexParameter(GL_TEXTURE_MIN_FILTER, GL_NEAREST); + m_texture->setTexParameter(GL_TEXTURE_SWIZZLE_R, GL_BLUE); + m_texture->setTexParameter(GL_TEXTURE_SWIZZLE_B, GL_RED); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA); diff --git a/src/debug/HyprNotificationOverlay.cpp b/src/debug/HyprNotificationOverlay.cpp index c50abfe6..05a13da4 100644 --- a/src/debug/HyprNotificationOverlay.cpp +++ b/src/debug/HyprNotificationOverlay.cpp @@ -235,11 +235,11 @@ void CHyprNotificationOverlay::draw(PHLMONITOR pMonitor) { // copy the data to an OpenGL texture we have const auto DATA = cairo_image_surface_get_data(m_cairoSurface); m_texture->allocate(); - glBindTexture(GL_TEXTURE_2D, m_texture->m_texID); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_BLUE); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED); + m_texture->bind(); + m_texture->setTexParameter(GL_TEXTURE_MAG_FILTER, GL_NEAREST); + m_texture->setTexParameter(GL_TEXTURE_MIN_FILTER, GL_NEAREST); + m_texture->setTexParameter(GL_TEXTURE_SWIZZLE_R, GL_BLUE); + m_texture->setTexParameter(GL_TEXTURE_SWIZZLE_B, GL_RED); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, MONSIZE.x, MONSIZE.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA); diff --git a/src/hyprerror/HyprError.cpp b/src/hyprerror/HyprError.cpp index b6080306..ad8a8782 100644 --- a/src/hyprerror/HyprError.cpp +++ b/src/hyprerror/HyprError.cpp @@ -143,11 +143,11 @@ void CHyprError::createQueued() { // copy the data to an OpenGL texture we have const auto DATA = cairo_image_surface_get_data(CAIROSURFACE); m_texture->allocate(); - glBindTexture(GL_TEXTURE_2D, m_texture->m_texID); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_BLUE); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED); + m_texture->bind(); + m_texture->setTexParameter(GL_TEXTURE_MAG_FILTER, GL_NEAREST); + m_texture->setTexParameter(GL_TEXTURE_MIN_FILTER, GL_NEAREST); + m_texture->setTexParameter(GL_TEXTURE_SWIZZLE_R, GL_BLUE); + m_texture->setTexParameter(GL_TEXTURE_SWIZZLE_B, GL_RED); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA); diff --git a/src/macros.hpp b/src/macros.hpp index 9ba0e188..851f1ca3 100644 --- a/src/macros.hpp +++ b/src/macros.hpp @@ -95,6 +95,8 @@ #define UNREACHABLE() std::unreachable(); #endif +#if ISDEBUG + #define GLCALL(__CALL__) \ { \ __CALL__; \ @@ -105,6 +107,13 @@ } \ } +#else + +#define GLCALL(__CALL__) \ + { __CALL__; } + +#endif + #define HYPRUTILS_FORWARD(ns, name) \ namespace Hyprutils { \ namespace ns { \ diff --git a/src/render/Framebuffer.cpp b/src/render/Framebuffer.cpp index b3681c95..9e590de5 100644 --- a/src/render/Framebuffer.cpp +++ b/src/render/Framebuffer.cpp @@ -20,11 +20,11 @@ bool CFramebuffer::alloc(int w, int h, uint32_t drmFormat) { if (!m_tex) { m_tex = makeShared<CTexture>(); m_tex->allocate(); - glBindTexture(GL_TEXTURE_2D, m_tex->m_texID); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + m_tex->bind(); + m_tex->setTexParameter(GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + m_tex->setTexParameter(GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + m_tex->setTexParameter(GL_TEXTURE_MAG_FILTER, GL_LINEAR); + m_tex->setTexParameter(GL_TEXTURE_MIN_FILTER, GL_LINEAR); firstAlloc = true; } @@ -35,13 +35,13 @@ bool CFramebuffer::alloc(int w, int h, uint32_t drmFormat) { } if (firstAlloc || m_size != Vector2D(w, h)) { - glBindTexture(GL_TEXTURE_2D, m_tex->m_texID); + m_tex->bind(); glTexImage2D(GL_TEXTURE_2D, 0, glFormat, w, h, 0, GL_RGBA, glType, nullptr); glBindFramebuffer(GL_FRAMEBUFFER, m_fb); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_tex->m_texID, 0); if (m_stencilTex) { - glBindTexture(GL_TEXTURE_2D, m_stencilTex->m_texID); + m_stencilTex->bind(); glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, w, h, 0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, nullptr); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, m_stencilTex->m_texID, 0); } @@ -62,7 +62,7 @@ bool CFramebuffer::alloc(int w, int h, uint32_t drmFormat) { void CFramebuffer::addStencil(SP<CTexture> tex) { m_stencilTex = tex; - glBindTexture(GL_TEXTURE_2D, m_stencilTex->m_texID); + m_stencilTex->bind(); glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, m_size.x, m_size.y, 0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, nullptr); glBindFramebuffer(GL_FRAMEBUFFER, m_fb); @@ -72,7 +72,7 @@ void CFramebuffer::addStencil(SP<CTexture> tex) { auto status = glCheckFramebufferStatus(GL_FRAMEBUFFER); RASSERT((status == GL_FRAMEBUFFER_COMPLETE), "Failed adding a stencil to fbo!", status); - glBindTexture(GL_TEXTURE_2D, 0); + m_stencilTex->unbind(); glBindFramebuffer(GL_FRAMEBUFFER, 0); } @@ -80,7 +80,7 @@ void CFramebuffer::bind() { glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_fb); if (g_pHyprOpenGL) - glViewport(0, 0, g_pHyprOpenGL->m_renderData.pMonitor->m_pixelSize.x, g_pHyprOpenGL->m_renderData.pMonitor->m_pixelSize.y); + g_pHyprOpenGL->setViewport(0, 0, g_pHyprOpenGL->m_renderData.pMonitor->m_pixelSize.x, g_pHyprOpenGL->m_renderData.pMonitor->m_pixelSize.y); else glViewport(0, 0, m_size.x, m_size.y); } diff --git a/src/render/OpenGL.cpp b/src/render/OpenGL.cpp index 30680497..5568e5b9 100644 --- a/src/render/OpenGL.cpp +++ b/src/render/OpenGL.cpp @@ -675,7 +675,7 @@ void CHyprOpenGLImpl::beginSimple(PHLMONITOR pMonitor, const CRegion& damage, SP const auto FBO = rb ? rb->getFB() : fb; - glViewport(0, 0, pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y); + setViewport(0, 0, pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y); m_renderData.projection = Mat3x3::outputProjection(pMonitor->m_pixelSize, HYPRUTILS_TRANSFORM_NORMAL); @@ -725,7 +725,7 @@ void CHyprOpenGLImpl::begin(PHLMONITOR pMonitor, const CRegion& damage_, CFrameb TRACY_GPU_ZONE("RenderBegin"); - glViewport(0, 0, pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y); + setViewport(0, 0, pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y); m_renderData.projection = Mat3x3::outputProjection(pMonitor->m_pixelSize, HYPRUTILS_TRANSFORM_NORMAL); @@ -895,26 +895,26 @@ static std::string processShader(const std::string& filename, const std::map<std // shader has #include "CM.glsl" static void getCMShaderUniforms(SShader& shader) { - shader.skipCM = glGetUniformLocation(shader.program, "skipCM"); - shader.sourceTF = glGetUniformLocation(shader.program, "sourceTF"); - shader.targetTF = glGetUniformLocation(shader.program, "targetTF"); - shader.srcTFRange = glGetUniformLocation(shader.program, "srcTFRange"); - shader.dstTFRange = glGetUniformLocation(shader.program, "dstTFRange"); - shader.targetPrimaries = glGetUniformLocation(shader.program, "targetPrimaries"); - shader.maxLuminance = glGetUniformLocation(shader.program, "maxLuminance"); - shader.dstMaxLuminance = glGetUniformLocation(shader.program, "dstMaxLuminance"); - shader.dstRefLuminance = glGetUniformLocation(shader.program, "dstRefLuminance"); - shader.sdrSaturation = glGetUniformLocation(shader.program, "sdrSaturation"); - shader.sdrBrightness = glGetUniformLocation(shader.program, "sdrBrightnessMultiplier"); - shader.convertMatrix = glGetUniformLocation(shader.program, "convertMatrix"); + shader.uniformLocations[SHADER_SKIP_CM] = glGetUniformLocation(shader.program, "skipCM"); + shader.uniformLocations[SHADER_SOURCE_TF] = glGetUniformLocation(shader.program, "sourceTF"); + shader.uniformLocations[SHADER_TARGET_TF] = glGetUniformLocation(shader.program, "targetTF"); + shader.uniformLocations[SHADER_SRC_TF_RANGE] = glGetUniformLocation(shader.program, "srcTFRange"); + shader.uniformLocations[SHADER_DST_TF_RANGE] = glGetUniformLocation(shader.program, "dstTFRange"); + shader.uniformLocations[SHADER_TARGET_PRIMARIES] = glGetUniformLocation(shader.program, "targetPrimaries"); + shader.uniformLocations[SHADER_MAX_LUMINANCE] = glGetUniformLocation(shader.program, "maxLuminance"); + shader.uniformLocations[SHADER_DST_MAX_LUMINANCE] = glGetUniformLocation(shader.program, "dstMaxLuminance"); + shader.uniformLocations[SHADER_DST_REF_LUMINANCE] = glGetUniformLocation(shader.program, "dstRefLuminance"); + shader.uniformLocations[SHADER_SDR_SATURATION] = glGetUniformLocation(shader.program, "sdrSaturation"); + shader.uniformLocations[SHADER_SDR_BRIGHTNESS] = glGetUniformLocation(shader.program, "sdrBrightnessMultiplier"); + shader.uniformLocations[SHADER_CONVERT_MATRIX] = glGetUniformLocation(shader.program, "convertMatrix"); } // shader has #include "rounding.glsl" static void getRoundingShaderUniforms(SShader& shader) { - shader.topLeft = glGetUniformLocation(shader.program, "topLeft"); - shader.fullSize = glGetUniformLocation(shader.program, "fullSize"); - shader.radius = glGetUniformLocation(shader.program, "radius"); - shader.roundingPower = glGetUniformLocation(shader.program, "roundingPower"); + shader.uniformLocations[SHADER_TOP_LEFT] = glGetUniformLocation(shader.program, "topLeft"); + shader.uniformLocations[SHADER_FULL_SIZE] = glGetUniformLocation(shader.program, "fullSize"); + shader.uniformLocations[SHADER_RADIUS] = glGetUniformLocation(shader.program, "radius"); + shader.uniformLocations[SHADER_ROUNDING_POWER] = glGetUniformLocation(shader.program, "roundingPower"); } bool CHyprOpenGLImpl::initShaders() { @@ -927,8 +927,7 @@ bool CHyprOpenGLImpl::initShaders() { loadShaderInclude("rounding.glsl", includes); loadShaderInclude("CM.glsl", includes); - shaders->TEXVERTSRC = processShader("tex.vert", includes); - shaders->TEXVERTSRC300 = processShader("tex300.vert", includes); + shaders->TEXVERTSRC = processShader("tex300.vert", includes); shaders->TEXVERTSRC320 = processShader("tex320.vert", includes); GLuint prog; @@ -938,7 +937,7 @@ bool CHyprOpenGLImpl::initShaders() { else { const auto TEXFRAGSRCCM = processShader("CM.frag", includes); - prog = createProgram(shaders->TEXVERTSRC300, TEXFRAGSRCCM, true, true); + prog = createProgram(shaders->TEXVERTSRC, TEXFRAGSRCCM, true, true); if (m_shadersInitialized && m_cmSupported && prog == 0) g_pHyprNotificationOverlay->addNotification("CM shader reload failed, falling back to rgba/rgbx", CHyprColor{}, 15000, ICON_WARNING); @@ -947,20 +946,20 @@ bool CHyprOpenGLImpl::initShaders() { shaders->m_shCM.program = prog; getCMShaderUniforms(shaders->m_shCM); getRoundingShaderUniforms(shaders->m_shCM); - shaders->m_shCM.proj = glGetUniformLocation(prog, "proj"); - shaders->m_shCM.tex = glGetUniformLocation(prog, "tex"); - shaders->m_shCM.texType = glGetUniformLocation(prog, "texType"); - shaders->m_shCM.alphaMatte = glGetUniformLocation(prog, "texMatte"); - shaders->m_shCM.alpha = glGetUniformLocation(prog, "alpha"); - shaders->m_shCM.texAttrib = glGetAttribLocation(prog, "texcoord"); - shaders->m_shCM.matteTexAttrib = glGetAttribLocation(prog, "texcoordMatte"); - shaders->m_shCM.posAttrib = glGetAttribLocation(prog, "pos"); - shaders->m_shCM.discardOpaque = glGetUniformLocation(prog, "discardOpaque"); - shaders->m_shCM.discardAlpha = glGetUniformLocation(prog, "discardAlpha"); - shaders->m_shCM.discardAlphaValue = glGetUniformLocation(prog, "discardAlphaValue"); - shaders->m_shCM.applyTint = glGetUniformLocation(prog, "applyTint"); - shaders->m_shCM.tint = glGetUniformLocation(prog, "tint"); - shaders->m_shCM.useAlphaMatte = glGetUniformLocation(prog, "useAlphaMatte"); + shaders->m_shCM.uniformLocations[SHADER_PROJ] = glGetUniformLocation(prog, "proj"); + shaders->m_shCM.uniformLocations[SHADER_TEX] = glGetUniformLocation(prog, "tex"); + shaders->m_shCM.uniformLocations[SHADER_TEX_TYPE] = glGetUniformLocation(prog, "texType"); + shaders->m_shCM.uniformLocations[SHADER_ALPHA_MATTE] = glGetUniformLocation(prog, "texMatte"); + shaders->m_shCM.uniformLocations[SHADER_ALPHA] = glGetUniformLocation(prog, "alpha"); + shaders->m_shCM.uniformLocations[SHADER_TEX_ATTRIB] = glGetAttribLocation(prog, "texcoord"); + shaders->m_shCM.uniformLocations[SHADER_MATTE_TEX_ATTRIB] = glGetAttribLocation(prog, "texcoordMatte"); + shaders->m_shCM.uniformLocations[SHADER_POS_ATTRIB] = glGetAttribLocation(prog, "pos"); + shaders->m_shCM.uniformLocations[SHADER_DISCARD_OPAQUE] = glGetUniformLocation(prog, "discardOpaque"); + shaders->m_shCM.uniformLocations[SHADER_DISCARD_ALPHA] = glGetUniformLocation(prog, "discardAlpha"); + shaders->m_shCM.uniformLocations[SHADER_DISCARD_ALPHA_VALUE] = glGetUniformLocation(prog, "discardAlphaValue"); + shaders->m_shCM.uniformLocations[SHADER_APPLY_TINT] = glGetUniformLocation(prog, "applyTint"); + shaders->m_shCM.uniformLocations[SHADER_TINT] = glGetUniformLocation(prog, "tint"); + shaders->m_shCM.uniformLocations[SHADER_USE_ALPHA_MATTE] = glGetUniformLocation(prog, "useAlphaMatte"); shaders->m_shCM.createVao(); } else Debug::log(ERR, @@ -968,10 +967,10 @@ bool CHyprOpenGLImpl::initShaders() { "about this!"); } - const auto FRAGSHADOW = processShader(m_cmSupported ? "shadow.frag" : "shadow_legacy.frag", includes); - const auto FRAGBORDER1 = processShader(m_cmSupported ? "border.frag" : "border_legacy.frag", includes); - const auto FRAGBLURPREPARE = processShader(m_cmSupported ? "blurprepare.frag" : "blurprepare_legacy.frag", includes); - const auto FRAGBLURFINISH = processShader(m_cmSupported ? "blurfinish.frag" : "blurfinish_legacy.frag", includes); + const auto FRAGSHADOW = processShader("shadow.frag", includes); + const auto FRAGBORDER1 = processShader("border.frag", includes); + const auto FRAGBLURPREPARE = processShader("blurprepare.frag", includes); + const auto FRAGBLURFINISH = processShader("blurfinish.frag", includes); const auto QUADFRAGSRC = processShader("quad.frag", includes); const auto TEXFRAGSRCRGBA = processShader("rgba.frag", includes); const auto TEXFRAGSRCRGBAPASSTHRU = processShader("passthru.frag", includes); @@ -987,9 +986,9 @@ bool CHyprOpenGLImpl::initShaders() { return false; shaders->m_shQUAD.program = prog; getRoundingShaderUniforms(shaders->m_shQUAD); - shaders->m_shQUAD.proj = glGetUniformLocation(prog, "proj"); - shaders->m_shQUAD.color = glGetUniformLocation(prog, "color"); - shaders->m_shQUAD.posAttrib = glGetAttribLocation(prog, "pos"); + shaders->m_shQUAD.uniformLocations[SHADER_PROJ] = glGetUniformLocation(prog, "proj"); + shaders->m_shQUAD.uniformLocations[SHADER_COLOR] = glGetUniformLocation(prog, "color"); + shaders->m_shQUAD.uniformLocations[SHADER_POS_ATTRIB] = glGetAttribLocation(prog, "pos"); shaders->m_shQUAD.createVao(); prog = createProgram(shaders->TEXVERTSRC, TEXFRAGSRCRGBA, isDynamic); @@ -997,53 +996,53 @@ bool CHyprOpenGLImpl::initShaders() { return false; shaders->m_shRGBA.program = prog; getRoundingShaderUniforms(shaders->m_shRGBA); - shaders->m_shRGBA.proj = glGetUniformLocation(prog, "proj"); - shaders->m_shRGBA.tex = glGetUniformLocation(prog, "tex"); - shaders->m_shRGBA.alphaMatte = glGetUniformLocation(prog, "texMatte"); - shaders->m_shRGBA.alpha = glGetUniformLocation(prog, "alpha"); - shaders->m_shRGBA.texAttrib = glGetAttribLocation(prog, "texcoord"); - shaders->m_shRGBA.matteTexAttrib = glGetAttribLocation(prog, "texcoordMatte"); - shaders->m_shRGBA.posAttrib = glGetAttribLocation(prog, "pos"); - shaders->m_shRGBA.discardOpaque = glGetUniformLocation(prog, "discardOpaque"); - shaders->m_shRGBA.discardAlpha = glGetUniformLocation(prog, "discardAlpha"); - shaders->m_shRGBA.discardAlphaValue = glGetUniformLocation(prog, "discardAlphaValue"); - shaders->m_shRGBA.applyTint = glGetUniformLocation(prog, "applyTint"); - shaders->m_shRGBA.tint = glGetUniformLocation(prog, "tint"); - shaders->m_shRGBA.useAlphaMatte = glGetUniformLocation(prog, "useAlphaMatte"); + shaders->m_shRGBA.uniformLocations[SHADER_PROJ] = glGetUniformLocation(prog, "proj"); + shaders->m_shRGBA.uniformLocations[SHADER_TEX] = glGetUniformLocation(prog, "tex"); + shaders->m_shRGBA.uniformLocations[SHADER_ALPHA_MATTE] = glGetUniformLocation(prog, "texMatte"); + shaders->m_shRGBA.uniformLocations[SHADER_ALPHA] = glGetUniformLocation(prog, "alpha"); + shaders->m_shRGBA.uniformLocations[SHADER_TEX_ATTRIB] = glGetAttribLocation(prog, "texcoord"); + shaders->m_shRGBA.uniformLocations[SHADER_MATTE_TEX_ATTRIB] = glGetAttribLocation(prog, "texcoordMatte"); + shaders->m_shRGBA.uniformLocations[SHADER_POS_ATTRIB] = glGetAttribLocation(prog, "pos"); + shaders->m_shRGBA.uniformLocations[SHADER_DISCARD_OPAQUE] = glGetUniformLocation(prog, "discardOpaque"); + shaders->m_shRGBA.uniformLocations[SHADER_DISCARD_ALPHA] = glGetUniformLocation(prog, "discardAlpha"); + shaders->m_shRGBA.uniformLocations[SHADER_DISCARD_ALPHA_VALUE] = glGetUniformLocation(prog, "discardAlphaValue"); + shaders->m_shRGBA.uniformLocations[SHADER_APPLY_TINT] = glGetUniformLocation(prog, "applyTint"); + shaders->m_shRGBA.uniformLocations[SHADER_TINT] = glGetUniformLocation(prog, "tint"); + shaders->m_shRGBA.uniformLocations[SHADER_USE_ALPHA_MATTE] = glGetUniformLocation(prog, "useAlphaMatte"); shaders->m_shRGBA.createVao(); prog = createProgram(shaders->TEXVERTSRC, TEXFRAGSRCRGBAPASSTHRU, isDynamic); if (!prog) return false; - shaders->m_shPASSTHRURGBA.program = prog; - shaders->m_shPASSTHRURGBA.proj = glGetUniformLocation(prog, "proj"); - shaders->m_shPASSTHRURGBA.tex = glGetUniformLocation(prog, "tex"); - shaders->m_shPASSTHRURGBA.texAttrib = glGetAttribLocation(prog, "texcoord"); - shaders->m_shPASSTHRURGBA.posAttrib = glGetAttribLocation(prog, "pos"); + shaders->m_shPASSTHRURGBA.program = prog; + shaders->m_shPASSTHRURGBA.uniformLocations[SHADER_PROJ] = glGetUniformLocation(prog, "proj"); + shaders->m_shPASSTHRURGBA.uniformLocations[SHADER_TEX] = glGetUniformLocation(prog, "tex"); + shaders->m_shPASSTHRURGBA.uniformLocations[SHADER_TEX_ATTRIB] = glGetAttribLocation(prog, "texcoord"); + shaders->m_shPASSTHRURGBA.uniformLocations[SHADER_POS_ATTRIB] = glGetAttribLocation(prog, "pos"); shaders->m_shPASSTHRURGBA.createVao(); prog = createProgram(shaders->TEXVERTSRC, TEXFRAGSRCRGBAMATTE, isDynamic); if (!prog) return false; - shaders->m_shMATTE.program = prog; - shaders->m_shMATTE.proj = glGetUniformLocation(prog, "proj"); - shaders->m_shMATTE.tex = glGetUniformLocation(prog, "tex"); - shaders->m_shMATTE.alphaMatte = glGetUniformLocation(prog, "texMatte"); - shaders->m_shMATTE.texAttrib = glGetAttribLocation(prog, "texcoord"); - shaders->m_shMATTE.posAttrib = glGetAttribLocation(prog, "pos"); + shaders->m_shMATTE.program = prog; + shaders->m_shMATTE.uniformLocations[SHADER_PROJ] = glGetUniformLocation(prog, "proj"); + shaders->m_shMATTE.uniformLocations[SHADER_TEX] = glGetUniformLocation(prog, "tex"); + shaders->m_shMATTE.uniformLocations[SHADER_ALPHA_MATTE] = glGetUniformLocation(prog, "texMatte"); + shaders->m_shMATTE.uniformLocations[SHADER_TEX_ATTRIB] = glGetAttribLocation(prog, "texcoord"); + shaders->m_shMATTE.uniformLocations[SHADER_POS_ATTRIB] = glGetAttribLocation(prog, "pos"); shaders->m_shMATTE.createVao(); prog = createProgram(shaders->TEXVERTSRC, FRAGGLITCH, isDynamic); if (!prog) return false; - shaders->m_shGLITCH.program = prog; - shaders->m_shGLITCH.proj = glGetUniformLocation(prog, "proj"); - shaders->m_shGLITCH.tex = glGetUniformLocation(prog, "tex"); - shaders->m_shGLITCH.texAttrib = glGetAttribLocation(prog, "texcoord"); - shaders->m_shGLITCH.posAttrib = glGetAttribLocation(prog, "pos"); - shaders->m_shGLITCH.distort = glGetUniformLocation(prog, "distort"); - shaders->m_shGLITCH.time = glGetUniformLocation(prog, "time"); - shaders->m_shGLITCH.fullSize = glGetUniformLocation(prog, "screenSize"); + shaders->m_shGLITCH.program = prog; + shaders->m_shGLITCH.uniformLocations[SHADER_PROJ] = glGetUniformLocation(prog, "proj"); + shaders->m_shGLITCH.uniformLocations[SHADER_TEX] = glGetUniformLocation(prog, "tex"); + shaders->m_shGLITCH.uniformLocations[SHADER_TEX_ATTRIB] = glGetAttribLocation(prog, "texcoord"); + shaders->m_shGLITCH.uniformLocations[SHADER_POS_ATTRIB] = glGetAttribLocation(prog, "pos"); + shaders->m_shGLITCH.uniformLocations[SHADER_DISTORT] = glGetUniformLocation(prog, "distort"); + shaders->m_shGLITCH.uniformLocations[SHADER_TIME] = glGetUniformLocation(prog, "time"); + shaders->m_shGLITCH.uniformLocations[SHADER_FULL_SIZE] = glGetUniformLocation(prog, "screenSize"); shaders->m_shGLITCH.createVao(); prog = createProgram(shaders->TEXVERTSRC, TEXFRAGSRCRGBX, isDynamic); @@ -1051,16 +1050,16 @@ bool CHyprOpenGLImpl::initShaders() { return false; shaders->m_shRGBX.program = prog; getRoundingShaderUniforms(shaders->m_shRGBX); - shaders->m_shRGBX.tex = glGetUniformLocation(prog, "tex"); - shaders->m_shRGBX.proj = glGetUniformLocation(prog, "proj"); - shaders->m_shRGBX.alpha = glGetUniformLocation(prog, "alpha"); - shaders->m_shRGBX.texAttrib = glGetAttribLocation(prog, "texcoord"); - shaders->m_shRGBX.posAttrib = glGetAttribLocation(prog, "pos"); - shaders->m_shRGBX.discardOpaque = glGetUniformLocation(prog, "discardOpaque"); - shaders->m_shRGBX.discardAlpha = glGetUniformLocation(prog, "discardAlpha"); - shaders->m_shRGBX.discardAlphaValue = glGetUniformLocation(prog, "discardAlphaValue"); - shaders->m_shRGBX.applyTint = glGetUniformLocation(prog, "applyTint"); - shaders->m_shRGBX.tint = glGetUniformLocation(prog, "tint"); + shaders->m_shRGBX.uniformLocations[SHADER_TEX] = glGetUniformLocation(prog, "tex"); + shaders->m_shRGBX.uniformLocations[SHADER_PROJ] = glGetUniformLocation(prog, "proj"); + shaders->m_shRGBX.uniformLocations[SHADER_ALPHA] = glGetUniformLocation(prog, "alpha"); + shaders->m_shRGBX.uniformLocations[SHADER_TEX_ATTRIB] = glGetAttribLocation(prog, "texcoord"); + shaders->m_shRGBX.uniformLocations[SHADER_POS_ATTRIB] = glGetAttribLocation(prog, "pos"); + shaders->m_shRGBX.uniformLocations[SHADER_DISCARD_OPAQUE] = glGetUniformLocation(prog, "discardOpaque"); + shaders->m_shRGBX.uniformLocations[SHADER_DISCARD_ALPHA] = glGetUniformLocation(prog, "discardAlpha"); + shaders->m_shRGBX.uniformLocations[SHADER_DISCARD_ALPHA_VALUE] = glGetUniformLocation(prog, "discardAlphaValue"); + shaders->m_shRGBX.uniformLocations[SHADER_APPLY_TINT] = glGetUniformLocation(prog, "applyTint"); + shaders->m_shRGBX.uniformLocations[SHADER_TINT] = glGetUniformLocation(prog, "tint"); shaders->m_shRGBX.createVao(); prog = createProgram(shaders->TEXVERTSRC, TEXFRAGSRCEXT, isDynamic); @@ -1068,115 +1067,113 @@ bool CHyprOpenGLImpl::initShaders() { return false; shaders->m_shEXT.program = prog; getRoundingShaderUniforms(shaders->m_shEXT); - shaders->m_shEXT.tex = glGetUniformLocation(prog, "tex"); - shaders->m_shEXT.proj = glGetUniformLocation(prog, "proj"); - shaders->m_shEXT.alpha = glGetUniformLocation(prog, "alpha"); - shaders->m_shEXT.posAttrib = glGetAttribLocation(prog, "pos"); - shaders->m_shEXT.texAttrib = glGetAttribLocation(prog, "texcoord"); - shaders->m_shEXT.discardOpaque = glGetUniformLocation(prog, "discardOpaque"); - shaders->m_shEXT.discardAlpha = glGetUniformLocation(prog, "discardAlpha"); - shaders->m_shEXT.discardAlphaValue = glGetUniformLocation(prog, "discardAlphaValue"); - shaders->m_shEXT.applyTint = glGetUniformLocation(prog, "applyTint"); - shaders->m_shEXT.tint = glGetUniformLocation(prog, "tint"); + shaders->m_shEXT.uniformLocations[SHADER_TEX] = glGetUniformLocation(prog, "tex"); + shaders->m_shEXT.uniformLocations[SHADER_PROJ] = glGetUniformLocation(prog, "proj"); + shaders->m_shEXT.uniformLocations[SHADER_ALPHA] = glGetUniformLocation(prog, "alpha"); + shaders->m_shEXT.uniformLocations[SHADER_POS_ATTRIB] = glGetAttribLocation(prog, "pos"); + shaders->m_shEXT.uniformLocations[SHADER_TEX_ATTRIB] = glGetAttribLocation(prog, "texcoord"); + shaders->m_shEXT.uniformLocations[SHADER_DISCARD_OPAQUE] = glGetUniformLocation(prog, "discardOpaque"); + shaders->m_shEXT.uniformLocations[SHADER_DISCARD_ALPHA] = glGetUniformLocation(prog, "discardAlpha"); + shaders->m_shEXT.uniformLocations[SHADER_DISCARD_ALPHA_VALUE] = glGetUniformLocation(prog, "discardAlphaValue"); + shaders->m_shEXT.uniformLocations[SHADER_APPLY_TINT] = glGetUniformLocation(prog, "applyTint"); + shaders->m_shEXT.uniformLocations[SHADER_TINT] = glGetUniformLocation(prog, "tint"); shaders->m_shEXT.createVao(); prog = createProgram(shaders->TEXVERTSRC, FRAGBLUR1, isDynamic); if (!prog) return false; - shaders->m_shBLUR1.program = prog; - shaders->m_shBLUR1.tex = glGetUniformLocation(prog, "tex"); - shaders->m_shBLUR1.alpha = glGetUniformLocation(prog, "alpha"); - shaders->m_shBLUR1.proj = glGetUniformLocation(prog, "proj"); - shaders->m_shBLUR1.posAttrib = glGetAttribLocation(prog, "pos"); - shaders->m_shBLUR1.texAttrib = glGetAttribLocation(prog, "texcoord"); - shaders->m_shBLUR1.radius = glGetUniformLocation(prog, "radius"); - shaders->m_shBLUR1.halfpixel = glGetUniformLocation(prog, "halfpixel"); - shaders->m_shBLUR1.passes = glGetUniformLocation(prog, "passes"); - shaders->m_shBLUR1.vibrancy = glGetUniformLocation(prog, "vibrancy"); - shaders->m_shBLUR1.vibrancy_darkness = glGetUniformLocation(prog, "vibrancy_darkness"); + shaders->m_shBLUR1.program = prog; + shaders->m_shBLUR1.uniformLocations[SHADER_TEX] = glGetUniformLocation(prog, "tex"); + shaders->m_shBLUR1.uniformLocations[SHADER_ALPHA] = glGetUniformLocation(prog, "alpha"); + shaders->m_shBLUR1.uniformLocations[SHADER_PROJ] = glGetUniformLocation(prog, "proj"); + shaders->m_shBLUR1.uniformLocations[SHADER_POS_ATTRIB] = glGetAttribLocation(prog, "pos"); + shaders->m_shBLUR1.uniformLocations[SHADER_TEX_ATTRIB] = glGetAttribLocation(prog, "texcoord"); + shaders->m_shBLUR1.uniformLocations[SHADER_RADIUS] = glGetUniformLocation(prog, "radius"); + shaders->m_shBLUR1.uniformLocations[SHADER_HALFPIXEL] = glGetUniformLocation(prog, "halfpixel"); + shaders->m_shBLUR1.uniformLocations[SHADER_PASSES] = glGetUniformLocation(prog, "passes"); + shaders->m_shBLUR1.uniformLocations[SHADER_VIBRANCY] = glGetUniformLocation(prog, "vibrancy"); + shaders->m_shBLUR1.uniformLocations[SHADER_VIBRANCY_DARKNESS] = glGetUniformLocation(prog, "vibrancy_darkness"); shaders->m_shBLUR1.createVao(); prog = createProgram(shaders->TEXVERTSRC, FRAGBLUR2, isDynamic); if (!prog) return false; - shaders->m_shBLUR2.program = prog; - shaders->m_shBLUR2.tex = glGetUniformLocation(prog, "tex"); - shaders->m_shBLUR2.alpha = glGetUniformLocation(prog, "alpha"); - shaders->m_shBLUR2.proj = glGetUniformLocation(prog, "proj"); - shaders->m_shBLUR2.posAttrib = glGetAttribLocation(prog, "pos"); - shaders->m_shBLUR2.texAttrib = glGetAttribLocation(prog, "texcoord"); - shaders->m_shBLUR2.radius = glGetUniformLocation(prog, "radius"); - shaders->m_shBLUR2.halfpixel = glGetUniformLocation(prog, "halfpixel"); + shaders->m_shBLUR2.program = prog; + shaders->m_shBLUR2.uniformLocations[SHADER_TEX] = glGetUniformLocation(prog, "tex"); + shaders->m_shBLUR2.uniformLocations[SHADER_ALPHA] = glGetUniformLocation(prog, "alpha"); + shaders->m_shBLUR2.uniformLocations[SHADER_PROJ] = glGetUniformLocation(prog, "proj"); + shaders->m_shBLUR2.uniformLocations[SHADER_POS_ATTRIB] = glGetAttribLocation(prog, "pos"); + shaders->m_shBLUR2.uniformLocations[SHADER_TEX_ATTRIB] = glGetAttribLocation(prog, "texcoord"); + shaders->m_shBLUR2.uniformLocations[SHADER_RADIUS] = glGetUniformLocation(prog, "radius"); + shaders->m_shBLUR2.uniformLocations[SHADER_HALFPIXEL] = glGetUniformLocation(prog, "halfpixel"); shaders->m_shBLUR2.createVao(); - prog = createProgram(m_cmSupported ? shaders->TEXVERTSRC300 : shaders->TEXVERTSRC, FRAGBLURPREPARE, isDynamic); + prog = createProgram(shaders->TEXVERTSRC, FRAGBLURPREPARE, isDynamic); if (!prog) return false; shaders->m_shBLURPREPARE.program = prog; - if (m_cmSupported) - getCMShaderUniforms(shaders->m_shBLURPREPARE); - - shaders->m_shBLURPREPARE.tex = glGetUniformLocation(prog, "tex"); - shaders->m_shBLURPREPARE.proj = glGetUniformLocation(prog, "proj"); - shaders->m_shBLURPREPARE.posAttrib = glGetAttribLocation(prog, "pos"); - shaders->m_shBLURPREPARE.texAttrib = glGetAttribLocation(prog, "texcoord"); - shaders->m_shBLURPREPARE.contrast = glGetUniformLocation(prog, "contrast"); - shaders->m_shBLURPREPARE.brightness = glGetUniformLocation(prog, "brightness"); + getCMShaderUniforms(shaders->m_shBLURPREPARE); + + shaders->m_shBLURPREPARE.uniformLocations[SHADER_TEX] = glGetUniformLocation(prog, "tex"); + shaders->m_shBLURPREPARE.uniformLocations[SHADER_PROJ] = glGetUniformLocation(prog, "proj"); + shaders->m_shBLURPREPARE.uniformLocations[SHADER_POS_ATTRIB] = glGetAttribLocation(prog, "pos"); + shaders->m_shBLURPREPARE.uniformLocations[SHADER_TEX_ATTRIB] = glGetAttribLocation(prog, "texcoord"); + shaders->m_shBLURPREPARE.uniformLocations[SHADER_CONTRAST] = glGetUniformLocation(prog, "contrast"); + shaders->m_shBLURPREPARE.uniformLocations[SHADER_BRIGHTNESS] = glGetUniformLocation(prog, "brightness"); shaders->m_shBLURPREPARE.createVao(); - prog = createProgram(m_cmSupported ? shaders->TEXVERTSRC300 : shaders->TEXVERTSRC, FRAGBLURFINISH, isDynamic); + prog = createProgram(shaders->TEXVERTSRC, FRAGBLURFINISH, isDynamic); if (!prog) return false; shaders->m_shBLURFINISH.program = prog; // getCMShaderUniforms(shaders->m_shBLURFINISH); - shaders->m_shBLURFINISH.tex = glGetUniformLocation(prog, "tex"); - shaders->m_shBLURFINISH.proj = glGetUniformLocation(prog, "proj"); - shaders->m_shBLURFINISH.posAttrib = glGetAttribLocation(prog, "pos"); - shaders->m_shBLURFINISH.texAttrib = glGetAttribLocation(prog, "texcoord"); - shaders->m_shBLURFINISH.brightness = glGetUniformLocation(prog, "brightness"); - shaders->m_shBLURFINISH.noise = glGetUniformLocation(prog, "noise"); + shaders->m_shBLURFINISH.uniformLocations[SHADER_TEX] = glGetUniformLocation(prog, "tex"); + shaders->m_shBLURFINISH.uniformLocations[SHADER_PROJ] = glGetUniformLocation(prog, "proj"); + shaders->m_shBLURFINISH.uniformLocations[SHADER_POS_ATTRIB] = glGetAttribLocation(prog, "pos"); + shaders->m_shBLURFINISH.uniformLocations[SHADER_TEX_ATTRIB] = glGetAttribLocation(prog, "texcoord"); + shaders->m_shBLURFINISH.uniformLocations[SHADER_BRIGHTNESS] = glGetUniformLocation(prog, "brightness"); + shaders->m_shBLURFINISH.uniformLocations[SHADER_NOISE] = glGetUniformLocation(prog, "noise"); shaders->m_shBLURFINISH.createVao(); - prog = createProgram(m_cmSupported ? shaders->TEXVERTSRC300 : shaders->TEXVERTSRC, FRAGSHADOW, isDynamic); + prog = createProgram(shaders->TEXVERTSRC, FRAGSHADOW, isDynamic); if (!prog) return false; - if (m_cmSupported) - shaders->m_shSHADOW.program = prog; + + shaders->m_shSHADOW.program = prog; getCMShaderUniforms(shaders->m_shSHADOW); getRoundingShaderUniforms(shaders->m_shSHADOW); - shaders->m_shSHADOW.proj = glGetUniformLocation(prog, "proj"); - shaders->m_shSHADOW.posAttrib = glGetAttribLocation(prog, "pos"); - shaders->m_shSHADOW.texAttrib = glGetAttribLocation(prog, "texcoord"); - shaders->m_shSHADOW.bottomRight = glGetUniformLocation(prog, "bottomRight"); - shaders->m_shSHADOW.range = glGetUniformLocation(prog, "range"); - shaders->m_shSHADOW.shadowPower = glGetUniformLocation(prog, "shadowPower"); - shaders->m_shSHADOW.color = glGetUniformLocation(prog, "color"); + shaders->m_shSHADOW.uniformLocations[SHADER_PROJ] = glGetUniformLocation(prog, "proj"); + shaders->m_shSHADOW.uniformLocations[SHADER_POS_ATTRIB] = glGetAttribLocation(prog, "pos"); + shaders->m_shSHADOW.uniformLocations[SHADER_TEX_ATTRIB] = glGetAttribLocation(prog, "texcoord"); + shaders->m_shSHADOW.uniformLocations[SHADER_BOTTOM_RIGHT] = glGetUniformLocation(prog, "bottomRight"); + shaders->m_shSHADOW.uniformLocations[SHADER_RANGE] = glGetUniformLocation(prog, "range"); + shaders->m_shSHADOW.uniformLocations[SHADER_SHADOW_POWER] = glGetUniformLocation(prog, "shadowPower"); + shaders->m_shSHADOW.uniformLocations[SHADER_COLOR] = glGetUniformLocation(prog, "color"); shaders->m_shSHADOW.createVao(); - prog = createProgram(m_cmSupported ? shaders->TEXVERTSRC300 : shaders->TEXVERTSRC, FRAGBORDER1, isDynamic); + prog = createProgram(shaders->TEXVERTSRC, FRAGBORDER1, isDynamic); if (!prog) return false; - shaders->m_shBORDER1.program = prog; - if (m_cmSupported) - getCMShaderUniforms(shaders->m_shBORDER1); + shaders->m_shBORDER1.program = prog; + getCMShaderUniforms(shaders->m_shBORDER1); getRoundingShaderUniforms(shaders->m_shBORDER1); - shaders->m_shBORDER1.proj = glGetUniformLocation(prog, "proj"); - shaders->m_shBORDER1.thick = glGetUniformLocation(prog, "thick"); - shaders->m_shBORDER1.posAttrib = glGetAttribLocation(prog, "pos"); - shaders->m_shBORDER1.texAttrib = glGetAttribLocation(prog, "texcoord"); - shaders->m_shBORDER1.bottomRight = glGetUniformLocation(prog, "bottomRight"); - shaders->m_shBORDER1.fullSizeUntransformed = glGetUniformLocation(prog, "fullSizeUntransformed"); - shaders->m_shBORDER1.radiusOuter = glGetUniformLocation(prog, "radiusOuter"); - shaders->m_shBORDER1.gradient = glGetUniformLocation(prog, "gradient"); - shaders->m_shBORDER1.gradient2 = glGetUniformLocation(prog, "gradient2"); - shaders->m_shBORDER1.gradientLength = glGetUniformLocation(prog, "gradientLength"); - shaders->m_shBORDER1.gradient2Length = glGetUniformLocation(prog, "gradient2Length"); - shaders->m_shBORDER1.angle = glGetUniformLocation(prog, "angle"); - shaders->m_shBORDER1.angle2 = glGetUniformLocation(prog, "angle2"); - shaders->m_shBORDER1.gradientLerp = glGetUniformLocation(prog, "gradientLerp"); - shaders->m_shBORDER1.alpha = glGetUniformLocation(prog, "alpha"); + shaders->m_shBORDER1.uniformLocations[SHADER_PROJ] = glGetUniformLocation(prog, "proj"); + shaders->m_shBORDER1.uniformLocations[SHADER_THICK] = glGetUniformLocation(prog, "thick"); + shaders->m_shBORDER1.uniformLocations[SHADER_POS_ATTRIB] = glGetAttribLocation(prog, "pos"); + shaders->m_shBORDER1.uniformLocations[SHADER_TEX_ATTRIB] = glGetAttribLocation(prog, "texcoord"); + shaders->m_shBORDER1.uniformLocations[SHADER_BOTTOM_RIGHT] = glGetUniformLocation(prog, "bottomRight"); + shaders->m_shBORDER1.uniformLocations[SHADER_FULL_SIZE_UNTRANSFORMED] = glGetUniformLocation(prog, "fullSizeUntransformed"); + shaders->m_shBORDER1.uniformLocations[SHADER_RADIUS_OUTER] = glGetUniformLocation(prog, "radiusOuter"); + shaders->m_shBORDER1.uniformLocations[SHADER_GRADIENT] = glGetUniformLocation(prog, "gradient"); + shaders->m_shBORDER1.uniformLocations[SHADER_GRADIENT2] = glGetUniformLocation(prog, "gradient2"); + shaders->m_shBORDER1.uniformLocations[SHADER_GRADIENT_LENGTH] = glGetUniformLocation(prog, "gradientLength"); + shaders->m_shBORDER1.uniformLocations[SHADER_GRADIENT2_LENGTH] = glGetUniformLocation(prog, "gradient2Length"); + shaders->m_shBORDER1.uniformLocations[SHADER_ANGLE] = glGetUniformLocation(prog, "angle"); + shaders->m_shBORDER1.uniformLocations[SHADER_ANGLE2] = glGetUniformLocation(prog, "angle2"); + shaders->m_shBORDER1.uniformLocations[SHADER_GRADIENT_LERP] = glGetUniformLocation(prog, "gradientLerp"); + shaders->m_shBORDER1.uniformLocations[SHADER_ALPHA] = glGetUniformLocation(prog, "alpha"); shaders->m_shBORDER1.createVao(); } catch (const std::exception& e) { @@ -1216,10 +1213,7 @@ void CHyprOpenGLImpl::applyScreenShader(const std::string& path) { fragmentShader.starts_with("#version 320 es") // do not break existing custom shaders ? m_shaders->TEXVERTSRC320 : - (fragmentShader.starts_with("#version 300 es") // support lower es versions - ? - m_shaders->TEXVERTSRC300 : - m_shaders->TEXVERTSRC), + m_shaders->TEXVERTSRC, fragmentShader, true); if (!m_finalScreenShader.program) { @@ -1227,23 +1221,23 @@ void CHyprOpenGLImpl::applyScreenShader(const std::string& path) { return; } - m_finalScreenShader.proj = glGetUniformLocation(m_finalScreenShader.program, "proj"); - m_finalScreenShader.tex = glGetUniformLocation(m_finalScreenShader.program, "tex"); - m_finalScreenShader.time = glGetUniformLocation(m_finalScreenShader.program, "time"); - if (m_finalScreenShader.time != -1) + m_finalScreenShader.uniformLocations[SHADER_PROJ] = glGetUniformLocation(m_finalScreenShader.program, "proj"); + m_finalScreenShader.uniformLocations[SHADER_TEX] = glGetUniformLocation(m_finalScreenShader.program, "tex"); + m_finalScreenShader.uniformLocations[SHADER_TIME] = glGetUniformLocation(m_finalScreenShader.program, "time"); + if (m_finalScreenShader.uniformLocations[SHADER_TIME] != -1) m_finalScreenShader.initialTime = m_globalTimer.getSeconds(); - m_finalScreenShader.wl_output = glGetUniformLocation(m_finalScreenShader.program, "wl_output"); - m_finalScreenShader.fullSize = glGetUniformLocation(m_finalScreenShader.program, "screen_size"); - if (m_finalScreenShader.fullSize == -1) - m_finalScreenShader.fullSize = glGetUniformLocation(m_finalScreenShader.program, "screenSize"); - if (m_finalScreenShader.time != -1 && *PDT != 0 && !g_pHyprRenderer->m_crashingInProgress) { + m_finalScreenShader.uniformLocations[SHADER_WL_OUTPUT] = glGetUniformLocation(m_finalScreenShader.program, "wl_output"); + m_finalScreenShader.uniformLocations[SHADER_FULL_SIZE] = glGetUniformLocation(m_finalScreenShader.program, "screen_size"); + if (m_finalScreenShader.uniformLocations[SHADER_FULL_SIZE] == -1) + m_finalScreenShader.uniformLocations[SHADER_FULL_SIZE] = glGetUniformLocation(m_finalScreenShader.program, "screenSize"); + if (m_finalScreenShader.uniformLocations[SHADER_TIME] != -1 && *PDT != 0 && !g_pHyprRenderer->m_crashingInProgress) { // The screen shader uses the "time" uniform // Since the screen shader could change every frame, damage tracking *needs* to be disabled g_pConfigManager->addParseError("Screen shader: Screen shader uses uniform 'time', which requires debug:damage_tracking to be switched off.\n" "WARNING: Disabling damage tracking will *massively* increase GPU utilization!"); } - m_finalScreenShader.texAttrib = glGetAttribLocation(m_finalScreenShader.program, "texcoord"); - m_finalScreenShader.posAttrib = glGetAttribLocation(m_finalScreenShader.program, "pos"); + m_finalScreenShader.uniformLocations[SHADER_TEX_ATTRIB] = glGetAttribLocation(m_finalScreenShader.program, "texcoord"); + m_finalScreenShader.uniformLocations[SHADER_POS_ATTRIB] = glGetAttribLocation(m_finalScreenShader.program, "pos"); m_finalScreenShader.createVao(); } @@ -1266,10 +1260,10 @@ void CHyprOpenGLImpl::clear(const CHyprColor& color) { void CHyprOpenGLImpl::blend(bool enabled) { if (enabled) { - glEnable(GL_BLEND); + setCapStatus(GL_BLEND, true); glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); // everything is premultiplied } else - glDisable(GL_BLEND); + setCapStatus(GL_BLEND, false); m_blend = enabled; } @@ -1277,24 +1271,36 @@ void CHyprOpenGLImpl::blend(bool enabled) { void CHyprOpenGLImpl::scissor(const CBox& originalBox, bool transform) { RASSERT(m_renderData.pMonitor, "Tried to scissor without begin()!"); + // only call glScissor if the box has changed + static CBox m_lastScissorBox = {}; + if (transform) { CBox box = originalBox; const auto TR = wlTransformToHyprutils(invertTransform(m_renderData.pMonitor->m_transform)); box.transform(TR, m_renderData.pMonitor->m_transformedSize.x, m_renderData.pMonitor->m_transformedSize.y); - glScissor(box.x, box.y, box.width, box.height); - glEnable(GL_SCISSOR_TEST); + + if (box != m_lastScissorBox) { + glScissor(box.x, box.y, box.width, box.height); + m_lastScissorBox = box; + } + + setCapStatus(GL_SCISSOR_TEST, true); return; } - glScissor(originalBox.x, originalBox.y, originalBox.width, originalBox.height); - glEnable(GL_SCISSOR_TEST); + if (originalBox != m_lastScissorBox) { + glScissor(originalBox.x, originalBox.y, originalBox.width, originalBox.height); + m_lastScissorBox = originalBox; + } + + setCapStatus(GL_SCISSOR_TEST, true); } void CHyprOpenGLImpl::scissor(const pixman_box32* pBox, bool transform) { RASSERT(m_renderData.pMonitor, "Tried to scissor without begin()!"); if (!pBox) { - glDisable(GL_SCISSOR_TEST); + setCapStatus(GL_SCISSOR_TEST, false); return; } @@ -1329,7 +1335,7 @@ void CHyprOpenGLImpl::renderRectWithBlur(const CBox& box, const CHyprColor& col, glClearStencil(0); glClear(GL_STENCIL_BUFFER_BIT); - glEnable(GL_STENCIL_TEST); + setCapStatus(GL_STENCIL_TEST, true); glStencilFunc(GL_ALWAYS, 1, 0xFF); glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); @@ -1352,7 +1358,7 @@ void CHyprOpenGLImpl::renderRectWithBlur(const CBox& box, const CHyprColor& col, glClearStencil(0); glClear(GL_STENCIL_BUFFER_BIT); - glDisable(GL_STENCIL_TEST); + setCapStatus(GL_STENCIL_TEST, false); glStencilMask(0xFF); glStencilFunc(GL_ALWAYS, 1, 0xFF); scissor(nullptr); @@ -1374,10 +1380,10 @@ void CHyprOpenGLImpl::renderRectWithDamage(const CBox& box, const CHyprColor& co Mat3x3 glMatrix = m_renderData.projection.copy().multiply(matrix); useProgram(m_shaders->m_shQUAD.program); - glUniformMatrix3fv(m_shaders->m_shQUAD.proj, 1, GL_TRUE, glMatrix.getMatrix().data()); + m_shaders->m_shQUAD.setUniformMatrix3fv(SHADER_PROJ, 1, GL_TRUE, glMatrix.getMatrix()); // premultiply the color as well as we don't work with straight alpha - glUniform4f(m_shaders->m_shQUAD.color, col.r * col.a, col.g * col.a, col.b * col.a, col.a); + m_shaders->m_shQUAD.setUniformFloat4(SHADER_COLOR, col.r * col.a, col.g * col.a, col.b * col.a, col.a); CBox transformedBox = box; transformedBox.transform(wlTransformToHyprutils(invertTransform(m_renderData.pMonitor->m_transform)), m_renderData.pMonitor->m_transformedSize.x, @@ -1387,12 +1393,12 @@ void CHyprOpenGLImpl::renderRectWithDamage(const CBox& box, const CHyprColor& co const auto FULLSIZE = Vector2D(transformedBox.width, transformedBox.height); // Rounded corners - glUniform2f(m_shaders->m_shQUAD.topLeft, (float)TOPLEFT.x, (float)TOPLEFT.y); - glUniform2f(m_shaders->m_shQUAD.fullSize, (float)FULLSIZE.x, (float)FULLSIZE.y); - glUniform1f(m_shaders->m_shQUAD.radius, round); - glUniform1f(m_shaders->m_shQUAD.roundingPower, roundingPower); + m_shaders->m_shQUAD.setUniformFloat2(SHADER_TOP_LEFT, (float)TOPLEFT.x, (float)TOPLEFT.y); + m_shaders->m_shQUAD.setUniformFloat2(SHADER_FULL_SIZE, (float)FULLSIZE.x, (float)FULLSIZE.y); + m_shaders->m_shQUAD.setUniformFloat(SHADER_RADIUS, round); + m_shaders->m_shQUAD.setUniformFloat(SHADER_ROUNDING_POWER, roundingPower); - glBindVertexArray(m_shaders->m_shQUAD.shaderVao); + glBindVertexArray(m_shaders->m_shQUAD.uniformLocations[SHADER_SHADER_VAO]); if (m_renderData.clipBox.width != 0 && m_renderData.clipBox.height != 0) { CRegion damageClip{m_renderData.clipBox.x, m_renderData.clipBox.y, m_renderData.clipBox.width, m_renderData.clipBox.height}; @@ -1412,7 +1418,6 @@ void CHyprOpenGLImpl::renderRectWithDamage(const CBox& box, const CHyprColor& co } glBindVertexArray(0); - scissor(nullptr); } @@ -1436,40 +1441,40 @@ void CHyprOpenGLImpl::renderTextureWithDamage(SP<CTexture> tex, const CBox& box, static std::map<std::pair<uint32_t, uint32_t>, std::array<GLfloat, 9>> primariesConversionCache; -void CHyprOpenGLImpl::passCMUniforms(const SShader& shader, const NColorManagement::SImageDescription& imageDescription, - const NColorManagement::SImageDescription& targetImageDescription, bool modifySDR, float sdrMinLuminance, int sdrMaxLuminance) { - glUniform1i(shader.sourceTF, imageDescription.transferFunction); - glUniform1i(shader.targetTF, targetImageDescription.transferFunction); +void CHyprOpenGLImpl::passCMUniforms(SShader& shader, const NColorManagement::SImageDescription& imageDescription, + const NColorManagement::SImageDescription& targetImageDescription, bool modifySDR, float sdrMinLuminance, int sdrMaxLuminance) { + shader.setUniformInt(SHADER_SOURCE_TF, imageDescription.transferFunction); + shader.setUniformInt(SHADER_TARGET_TF, targetImageDescription.transferFunction); - const auto targetPrimaries = targetImageDescription.primariesNameSet || targetImageDescription.primaries == SPCPRimaries{} ? - getPrimaries(targetImageDescription.primariesNamed) : - targetImageDescription.primaries; + const auto targetPrimaries = targetImageDescription.primariesNameSet || targetImageDescription.primaries == SPCPRimaries{} ? + getPrimaries(targetImageDescription.primariesNamed) : + targetImageDescription.primaries; - const GLfloat glTargetPrimaries[8] = { + const std::array<GLfloat, 8> glTargetPrimaries = { targetPrimaries.red.x, targetPrimaries.red.y, targetPrimaries.green.x, targetPrimaries.green.y, targetPrimaries.blue.x, targetPrimaries.blue.y, targetPrimaries.white.x, targetPrimaries.white.y, }; - glUniformMatrix4x2fv(shader.targetPrimaries, 1, false, glTargetPrimaries); + shader.setUniformMatrix4x2fv(SHADER_TARGET_PRIMARIES, 1, false, glTargetPrimaries); - glUniform2f(shader.srcTFRange, imageDescription.getTFMinLuminance(sdrMinLuminance), imageDescription.getTFMaxLuminance(sdrMaxLuminance)); - glUniform2f(shader.dstTFRange, targetImageDescription.getTFMinLuminance(sdrMinLuminance), targetImageDescription.getTFMaxLuminance(sdrMaxLuminance)); + shader.setUniformFloat2(SHADER_SRC_TF_RANGE, imageDescription.getTFMinLuminance(sdrMinLuminance), imageDescription.getTFMaxLuminance(sdrMaxLuminance)); + shader.setUniformFloat2(SHADER_DST_TF_RANGE, targetImageDescription.getTFMinLuminance(sdrMinLuminance), targetImageDescription.getTFMaxLuminance(sdrMaxLuminance)); const float maxLuminance = imageDescription.luminances.max > 0 ? imageDescription.luminances.max : imageDescription.luminances.reference; - glUniform1f(shader.maxLuminance, maxLuminance * targetImageDescription.luminances.reference / imageDescription.luminances.reference); - glUniform1f(shader.dstMaxLuminance, targetImageDescription.luminances.max > 0 ? targetImageDescription.luminances.max : 10000); - glUniform1f(shader.dstRefLuminance, targetImageDescription.luminances.reference); - glUniform1f(shader.sdrSaturation, - modifySDR && m_renderData.pMonitor->m_sdrSaturation > 0 && targetImageDescription.transferFunction == NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ ? - m_renderData.pMonitor->m_sdrSaturation : - 1.0f); - glUniform1f(shader.sdrBrightness, - modifySDR && m_renderData.pMonitor->m_sdrBrightness > 0 && targetImageDescription.transferFunction == NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ ? - m_renderData.pMonitor->m_sdrBrightness : - - 1.0f); + shader.setUniformFloat(SHADER_MAX_LUMINANCE, maxLuminance * targetImageDescription.luminances.reference / imageDescription.luminances.reference); + shader.setUniformFloat(SHADER_DST_MAX_LUMINANCE, targetImageDescription.luminances.max > 0 ? targetImageDescription.luminances.max : 10000); + shader.setUniformFloat(SHADER_DST_REF_LUMINANCE, targetImageDescription.luminances.reference); + shader.setUniformFloat(SHADER_SDR_SATURATION, + modifySDR && m_renderData.pMonitor->m_sdrSaturation > 0 && targetImageDescription.transferFunction == NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ ? + m_renderData.pMonitor->m_sdrSaturation : + 1.0f); + shader.setUniformFloat(SHADER_SDR_BRIGHTNESS, + modifySDR && m_renderData.pMonitor->m_sdrBrightness > 0 && targetImageDescription.transferFunction == NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ ? + m_renderData.pMonitor->m_sdrBrightness : + + 1.0f); const auto cacheKey = std::make_pair(imageDescription.getId(), targetImageDescription.getId()); if (!primariesConversionCache.contains(cacheKey)) { - const auto mat = imageDescription.getPrimaries().convertMatrix(targetImageDescription.getPrimaries()).mat(); + const auto mat = imageDescription.getPrimaries().convertMatrix(targetImageDescription.getPrimaries()).mat(); const std::array<GLfloat, 9> glConvertMatrix = { mat[0][0], mat[1][0], mat[2][0], // mat[0][1], mat[1][1], mat[2][1], // @@ -1477,10 +1482,10 @@ void CHyprOpenGLImpl::passCMUniforms(const SShader& shader, const NColorManageme }; primariesConversionCache.insert(std::make_pair(cacheKey, glConvertMatrix)); } - glUniformMatrix3fv(shader.convertMatrix, 1, false, &primariesConversionCache[cacheKey][0]); + shader.setUniformMatrix3fv(SHADER_CONVERT_MATRIX, 1, false, primariesConversionCache[cacheKey]); } -void CHyprOpenGLImpl::passCMUniforms(const SShader& shader, const SImageDescription& imageDescription) { +void CHyprOpenGLImpl::passCMUniforms(SShader& shader, const SImageDescription& imageDescription) { passCMUniforms(shader, imageDescription, m_renderData.pMonitor->m_imageDescription, true, m_renderData.pMonitor->m_sdrMinLuminance, m_renderData.pMonitor->m_sdrMaxLuminance); } @@ -1547,17 +1552,17 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(SP<CTexture> tex, const CB } glActiveTexture(GL_TEXTURE0); - glBindTexture(tex->m_target, tex->m_texID); + tex->bind(); - glTexParameteri(tex->m_target, GL_TEXTURE_WRAP_S, wrapX); - glTexParameteri(tex->m_target, GL_TEXTURE_WRAP_T, wrapY); + tex->setTexParameter(GL_TEXTURE_WRAP_S, wrapX); + tex->setTexParameter(GL_TEXTURE_WRAP_T, wrapY); if (m_renderData.useNearestNeighbor) { - glTexParameteri(tex->m_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); - glTexParameteri(tex->m_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + tex->setTexParameter(GL_TEXTURE_MAG_FILTER, GL_NEAREST); + tex->setTexParameter(GL_TEXTURE_MIN_FILTER, GL_NEAREST); } else { - glTexParameteri(tex->m_target, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - glTexParameteri(tex->m_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + tex->setTexParameter(GL_TEXTURE_MAG_FILTER, GL_LINEAR); + tex->setTexParameter(GL_TEXTURE_MIN_FILTER, GL_LINEAR); } const auto imageDescription = @@ -1575,40 +1580,38 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(SP<CTexture> tex, const CB useProgram(shader->program); if (shader == &m_shaders->m_shCM) { - glUniform1i(shader->texType, texType); + shader->setUniformInt(SHADER_TEX_TYPE, texType); passCMUniforms(*shader, imageDescription); } - glUniformMatrix3fv(shader->proj, 1, GL_TRUE, glMatrix.getMatrix().data()); - glUniform1i(shader->tex, 0); + shader->setUniformMatrix3fv(SHADER_PROJ, 1, GL_TRUE, glMatrix.getMatrix()); + shader->setUniformInt(SHADER_TEX, 0); - if ((usingFinalShader && *PDT == 0) || CRASHING) { - glUniform1f(shader->time, m_globalTimer.getSeconds() - shader->initialTime); - } else if (usingFinalShader && shader->time != -1) { - // Don't let time be unitialised - glUniform1f(shader->time, 0.f); - } + if ((usingFinalShader && *PDT == 0) || CRASHING) + shader->setUniformFloat(SHADER_TIME, m_globalTimer.getSeconds() - shader->initialTime); + else if (usingFinalShader) + shader->setUniformFloat(SHADER_TIME, 0.f); - if (usingFinalShader && shader->wl_output != -1) - glUniform1i(shader->wl_output, m_renderData.pMonitor->m_id); - if (usingFinalShader && shader->fullSize != -1) - glUniform2f(shader->fullSize, m_renderData.pMonitor->m_pixelSize.x, m_renderData.pMonitor->m_pixelSize.y); + if (usingFinalShader) { + shader->setUniformInt(SHADER_WL_OUTPUT, m_renderData.pMonitor->m_id); + shader->setUniformFloat2(SHADER_FULL_SIZE, m_renderData.pMonitor->m_pixelSize.x, m_renderData.pMonitor->m_pixelSize.y); + } if (CRASHING) { - glUniform1f(shader->distort, g_pHyprRenderer->m_crashingDistort); - glUniform2f(shader->fullSize, m_renderData.pMonitor->m_pixelSize.x, m_renderData.pMonitor->m_pixelSize.y); + shader->setUniformFloat(SHADER_DISTORT, g_pHyprRenderer->m_crashingDistort); + shader->setUniformFloat2(SHADER_FULL_SIZE, m_renderData.pMonitor->m_pixelSize.x, m_renderData.pMonitor->m_pixelSize.y); } if (!usingFinalShader) { - glUniform1f(shader->alpha, alpha); + shader->setUniformFloat(SHADER_ALPHA, alpha); if (discardActive) { - glUniform1i(shader->discardOpaque, !!(m_renderData.discardMode & DISCARD_OPAQUE)); - glUniform1i(shader->discardAlpha, !!(m_renderData.discardMode & DISCARD_ALPHA)); - glUniform1f(shader->discardAlphaValue, m_renderData.discardOpacity); + shader->setUniformInt(SHADER_DISCARD_OPAQUE, !!(m_renderData.discardMode & DISCARD_OPAQUE)); + shader->setUniformInt(SHADER_DISCARD_ALPHA, !!(m_renderData.discardMode & DISCARD_ALPHA)); + shader->setUniformFloat(SHADER_DISCARD_ALPHA_VALUE, m_renderData.discardOpacity); } else { - glUniform1i(shader->discardOpaque, 0); - glUniform1i(shader->discardAlpha, 0); + shader->setUniformInt(SHADER_DISCARD_OPAQUE, 0); + shader->setUniformInt(SHADER_DISCARD_ALPHA, 0); } } @@ -1621,27 +1624,27 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(SP<CTexture> tex, const CB if (!usingFinalShader) { // Rounded corners - glUniform2f(shader->topLeft, TOPLEFT.x, TOPLEFT.y); - glUniform2f(shader->fullSize, FULLSIZE.x, FULLSIZE.y); - glUniform1f(shader->radius, round); - glUniform1f(shader->roundingPower, roundingPower); + shader->setUniformFloat2(SHADER_TOP_LEFT, TOPLEFT.x, TOPLEFT.y); + shader->setUniformFloat2(SHADER_FULL_SIZE, FULLSIZE.x, FULLSIZE.y); + shader->setUniformFloat(SHADER_RADIUS, round); + shader->setUniformFloat(SHADER_ROUNDING_POWER, roundingPower); if (allowDim && m_renderData.currentWindow) { if (m_renderData.currentWindow->m_notRespondingTint->value() > 0) { const auto DIM = m_renderData.currentWindow->m_notRespondingTint->value(); - glUniform1i(shader->applyTint, 1); - glUniform3f(shader->tint, 1.f - DIM, 1.f - DIM, 1.f - DIM); + shader->setUniformInt(SHADER_APPLY_TINT, 1); + shader->setUniformFloat3(SHADER_TINT, 1.f - DIM, 1.f - DIM, 1.f - DIM); } else if (m_renderData.currentWindow->m_dimPercent->value() > 0) { - glUniform1i(shader->applyTint, 1); + shader->setUniformInt(SHADER_APPLY_TINT, 1); const auto DIM = m_renderData.currentWindow->m_dimPercent->value(); - glUniform3f(shader->tint, 1.f - DIM, 1.f - DIM, 1.f - DIM); + shader->setUniformFloat3(SHADER_TINT, 1.f - DIM, 1.f - DIM, 1.f - DIM); } else - glUniform1i(shader->applyTint, 0); + shader->setUniformInt(SHADER_APPLY_TINT, 0); } else - glUniform1i(shader->applyTint, 0); + shader->setUniformInt(SHADER_APPLY_TINT, 0); } - glBindVertexArray(shader->shaderVao); + glBindVertexArray(shader->uniformLocations[SHADER_SHADER_VAO]); if (allowCustomUV && m_renderData.primarySurfaceUVTopLeft != Vector2D(-1, -1)) { const float customUVs[] = { m_renderData.primarySurfaceUVBottomRight.x, m_renderData.primarySurfaceUVTopLeft.y, m_renderData.primarySurfaceUVTopLeft.x, @@ -1649,10 +1652,10 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(SP<CTexture> tex, const CB m_renderData.primarySurfaceUVTopLeft.x, m_renderData.primarySurfaceUVBottomRight.y, }; - glBindBuffer(GL_ARRAY_BUFFER, shader->shaderVboUv); + glBindBuffer(GL_ARRAY_BUFFER, shader->uniformLocations[SHADER_SHADER_VBO_UV]); glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(customUVs), customUVs); } else { - glBindBuffer(GL_ARRAY_BUFFER, shader->shaderVboUv); + glBindBuffer(GL_ARRAY_BUFFER, shader->uniformLocations[SHADER_SHADER_VBO_UV]); glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(fullVerts), fullVerts); } @@ -1681,7 +1684,7 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(SP<CTexture> tex, const CB glBindVertexArray(0); glBindBuffer(GL_ARRAY_BUFFER, 0); - glBindTexture(tex->m_target, 0); + tex->unbind(); } void CHyprOpenGLImpl::renderTexturePrimitive(SP<CTexture> tex, const CBox& box) { @@ -1704,12 +1707,12 @@ void CHyprOpenGLImpl::renderTexturePrimitive(SP<CTexture> tex, const CBox& box) SShader* shader = &m_shaders->m_shPASSTHRURGBA; glActiveTexture(GL_TEXTURE0); - glBindTexture(tex->m_target, tex->m_texID); + tex->bind(); useProgram(shader->program); - glUniformMatrix3fv(shader->proj, 1, GL_TRUE, glMatrix.getMatrix().data()); - glUniform1i(shader->tex, 0); - glBindVertexArray(shader->shaderVao); + shader->setUniformMatrix3fv(SHADER_PROJ, 1, GL_TRUE, glMatrix.getMatrix()); + shader->setUniformInt(SHADER_TEX, 0); + glBindVertexArray(shader->uniformLocations[SHADER_SHADER_VAO]); for (auto const& RECT : m_renderData.damage.getRects()) { scissor(&RECT); @@ -1717,9 +1720,8 @@ void CHyprOpenGLImpl::renderTexturePrimitive(SP<CTexture> tex, const CBox& box) } scissor(nullptr); - glBindVertexArray(0); - glBindTexture(tex->m_target, 0); + tex->unbind(); } void CHyprOpenGLImpl::renderTextureMatte(SP<CTexture> tex, const CBox& box, CFramebuffer& matte) { @@ -1742,18 +1744,18 @@ void CHyprOpenGLImpl::renderTextureMatte(SP<CTexture> tex, const CBox& box, CFra SShader* shader = &m_shaders->m_shMATTE; useProgram(shader->program); - glUniformMatrix3fv(shader->proj, 1, GL_TRUE, glMatrix.getMatrix().data()); - glUniform1i(shader->tex, 0); - glUniform1i(shader->alphaMatte, 1); + shader->setUniformMatrix3fv(SHADER_PROJ, 1, GL_TRUE, glMatrix.getMatrix()); + shader->setUniformInt(SHADER_TEX, 0); + shader->setUniformInt(SHADER_ALPHA_MATTE, 1); glActiveTexture(GL_TEXTURE0); - glBindTexture(tex->m_target, tex->m_texID); + tex->bind(); glActiveTexture(GL_TEXTURE0 + 1); auto matteTex = matte.getTexture(); - glBindTexture(matteTex->m_target, matteTex->m_texID); + matteTex->bind(); - glBindVertexArray(shader->shaderVao); + glBindVertexArray(shader->uniformLocations[SHADER_SHADER_VAO]); for (auto const& RECT : m_renderData.damage.getRects()) { scissor(&RECT); @@ -1761,9 +1763,8 @@ void CHyprOpenGLImpl::renderTextureMatte(SP<CTexture> tex, const CBox& box, CFra } scissor(nullptr); - glBindVertexArray(0); - glBindTexture(tex->m_target, 0); + tex->unbind(); } // This probably isn't the fastest @@ -1784,7 +1785,7 @@ CFramebuffer* CHyprOpenGLImpl::blurFramebufferWithDamage(float a, CRegion* origi const auto BLENDBEFORE = m_blend; blend(false); - glDisable(GL_STENCIL_TEST); + setCapStatus(GL_STENCIL_TEST, false); // get transforms for the full monitor const auto TRANSFORM = wlTransformToHyprutils(invertTransform(m_renderData.pMonitor->m_transform)); @@ -1822,35 +1823,34 @@ CFramebuffer* CHyprOpenGLImpl::blurFramebufferWithDamage(float a, CRegion* origi auto currentTex = source.getTexture(); - glBindTexture(currentTex->m_target, currentTex->m_texID); - - glTexParameteri(currentTex->m_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + currentTex->bind(); + currentTex->setTexParameter(GL_TEXTURE_MIN_FILTER, GL_LINEAR); useProgram(m_shaders->m_shBLURPREPARE.program); // From FB to sRGB const bool skipCM = !m_cmSupported || m_renderData.pMonitor->m_imageDescription == SImageDescription{}; - glUniform1i(m_shaders->m_shBLURPREPARE.skipCM, skipCM); + m_shaders->m_shBLURPREPARE.setUniformInt(SHADER_SKIP_CM, skipCM); if (!skipCM) { passCMUniforms(m_shaders->m_shBLURPREPARE, m_renderData.pMonitor->m_imageDescription, SImageDescription{}); - glUniform1f(m_shaders->m_shBLURPREPARE.sdrSaturation, - m_renderData.pMonitor->m_sdrSaturation > 0 && - m_renderData.pMonitor->m_imageDescription.transferFunction == NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ ? - m_renderData.pMonitor->m_sdrSaturation : - 1.0f); - glUniform1f(m_shaders->m_shBLURPREPARE.sdrBrightness, - m_renderData.pMonitor->m_sdrBrightness > 0 && - m_renderData.pMonitor->m_imageDescription.transferFunction == NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ ? - m_renderData.pMonitor->m_sdrBrightness : - 1.0f); + m_shaders->m_shBLURPREPARE.setUniformFloat(SHADER_SDR_SATURATION, + m_renderData.pMonitor->m_sdrSaturation > 0 && + m_renderData.pMonitor->m_imageDescription.transferFunction == NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ ? + m_renderData.pMonitor->m_sdrSaturation : + 1.0f); + m_shaders->m_shBLURPREPARE.setUniformFloat(SHADER_SDR_BRIGHTNESS, + m_renderData.pMonitor->m_sdrBrightness > 0 && + m_renderData.pMonitor->m_imageDescription.transferFunction == NColorManagement::CM_TRANSFER_FUNCTION_ST2084_PQ ? + m_renderData.pMonitor->m_sdrBrightness : + 1.0f); } - glUniformMatrix3fv(m_shaders->m_shBLURPREPARE.proj, 1, GL_TRUE, glMatrix.getMatrix().data()); - glUniform1f(m_shaders->m_shBLURPREPARE.contrast, *PBLURCONTRAST); - glUniform1f(m_shaders->m_shBLURPREPARE.brightness, *PBLURBRIGHTNESS); - glUniform1i(m_shaders->m_shBLURPREPARE.tex, 0); + m_shaders->m_shBLURPREPARE.setUniformMatrix3fv(SHADER_PROJ, 1, GL_TRUE, glMatrix.getMatrix()); + m_shaders->m_shBLURPREPARE.setUniformFloat(SHADER_CONTRAST, *PBLURCONTRAST); + m_shaders->m_shBLURPREPARE.setUniformFloat(SHADER_BRIGHTNESS, *PBLURBRIGHTNESS); + m_shaders->m_shBLURPREPARE.setUniformInt(SHADER_TEX, 0); - glBindVertexArray(m_shaders->m_shBLURPREPARE.shaderVao); + glBindVertexArray(m_shaders->m_shBLURPREPARE.uniformLocations[SHADER_SHADER_VAO]); if (!damage.empty()) { for (auto const& RECT : damage.getRects()) { @@ -1874,25 +1874,26 @@ CFramebuffer* CHyprOpenGLImpl::blurFramebufferWithDamage(float a, CRegion* origi auto currentTex = currentRenderToFB->getTexture(); - glBindTexture(currentTex->m_target, currentTex->m_texID); + currentTex->bind(); - glTexParameteri(currentTex->m_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + currentTex->setTexParameter(GL_TEXTURE_MIN_FILTER, GL_LINEAR); useProgram(pShader->program); // prep two shaders - glUniformMatrix3fv(pShader->proj, 1, GL_TRUE, glMatrix.getMatrix().data()); - glUniform1f(pShader->radius, *PBLURSIZE * a); // this makes the blursize change with a + pShader->setUniformMatrix3fv(SHADER_PROJ, 1, GL_TRUE, glMatrix.getMatrix()); + pShader->setUniformFloat(SHADER_RADIUS, *PBLURSIZE * a); // this makes the blursize change with a if (pShader == &m_shaders->m_shBLUR1) { - glUniform2f(m_shaders->m_shBLUR1.halfpixel, 0.5f / (m_renderData.pMonitor->m_pixelSize.x / 2.f), 0.5f / (m_renderData.pMonitor->m_pixelSize.y / 2.f)); - glUniform1i(m_shaders->m_shBLUR1.passes, *PBLURPASSES); - glUniform1f(m_shaders->m_shBLUR1.vibrancy, *PBLURVIBRANCY); - glUniform1f(m_shaders->m_shBLUR1.vibrancy_darkness, *PBLURVIBRANCYDARKNESS); + m_shaders->m_shBLUR1.setUniformFloat2(SHADER_HALFPIXEL, 0.5f / (m_renderData.pMonitor->m_pixelSize.x / 2.f), 0.5f / (m_renderData.pMonitor->m_pixelSize.y / 2.f)); + m_shaders->m_shBLUR1.setUniformInt(SHADER_PASSES, *PBLURPASSES); + m_shaders->m_shBLUR1.setUniformFloat(SHADER_VIBRANCY, *PBLURVIBRANCY); + m_shaders->m_shBLUR1.setUniformFloat(SHADER_VIBRANCY_DARKNESS, *PBLURVIBRANCYDARKNESS); } else - glUniform2f(m_shaders->m_shBLUR2.halfpixel, 0.5f / (m_renderData.pMonitor->m_pixelSize.x * 2.f), 0.5f / (m_renderData.pMonitor->m_pixelSize.y * 2.f)); - glUniform1i(pShader->tex, 0); + m_shaders->m_shBLUR2.setUniformFloat2(SHADER_HALFPIXEL, 0.5f / (m_renderData.pMonitor->m_pixelSize.x * 2.f), 0.5f / (m_renderData.pMonitor->m_pixelSize.y * 2.f)); + pShader->setUniformInt(SHADER_TEX, 0); + + glBindVertexArray(pShader->uniformLocations[SHADER_SHADER_VAO]); - glBindVertexArray(pShader->shaderVao); if (!pDamage->empty()) { for (auto const& RECT : pDamage->getRects()) { scissor(&RECT, false /* this region is already transformed */); @@ -1911,7 +1912,7 @@ CFramebuffer* CHyprOpenGLImpl::blurFramebufferWithDamage(float a, CRegion* origi // draw the things. // first draw is swap -> mirr PMIRRORFB->bind(); - glBindTexture(PMIRRORSWAPFB->getTexture()->m_target, PMIRRORSWAPFB->getTexture()->m_texID); + PMIRRORSWAPFB->getTexture()->bind(); // damage region will be scaled, make a temp CRegion tempDamage{damage}; @@ -1941,18 +1942,18 @@ CFramebuffer* CHyprOpenGLImpl::blurFramebufferWithDamage(float a, CRegion* origi auto currentTex = currentRenderToFB->getTexture(); - glBindTexture(currentTex->m_target, currentTex->m_texID); + currentTex->bind(); - glTexParameteri(currentTex->m_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + currentTex->setTexParameter(GL_TEXTURE_MIN_FILTER, GL_LINEAR); useProgram(m_shaders->m_shBLURFINISH.program); - glUniformMatrix3fv(m_shaders->m_shBLURFINISH.proj, 1, GL_TRUE, glMatrix.getMatrix().data()); - glUniform1f(m_shaders->m_shBLURFINISH.noise, *PBLURNOISE); - glUniform1f(m_shaders->m_shBLURFINISH.brightness, *PBLURBRIGHTNESS); + m_shaders->m_shBLURFINISH.setUniformMatrix3fv(SHADER_PROJ, 1, GL_TRUE, glMatrix.getMatrix()); + m_shaders->m_shBLURFINISH.setUniformFloat(SHADER_NOISE, *PBLURNOISE); + m_shaders->m_shBLURFINISH.setUniformFloat(SHADER_BRIGHTNESS, *PBLURBRIGHTNESS); - glUniform1i(m_shaders->m_shBLURFINISH.tex, 0); + m_shaders->m_shBLURFINISH.setUniformInt(SHADER_TEX, 0); - glBindVertexArray(m_shaders->m_shBLURFINISH.shaderVao); + glBindVertexArray(m_shaders->m_shBLURFINISH.uniformLocations[SHADER_SHADER_VAO]); if (!damage.empty()) { for (auto const& RECT : damage.getRects()) { @@ -1970,7 +1971,7 @@ CFramebuffer* CHyprOpenGLImpl::blurFramebufferWithDamage(float a, CRegion* origi } // finish - glBindTexture(PMIRRORFB->getTexture()->m_target, 0); + PMIRRORFB->getTexture()->unbind(); blend(BLENDBEFORE); @@ -2188,7 +2189,7 @@ void CHyprOpenGLImpl::renderTextureWithBlur(SP<CTexture> tex, const CBox& box, f glClearStencil(0); glClear(GL_STENCIL_BUFFER_BIT); - glEnable(GL_STENCIL_TEST); + setCapStatus(GL_STENCIL_TEST, true); glStencilFunc(GL_ALWAYS, 1, 0xFF); glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); @@ -2237,7 +2238,7 @@ void CHyprOpenGLImpl::renderTextureWithBlur(SP<CTexture> tex, const CBox& box, f glClear(GL_STENCIL_BUFFER_BIT); // draw window - glDisable(GL_STENCIL_TEST); + setCapStatus(GL_STENCIL_TEST, false); renderTextureInternalWithDamage(tex, box, a * overallA, texDamage, round, roundingPower, false, false, true, true, wrapX, wrapY); glStencilMask(0xFF); @@ -2281,16 +2282,16 @@ void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& gr useProgram(m_shaders->m_shBORDER1.program); const bool skipCM = !m_cmSupported || m_renderData.pMonitor->m_imageDescription == SImageDescription{}; - glUniform1i(m_shaders->m_shBORDER1.skipCM, skipCM); + m_shaders->m_shBORDER1.setUniformInt(SHADER_SKIP_CM, skipCM); if (!skipCM) passCMUniforms(m_shaders->m_shBORDER1, SImageDescription{}); - glUniformMatrix3fv(m_shaders->m_shBORDER1.proj, 1, GL_TRUE, glMatrix.getMatrix().data()); - glUniform4fv(m_shaders->m_shBORDER1.gradient, grad.m_colorsOkLabA.size() / 4, (float*)grad.m_colorsOkLabA.data()); - glUniform1i(m_shaders->m_shBORDER1.gradientLength, grad.m_colorsOkLabA.size() / 4); - glUniform1f(m_shaders->m_shBORDER1.angle, (int)(grad.m_angle / (PI / 180.0)) % 360 * (PI / 180.0)); - glUniform1f(m_shaders->m_shBORDER1.alpha, a); - glUniform1i(m_shaders->m_shBORDER1.gradient2Length, 0); + m_shaders->m_shBORDER1.setUniformMatrix3fv(SHADER_PROJ, 1, GL_TRUE, glMatrix.getMatrix()); + m_shaders->m_shBORDER1.setUniform4fv(SHADER_GRADIENT, grad.m_colorsOkLabA.size() / 4, grad.m_colorsOkLabA); + m_shaders->m_shBORDER1.setUniformInt(SHADER_GRADIENT_LENGTH, grad.m_colorsOkLabA.size() / 4); + m_shaders->m_shBORDER1.setUniformFloat(SHADER_ANGLE, (int)(grad.m_angle / (PI / 180.0)) % 360 * (PI / 180.0)); + m_shaders->m_shBORDER1.setUniformFloat(SHADER_ALPHA, a); + m_shaders->m_shBORDER1.setUniformInt(SHADER_GRADIENT2_LENGTH, 0); CBox transformedBox = newBox; transformedBox.transform(wlTransformToHyprutils(invertTransform(m_renderData.pMonitor->m_transform)), m_renderData.pMonitor->m_transformedSize.x, @@ -2299,15 +2300,15 @@ void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& gr const auto TOPLEFT = Vector2D(transformedBox.x, transformedBox.y); const auto FULLSIZE = Vector2D(transformedBox.width, transformedBox.height); - glUniform2f(m_shaders->m_shBORDER1.topLeft, (float)TOPLEFT.x, (float)TOPLEFT.y); - glUniform2f(m_shaders->m_shBORDER1.fullSize, (float)FULLSIZE.x, (float)FULLSIZE.y); - glUniform2f(m_shaders->m_shBORDER1.fullSizeUntransformed, (float)newBox.width, (float)newBox.height); - glUniform1f(m_shaders->m_shBORDER1.radius, round); - glUniform1f(m_shaders->m_shBORDER1.radiusOuter, outerRound == -1 ? round : outerRound); - glUniform1f(m_shaders->m_shBORDER1.roundingPower, roundingPower); - glUniform1f(m_shaders->m_shBORDER1.thick, scaledBorderSize); + m_shaders->m_shBORDER1.setUniformFloat2(SHADER_TOP_LEFT, (float)TOPLEFT.x, (float)TOPLEFT.y); + m_shaders->m_shBORDER1.setUniformFloat2(SHADER_FULL_SIZE, (float)FULLSIZE.x, (float)FULLSIZE.y); + m_shaders->m_shBORDER1.setUniformFloat2(SHADER_FULL_SIZE_UNTRANSFORMED, (float)newBox.width, (float)newBox.height); + m_shaders->m_shBORDER1.setUniformFloat(SHADER_RADIUS, round); + m_shaders->m_shBORDER1.setUniformFloat(SHADER_RADIUS_OUTER, outerRound == -1 ? round : outerRound); + m_shaders->m_shBORDER1.setUniformFloat(SHADER_ROUNDING_POWER, roundingPower); + m_shaders->m_shBORDER1.setUniformFloat(SHADER_THICK, scaledBorderSize); - glBindVertexArray(m_shaders->m_shBORDER1.shaderVao); + glBindVertexArray(m_shaders->m_shBORDER1.uniformLocations[SHADER_SHADER_VAO]); if (m_renderData.clipBox.width != 0 && m_renderData.clipBox.height != 0) { CRegion damageClip{m_renderData.clipBox.x, m_renderData.clipBox.y, m_renderData.clipBox.width, m_renderData.clipBox.height}; @@ -2366,16 +2367,16 @@ void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& gr blend(true); useProgram(m_shaders->m_shBORDER1.program); - glUniformMatrix3fv(m_shaders->m_shBORDER1.proj, 1, GL_TRUE, glMatrix.getMatrix().data()); - glUniform4fv(m_shaders->m_shBORDER1.gradient, grad1.m_colorsOkLabA.size() / 4, (float*)grad1.m_colorsOkLabA.data()); - glUniform1i(m_shaders->m_shBORDER1.gradientLength, grad1.m_colorsOkLabA.size() / 4); - glUniform1f(m_shaders->m_shBORDER1.angle, (int)(grad1.m_angle / (PI / 180.0)) % 360 * (PI / 180.0)); + m_shaders->m_shBORDER1.setUniformMatrix3fv(SHADER_PROJ, 1, GL_TRUE, glMatrix.getMatrix()); + m_shaders->m_shBORDER1.setUniform4fv(SHADER_GRADIENT, grad1.m_colorsOkLabA.size() / 4, grad1.m_colorsOkLabA); + m_shaders->m_shBORDER1.setUniformInt(SHADER_GRADIENT_LENGTH, grad1.m_colorsOkLabA.size() / 4); + m_shaders->m_shBORDER1.setUniformFloat(SHADER_ANGLE, (int)(grad1.m_angle / (PI / 180.0)) % 360 * (PI / 180.0)); if (!grad2.m_colorsOkLabA.empty()) - glUniform4fv(m_shaders->m_shBORDER1.gradient2, grad2.m_colorsOkLabA.size() / 4, (float*)grad2.m_colorsOkLabA.data()); - glUniform1i(m_shaders->m_shBORDER1.gradient2Length, grad2.m_colorsOkLabA.size() / 4); - glUniform1f(m_shaders->m_shBORDER1.angle2, (int)(grad2.m_angle / (PI / 180.0)) % 360 * (PI / 180.0)); - glUniform1f(m_shaders->m_shBORDER1.alpha, a); - glUniform1f(m_shaders->m_shBORDER1.gradientLerp, lerp); + m_shaders->m_shBORDER1.setUniform4fv(SHADER_GRADIENT2, grad2.m_colorsOkLabA.size() / 4, grad2.m_colorsOkLabA); + m_shaders->m_shBORDER1.setUniformInt(SHADER_GRADIENT2_LENGTH, grad2.m_colorsOkLabA.size() / 4); + m_shaders->m_shBORDER1.setUniformFloat(SHADER_ANGLE2, (int)(grad2.m_angle / (PI / 180.0)) % 360 * (PI / 180.0)); + m_shaders->m_shBORDER1.setUniformFloat(SHADER_ALPHA, a); + m_shaders->m_shBORDER1.setUniformFloat(SHADER_GRADIENT_LERP, lerp); CBox transformedBox = newBox; transformedBox.transform(wlTransformToHyprutils(invertTransform(m_renderData.pMonitor->m_transform)), m_renderData.pMonitor->m_transformedSize.x, @@ -2384,15 +2385,15 @@ void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& gr const auto TOPLEFT = Vector2D(transformedBox.x, transformedBox.y); const auto FULLSIZE = Vector2D(transformedBox.width, transformedBox.height); - glUniform2f(m_shaders->m_shBORDER1.topLeft, (float)TOPLEFT.x, (float)TOPLEFT.y); - glUniform2f(m_shaders->m_shBORDER1.fullSize, (float)FULLSIZE.x, (float)FULLSIZE.y); - glUniform2f(m_shaders->m_shBORDER1.fullSizeUntransformed, (float)newBox.width, (float)newBox.height); - glUniform1f(m_shaders->m_shBORDER1.radius, round); - glUniform1f(m_shaders->m_shBORDER1.radiusOuter, outerRound == -1 ? round : outerRound); - glUniform1f(m_shaders->m_shBORDER1.roundingPower, roundingPower); - glUniform1f(m_shaders->m_shBORDER1.thick, scaledBorderSize); + m_shaders->m_shBORDER1.setUniformFloat2(SHADER_TOP_LEFT, (float)TOPLEFT.x, (float)TOPLEFT.y); + m_shaders->m_shBORDER1.setUniformFloat2(SHADER_FULL_SIZE, (float)FULLSIZE.x, (float)FULLSIZE.y); + m_shaders->m_shBORDER1.setUniformFloat2(SHADER_FULL_SIZE_UNTRANSFORMED, (float)newBox.width, (float)newBox.height); + m_shaders->m_shBORDER1.setUniformFloat(SHADER_RADIUS, round); + m_shaders->m_shBORDER1.setUniformFloat(SHADER_RADIUS_OUTER, outerRound == -1 ? round : outerRound); + m_shaders->m_shBORDER1.setUniformFloat(SHADER_ROUNDING_POWER, roundingPower); + m_shaders->m_shBORDER1.setUniformFloat(SHADER_THICK, scaledBorderSize); - glBindVertexArray(m_shaders->m_shBORDER1.shaderVao); + glBindVertexArray(m_shaders->m_shBORDER1.uniformLocations[SHADER_SHADER_VAO]); if (m_renderData.clipBox.width != 0 && m_renderData.clipBox.height != 0) { CRegion damageClip{m_renderData.clipBox.x, m_renderData.clipBox.y, m_renderData.clipBox.width, m_renderData.clipBox.height}; @@ -2442,27 +2443,27 @@ void CHyprOpenGLImpl::renderRoundedShadow(const CBox& box, int round, float roun useProgram(m_shaders->m_shSHADOW.program); const bool skipCM = !m_cmSupported || m_renderData.pMonitor->m_imageDescription == SImageDescription{}; - glUniform1i(m_shaders->m_shSHADOW.skipCM, skipCM); + m_shaders->m_shSHADOW.setUniformInt(SHADER_SKIP_CM, skipCM); if (!skipCM) passCMUniforms(m_shaders->m_shSHADOW, SImageDescription{}); - glUniformMatrix3fv(m_shaders->m_shSHADOW.proj, 1, GL_TRUE, glMatrix.getMatrix().data()); - glUniform4f(m_shaders->m_shSHADOW.color, col.r, col.g, col.b, col.a * a); + m_shaders->m_shSHADOW.setUniformMatrix3fv(SHADER_PROJ, 1, GL_TRUE, glMatrix.getMatrix()); + m_shaders->m_shSHADOW.setUniformFloat4(SHADER_COLOR, col.r, col.g, col.b, col.a * a); const auto TOPLEFT = Vector2D(range + round, range + round); const auto BOTTOMRIGHT = Vector2D(newBox.width - (range + round), newBox.height - (range + round)); const auto FULLSIZE = Vector2D(newBox.width, newBox.height); // Rounded corners - glUniform2f(m_shaders->m_shSHADOW.topLeft, (float)TOPLEFT.x, (float)TOPLEFT.y); - glUniform2f(m_shaders->m_shSHADOW.bottomRight, (float)BOTTOMRIGHT.x, (float)BOTTOMRIGHT.y); - glUniform2f(m_shaders->m_shSHADOW.fullSize, (float)FULLSIZE.x, (float)FULLSIZE.y); - glUniform1f(m_shaders->m_shSHADOW.radius, range + round); - glUniform1f(m_shaders->m_shSHADOW.roundingPower, roundingPower); - glUniform1f(m_shaders->m_shSHADOW.range, range); - glUniform1f(m_shaders->m_shSHADOW.shadowPower, SHADOWPOWER); + m_shaders->m_shSHADOW.setUniformFloat2(SHADER_TOP_LEFT, (float)TOPLEFT.x, (float)TOPLEFT.y); + m_shaders->m_shSHADOW.setUniformFloat2(SHADER_BOTTOM_RIGHT, (float)BOTTOMRIGHT.x, (float)BOTTOMRIGHT.y); + m_shaders->m_shSHADOW.setUniformFloat2(SHADER_FULL_SIZE, (float)FULLSIZE.x, (float)FULLSIZE.y); + m_shaders->m_shSHADOW.setUniformFloat(SHADER_RADIUS, range + round); + m_shaders->m_shSHADOW.setUniformFloat(SHADER_ROUNDING_POWER, roundingPower); + m_shaders->m_shSHADOW.setUniformFloat(SHADER_RANGE, range); + m_shaders->m_shSHADOW.setUniformFloat(SHADER_SHADOW_POWER, SHADOWPOWER); - glBindVertexArray(m_shaders->m_shSHADOW.shaderVao); + glBindVertexArray(m_shaders->m_shSHADOW.uniformLocations[SHADER_SHADER_VAO]); if (m_renderData.clipBox.width != 0 && m_renderData.clipBox.height != 0) { CRegion damageClip{m_renderData.clipBox.x, m_renderData.clipBox.y, m_renderData.clipBox.width, m_renderData.clipBox.height}; @@ -2606,13 +2607,13 @@ SP<CTexture> CHyprOpenGLImpl::loadAsset(const std::string& filename) { const GLint glType = CAIROFORMAT == CAIRO_FORMAT_RGB96F ? GL_FLOAT : GL_UNSIGNED_BYTE; const auto DATA = cairo_image_surface_get_data(CAIROSURFACE); - glBindTexture(GL_TEXTURE_2D, tex->m_texID); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + tex->bind(); + tex->setTexParameter(GL_TEXTURE_MAG_FILTER, GL_LINEAR); + tex->setTexParameter(GL_TEXTURE_MIN_FILTER, GL_LINEAR); if (CAIROFORMAT != CAIRO_FORMAT_RGB96F) { - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_BLUE); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED); + tex->setTexParameter(GL_TEXTURE_SWIZZLE_R, GL_BLUE); + tex->setTexParameter(GL_TEXTURE_SWIZZLE_B, GL_RED); } glTexImage2D(GL_TEXTURE_2D, 0, glIFormat, tex->m_size.x, tex->m_size.y, 0, glFormat, glType, DATA); @@ -2689,11 +2690,11 @@ SP<CTexture> CHyprOpenGLImpl::renderText(const std::string& text, CHyprColor col tex->m_size = {cairo_image_surface_get_width(CAIROSURFACE), cairo_image_surface_get_height(CAIROSURFACE)}; const auto DATA = cairo_image_surface_get_data(CAIROSURFACE); - glBindTexture(GL_TEXTURE_2D, tex->m_texID); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_BLUE); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED); + tex->bind(); + tex->setTexParameter(GL_TEXTURE_MAG_FILTER, GL_LINEAR); + tex->setTexParameter(GL_TEXTURE_MIN_FILTER, GL_LINEAR); + tex->setTexParameter(GL_TEXTURE_SWIZZLE_R, GL_BLUE); + tex->setTexParameter(GL_TEXTURE_SWIZZLE_B, GL_RED); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tex->m_size.x, tex->m_size.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA); cairo_destroy(CAIRO); @@ -2730,11 +2731,11 @@ void CHyprOpenGLImpl::initMissingAssetTexture() { const GLint glType = GL_UNSIGNED_BYTE; const auto DATA = cairo_image_surface_get_data(CAIROSURFACE); - glBindTexture(GL_TEXTURE_2D, tex->m_texID); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_BLUE); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED); + tex->bind(); + tex->setTexParameter(GL_TEXTURE_MAG_FILTER, GL_LINEAR); + tex->setTexParameter(GL_TEXTURE_MIN_FILTER, GL_LINEAR); + tex->setTexParameter(GL_TEXTURE_SWIZZLE_R, GL_BLUE); + tex->setTexParameter(GL_TEXTURE_SWIZZLE_B, GL_RED); glTexImage2D(GL_TEXTURE_2D, 0, glFormat, tex->m_size.x, tex->m_size.y, 0, glFormat, glType, DATA); cairo_surface_destroy(CAIROSURFACE); @@ -2858,11 +2859,12 @@ void CHyprOpenGLImpl::createBGTextureForMonitor(PHLMONITOR pMonitor) { const GLint glType = GL_UNSIGNED_BYTE; const auto DATA = cairo_image_surface_get_data(CAIROSURFACE); - glBindTexture(GL_TEXTURE_2D, tex->m_texID); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_BLUE); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED); + tex->bind(); + tex->setTexParameter(GL_TEXTURE_MAG_FILTER, GL_LINEAR); + tex->setTexParameter(GL_TEXTURE_MIN_FILTER, GL_LINEAR); + tex->setTexParameter(GL_TEXTURE_SWIZZLE_R, GL_BLUE); + tex->setTexParameter(GL_TEXTURE_SWIZZLE_B, GL_RED); + glTexImage2D(GL_TEXTURE_2D, 0, glFormat, tex->m_size.x, tex->m_size.y, 0, glFormat, glType, DATA); cairo_surface_destroy(CAIROSURFACE); @@ -3000,6 +3002,29 @@ void CHyprOpenGLImpl::setRenderModifEnabled(bool enabled) { m_renderData.renderModif.enabled = enabled; } +void CHyprOpenGLImpl::setViewport(GLint x, GLint y, GLsizei width, GLsizei height) { + if (m_lastViewport.x == x && m_lastViewport.y == y && m_lastViewport.width == width && m_lastViewport.height == height) + return; + + glViewport(x, y, width, height); + m_lastViewport = {.x = x, .y = y, .width = width, .height = height}; +} + +void CHyprOpenGLImpl::setCapStatus(int cap, bool status) { + // check if the capability status is already set to the desired status + auto it = m_capStatus.find(cap); + bool currentStatus = (it != m_capStatus.end()) ? it->second : false; // default to 'false' if not found + + if (currentStatus == status) + return; + + m_capStatus[cap] = status; + + // Enable or disable the capability based on status + auto func = status ? [](int c) { glEnable(c); } : [](int c) { glDisable(c); }; + func(cap); +} + uint32_t CHyprOpenGLImpl::getPreferredReadFormat(PHLMONITOR pMonitor) { return pMonitor->m_output->state->state().drmFormat; } diff --git a/src/render/OpenGL.hpp b/src/render/OpenGL.hpp index eeea2b24..4c6f55f9 100644 --- a/src/render/OpenGL.hpp +++ b/src/render/OpenGL.hpp @@ -83,7 +83,6 @@ enum eMonitorExtraRenderFBs : uint8_t { struct SPreparedShaders { std::string TEXVERTSRC; - std::string TEXVERTSRC300; std::string TEXVERTSRC320; SShader m_shQUAD; SShader m_shRGBA; @@ -201,6 +200,8 @@ class CHyprOpenGLImpl { void popMonitorTransformEnabled(); void setRenderModifEnabled(bool enabled); + void setViewport(GLint x, GLint y, GLsizei width, GLsizei height); + void setCapStatus(int cap, bool status); void saveMatrix(); void setMatrixScaleTranslate(const Vector2D& translate, const float& scale); @@ -307,40 +308,47 @@ class CHyprOpenGLImpl { EGL_CONTEXT_GLES_3_2, }; - eEGLContextVersion m_eglContextVersion = EGL_CONTEXT_GLES_3_2; - - std::vector<SDRMFormat> m_drmFormats; - bool m_hasModifiers = false; - - int m_drmFD = -1; - std::string m_extensions; - - bool m_fakeFrame = false; - bool m_applyFinalShader = false; - bool m_blend = false; - bool m_offloadedFramebuffer = false; - bool m_cmSupported = true; - - bool m_monitorTransformEnabled = false; // do not modify directly - std::stack<bool> m_monitorTransformStack; - - SShader m_finalScreenShader; - CTimer m_globalTimer; - GLuint m_currentProgram; - - SP<CTexture> m_missingAssetTexture; - SP<CTexture> m_backgroundTexture; - SP<CTexture> m_lockDeadTexture; - SP<CTexture> m_lockDead2Texture; - SP<CTexture> m_lockTtyTextTexture; - - void logShaderError(const GLuint&, bool program = false, bool silent = false); - void createBGTextureForMonitor(PHLMONITOR); - void initDRMFormats(); - void initEGL(bool gbm); - EGLDeviceEXT eglDeviceFromDRMFD(int drmFD); - void initAssets(); - void initMissingAssetTexture(); + struct { + GLint x = 0; + GLint y = 0; + GLsizei width = 0; + GLsizei height = 0; + } m_lastViewport; + + std::unordered_map<int, bool> m_capStatus; + + eEGLContextVersion m_eglContextVersion = EGL_CONTEXT_GLES_3_2; + + std::vector<SDRMFormat> m_drmFormats; + bool m_hasModifiers = false; + + int m_drmFD = -1; + std::string m_extensions; + + bool m_fakeFrame = false; + bool m_applyFinalShader = false; + bool m_blend = false; + bool m_offloadedFramebuffer = false; + bool m_cmSupported = true; + + bool m_monitorTransformEnabled = false; // do not modify directly + std::stack<bool> m_monitorTransformStack; + SP<CTexture> m_missingAssetTexture; + SP<CTexture> m_backgroundTexture; + SP<CTexture> m_lockDeadTexture; + SP<CTexture> m_lockDead2Texture; + SP<CTexture> m_lockTtyTextTexture; + SShader m_finalScreenShader; + CTimer m_globalTimer; + GLuint m_currentProgram; + + void logShaderError(const GLuint&, bool program = false, bool silent = false); + void createBGTextureForMonitor(PHLMONITOR); + void initDRMFormats(); + void initEGL(bool gbm); + EGLDeviceEXT eglDeviceFromDRMFD(int drmFD); + void initAssets(); + void initMissingAssetTexture(); // std::optional<std::vector<uint64_t>> getModsForFormat(EGLint format); @@ -349,9 +357,9 @@ class CHyprOpenGLImpl { CFramebuffer* blurMainFramebufferWithDamage(float a, CRegion* damage); CFramebuffer* blurFramebufferWithDamage(float a, CRegion* damage, CFramebuffer& source); - void passCMUniforms(const SShader&, const NColorManagement::SImageDescription& imageDescription, const NColorManagement::SImageDescription& targetImageDescription, + void passCMUniforms(SShader&, const NColorManagement::SImageDescription& imageDescription, const NColorManagement::SImageDescription& targetImageDescription, bool modifySDR = false, float sdrMinLuminance = -1.0f, int sdrMaxLuminance = -1); - void passCMUniforms(const SShader&, const NColorManagement::SImageDescription& imageDescription); + void passCMUniforms(SShader&, const NColorManagement::SImageDescription& imageDescription); void renderTextureInternalWithDamage(SP<CTexture>, const CBox& box, float a, const CRegion& damage, int round = 0, float roundingPower = 2.0f, bool discardOpaque = false, bool noAA = false, bool allowCustomUV = false, bool allowDim = false, GLenum wrapX = GL_CLAMP_TO_EDGE, GLenum wrapY = GL_CLAMP_TO_EDGE); void renderTexturePrimitive(SP<CTexture> tex, const CBox& box); diff --git a/src/render/Shader.cpp b/src/render/Shader.cpp index 7201d1c0..60a27092 100644 --- a/src/render/Shader.cpp +++ b/src/render/Shader.cpp @@ -1,44 +1,204 @@ #include "Shader.hpp" #include "render/OpenGL.hpp" +#define EPSILON(x, y) (std::abs((x) - (y)) < 1e-5f) + +static bool compareFloat(auto a, auto b) { + if (a.size() != b.size()) + return false; + + for (size_t i = 0; i < a.size(); ++i) + if (std::fabs(a[i] - b[i]) > 1e-5f) + return false; + + return true; +} + +SShader::SShader() { + uniformLocations.fill(-1); +} + SShader::~SShader() { destroy(); } void SShader::createVao() { + GLuint shaderVao = 0, shaderVbo = 0, shaderVboUv = 0; + glGenVertexArrays(1, &shaderVao); glBindVertexArray(shaderVao); - if (posAttrib != -1) { - glGenBuffers(1, &shaderVboPos); - glBindBuffer(GL_ARRAY_BUFFER, shaderVboPos); + if (uniformLocations[SHADER_POS_ATTRIB] != -1) { + glGenBuffers(1, &shaderVbo); + glBindBuffer(GL_ARRAY_BUFFER, shaderVbo); glBufferData(GL_ARRAY_BUFFER, sizeof(fullVerts), fullVerts, GL_STATIC_DRAW); - glEnableVertexAttribArray(posAttrib); - glVertexAttribPointer(posAttrib, 2, GL_FLOAT, GL_FALSE, 0, (void*)0); + glEnableVertexAttribArray(uniformLocations[SHADER_POS_ATTRIB]); + glVertexAttribPointer(uniformLocations[SHADER_POS_ATTRIB], 2, GL_FLOAT, GL_FALSE, 0, nullptr); } // UV VBO (dynamic, may be updated per frame) - if (texAttrib != -1) { + if (uniformLocations[SHADER_TEX_ATTRIB] != -1) { glGenBuffers(1, &shaderVboUv); glBindBuffer(GL_ARRAY_BUFFER, shaderVboUv); glBufferData(GL_ARRAY_BUFFER, sizeof(fullVerts), fullVerts, GL_DYNAMIC_DRAW); // Initial dummy UVs - glEnableVertexAttribArray(texAttrib); - glVertexAttribPointer(texAttrib, 2, GL_FLOAT, GL_FALSE, 0, (void*)0); + glEnableVertexAttribArray(uniformLocations[SHADER_TEX_ATTRIB]); + glVertexAttribPointer(uniformLocations[SHADER_TEX_ATTRIB], 2, GL_FLOAT, GL_FALSE, 0, nullptr); } glBindVertexArray(0); glBindBuffer(GL_ARRAY_BUFFER, 0); + + uniformLocations[SHADER_SHADER_VAO] = shaderVao; + uniformLocations[SHADER_SHADER_VBO_POS] = shaderVbo; + uniformLocations[SHADER_SHADER_VBO_UV] = shaderVboUv; + + RASSERT(uniformLocations[SHADER_SHADER_VAO] >= 0, "SHADER_SHADER_VAO could not be created"); + RASSERT(uniformLocations[SHADER_SHADER_VBO_POS] >= 0, "SHADER_SHADER_VBO_POS could not be created"); + RASSERT(uniformLocations[SHADER_SHADER_VBO_UV] >= 0, "SHADER_SHADER_VBO_UV could not be created"); +} + +void SShader::setUniformInt(eShaderUniform location, GLint v0) { + if (uniformLocations.at(location) == -1) + return; + + auto& cached = uniformStatus.at(location); + + if (cached.index() != 0 && std::get<GLint>(cached) == v0) + return; + + cached = v0; + glUniform1i(uniformLocations[location], v0); +} + +void SShader::setUniformFloat(eShaderUniform location, GLfloat v0) { + if (uniformLocations.at(location) == -1) + return; + + auto& cached = uniformStatus.at(location); + + if (cached.index() != 0) { + auto val = std::get<GLfloat>(cached); + if (EPSILON(val, v0)) + return; + } + + cached = v0; + glUniform1f(uniformLocations[location], v0); +} + +void SShader::setUniformFloat2(eShaderUniform location, GLfloat v0, GLfloat v1) { + if (uniformLocations.at(location) == -1) + return; + + auto& cached = uniformStatus.at(location); + + if (cached.index() != 0) { + auto val = std::get<std::array<GLfloat, 2>>(cached); + if (EPSILON(val[0], v0) && EPSILON(val[1], v1)) + return; + } + + cached = std::array<GLfloat, 2>{v0, v1}; + glUniform2f(uniformLocations[location], v0, v1); +} + +void SShader::setUniformFloat3(eShaderUniform location, GLfloat v0, GLfloat v1, GLfloat v2) { + if (uniformLocations.at(location) == -1) + return; + + auto& cached = uniformStatus.at(location); + + if (cached.index() != 0) { + auto val = std::get<std::array<GLfloat, 3>>(cached); + if (EPSILON(val[0], v0) && EPSILON(val[1], v1) && EPSILON(val[2], v2)) + return; + } + + cached = std::array<GLfloat, 3>{v0, v1, v2}; + glUniform3f(uniformLocations[location], v0, v1, v2); +} + +void SShader::setUniformFloat4(eShaderUniform location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) { + if (uniformLocations.at(location) == -1) + return; + + auto& cached = uniformStatus.at(location); + + if (cached.index() != 0) { + auto val = std::get<std::array<GLfloat, 4>>(cached); + if (EPSILON(val[0], v0) && EPSILON(val[1], v1) && EPSILON(val[2], v2) && EPSILON(val[3], v3)) + return; + } + + cached = std::array<GLfloat, 4>{v0, v1, v2, v3}; + glUniform4f(uniformLocations[location], v0, v1, v2, v3); +} + +void SShader::setUniformMatrix3fv(eShaderUniform location, GLsizei count, GLboolean transpose, std::array<GLfloat, 9> value) { + if (uniformLocations.at(location) == -1) + return; + + auto& cached = uniformStatus.at(location); + + if (cached.index() != 0) { + auto val = std::get<SUniformMatrix3Data>(cached); + if (val.count == count && val.transpose == transpose && compareFloat(val.value, value)) + return; + } + + cached = SUniformMatrix3Data{.count = count, .transpose = transpose, .value = value}; + glUniformMatrix3fv(uniformLocations[location], count, transpose, value.data()); +} + +void SShader::setUniformMatrix4x2fv(eShaderUniform location, GLsizei count, GLboolean transpose, std::array<GLfloat, 8> value) { + if (uniformLocations.at(location) == -1) + return; + + auto& cached = uniformStatus.at(location); + + if (cached.index() != 0) { + auto val = std::get<SUniformMatrix4Data>(cached); + if (val.count == count && val.transpose == transpose && compareFloat(val.value, value)) + return; + } + + cached = SUniformMatrix4Data{.count = count, .transpose = transpose, .value = value}; + glUniformMatrix4x2fv(uniformLocations[location], count, transpose, value.data()); +} + +void SShader::setUniform4fv(eShaderUniform location, GLsizei count, std::vector<float> value) { + if (uniformLocations.at(location) == -1) + return; + + auto& cached = uniformStatus.at(location); + + if (cached.index() != 0) { + auto val = std::get<SUniform4Data>(cached); + if (val.count == count && compareFloat(val.value, value)) + return; + } + + cached = SUniform4Data{.count = count, .value = value}; + glUniform4fv(uniformLocations[location], count, value.data()); } void SShader::destroy() { + uniformStatus.fill(std::monostate()); + if (program == 0) return; + GLuint shaderVao, shaderVbo, shaderVboUv; + + shaderVao = uniformLocations[SHADER_SHADER_VAO] == -1 ? 0 : uniformLocations[SHADER_SHADER_VAO]; + shaderVbo = uniformLocations[SHADER_SHADER_VBO_POS] == -1 ? 0 : uniformLocations[SHADER_SHADER_VBO_POS]; + shaderVboUv = uniformLocations[SHADER_SHADER_VBO_UV] == -1 ? 0 : uniformLocations[SHADER_SHADER_VBO_UV]; + if (shaderVao) glDeleteVertexArrays(1, &shaderVao); - if (shaderVboPos) - glDeleteBuffers(1, &shaderVboPos); + if (shaderVbo) + glDeleteBuffers(1, &shaderVbo); if (shaderVboUv) glDeleteBuffers(1, &shaderVboUv); diff --git a/src/render/Shader.hpp b/src/render/Shader.hpp index 7bed9041..76d1235f 100644 --- a/src/render/Shader.hpp +++ b/src/render/Shader.hpp @@ -1,85 +1,113 @@ #pragma once #include "../defines.hpp" -#include <unordered_map> +#include <array> +#include <variant> -struct SShader { - ~SShader(); - - GLuint program = 0; - GLint proj = -1; - GLint color = -1; - GLint alphaMatte = -1; - GLint texType = -1; - GLint skipCM = -1; - GLint sourceTF = -1; - GLint targetTF = -1; - GLint srcTFRange = -1; - GLint dstTFRange = -1; - GLint targetPrimaries = -1; - GLint maxLuminance = -1; - GLint dstMaxLuminance = -1; - GLint dstRefLuminance = -1; - GLint sdrSaturation = -1; // sdr -> hdr saturation - GLint sdrBrightness = -1; // sdr -> hdr brightness multiplier - GLint convertMatrix = -1; - GLint tex = -1; - GLint alpha = -1; - GLint posAttrib = -1; - GLint texAttrib = -1; - GLint matteTexAttrib = -1; - GLint discardOpaque = -1; - GLint discardAlpha = -1; - GLfloat discardAlphaValue = -1; - - GLuint shaderVao = 0; - GLuint shaderVboPos = 0; - GLuint shaderVboUv = 0; +enum eShaderUniform : uint8_t { + SHADER_PROJ = 0, + SHADER_COLOR, + SHADER_ALPHA_MATTE, + SHADER_TEX_TYPE, + SHADER_SKIP_CM, + SHADER_SOURCE_TF, + SHADER_TARGET_TF, + SHADER_SRC_TF_RANGE, + SHADER_DST_TF_RANGE, + SHADER_TARGET_PRIMARIES, + SHADER_MAX_LUMINANCE, + SHADER_DST_MAX_LUMINANCE, + SHADER_DST_REF_LUMINANCE, + SHADER_SDR_SATURATION, + SHADER_SDR_BRIGHTNESS, + SHADER_CONVERT_MATRIX, + SHADER_TEX, + SHADER_ALPHA, + SHADER_POS_ATTRIB, + SHADER_TEX_ATTRIB, + SHADER_MATTE_TEX_ATTRIB, + SHADER_DISCARD_OPAQUE, + SHADER_DISCARD_ALPHA, + SHADER_DISCARD_ALPHA_VALUE, + SHADER_SHADER_VAO, + SHADER_SHADER_VBO_POS, + SHADER_SHADER_VBO_UV, + SHADER_TOP_LEFT, + SHADER_BOTTOM_RIGHT, + SHADER_FULL_SIZE, + SHADER_FULL_SIZE_UNTRANSFORMED, + SHADER_RADIUS, + SHADER_RADIUS_OUTER, + SHADER_ROUNDING_POWER, + SHADER_THICK, + SHADER_HALFPIXEL, + SHADER_RANGE, + SHADER_SHADOW_POWER, + SHADER_USE_ALPHA_MATTE, + SHADER_APPLY_TINT, + SHADER_TINT, + SHADER_GRADIENT, + SHADER_GRADIENT_LENGTH, + SHADER_ANGLE, + SHADER_GRADIENT2, + SHADER_GRADIENT2_LENGTH, + SHADER_ANGLE2, + SHADER_GRADIENT_LERP, + SHADER_TIME, + SHADER_DISTORT, + SHADER_WL_OUTPUT, + SHADER_CONTRAST, + SHADER_PASSES, + SHADER_VIBRANCY, + SHADER_VIBRANCY_DARKNESS, + SHADER_BRIGHTNESS, + SHADER_NOISE, - GLint topLeft = -1; - GLint bottomRight = -1; - GLint fullSize = -1; - GLint fullSizeUntransformed = -1; - GLint radius = -1; - GLint radiusOuter = -1; - GLfloat roundingPower = -1; - - GLint thick = -1; + SHADER_LAST, +}; - GLint halfpixel = -1; +struct SShader { + SShader(); + ~SShader(); - GLint range = -1; - GLint shadowPower = -1; - GLint useAlphaMatte = -1; // always inverted + GLuint program = 0; - GLint applyTint = -1; - GLint tint = -1; + std::array<GLint, SHADER_LAST> uniformLocations; - GLint gradient = -1; - GLint gradientLength = -1; - GLint angle = -1; - GLint gradient2 = -1; - GLint gradient2Length = -1; - GLint angle2 = -1; - GLint gradientLerp = -1; + float initialTime = 0; - float initialTime = 0; - GLint time = -1; - GLint distort = -1; - GLint wl_output = -1; + struct SUniformMatrix3Data { + GLsizei count = 0; + GLboolean transpose = false; + std::array<GLfloat, 9> value = {}; + }; - // Blur prepare - GLint contrast = -1; + struct SUniformMatrix4Data { + GLsizei count = 0; + GLboolean transpose = false; + std::array<GLfloat, 8> value = {}; + }; - // Blur - GLint passes = -1; // Used by `vibrancy` - GLint vibrancy = -1; - GLint vibrancy_darkness = -1; + struct SUniform4Data { + GLsizei count = 0; + std::vector<float> value; + }; - // Blur finish - GLint brightness = -1; - GLint noise = -1; + // + std::array<std::variant<std::monostate, GLint, GLfloat, std::array<GLfloat, 2>, std::array<GLfloat, 3>, std::array<GLfloat, 4>, SUniformMatrix3Data, SUniformMatrix4Data, + SUniform4Data>, + SHADER_LAST> + uniformStatus; + // - void createVao(); - void destroy(); + void createVao(); + void setUniformInt(eShaderUniform location, GLint v0); + void setUniformFloat(eShaderUniform location, GLfloat v0); + void setUniformFloat2(eShaderUniform location, GLfloat v0, GLfloat v1); + void setUniformFloat3(eShaderUniform location, GLfloat v0, GLfloat v1, GLfloat v2); + void setUniformFloat4(eShaderUniform location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); + void setUniformMatrix3fv(eShaderUniform location, GLsizei count, GLboolean transpose, std::array<GLfloat, 9> value); + void setUniformMatrix4x2fv(eShaderUniform location, GLsizei count, GLboolean transpose, std::array<GLfloat, 8> value); + void setUniform4fv(eShaderUniform location, GLsizei count, std::vector<float> value); + void destroy(); }; diff --git a/src/render/Texture.cpp b/src/render/Texture.cpp index 52b79e8d..9b349efb 100644 --- a/src/render/Texture.cpp +++ b/src/render/Texture.cpp @@ -67,21 +67,21 @@ void CTexture::createFromShm(uint32_t drmFormat, uint8_t* pixels, uint32_t strid m_type = format->withAlpha ? TEXTURE_RGBA : TEXTURE_RGBX; m_size = size_; m_isSynchronous = true; + m_target = GL_TEXTURE_2D; allocate(); - - GLCALL(glBindTexture(GL_TEXTURE_2D, m_texID)); - GLCALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)); - GLCALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)); + bind(); + setTexParameter(GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + setTexParameter(GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); if (format->flipRB) { - GLCALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_BLUE)); - GLCALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED)); + setTexParameter(GL_TEXTURE_SWIZZLE_R, GL_BLUE); + setTexParameter(GL_TEXTURE_SWIZZLE_B, GL_RED); } GLCALL(glPixelStorei(GL_UNPACK_ROW_LENGTH_EXT, stride / format->bytesPerBlock)); GLCALL(glTexImage2D(GL_TEXTURE_2D, 0, format->glInternalFormat ? format->glInternalFormat : format->glFormat, size_.x, size_.y, 0, format->glFormat, format->glType, pixels)); GLCALL(glPixelStorei(GL_UNPACK_ROW_LENGTH_EXT, 0)); - GLCALL(glBindTexture(GL_TEXTURE_2D, 0)); + unbind(); if (m_keepDataCopy) { m_dataCopy.resize(stride * size_.y); @@ -103,11 +103,11 @@ void CTexture::createFromDma(const Aquamarine::SDMABUFAttrs& attrs, void* image) allocate(); m_eglImage = image; - GLCALL(glBindTexture(GL_TEXTURE_2D, m_texID)); - GLCALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)); - GLCALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)); + bind(); + setTexParameter(GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + setTexParameter(GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); GLCALL(g_pHyprOpenGL->m_proc.glEGLImageTargetTexture2DOES(m_target, image)); - GLCALL(glBindTexture(GL_TEXTURE_2D, 0)); + unbind(); } void CTexture::update(uint32_t drmFormat, uint8_t* pixels, uint32_t stride, const CRegion& damage) { @@ -116,13 +116,13 @@ void CTexture::update(uint32_t drmFormat, uint8_t* pixels, uint32_t stride, cons const auto format = NFormatUtils::getPixelFormatFromDRM(drmFormat); ASSERT(format); - glBindTexture(GL_TEXTURE_2D, m_texID); + bind(); auto rects = damage.copy().intersect(CBox{{}, m_size}).getRects(); if (format->flipRB) { - GLCALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_BLUE)); - GLCALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED)); + setTexParameter(GL_TEXTURE_SWIZZLE_R, GL_BLUE); + setTexParameter(GL_TEXTURE_SWIZZLE_B, GL_RED); } for (auto const& rect : rects) { @@ -139,7 +139,7 @@ void CTexture::update(uint32_t drmFormat, uint8_t* pixels, uint32_t stride, cons GLCALL(glPixelStorei(GL_UNPACK_SKIP_PIXELS_EXT, 0)); GLCALL(glPixelStorei(GL_UNPACK_SKIP_ROWS_EXT, 0)); - glBindTexture(GL_TEXTURE_2D, 0); + unbind(); if (m_keepDataCopy) { m_dataCopy.resize(stride * m_size.y); @@ -166,3 +166,40 @@ void CTexture::allocate() { const std::vector<uint8_t>& CTexture::dataCopy() { return m_dataCopy; } + +void CTexture::bind() { + GLCALL(glBindTexture(m_target, m_texID)); +} + +void CTexture::unbind() { + GLCALL(glBindTexture(m_target, 0)); +} + +constexpr std::optional<size_t> CTexture::getCacheStateIndex(GLenum pname) { + switch (pname) { + case GL_TEXTURE_WRAP_S: return TEXTURE_PAR_WRAP_S; + case GL_TEXTURE_WRAP_T: return TEXTURE_PAR_WRAP_T; + case GL_TEXTURE_MAG_FILTER: return TEXTURE_PAR_MAG_FILTER; + case GL_TEXTURE_MIN_FILTER: return TEXTURE_PAR_MIN_FILTER; + case GL_TEXTURE_SWIZZLE_R: return TEXTURE_PAR_SWIZZLE_R; + case GL_TEXTURE_SWIZZLE_B: return TEXTURE_PAR_SWIZZLE_B; + default: return std::nullopt; + } +} + +void CTexture::setTexParameter(GLenum pname, GLint param) { + const auto cacheIndex = getCacheStateIndex(pname); + + if (!cacheIndex) { + GLCALL(glTexParameteri(m_target, pname, param)); + return; + } + + const auto idx = cacheIndex.value(); + + if (m_cachedStates[idx] == param) + return; + + m_cachedStates[idx] = param; + GLCALL(glTexParameteri(m_target, pname, param)); +} diff --git a/src/render/Texture.hpp b/src/render/Texture.hpp index 0446f9be..b9811230 100644 --- a/src/render/Texture.hpp +++ b/src/render/Texture.hpp @@ -34,6 +34,9 @@ class CTexture { void allocate(); void update(uint32_t drmFormat, uint8_t* pixels, uint32_t stride, const CRegion& damage); const std::vector<uint8_t>& dataCopy(); + void bind(); + void unbind(); + void setTexParameter(GLenum pname, GLint param); eTextureType m_type = TEXTURE_RGBA; GLenum m_target = GL_TEXTURE_2D; @@ -46,10 +49,21 @@ class CTexture { bool m_isSynchronous = false; private: - void createFromShm(uint32_t drmFormat, uint8_t* pixels, uint32_t stride, const Vector2D& size); - void createFromDma(const Aquamarine::SDMABUFAttrs&, void* image); + enum eTextureParam : uint8_t { + TEXTURE_PAR_WRAP_S = 0, + TEXTURE_PAR_WRAP_T, + TEXTURE_PAR_MAG_FILTER, + TEXTURE_PAR_MIN_FILTER, + TEXTURE_PAR_SWIZZLE_R, + TEXTURE_PAR_SWIZZLE_B, + TEXTURE_PAR_LAST, + }; - bool m_keepDataCopy = false; + void createFromShm(uint32_t drmFormat, uint8_t* pixels, uint32_t stride, const Vector2D& size); + void createFromDma(const Aquamarine::SDMABUFAttrs&, void* image); + inline constexpr std::optional<size_t> getCacheStateIndex(GLenum pname); - std::vector<uint8_t> m_dataCopy; -};
\ No newline at end of file + bool m_keepDataCopy = false; + std::vector<uint8_t> m_dataCopy; + std::array<std::optional<GLint>, TEXTURE_PAR_LAST> m_cachedStates; +}; diff --git a/src/render/decorations/CHyprGroupBarDecoration.cpp b/src/render/decorations/CHyprGroupBarDecoration.cpp index 386f158a..9a17a3fe 100644 --- a/src/render/decorations/CHyprGroupBarDecoration.cpp +++ b/src/render/decorations/CHyprGroupBarDecoration.cpp @@ -347,11 +347,11 @@ static void renderGradientTo(SP<CTexture> tex, CGradientValueData* grad) { // copy the data to an OpenGL texture we have const auto DATA = cairo_image_surface_get_data(CAIROSURFACE); tex->allocate(); - glBindTexture(GL_TEXTURE_2D, tex->m_texID); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_BLUE); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED); + tex->bind(); + tex->setTexParameter(GL_TEXTURE_MAG_FILTER, GL_NEAREST); + tex->setTexParameter(GL_TEXTURE_MIN_FILTER, GL_NEAREST); + tex->setTexParameter(GL_TEXTURE_SWIZZLE_R, GL_BLUE); + tex->setTexParameter(GL_TEXTURE_SWIZZLE_B, GL_RED); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, bufferSize.x, bufferSize.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA); diff --git a/src/render/shaders/glsl/blur1.frag b/src/render/shaders/glsl/blur1.frag index dbabd610..f0f8cc10 100644 --- a/src/render/shaders/glsl/blur1.frag +++ b/src/render/shaders/glsl/blur1.frag @@ -1,6 +1,5 @@ -#version 100 +#version 300 es precision highp float; -varying highp vec2 v_texcoord; // is in 0-1 uniform sampler2D tex; uniform float radius; @@ -9,6 +8,8 @@ uniform int passes; uniform float vibrancy; uniform float vibrancy_darkness; +in vec2 v_texcoord; + // see http://alienryderflex.com/hsp.html const float Pr = 0.299; const float Pg = 0.587; @@ -107,6 +108,7 @@ vec3 hsl2rgb(vec3 col) { return rgb; } +layout(location = 0) out vec4 fragColor; void main() { vec2 uv = v_texcoord * 2.0; @@ -119,7 +121,7 @@ void main() { vec4 color = sum / 8.0; if (vibrancy == 0.0) { - gl_FragColor = color; + fragColor = color; } else { // Invert it so that it correctly maps to the config setting float vibrancy_darkness1 = 1.0 - vibrancy_darkness; @@ -136,6 +138,6 @@ void main() { vec3 newColor = hsl2rgb(vec3(hsl[0], saturation, hsl[2])); - gl_FragColor = vec4(newColor, color[3]); + fragColor = vec4(newColor, color[3]); } } diff --git a/src/render/shaders/glsl/blur2.frag b/src/render/shaders/glsl/blur2.frag index dfd8eeab..2483bcf4 100644 --- a/src/render/shaders/glsl/blur2.frag +++ b/src/render/shaders/glsl/blur2.frag @@ -1,11 +1,15 @@ -#version 100 +#version 300 es precision highp float; -varying highp vec2 v_texcoord; // is in 0-1 uniform sampler2D tex; uniform float radius; uniform vec2 halfpixel; +in vec2 v_texcoord; + +out vec4 v_color; + +layout(location = 0) out vec4 fragColor; void main() { vec2 uv = v_texcoord / 2.0; @@ -19,5 +23,5 @@ void main() { sum += texture2D(tex, uv + vec2(0.0, -halfpixel.y * 2.0) * radius); sum += texture2D(tex, uv + vec2(-halfpixel.x, -halfpixel.y) * radius) * 2.0; - gl_FragColor = sum / 12.0; + fragColor = sum / 12.0; } diff --git a/src/render/shaders/glsl/blurfinish_legacy.frag b/src/render/shaders/glsl/blurfinish_legacy.frag deleted file mode 100644 index 2a7ebca1..00000000 --- a/src/render/shaders/glsl/blurfinish_legacy.frag +++ /dev/null @@ -1,28 +0,0 @@ -precision highp float; -varying vec2 v_texcoord; // is in 0-1 -uniform sampler2D tex; - -uniform float noise; -uniform float brightness; - -float hash(vec2 p) { - vec3 p3 = fract(vec3(p.xyx) * 1689.1984); - p3 += dot(p3, p3.yzx + 33.33); - return fract((p3.x + p3.y) * p3.z); -} - -void main() { - vec4 pixColor = texture2D(tex, v_texcoord); - - // noise - float noiseHash = hash(v_texcoord); - float noiseAmount = (mod(noiseHash, 1.0) - 0.5); - pixColor.rgb += noiseAmount * noise; - - // brightness - if (brightness < 1.0) { - pixColor.rgb *= brightness; - } - - gl_FragColor = pixColor; -} diff --git a/src/render/shaders/glsl/blurprepare_legacy.frag b/src/render/shaders/glsl/blurprepare_legacy.frag deleted file mode 100644 index 2df933d5..00000000 --- a/src/render/shaders/glsl/blurprepare_legacy.frag +++ /dev/null @@ -1,29 +0,0 @@ -precision highp float; -varying vec2 v_texcoord; // is in 0-1 -uniform sampler2D tex; - -uniform float contrast; -uniform float brightness; - -float gain(float x, float k) { - float a = 0.5 * pow(2.0 * ((x < 0.5) ? x : 1.0 - x), k); - return (x < 0.5) ? a : 1.0 - a; -} - -void main() { - vec4 pixColor = texture2D(tex, v_texcoord); - - // contrast - if (contrast != 1.0) { - pixColor.r = gain(pixColor.r, contrast); - pixColor.g = gain(pixColor.g, contrast); - pixColor.b = gain(pixColor.b, contrast); - } - - // brightness - if (brightness > 1.0) { - pixColor.rgb *= brightness; - } - - gl_FragColor = pixColor; -} diff --git a/src/render/shaders/glsl/border_legacy.frag b/src/render/shaders/glsl/border_legacy.frag deleted file mode 100644 index 39842be5..00000000 --- a/src/render/shaders/glsl/border_legacy.frag +++ /dev/null @@ -1,174 +0,0 @@ -#extension GL_ARB_shading_language_include : enable - -precision highp float; -varying vec4 v_color; -varying vec2 v_texcoord; - -uniform vec2 fullSizeUntransformed; -uniform float radiusOuter; -uniform float thick; - -// Gradients are in OkLabA!!!! {l, a, b, alpha} -uniform vec4 gradient[10]; -uniform vec4 gradient2[10]; -uniform int gradientLength; -uniform int gradient2Length; -uniform float angle; -uniform float angle2; -uniform float gradientLerp; -uniform float alpha; - -#include "rounding.glsl" - -float linearToGamma(float x) { - return x >= 0.0031308 ? 1.055 * pow(x, 0.416666666) - 0.055 : 12.92 * x; -} - -vec4 okLabAToSrgb(vec4 lab) { - float l = pow(lab[0] + lab[1] * 0.3963377774 + lab[2] * 0.2158037573, 3.0); - float m = pow(lab[0] + lab[1] * (-0.1055613458) + lab[2] * (-0.0638541728), 3.0); - float s = pow(lab[0] + lab[1] * (-0.0894841775) + lab[2] * (-1.2914855480), 3.0); - - return vec4(linearToGamma(l * 4.0767416621 + m * -3.3077115913 + s * 0.2309699292), - linearToGamma(l * (-1.2684380046) + m * 2.6097574011 + s * (-0.3413193965)), - linearToGamma(l * (-0.0041960863) + m * (-0.7034186147) + s * 1.7076147010), - lab[3]); -} - -vec4 getOkColorForCoordArray1(vec2 normalizedCoord) { - if (gradientLength < 2) - return gradient[0]; - - float finalAng = 0.0; - - if (angle > 4.71 /* 270 deg */) { - normalizedCoord[1] = 1.0 - normalizedCoord[1]; - finalAng = 6.28 - angle; - } else if (angle > 3.14 /* 180 deg */) { - normalizedCoord[0] = 1.0 - normalizedCoord[0]; - normalizedCoord[1] = 1.0 - normalizedCoord[1]; - finalAng = angle - 3.14; - } else if (angle > 1.57 /* 90 deg */) { - normalizedCoord[0] = 1.0 - normalizedCoord[0]; - finalAng = 3.14 - angle; - } else { - finalAng = angle; - } - - float sine = sin(finalAng); - - float progress = (normalizedCoord[1] * sine + normalizedCoord[0] * (1.0 - sine)) * float(gradientLength - 1); - int bottom = int(floor(progress)); - int top = bottom + 1; - - return gradient[top] * (progress - float(bottom)) + gradient[bottom] * (float(top) - progress); -} - -vec4 getOkColorForCoordArray2(vec2 normalizedCoord) { - if (gradient2Length < 2) - return gradient2[0]; - - float finalAng = 0.0; - - if (angle2 > 4.71 /* 270 deg */) { - normalizedCoord[1] = 1.0 - normalizedCoord[1]; - finalAng = 6.28 - angle; - } else if (angle2 > 3.14 /* 180 deg */) { - normalizedCoord[0] = 1.0 - normalizedCoord[0]; - normalizedCoord[1] = 1.0 - normalizedCoord[1]; - finalAng = angle - 3.14; - } else if (angle2 > 1.57 /* 90 deg */) { - normalizedCoord[0] = 1.0 - normalizedCoord[0]; - finalAng = 3.14 - angle2; - } else { - finalAng = angle2; - } - - float sine = sin(finalAng); - - float progress = (normalizedCoord[1] * sine + normalizedCoord[0] * (1.0 - sine)) * float(gradient2Length - 1); - int bottom = int(floor(progress)); - int top = bottom + 1; - - return gradient2[top] * (progress - float(bottom)) + gradient2[bottom] * (float(top) - progress); -} - -vec4 getColorForCoord(vec2 normalizedCoord) { - vec4 result1 = getOkColorForCoordArray1(normalizedCoord); - - if (gradient2Length <= 0) - return okLabAToSrgb(result1); - - vec4 result2 = getOkColorForCoordArray2(normalizedCoord); - - return okLabAToSrgb(mix(result1, result2, gradientLerp)); -} - -void main() { - - highp vec2 pixCoord = vec2(gl_FragCoord); - highp vec2 pixCoordOuter = pixCoord; - highp vec2 originalPixCoord = v_texcoord; - originalPixCoord *= fullSizeUntransformed; - float additionalAlpha = 1.0; - - vec4 pixColor = vec4(1.0, 1.0, 1.0, 1.0); - - bool done = false; - - pixCoord -= topLeft + fullSize * 0.5; - pixCoord *= vec2(lessThan(pixCoord, vec2(0.0))) * -2.0 + 1.0; - pixCoordOuter = pixCoord; - pixCoord -= fullSize * 0.5 - radius; - pixCoordOuter -= fullSize * 0.5 - radiusOuter; - - // center the pixes dont make it top-left - pixCoord += vec2(1.0, 1.0) / fullSize; - pixCoordOuter += vec2(1.0, 1.0) / fullSize; - - if (min(pixCoord.x, pixCoord.y) > 0.0 && radius > 0.0) { - float dist = pow(pow(pixCoord.x,roundingPower)+pow(pixCoord.y,roundingPower),1.0/roundingPower); - float distOuter = pow(pow(pixCoordOuter.x,roundingPower)+pow(pixCoordOuter.y,roundingPower),1.0/roundingPower); - float h = (thick / 2.0); - - if (dist < radius - h) { - // lower - float normalized = smoothstep(0.0, 1.0, (dist - radius + thick + SMOOTHING_CONSTANT) / (SMOOTHING_CONSTANT * 2.0)); - additionalAlpha *= normalized; - done = true; - } else if (min(pixCoordOuter.x, pixCoordOuter.y) > 0.0) { - // higher - float normalized = 1.0 - smoothstep(0.0, 1.0, (distOuter - radiusOuter + SMOOTHING_CONSTANT) / (SMOOTHING_CONSTANT * 2.0)); - additionalAlpha *= normalized; - done = true; - } else if (distOuter < radiusOuter - h) { - additionalAlpha = 1.0; - done = true; - } - } - - // now check for other shit - if (!done) { - // distance to all straight bb borders - float distanceT = originalPixCoord[1]; - float distanceB = fullSizeUntransformed[1] - originalPixCoord[1]; - float distanceL = originalPixCoord[0]; - float distanceR = fullSizeUntransformed[0] - originalPixCoord[0]; - - // get the smallest - float smallest = min(min(distanceT, distanceB), min(distanceL, distanceR)); - - if (smallest > thick) - discard; - } - - if (additionalAlpha == 0.0) - discard; - - pixColor = getColorForCoord(v_texcoord); - pixColor.rgb *= pixColor[3]; - - pixColor *= alpha * additionalAlpha; - - gl_FragColor = pixColor; -} diff --git a/src/render/shaders/glsl/ext.frag b/src/render/shaders/glsl/ext.frag index 3b71f59c..d8a12c39 100644 --- a/src/render/shaders/glsl/ext.frag +++ b/src/render/shaders/glsl/ext.frag @@ -1,8 +1,10 @@ +#version 300 es + #extension GL_ARB_shading_language_include : enable #extension GL_OES_EGL_image_external : require precision highp float; -varying vec2 v_texcoord; +in vec2 v_texcoord; uniform samplerExternalOES texture0; uniform float alpha; @@ -15,6 +17,7 @@ uniform int discardAlphaValue; uniform int applyTint; uniform vec3 tint; +layout(location = 0) out vec4 fragColor; void main() { vec4 pixColor = texture2D(texture0, v_texcoord); @@ -31,5 +34,5 @@ void main() { if (radius > 0.0) pixColor = rounding(pixColor); - gl_FragColor = pixColor * alpha; + fragColor = pixColor * alpha; } diff --git a/src/render/shaders/glsl/glitch.frag b/src/render/shaders/glsl/glitch.frag index f1dc121e..2b03b498 100644 --- a/src/render/shaders/glsl/glitch.frag +++ b/src/render/shaders/glsl/glitch.frag @@ -1,5 +1,7 @@ +#version 300 es + precision highp float; -varying vec2 v_texcoord; +in vec2 v_texcoord; uniform sampler2D tex; uniform float time; // quirk: time is set to 0 at the beginning, should be around 10 when crash. uniform float distort; @@ -24,6 +26,7 @@ float noise(vec2 point) { return mixed * mixed; } +layout(location = 0) out vec4 fragColor; void main() { float ABERR_OFFSET = 4.0 * (distort / 5.5) * time; float TEAR_AMOUNT = 9000.0 * (1.0 - (distort / 5.5)); @@ -60,5 +63,5 @@ void main() { pixColor[0] += distort / 90.0; - gl_FragColor = pixColor; + fragColor = pixColor; } diff --git a/src/render/shaders/glsl/passthru.frag b/src/render/shaders/glsl/passthru.frag index 532b5525..a5075abf 100644 --- a/src/render/shaders/glsl/passthru.frag +++ b/src/render/shaders/glsl/passthru.frag @@ -1,7 +1,10 @@ +#version 300 es + precision highp float; -varying vec2 v_texcoord; // is in 0-1 +in vec2 v_texcoord; // is in 0-1 uniform sampler2D tex; +layout(location = 0) out vec4 fragColor; void main() { - gl_FragColor = texture2D(tex, v_texcoord); + fragColor = texture2D(tex, v_texcoord); } diff --git a/src/render/shaders/glsl/quad.frag b/src/render/shaders/glsl/quad.frag index 303d1a81..5dae493e 100644 --- a/src/render/shaders/glsl/quad.frag +++ b/src/render/shaders/glsl/quad.frag @@ -1,14 +1,17 @@ +#version 300 es + #extension GL_ARB_shading_language_include : enable precision highp float; -varying vec4 v_color; +in vec4 v_color; #include "rounding.glsl" +layout(location = 0) out vec4 fragColor; void main() { vec4 pixColor = v_color; if (radius > 0.0) pixColor = rounding(pixColor); - gl_FragColor = pixColor; + fragColor = pixColor; } diff --git a/src/render/shaders/glsl/rgba.frag b/src/render/shaders/glsl/rgba.frag index ac2d237d..86ea6d87 100644 --- a/src/render/shaders/glsl/rgba.frag +++ b/src/render/shaders/glsl/rgba.frag @@ -1,6 +1,8 @@ +#version 300 es + #extension GL_ARB_shading_language_include : enable precision highp float; -varying vec2 v_texcoord; // is in 0-1 +in vec2 v_texcoord; // is in 0-1 uniform sampler2D tex; uniform float alpha; @@ -13,6 +15,7 @@ uniform float discardAlphaValue; uniform int applyTint; uniform vec3 tint; +layout(location = 0) out vec4 fragColor; void main() { vec4 pixColor = texture2D(tex, v_texcoord); @@ -32,5 +35,5 @@ void main() { if (radius > 0.0) pixColor = rounding(pixColor); - gl_FragColor = pixColor * alpha; + fragColor = pixColor * alpha; } diff --git a/src/render/shaders/glsl/rgbamatte.frag b/src/render/shaders/glsl/rgbamatte.frag index 618e495f..bf295f73 100644 --- a/src/render/shaders/glsl/rgbamatte.frag +++ b/src/render/shaders/glsl/rgbamatte.frag @@ -1,8 +1,11 @@ +#version 300 es + precision highp float; -varying vec2 v_texcoord; // is in 0-1 +in vec2 v_texcoord; // is in 0-1 uniform sampler2D tex; uniform sampler2D texMatte; +layout(location = 0) out vec4 fragColor; void main() { - gl_FragColor = texture2D(tex, v_texcoord) * texture2D(texMatte, v_texcoord)[0]; // I know it only uses R, but matte should be black/white anyways. + fragColor = texture2D(tex, v_texcoord) * texture2D(texMatte, v_texcoord)[0]; // I know it only uses R, but matte should be black/white anyways. } diff --git a/src/render/shaders/glsl/rgbx.frag b/src/render/shaders/glsl/rgbx.frag index 2a2aad63..5376a257 100644 --- a/src/render/shaders/glsl/rgbx.frag +++ b/src/render/shaders/glsl/rgbx.frag @@ -1,6 +1,7 @@ +#version 300 es #extension GL_ARB_shading_language_include : enable precision highp float; -varying vec2 v_texcoord; +in vec2 v_texcoord; uniform sampler2D tex; uniform float alpha; @@ -13,6 +14,7 @@ uniform int discardAlphaValue; uniform int applyTint; uniform vec3 tint; +layout(location = 0) out vec4 fragColor; void main() { if (discardOpaque == 1 && alpha == 1.0) @@ -21,13 +23,13 @@ void main() { vec4 pixColor = vec4(texture2D(tex, v_texcoord).rgb, 1.0); if (applyTint == 1) { - pixColor[0] = pixColor[0] * tint[0]; - pixColor[1] = pixColor[1] * tint[1]; - pixColor[2] = pixColor[2] * tint[2]; + pixColor[0] = pixColor[0] * tint[0]; + pixColor[1] = pixColor[1] * tint[1]; + pixColor[2] = pixColor[2] * tint[2]; } if (radius > 0.0) pixColor = rounding(pixColor); - gl_FragColor = pixColor * alpha; + fragColor = pixColor * alpha; } diff --git a/src/render/shaders/glsl/shadow_legacy.frag b/src/render/shaders/glsl/shadow_legacy.frag deleted file mode 100644 index bf929e63..00000000 --- a/src/render/shaders/glsl/shadow_legacy.frag +++ /dev/null @@ -1,86 +0,0 @@ -#extension GL_ARB_shading_language_include : enable -precision highp float; -varying vec4 v_color; -varying vec2 v_texcoord; - -uniform vec2 topLeft; -uniform vec2 bottomRight; -uniform vec2 fullSize; -uniform float radius; -uniform float roundingPower; -uniform float range; -uniform float shadowPower; - -float pixAlphaRoundedDistance(float distanceToCorner) { - if (distanceToCorner > radius) { - return 0.0; - } - - if (distanceToCorner > radius - range) { - return pow((range - (distanceToCorner - radius + range)) / range, shadowPower); // i think? - } - - return 1.0; -} - -float modifiedLength(vec2 a) { - return pow(pow(abs(a.x),roundingPower)+pow(abs(a.y),roundingPower),1.0/roundingPower); -} - -void main() { - - vec4 pixColor = v_color; - float originalAlpha = pixColor[3]; - - bool done = false; - - vec2 pixCoord = fullSize * v_texcoord; - - // ok, now we check the distance to a border. - - if (pixCoord[0] < topLeft[0]) { - if (pixCoord[1] < topLeft[1]) { - // top left - pixColor[3] = pixColor[3] * pixAlphaRoundedDistance(modifiedLength(pixCoord - topLeft)); - done = true; - } else if (pixCoord[1] > bottomRight[1]) { - // bottom left - pixColor[3] = pixColor[3] * pixAlphaRoundedDistance(modifiedLength(pixCoord - vec2(topLeft[0], bottomRight[1]))); - done = true; - } - } else if (pixCoord[0] > bottomRight[0]) { - if (pixCoord[1] < topLeft[1]) { - // top right - pixColor[3] = pixColor[3] * pixAlphaRoundedDistance(modifiedLength(pixCoord - vec2(bottomRight[0], topLeft[1]))); - done = true; - } else if (pixCoord[1] > bottomRight[1]) { - // bottom right - pixColor[3] = pixColor[3] * pixAlphaRoundedDistance(modifiedLength(pixCoord - bottomRight)); - done = true; - } - } - - if (!done) { - // distance to all straight bb borders - float distanceT = pixCoord[1]; - float distanceB = fullSize[1] - pixCoord[1]; - float distanceL = pixCoord[0]; - float distanceR = fullSize[0] - pixCoord[0]; - - // get the smallest - float smallest = min(min(distanceT, distanceB), min(distanceL, distanceR)); - - if (smallest < range) { - pixColor[3] = pixColor[3] * pow((smallest / range), shadowPower); - } - } - - if (pixColor[3] == 0.0) { - discard; return; - } - - // premultiply - pixColor.rgb *= pixColor[3]; - - gl_FragColor = pixColor; -} diff --git a/src/render/shaders/glsl/tex.vert b/src/render/shaders/glsl/tex.vert deleted file mode 100644 index 6ede6a8e..00000000 --- a/src/render/shaders/glsl/tex.vert +++ /dev/null @@ -1,15 +0,0 @@ -uniform mat3 proj; -uniform vec4 color; -attribute vec2 pos; -attribute vec2 texcoord; -attribute vec2 texcoordMatte; -varying vec4 v_color; -varying vec2 v_texcoord; -varying vec2 v_texcoordMatte; - -void main() { - gl_Position = vec4(proj * vec3(pos, 1.0), 1.0); - v_color = color; - v_texcoord = texcoord; - v_texcoordMatte = texcoordMatte; -}
\ No newline at end of file diff --git a/src/render/shaders/glsl/tex300.vert b/src/render/shaders/glsl/tex300.vert index f9f12998..e20e7356 100644 --- a/src/render/shaders/glsl/tex300.vert +++ b/src/render/shaders/glsl/tex300.vert @@ -2,9 +2,11 @@ uniform mat3 proj; uniform vec4 color; + in vec2 pos; in vec2 texcoord; in vec2 texcoordMatte; + out vec4 v_color; out vec2 v_texcoord; out vec2 v_texcoordMatte; diff --git a/src/render/shaders/glsl/tex320.vert b/src/render/shaders/glsl/tex320.vert index 309bc02b..b99e2ba7 100644 --- a/src/render/shaders/glsl/tex320.vert +++ b/src/render/shaders/glsl/tex320.vert @@ -2,9 +2,11 @@ uniform mat3 proj; uniform vec4 color; + in vec2 pos; in vec2 texcoord; in vec2 texcoordMatte; + out vec4 v_color; out vec2 v_texcoord; out vec2 v_texcoordMatte; |