GLUtil.hh

Go to the documentation of this file.

#ifndef GLUTIL_HH
#define GLUTIL_HH

// Check for availability of OpenGL.
#include "components.hh"
#if COMPONENT_GL

// 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 "noncopyable.hh"
#include "build-info.hh"
#include <string>
#include <cassert>

namespace openmsx {

namespace GLUtil {

// TODO this needs glu, but atm we don't link against glu (in windows)
//void checkGLError(const std::string& prefix);

} // namespace GLUtil


class Texture //: public noncopyable
{
public:
        Texture();

        Texture(Texture&& other)
                : textureId(other.textureId)
        {
                other.textureId = 0; // 0 is not a valid openGL texture name
        }
        Texture& operator=(Texture&& other) {
                std::swap(textureId, other.textureId);
                return *this;
        }

        ~Texture();

        void bind() {
                glBindTexture(GL_TEXTURE_2D, textureId);
        }

        void enableInterpolation();

        void disableInterpolation();

        void setWrapMode(bool wrap);

        void drawRect(GLfloat tx, GLfloat ty, GLfloat twidth, GLfloat theight,
                      GLint   x,  GLint   y,  GLint   width,  GLint   height);

protected:
        GLuint textureId;

        friend class FrameBufferObject;
};

class ColorTexture : public Texture
{
public:
        ColorTexture() : width(0), height(0) {}

        ColorTexture(GLsizei width, GLsizei height);
        void resize(GLsizei width, GLsizei height);

        GLsizei getWidth () const { return width;  }
        GLsizei getHeight() const { return height; }

private:
        GLsizei width;
        GLsizei height;
};

class LuminanceTexture : public Texture
{
public:
        LuminanceTexture(GLsizei width, GLsizei height);

        void updateImage(GLint x, GLint y,
                         GLsizei width, GLsizei height,
                         GLbyte* data);
};

class FrameBufferObject //: public noncopyable
{
public:
        FrameBufferObject();
        explicit FrameBufferObject(Texture& texture);
        FrameBufferObject(FrameBufferObject&& other)
                : bufferId(other.bufferId)
        {
                other.bufferId = 0;
        }
        FrameBufferObject& operator=(FrameBufferObject&& other) {
                std::swap(bufferId, other.bufferId);
                return *this;
        }
        ~FrameBufferObject();

        void push();
        void pop();

private:
        GLuint bufferId;
};

struct PixelBuffers
{
        static bool enabled;
};

template <typename T> class PixelBuffer //: public noncopyable
{
public:
        PixelBuffer();
        PixelBuffer(PixelBuffer&& other);
        PixelBuffer& operator=(PixelBuffer&& other);
        ~PixelBuffer();

        bool openGLSupported() const;

        void setImage(GLuint width, GLuint height);

        void bind() const;

        void unbind() const;

        T* getOffset(GLuint x, GLuint y);

        T* mapWrite();

        void unmap() const;

private:
        MemBuffer<T> allocated;

        GLuint bufferId;

        GLuint width;

        GLuint height;
};

// class PixelBuffer

template <typename T>
PixelBuffer<T>::PixelBuffer()
{
#ifdef GL_VERSION_1_5
        if (PixelBuffers::enabled &&
            GLEW_ARB_pixel_buffer_object) {
                glGenBuffers(1, &bufferId);
        } else
#endif
        {
                //std::cerr << "OpenGL pixel buffers are not available" << std::endl;
                bufferId = 0;
        }
}

template <typename T>
PixelBuffer<T>::PixelBuffer(PixelBuffer<T>&& other)
        : 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)
{
        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>
PixelBuffer<T>::~PixelBuffer()
{
#ifdef GL_VERSION_1_5
        if (bufferId != 0) {
                glDeleteBuffers(1, &bufferId);
        }
#endif
}

template <typename T>
bool PixelBuffer<T>::openGLSupported() const
{
        return bufferId != 0;
}

template <typename T>
void PixelBuffer<T>::setImage(GLuint width, GLuint height)
{
        this->width = width;
        this->height = height;
#ifdef GL_VERSION_1_5
        if (bufferId != 0) {
                bind();
                // TODO make performance hint configurable?
                glBufferData(GL_PIXEL_UNPACK_BUFFER_ARB,
                             width * height * 4,
                             nullptr, // leave data undefined
                             GL_STREAM_DRAW); // performance hint
                unbind();
        } else
#endif
        {
                allocated.resize(width * height);
        }
}

template <typename T>
void PixelBuffer<T>::bind() const
{
#ifdef GL_VERSION_1_5
        if (bufferId != 0) {
                glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, bufferId);
        }
#endif
}

template <typename T>
void PixelBuffer<T>::unbind() const
{
#ifdef GL_VERSION_1_5
        if (bufferId != 0) {
                glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
        }
#endif
}

template <typename T>
T* PixelBuffer<T>::getOffset(GLuint x, GLuint y)
{
        assert(x < width);
        assert(y < height);
        unsigned offset = x + width * y;
#ifdef GL_VERSION_1_5
        if (bufferId != 0) {
                return static_cast<T*>(nullptr) + offset;
        }
#endif
        return &allocated[offset];
}

template <typename T>
T* PixelBuffer<T>::mapWrite()
{
#ifdef GL_VERSION_1_5
        if (bufferId != 0) {
                return reinterpret_cast<T*>(glMapBuffer(
                        GL_PIXEL_UNPACK_BUFFER_ARB, GL_WRITE_ONLY));
        }
#endif
        return allocated.data();
}

template <typename T>
void PixelBuffer<T>::unmap() const
{
#ifdef GL_VERSION_1_5
        if (bufferId != 0) {
                glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER_ARB);
        }
#endif
}



class Shader
{
public:
        bool isOK() const;

protected:
        Shader(GLenum type, const std::string& filename);
        Shader(GLenum type, const std::string& header,
                            const std::string& filename);
        ~Shader();

private:
        void init(GLenum type, const std::string& header,
                               const std::string& filename);

        friend class ShaderProgram;

        GLuint handle;
};

class VertexShader : public Shader
{
public:
        explicit VertexShader(const std::string& filename);
        VertexShader(const std::string& header, const std::string& filename);
};

class FragmentShader : public Shader
{
public:
        explicit FragmentShader(const std::string& filename);
        FragmentShader(const std::string& header, const std::string& filename);
};

class ShaderProgram : public noncopyable
{
public:
        ShaderProgram();
        ~ShaderProgram();

        bool isOK() const;

        void attach(const Shader& shader);

        void link();

        GLint getUniformLocation(const char* name) const;

        void activate() const;

        static void deactivate();

        void validate();

private:
        GLuint handle;
};

} // namespace openmsx

#endif // COMPONENT_GL
#endif // GLUTIL_HH