cursordelegate_opengl.cpp

Go to the documentation of this file.

/*
    SPDX-FileCopyrightText: 2022 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
    SPDX-License-Identifier: GPL-2.0-or-later
*/
 
#include "scene/cursordelegate_opengl.h"
#include "compositor.h"
#include "core/output.h"
#include "core/pixelgrid.h"
#include "core/renderlayer.h"
#include "core/rendertarget.h"
#include "core/renderviewport.h"
#include "cursor.h"
#include "opengl/gltexture.h"
#include "opengl/glutils.h"
#include "scene/cursorscene.h"
 
#include <cmath>
 
namespace KWin
{
 
CursorDelegateOpenGL::CursorDelegateOpenGL(Output *output)
    : m_output(output)
{
}
 
CursorDelegateOpenGL::~CursorDelegateOpenGL()
{
}
 
void CursorDelegateOpenGL::paint(const RenderTarget &renderTarget, const QRegion &region)
{
    const QRegion dirty = region.intersected(layer()->mapToGlobal(layer()->rect()).toAlignedRect());
    if (dirty.isEmpty()) {
        return;
    }
 
    // Show the rendered cursor scene on the screen.
    const QRect cursorRect = snapToPixelGrid(scaledRect(layer()->mapToGlobal(layer()->rect()), m_output->scale()));
 
    // Render the cursor scene in an offscreen render target.
    const QSize bufferSize = cursorRect.size();
    const GLenum bufferFormat = renderTarget.colorDescription() == ColorDescription::sRGB ? GL_RGBA8 : GL_RGBA16F;
    if (!m_texture || m_texture->size() != bufferSize || m_texture->internalFormat() != bufferFormat) {
        m_texture = GLTexture::allocate(bufferFormat, bufferSize);
        if (!m_texture) {
            return;
        }
        m_framebuffer = std::make_unique<GLFramebuffer>(m_texture.get());
    }
 
    RenderTarget offscreenRenderTarget(m_framebuffer.get(), renderTarget.colorDescription());
 
    RenderLayer renderLayer(layer()->loop());
    renderLayer.setDelegate(std::make_unique<SceneDelegate>(Compositor::self()->cursorScene(), m_output));
    renderLayer.delegate()->prePaint();
    renderLayer.delegate()->paint(offscreenRenderTarget, infiniteRegion());
    renderLayer.delegate()->postPaint();
 
    QMatrix4x4 mvp;
    mvp.scale(1, -1); // flip the y axis back
    mvp *= renderTarget.transform().toMatrix();
    mvp.scale(1, -1); // undo ortho() flipping the y axis
    mvp.ortho(QRectF(QPointF(0, 0), m_output->transform().map(renderTarget.size())));
    mvp.translate(cursorRect.x(), cursorRect.y());
 
    GLFramebuffer *fbo = renderTarget.framebuffer();
    GLFramebuffer::pushFramebuffer(fbo);
 
    const bool clipping = region != infiniteRegion();
    const QRegion clipRegion = clipping ? RenderViewport(m_output->rectF(), m_output->scale(), renderTarget).mapToRenderTarget(dirty) : infiniteRegion();
 
    if (clipping) {
        glEnable(GL_SCISSOR_TEST);
    }
 
    // Don't need to call GLVertexBuffer::beginFrame() and GLVertexBuffer::endOfFrame() because
    // the GLVertexBuffer::streamingBuffer() is not being used when painting cursor.
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
    ShaderBinder binder(ShaderTrait::MapTexture);
    binder.shader()->setUniform(GLShader::Mat4Uniform::ModelViewProjectionMatrix, mvp);
    m_texture->render(clipRegion, cursorRect.size(), clipping);
    glDisable(GL_BLEND);
 
    if (clipping) {
        glDisable(GL_SCISSOR_TEST);
    }
 
    GLFramebuffer::popFramebuffer();
}
 
} // namespace KWin
 
#include "moc_cursordelegate_opengl.cpp"