framebuffer_object.h

/********************************************************************
 * Copyright (C) 2015 Liangliang Nan <liangliang.nan@gmail.com>
 * https://3d.bk.tudelft.nl/liangliang/
 *
 * This file is part of Easy3D. If it is useful in your research/work,
 * I would be grateful if you show your appreciation by citing it:
 * ------------------------------------------------------------------
 *      Liangliang Nan.
 *      Easy3D: a lightweight, easy-to-use, and efficient C++ library
 *      for processing and rendering 3D data.
 *      Journal of Open Source Software, 6(64), 3255, 2021.
 * ------------------------------------------------------------------
 *
 * Easy3D is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License Version 3
 * as published by the Free Software Foundation.
 *
 * Easy3D is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 ********************************************************************/
 
#ifndef EASY3D_RENDERER_FRAMEBUFFER_OBJECT_H
#define EASY3D_RENDERER_FRAMEBUFFER_OBJECT_H
 
 
#include <string>
#include <vector>
 
#include <easy3d/renderer/opengl.h>
 
 
namespace easy3d {

    class FramebufferObject
    {
    public:
        static bool is_supported();

        FramebufferObject(int w, int h, int samples = 0);
        virtual ~FramebufferObject();


        bool add_color_texture(
            GLenum internal_format = GL_RGBA8,
            GLenum format = GL_RGBA,
            GLenum type = GL_UNSIGNED_BYTE,
            GLenum filter = GL_NEAREST
        );
        bool add_color_buffer(
            GLenum internal_format = GL_RGBA8,
            GLenum format = GL_RGBA,
            GLenum type = GL_UNSIGNED_BYTE
        );
        bool add_depth_texture(
            GLenum internal_format = GL_DEPTH24_STENCIL8,
            GLenum filter = GL_NEAREST,
            GLenum compare_mode = GL_NONE,
            GLenum compare_func = GL_LEQUAL
        );
        bool add_depth_buffer(GLenum internal_format = GL_DEPTH24_STENCIL8);

        bool attach_color_texture(GLenum target, GLuint texture_id, GLenum attachment);
        bool attach_depth_texture(GLenum target, GLuint texture_id, GLenum attachment);


        void ensure_size(int w, int h);

        bool bind(GLenum target = GL_FRAMEBUFFER);
        bool release(GLenum target = GL_FRAMEBUFFER);

        bool is_valid() const;
        bool is_bound(GLenum target = GL_FRAMEBUFFER) const;

        void activate_draw_buffer(unsigned int index) const;
        void activate_draw_buffers(unsigned int num_buffers, const unsigned int indices[]) const;
        void activate_draw_buffers(unsigned int minId, unsigned int maxId) const;
        void deactivate_draw_buffers() const;

        void activate_read_buffer(unsigned int index) const;
        void deactivate_read_buffer() const;

        GLuint handle() const { return fbo_id_; }

        int  width() const { return width_; }
        int  height() const { return height_; }

        int  samples() const { return samples_; }

        int  num_color_attachments() const;
        bool has_color_attachment(unsigned int index) const;

        bool has_depth_attachment() const;
        int  depth_bits() const;

        bool has_stencil() const;

        GLenum texture_target() const;

        GLuint color_texture(unsigned int index = 0, bool resolve = true) const;
        bool   has_color_texture(unsigned int index) const;

        GLuint depth_texture(bool resolve = true) const;
        bool   has_depth_texture() const;

        bool copy_color_to_texture(
            GLuint& texture_handle,
            unsigned int index = 0,
            int internal_format = GL_RGBA8,
            GLenum format = GL_RGBA,
            GLenum type = GL_UNSIGNED_BYTE,
            GLenum filter = GL_NEAREST
        );

        bool copy_depth_to_texture(
            GLuint& texture_handle,
            unsigned int internal_format = GL_DEPTH24_STENCIL8,
            GLenum filter = GL_NEAREST
        );

        void print_attachments() const;
        void print_draw_buffers() const;
        void print_read_buffer() const;

        bool read_color(unsigned int index, unsigned char* buffer, unsigned int format, bool flip_vertically = true) const;
        bool read_color(unsigned int index, std::vector<unsigned char>& buffer, unsigned int format, bool flip_vertically = true) const;

        bool read_depth(float* buffer, bool flip_vertically = true) const;
        bool read_depth(std::vector<float>& buffer, bool flip_vertically = true) const;

        bool read_color(unsigned char rgba[4], int x, int y, int index = 0) const;

        bool read_depth(float& depth, int x, int y) const;

        bool snapshot_color(unsigned int index, const std::string& file_name) const;
        bool snapshot_depth(const std::string& file_name) const;

         static void blit_framebuffer(
             FramebufferObject* target,
             const FramebufferObject* source,
             GLbitfield buffers,
             GLenum filter = GL_NEAREST
         );

        static void blit_framebuffer(
            FramebufferObject* target,
            const FramebufferObject* source,
            int target_color_attachment_index, int source_color_attachment_index,
            GLbitfield buffers,
            GLenum filter = GL_NEAREST
        );

        static void blit_framebuffer(
            FramebufferObject* target, int tx0, int ty0, int tx1, int ty1,
            const FramebufferObject* source, int sx0, int sy0, int sx1, int sy1,
            GLbitfield buffers,
            GLenum filter = GL_NEAREST
        );

        static void blit_framebuffer(
            FramebufferObject* target, int tx0, int ty0, int tx1, int ty1,
            const FramebufferObject* source, int sx0, int sy0, int sx1, int sy1,
            int target_color_attachment_index, int source_color_attachment_index,
            GLbitfield buffers,
            GLenum filter = GL_NEAREST
        );
 
    private:
 
        void init(int w, int h, int samples);
 
        void clear();
 
        bool check_status() const;
 
        // Display a given attachment for the current framebuffer object.
        void _print_attachment(unsigned int index) const;
 
        // Display any buffer (convert value into string).
        void _print_buffer(int value) const;
 
        void _prepare_resolve_fbo();
 
    private:
        GLuint fbo_id_;
        GLuint prev_draw_fbo_;      // for release()
        GLuint prev_read_fbo_;      // for release()
 
        int width_;
        int height_;
 
        int samples_;
        FramebufferObject* resolved_fbo_;  // for multisample FBO,
 
        GLenum texture_target_;
 
        GLuint depth_buffer_;
        GLuint depth_texture_;
        GLenum depth_internal_format_;
        GLenum depth_texture_filter_;
        GLenum depth_texture_compare_mode_;
        GLenum depth_texture_compare_func_;
 
        struct ColorAttachment {
            ColorAttachment() : buffer(0), texture(0), internal_format(GL_RGBA8), format(GL_RGBA), type(GL_UNSIGNED_BYTE), texture_filter(GL_NEAREST) {}
            GLuint buffer;
            GLuint texture;
            GLenum internal_format;
            GLenum format;
            GLenum type;
            GLenum texture_filter;
        };
        std::vector<ColorAttachment> color_attachments_;
 
        bool   valid_;
 
    private:
        //copying disabled
        FramebufferObject(const FramebufferObject&);
        FramebufferObject& operator=(const FramebufferObject&);
    };
 
 
} // namespace easy3d
 
 
#endif // EASY3D_RENDERER_FRAMEBUFFER_OBJECT_H