spk_opengl_utils.hpp

#pragma once
 
#include <cstdint>
#include <string>
#include <vector>
 
#include "structure/math/spk_vector2.hpp"
#include "structure/opengl/spk_opengl_includes.hpp"
#include "type/spk_activation_status.hpp"
 
namespace spk
{
    namespace OpenGLUtils
    {
        GLuint generateVertexArrayObjectID();
        void releaseVertexArrayObjectID(GLuint p_idToRelease);
        void activateVertexArrayObject(GLuint p_idToRelease);
        void deactivateVertexArrayObject();

        GLuint compileShader(const std::string &p_shaderCode, GLenum p_shaderType);
        GLuint linkProgram(GLuint p_vertexShader, GLuint p_fragmentShader);
        GLuint loadProgram(const std::string &p_vertexShaderCode, const std::string &p_fragmentShaderCode);
        void releaseProgram(GLuint p_programID);
        void activateProgram(GLuint p_programID);
        void deactivateProgram();

        void launchProgramRenderInstanciatedMode(GLsizei p_nbIndexes, GLsizei p_nbInstance);
        void launchProgramRenderIndirectInstanciatedMode(GLintptr p_commandOffset, GLsizei p_drawCount, GLsizei p_stride);

        GLuint generateBufferObjectID();
        void releaseBufferObjectID(GLuint p_bufferID);
        void activateBufferObject(GLenum p_target, GLuint p_bufferID);
        void deactivateBufferObject(GLenum p_target);
        void updateBufferObject(GLenum p_type, const std::vector<uint8_t> &p_bufferData);
        void updateBufferObject(GLenum p_type, GLenum p_usage, const std::vector<uint8_t> &p_bufferData);
        std::size_t getBufferSize(GLenum p_target);
        void readBufferObject(GLenum p_target, void *p_destination, std::size_t p_size, std::size_t p_offset = 0);
        std::vector<uint8_t> readBuffer(GLenum p_target, GLuint p_id);

        GLuint generateTextureObjectID();
        void releaseTextureObjectID(GLuint p_textureID);
        void activateTexture(GLenum p_target, GLuint p_textureID);
        void deactivateTexture(GLenum p_target);
        void setTextureParameter(GLenum p_target, GLenum p_parameter, GLint p_value);
        void uploadTexture2D(GLenum p_target, GLenum p_internalFormat, const spk::Vector2UInt &p_size, GLenum p_format, GLenum p_type, const void *p_data);
        void applyTextureMipmapState(GLenum p_target, spk::ActivationStatus p_state);
        void activateTextureUnitIndex(GLuint p_textureUnitIndex);

        GLuint generateFrameBufferObjectID();
        void releaseFrameBufferObjectID(GLuint p_framebufferID);
        void activateFrameBufferObject(GLuint p_framebufferID);
        void deactivateFrameBufferObject();
 
        GLuint currentFrameBufferObject();

        std::string frameBufferStatusToString(GLenum p_status);
        void ensureFrameBufferCompleteness();

        enum class BindableBufferType
        {
            Uniform = GL_UNIFORM_BUFFER,
            ShaderStorage = GL_SHADER_STORAGE_BUFFER
        };

        void bindBufferBase(BindableBufferType p_target, GLuint p_bindingPoint, GLuint p_id);
        GLint getUniformBlockIndex(GLint p_prog, std::string p_uniformBlockName);
        GLint getShaderStorageBlockIndex(GLint p_prog, std::string p_shaderStorageBlockName);
        void linkUniformBlockIndexToBindingPoint(GLint p_prog, GLint p_blockIndex, GLuint p_bindingPoint);
        void linkShaderStorageBlockIndexToBindingPoint(GLint p_prog, GLint p_blockIndex, GLuint p_bindingPoint);

        void setViewport(GLint p_x, GLint p_y, GLsizei p_width, GLsizei p_height);
        void setScissorTestState(spk::ActivationStatus p_state);
        void setScissor(GLint p_x, GLint p_y, GLsizei p_width, GLsizei p_height);
        void setClearColor(GLfloat p_r, GLfloat p_g, GLfloat p_b, GLfloat p_a);
        void clearFrame(GLbitfield p_mask);
    }
}