rendering_context.h

Go to the documentation of this file.

/*
 *  OGF/Graphite: Geometry and Graphics Programming Library + Utilities
 *  Copyright (C) 2000 Bruno Levy
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program 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, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *  If you modify this software, you should include a notice giving the
 *  name of the person performing the modification, the date of modification,
 *  and the reason for such modification.
 *
 *  Contact: Bruno Levy
 *
 *     levy@loria.fr
 *
 *     ISA Project
 *     LORIA, INRIA Lorraine,
 *     Campus Scientifique, BP 239
 *     54506 VANDOEUVRE LES NANCY CEDEX
 *     FRANCE
 *
 *  Note that the GNU General Public License does not permit incorporating
 *  the Software into proprietary programs.
 */
 
 
#ifndef H_OGF_RENDERER_CONTEXT_RENDERING_CONTEXT_H
#define H_OGF_RENDERER_CONTEXT_RENDERING_CONTEXT_H
 
#include <OGF/renderer/common/common.h>
#include <OGF/renderer/context/texture.h>
#include <OGF/renderer/context/overlay.h>
#include <geogram/image/image.h>
#include <geogram_gfx/full_screen_effects/full_screen_effect.h>
#include <geogram_gfx/basic/GL.h>
 
namespace OGF {
 
    class Colormap;
    class RenderArea;
 
/*****************************************************************/
 
    class RENDERER_API RenderingContext : public Counted {
    public:
 
        RenderingContext(GLUPcontext glup_context=nullptr);
 
        ~RenderingContext() override;
 
        static RenderingContext* current() {
            return current_;
        }
 
 
        static bool is_currently_rendering();
 
 
        static bool is_currently_picking();
 
 
        index_t get_width() const {
            return width_;
        }
 
        index_t get_height() const {
            return height_;
        }
 
        bool initialized() const {
            return initialized_;
        }
 
        virtual void make_current();
 
        virtual void done_current();
 
        virtual void swap_buffers();
 
        void clear();
 
        void load_viewing_matrix(const mat4& m);
 
        void mul_viewing_matrix(const mat4& m);
 
        const mat4& viewing_matrix() const;
 
        const mat4& inverse_viewing_matrix() const;
 
        void load_projection_matrix(const mat4& m);
 
        mat4 projection_matrix() const;
 
        virtual void begin_frame();
 
        virtual void end_frame();
 
 
        const Color& background_color() const;
 
        void set_background_color(const Color& c);
 
 
        const Color& background_color_2() const;
 
        void set_background_color_2(const Color& c);
 
        void set_background_image(Image* image);
 
        void update_background_image_from_data(
            Memory::pointer ptr,
            Image::ColorEncoding color_encoding,
            Image::ComponentEncoding component_encoding,
            index_t width, index_t height
        );
 
        void set_lighting_matrix(const mat4& m);
 
        const mat4& lighting_matrix() const;
 
        mat4 clipping_matrix() const;
 
        void set_clipping_matrix(const mat4& m);
 
        void set_clipping(bool x);
 
        bool get_clipping() const;
 
        void set_clipping_equation(const vec4& x) {
            clipping_equation_ = x;
        }
 
        const vec4& get_clipping_translation() const {
            return clipping_equation_;
        }
 
        void set_clipping_viewer(bool x) {
            clipping_viewer_ = x;
        }
 
        bool get_clipping_viewer() const {
            return clipping_viewer_;
        }
 
        GLUPclipMode get_clipping_mode() const {
            return clipping_mode_;
        }
 
        void set_clipping_mode(GLUPclipMode mode) {
            clipping_mode_ = mode;
        }
 
        bool double_buffer() const {
            return double_buffer_;
        }
 
        bool stereo() const {
            return stereo_;
        }
 
        virtual void set_double_buffer(bool b);
 
        virtual void snapshot(
            Image* image, bool make_current=true,
            index_t x0=0, index_t y0=0,
            index_t width=0, index_t height=0
        );
 
        std::string gl_vendor() const;
 
        std::string gl_renderer() const;
 
        std::string gl_version() const;
 
        std::string gl_extensions() const;
 
        std::string get_gpu_information() const;
 
        std::string get_gpu_extensions() const;
 
        void set_full_screen_effect(FullScreenEffectImpl* fse);
 
        FullScreenEffectImpl* get_full_screen_effect() const {
            return full_screen_effect_;
        }
 
        virtual void resize(index_t w, index_t h);
 
 
        void set_center(int x, int y);
 
        int get_center_x() const {
            return center_x_;
        }
 
        int get_center_y() const {
            return center_y_;
        }
 
        vec2 screen_to_ndc(index_t x, index_t y) const;
 
        void ndc_to_screen(const vec2& ndc, index_t& x, index_t& y) const;
 
        virtual void begin_picking(const vec2& ndc);
 
        virtual void end_picking();
 
        index_t picked_id() const {
            return picked_id_;
        }
 
        double picked_depth() const {
            return picked_depth_;
        }
 
        const vec3& picked_point() const {
            return picked_point_;
        }
 
        bool picked_background() const {
            return picked_background_;
        }
 
        vec3 unproject(const vec2& p_ndc, double depth) const;
 
        void check_gl() const;
 
        GLuint frame_buffer_id() const {
            return frame_buffer_id_;
        }
 
        bool contains_picking_image() const {
            return last_frame_was_picking_;
        }
 
        Overlay& overlay() {
            return overlay_;
        }
 
        enum RenderingContextFBO {
            MAIN_FBO=0,
            AUX_FBO=1
        };
 
        virtual FrameBufferObject* get_FBO(RenderingContextFBO FBO_id);
 
    protected:
 
        virtual void draw_background();
 
        void setup_viewport();
 
        void setup_projection_ortho(double zNear, double zFar);
 
        void setup_projection_perspective(
            double zScreen, double zNear, double zFar,
            double eye_offset=0.0
        );
 
        void setup_modelview(double zScreen);
 
        void setup_lighting();
 
 
        void update_clipping();
 
        static const double* convert_matrix(const mat4& M);
 
        Texture* background_texture() const {
            return background_texture_;
        }
 
        void set_initialized(bool x = true) {
            initialized_ = x;
        }
 
        void set_width(index_t w) {
            width_ = w;
        }
 
        void set_height(index_t h) {
            height_ = h;
        }
 
        void get_view_parameters();
 
 
        void get_picked_point();
 
 
    protected:
 
        static RenderingContext* current_;
        bool initialized_;
 
        index_t width_;
        index_t height_;
        bool double_buffer_;
 
        int viewport_x_;
        int viewport_y_;
        int viewport_width_;
        int viewport_height_;
        int center_x_;
        int center_y_;
 
        mat4 viewing_matrix_;
        mutable mat4 inverse_viewing_matrix_;
        mutable bool inverse_viewing_matrix_dirty_;
 
        bool lighting_;
        mat4 lighting_matrix_;
 
        bool clipping_;
        mat4 clipping_matrix_;
        vec4 clipping_equation_;
        bool clipping_viewer_;
        GLUPclipMode clipping_mode_;
 
        Color background_color_;
        Color background_color_2_;
        Texture_var background_texture_;
        FullScreenEffectImpl_var full_screen_effect_;
 
        bool perspective_;
        bool stereo_;
        bool stereo_odd_frame_;
        double stereo_eye_dist_;
        vec3 head_position_;
        double head_tilt_;
 
        bool picking_mode_;
        vec2 picked_ndc_;
        double picked_depth_;
        index_t picked_id_;
        vec3 picked_point_;
        bool picked_background_;
        bool last_frame_was_picking_;
 
        GLuint frame_buffer_id_;
        bool frame_buffer_id_init_;
 
        static bool geogram_gfx_initialized_;
 
        static index_t nb_render_locks_;
 
        static index_t nb_picking_locks_;
 
        GLUPcontext glup_context_;
        bool owns_glup_context_;
 
        bool use_core_profile_;
        bool use_ES_profile_;
 
        bool transparent_;
 
        Overlay overlay_;
 
        friend class RenderArea;
    };
 
    typedef SmartPointer<RenderingContext> RenderingContext_var;
 
/******************************************************************/
 
}
 
#endif