glvertexbuffer.h

Go to the documentation of this file.

/*
    KWin - the KDE window manager
    This file is part of the KDE project.
 
    SPDX-FileCopyrightText: 2006-2007 Rivo Laks <rivolaks@hot.ee>
    SPDX-FileCopyrightText: 2010, 2011 Martin Gräßlin <mgraesslin@kde.org>
    SPDX-FileCopyrightText: 2023 Xaver Hugl <xaver.hugl@kde.org>
 
    SPDX-License-Identifier: GPL-2.0-or-later
*/
#pragma once
#include "kwin_export.h"
 
#include <QColor>
#include <QRegion>
#include <QVector2D>
 
#include <epoxy/gl.h>
#include <optional>
#include <ranges>
#include <span>
 
namespace KWin
{
 
enum VertexAttributeType {
    VA_Position = 0,
    VA_TexCoord = 1,
    VertexAttributeCount = 2,
};
 
struct GLVertex2D
{
    QVector2D position;
    QVector2D texcoord;
};
 
struct GLVertex3D
{
    QVector3D position;
    QVector2D texcoord;
};
 
struct GLVertexAttrib
{
    size_t attributeIndex;
    size_t componentCount;
    GLenum type; 
    size_t relativeOffset; 
};
 
class GLVertexBufferPrivate;
 
class KWIN_EXPORT GLVertexBuffer
{
public:
    enum UsageHint {
        Dynamic, 
        Static, 
        Stream 
    };
 
    explicit GLVertexBuffer(UsageHint hint);
    ~GLVertexBuffer();
 
    void setAttribLayout(std::span<const GLVertexAttrib> attribs, size_t stride);
 
    void setData(const void *data, size_t sizeInBytes);
 
    void setVertexCount(int count);
 
    // clang-format off
    template<std::ranges::contiguous_range T>
        requires std::is_same<std::ranges::range_value_t<T>, GLVertex2D>::value
    void setVertices(const T &range)
    {
        setData(range.data(), range.size() * sizeof(GLVertex2D));
        setVertexCount(range.size());
        setAttribLayout(std::span(GLVertex2DLayout), sizeof(GLVertex2D));
    }
 
    template<std::ranges::contiguous_range T>
        requires std::is_same<std::ranges::range_value_t<T>, GLVertex3D>::value
    void setVertices(const T &range)
    {
        setData(range.data(), range.size() * sizeof(GLVertex3D));
        setVertexCount(range.size());
        setAttribLayout(std::span(GLVertex3DLayout), sizeof(GLVertex3D));
    }
 
    template<std::ranges::contiguous_range T>
        requires std::is_same<std::ranges::range_value_t<T>, QVector2D>::value
    void setVertices(const T &range)
    {
        setData(range.data(), range.size() * sizeof(QVector2D));
        setVertexCount(range.size());
        static constexpr GLVertexAttrib layout{
            .attributeIndex = VA_Position,
            .componentCount = 2,
            .type = GL_FLOAT,
            .relativeOffset = 0,
        };
        setAttribLayout(std::span(&layout, 1), sizeof(QVector2D));
    }
    // clang-format on
 
    template<typename T>
    std::optional<std::span<T>> map(size_t count)
    {
        if (const auto m = map(sizeof(T) * count)) {
            return std::span(reinterpret_cast<T *>(m), count);
        } else {
            return std::nullopt;
        }
    }
 
    void unmap();
 
    void bindArrays();
 
    void unbindArrays();
 
    void draw(GLenum primitiveMode, int first, int count);
 
    void draw(const QRegion &region, GLenum primitiveMode, int first, int count, bool hardwareClipping = false);
 
    void render(GLenum primitiveMode);
    void render(const QRegion &region, GLenum primitiveMode, bool hardwareClipping = false);
 
    void reset();
 
    void endOfFrame();
 
    void beginFrame();
 
    static void initStatic();
 
    static void cleanup();
 
    static bool supportsIndexedQuads();
 
    static GLVertexBuffer *streamingBuffer();
 
    static constexpr std::array GLVertex2DLayout{
        GLVertexAttrib{
            .attributeIndex = VA_Position,
            .componentCount = 2,
            .type = GL_FLOAT,
            .relativeOffset = offsetof(GLVertex2D, position),
        },
        GLVertexAttrib{
            .attributeIndex = VA_TexCoord,
            .componentCount = 2,
            .type = GL_FLOAT,
            .relativeOffset = offsetof(GLVertex2D, texcoord),
        },
    };
    static constexpr std::array GLVertex3DLayout{
        GLVertexAttrib{
            .attributeIndex = VA_Position,
            .componentCount = 3,
            .type = GL_FLOAT,
            .relativeOffset = offsetof(GLVertex3D, position),
        },
        GLVertexAttrib{
            .attributeIndex = VA_TexCoord,
            .componentCount = 2,
            .type = GL_FLOAT,
            .relativeOffset = offsetof(GLVertex3D, texcoord),
        },
    };
 
private:
    GLvoid *map(size_t size);
 
    const std::unique_ptr<GLVertexBufferPrivate> d;
};
 
}