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 <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]] void* getImGui() const {
                assert(textureId);
                return std::bit_cast<void*>(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 setImage(GLuint width, GLuint height);
 
        void bind() const;
 
        void unbind() const;
 
        [[nodiscard]] T* getOffset(GLuint x, GLuint y);
 
        [[nodiscard]] T* mapWrite();
 
        void unmap() const;
 
private:
        openmsx::MemBuffer<T> allocated;
 
        //GLuint bufferId;
 
        GLuint width = 0;
 
        GLuint height = 0;
};
 
// 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)
        , width(other.width)
        , height(other.height)
{
        //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);
        std::swap(width,     other.width);
        std::swap(height,    other.height);
        return *this;
}
 
template<typename T>
void PixelBuffer<T>::setImage(GLuint width_, GLuint height_)
{
        width = width_;
        height = height_;
        //if (bufferId != 0) {
        //      bind();
        //      // TODO make performance hint configurable?
        //      glBufferData(GL_PIXEL_UNPACK_BUFFER,
        //                   width * height * 4,
        //                   nullptr, // leave data undefined
        //                   GL_STREAM_DRAW); // performance hint
        //      unbind();
        //} else {
                allocated.resize(width * height);
        //}
}
 
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>
T* PixelBuffer<T>::getOffset(GLuint x, GLuint y)
{
        assert(x < width);
        assert(y < height);
        auto offset = x + size_t(width) * y;
        //if (bufferId != 0) {
        //      return std::bit_cast<T*>(offset * sizeof(T));
        //} else {
                return &allocated[offset];
        //}
}
 
template<typename T>
T* PixelBuffer<T>::mapWrite()
{
        //if (bufferId != 0) {
        //      return std::bit_cast<T*>(glMapBuffer(
        //              GL_PIXEL_UNPACK_BUFFER, GL_WRITE_ONLY));
        //} else {
                return allocated.data();
        //}
}
 
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