Renderbuffer.hpp

#pragma once
#ifndef KJY_OBJECT_ORIENTED_OPENGL_RENDERBUFFER_HPP_
#define KJY_OBJECT_ORIENTED_OPENGL_RENDERBUFFER_HPP_
#include "../OOOGL_Core.hpp"
#include "fbo_interface.hpp"

namespace OOOGL{

    struct RenderbufferParameters{
        GLint width = 0;
        GLint height = 0;
        GLenum internal_format = 0;
        GLint samples = 0;
    };

    class Renderbuffer : public FramebufferAttachable{
     public:
        Renderbuffer() : FramebufferAttachable(_destroyer) {
            glGenRenderbuffers(1, getIdPtr());
        }

        void bind() const {glBindRenderbuffer(GL_RENDERBUFFER, getNameDirect());}
        void unbind() const {glBindRenderbuffer(GL_RENDERBUFFER, 0);}

        void bufferStorage(GLenum internal_format, GLsizei width, GLsizei height);
        void bufferStorageMultisample(GLsizei samples, GLenum internal_format, GLsizei width, GLsizei height);

        virtual AttachmentType getAttachmentType() const override{return(AttachmentType::ATTACHMENT_RENDERBUFFER);}

     private:
        static void _destroyer(const GLuint* name){
            glDeleteRenderbuffers(1, name);
        }

    };

    class ThinRenderbuffer : public Renderbuffer{};
    class SpecifiedRenderbuffer : public Renderbuffer{
     public:
        SpecifiedRenderbuffer() : Renderbuffer() {}
        SpecifiedRenderbuffer(GLsizei width, GLsizei height, GLenum internal_format = GL_RGBA) : Renderbuffer() {
            bufferStorage(internal_format, width, height);
        }

        const RenderbufferParameters& getParameters() const {return(parameters);}
        GLint getWidth() const {return(parameters.width);}
        GLint getHeight() const {return(parameters.height);}
        GLenum getInternalFormat() const {return(parameters.internal_format);}
        GLenum getNumSamples() const {return(parameters.samples);}
        void setWidth(GLsizei width){
            bool needs_update = parameters.width != width;
            parameters.width = width;
            if(needs_update) _update_renderbuffer(parameters);
        }
        void setHeight(GLsizei height){
            bool needs_update = parameters.height != height;
            parameters.height = height;
            if(needs_update) _update_renderbuffer(parameters);
        }
        void setInternalFormat(GLenum internal_format) {
            bool needs_update = parameters.internal_format != internal_format;
            parameters.internal_format = internal_format;
            if(needs_update) _update_renderbuffer(parameters);
        }
        void setNumSamples(GLenum samples) {
            bool needs_update = parameters.samples != samples;
            parameters.samples = samples;
            if(needs_update) _update_renderbuffer(parameters);
        }
        void setParameters(const RenderbufferParameters& parameters){
           this->parameters = parameters;
           _update_renderbuffer(parameters);
        }

     protected:
        RenderbufferParameters parameters;
     private:
        inline void _update_renderbuffer(const RenderbufferParameters& params){
            glBindRenderbuffer(GL_RENDERBUFFER, getNameDirect());
            glRenderbufferStorageMultisample(GL_RENDERBUFFER, params.samples, params.internal_format, params.width, params.height);
            glBindRenderbuffer(GL_FRAMEBUFFER, 0);
        }
    };
}

#endif