GLUtil.hh

Go to the documentation of this file.

#ifndef GLUTIL_HH
#define GLUTIL_HH
 
// Include GLEW headers.
#include <GL/glew.h>
// Include OpenGL headers.
#ifdef __APPLE__
#include <OpenGL/gl.h>
#else
#include <GL/gl.h>
#endif
 
#include "MemBuffer.hh"
 
#include <bit>
#include <cassert>
#include <cstdint>
#include <span>
#include <string_view>
 
// arbitrary but distinct values, (roughly) ordered according to version number
#define OPENGL_ES_2_0 1
#define OPENGL_2_1    2
#define OPENGL_3_3    3
#define OPENGL_VERSION OPENGL_2_1
 
namespace gl {
 
void checkGLError(std::string_view prefix);
 
 
// Dummy object, to be able to construct empty handler objects.
struct Null {};
 
 
class Texture
{
public:
        Texture(const Texture&) = delete;
        Texture& operator=(const Texture&) = delete;
 
        explicit Texture(bool interpolation = false, bool wrap = false);
 
        explicit Texture(Null) : textureId(0) {}
 
        ~Texture() { reset(); }
 
        Texture(Texture&& other) noexcept
                : textureId(other.textureId)
        {
                other.textureId = 0; // 0 is not a valid openGL texture name
        }
        Texture& operator=(Texture&& other) noexcept {
                std::swap(textureId, other.textureId);
                return *this;
        }
 
        void allocate();
 
        void reset();
 
        [[nodiscard]] GLuint get() const { return textureId; }
 
        [[nodiscard]] unsigned long long getImGui() const {
                assert(textureId);
                return uintptr_t(textureId);
        }
 
        void bind() const {
                glBindTexture(GL_TEXTURE_2D, textureId);
        }
 
        void setInterpolation(bool interpolation);
 
        void setWrapMode(bool wrap);
 
protected:
        GLuint textureId;
 
        friend class FrameBufferObject;
};
 
class ColorTexture : public Texture
{
public:
        ColorTexture() = default;
 
        ColorTexture(GLsizei width, GLsizei height);
        void resize(GLsizei width, GLsizei height);
 
        [[nodiscard]] GLsizei getWidth () const { return width;  }
        [[nodiscard]] GLsizei getHeight() const { return height; }
 
private:
        GLsizei width = 0;
        GLsizei height = 0;
};
 
class FrameBufferObject
{
public:
        FrameBufferObject() = default;
        explicit FrameBufferObject(Texture& texture);
        FrameBufferObject(FrameBufferObject&& other) noexcept
                : bufferId(other.bufferId)
        {
                other.bufferId = 0;
        }
        FrameBufferObject& operator=(FrameBufferObject&& other) noexcept {
                std::swap(bufferId, other.bufferId);
                return *this;
        }
        ~FrameBufferObject();
 
        void push();
        void pop();
 
private:
        GLuint bufferId = 0; // 0 is not a valid openGL name
        GLint previousId = 0;
};
 
template<typename T> class PixelBuffer
{
public:
        PixelBuffer();
        PixelBuffer(const PixelBuffer& other) = delete;
        PixelBuffer(PixelBuffer&& other) noexcept;
        PixelBuffer& operator=(const PixelBuffer& other) = delete;
        PixelBuffer& operator=(PixelBuffer&& other) noexcept;
        ~PixelBuffer();
 
        void allocate(GLuint size);
 
        void bind() const;
 
        void unbind() const;
 
        [[nodiscard]] std::span<T> mapWrite();
 
        void unmap() const;
 
private:
        openmsx::MemBuffer<T> allocated;
 
        //GLuint bufferId;
};
 
// class PixelBuffer
 
template<typename T>
PixelBuffer<T>::PixelBuffer()
{
        //glGenBuffers(1, &bufferId);
}
 
template<typename T>
PixelBuffer<T>::~PixelBuffer()
{
        //glDeleteBuffers(1, &bufferId); // ok to delete '0'
}
 
template<typename T>
PixelBuffer<T>::PixelBuffer(PixelBuffer<T>&& other) noexcept
        : allocated(std::move(other.allocated))
        //, bufferId(other.bufferId)
{
        //other.bufferId = 0;
}
 
template<typename T>
PixelBuffer<T>& PixelBuffer<T>::operator=(PixelBuffer<T>&& other) noexcept
{
        std::swap(allocated, other.allocated);
        //std::swap(bufferId,  other.bufferId);
        return *this;
}
 
template<typename T>
void PixelBuffer<T>::allocate(GLuint size)
{
        //if (bufferId != 0) {
        //      bind();
        //      // TODO make performance hint configurable?
        //      glBufferData(GL_PIXEL_UNPACK_BUFFER,
        //                   size * 4,
        //                   nullptr, // leave data undefined
        //                   GL_STREAM_DRAW); // performance hint
        //      unbind();
        //} else {
                allocated.resize(size);
        //}
}
 
template<typename T>
void PixelBuffer<T>::bind() const
{
        //if (bufferId != 0) {
        //      glBindBuffer(GL_PIXEL_UNPACK_BUFFER, bufferId);
        //}
}
 
template<typename T>
void PixelBuffer<T>::unbind() const
{
        //if (bufferId != 0) {
        //      glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
        //}
}
 
template<typename T>
std::span<T> PixelBuffer<T>::mapWrite()
{
        //if (bufferId != 0) {
        //      return std::bit_cast<T*>(glMapBuffer(
        //              GL_PIXEL_UNPACK_BUFFER, GL_WRITE_ONLY));
        //} else {
                return std::span{allocated};
        //}
}
 
template<typename T>
void PixelBuffer<T>::unmap() const
{
        //if (bufferId != 0) {
        //      glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
        //}
}
 
 
 
class Shader
{
public:
        Shader(const Shader&) = delete;
        Shader(Shader&&) = delete;
        Shader& operator=(const Shader&) = delete;
        Shader& operator=(Shader&&) = delete;
 
        [[nodiscard]] bool isOK() const;
 
protected:
        Shader(GLenum type, std::string_view filename) {
                init(type, {}, filename);
        }
        Shader(GLenum type, std::string_view header, std::string_view filename) {
                init(type, header, filename);
        }
        ~Shader();
 
private:
        void init(GLenum type, std::string_view header,
                               std::string_view filename);
 
        friend class ShaderProgram;
 
private:
        GLuint handle;
};
 
class VertexShader : public Shader
{
public:
        explicit VertexShader(std::string_view filename)
                : Shader(GL_VERTEX_SHADER, filename) {}
        VertexShader(std::string_view header, std::string_view filename)
                : Shader(GL_VERTEX_SHADER, header, filename) {}
};
 
class FragmentShader : public Shader
{
public:
        explicit FragmentShader(std::string_view filename)
                : Shader(GL_FRAGMENT_SHADER, filename) {}
        FragmentShader(std::string_view header, std::string_view filename)
                : Shader(GL_FRAGMENT_SHADER, header, filename) {}
};
 
class ShaderProgram
{
public:
        ShaderProgram(const ShaderProgram&) = delete;
        ShaderProgram(ShaderProgram&&) = delete;
        ShaderProgram& operator=(const ShaderProgram&) = delete;
        ShaderProgram& operator=(ShaderProgram&&) = delete;
 
        ShaderProgram() { allocate(); }
 
        explicit ShaderProgram(Null) : handle(0) {}
 
        ~ShaderProgram() { reset(); }
 
        void allocate();
 
        void reset();
 
        [[nodiscard]] GLuint get() const { return handle; }
 
        [[nodiscard]] bool isOK() const;
 
        void attach(const Shader& shader);
 
        void link();
 
        void bindAttribLocation(unsigned index, const char* name);
 
        [[nodiscard]] GLint getUniformLocation(const char* name) const;
 
        void activate() const;
 
        void validate() const;
 
private:
        GLuint handle;
};
 
class BufferObject
{
public:
        BufferObject();
        BufferObject(const BufferObject&) = delete;
        BufferObject& operator=(const BufferObject&) = delete;
        ~BufferObject();
 
        BufferObject(BufferObject&& other) noexcept
                : bufferId(other.bufferId)
        {
                other.bufferId = 0;
        }
        BufferObject& operator=(BufferObject&& other) noexcept {
                std::swap(bufferId, other.bufferId);
                return *this;
        }
 
        [[nodiscard]] GLuint get() const { return bufferId; }
 
private:
        GLuint bufferId;
};
 
} // namespace gl
 
#endif // GLUTIL_HH