render_area.h

/*
 *  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_SKIN_IMGUI_RENDER_AREA_H
#define H_SKIN_IMGUI_RENDER_AREA_H
 
#include <OGF/skin_imgui/common/common.h>
#include <OGF/scene_graph_gfx/transforms/ray_picker.h>
#include <OGF/renderer/context/rendering_context.h>
#include <OGF/gom/types/node.h>
 
#include <geogram/image/color.h>
 
struct GLUPContext;
 
namespace OGF {
 
    gom_class SKIN_IMGUI_API RenderArea : public Object {
    public:
 
        RenderArea(index_t w, index_t h, index_t fb_w, index_t fb_h);
 
        ~RenderArea() override;
 
        void resize(index_t w, index_t h, index_t fb_w, index_t fb_h);
 
        bool needs_to_redraw() const {
            return dirty_;
        }
 
 
    gom_slots:
 
        void draw();
 
        void update();
 
        void update_memorized_frame();
 
        void draw_memorized_frame();
 
        void snapshot(
            const std::string& filename, bool make_current = true,
            bool with_gui = false
        );
 
        void update_view_parameters();
 
        void update_background_image_from_data(
            Memory::pointer ptr,
            Image::ColorEncoding color_encoding,
            Image::ComponentEncoding component_encoding,
            index_t width, index_t height
        );
 
    gom_properties:
        index_t get_width() const {
            return width_;
        }
 
        index_t get_height() const {
            return height_;
        }
 
        index_t get_frame_buffer_width() const {
            return frame_buffer_width_;
        }
 
        index_t get_frame_buffer_height() const {
            return frame_buffer_height_;
        }
 
        void set_projection_matrix(const mat4& value);
 
        const mat4& get_projection_matrix() const;
 
        void set_viewing_matrix(const mat4& value);
 
        const mat4& get_viewing_matrix() const;
 
        void set_background_color_1(const Color& value);
 
        const Color& get_background_color_1() const;
 
        void set_background_color_2(const Color& value);
 
        const Color& get_background_color_2() const;
 
        void set_background_image(const std::string& value);
 
        const std::string& get_background_image() const;
 
        void set_lighting_matrix(const mat4& value);
 
        const mat4& get_lighting_matrix() const;
 
        RenderingContext* get_rendering_context() const;
 
        std::string get_gpu_information() const;
 
        std::string get_gpu_extensions() const;
 
        const std::string& get_clipping_config() const {
            return clipping_config_;
        }
 
        void set_clipping_config(const std::string& clipping_config) {
            clipping_config_ = clipping_config;
            update_clipping_config();
        }
 
    gom_signals:
        void redraw_request(RenderingContext* rendering_context=nullptr);
 
        void resize_request(
            RenderingContext* rendering_context, int width, int height
        );
 
        void mouse_down(
            RenderingContext* rendering_context,
            const vec2& point_ndc, const vec2& point_wc,
            int button, bool control, bool shift
        );
 
        void mouse_move(
            RenderingContext* rendering_context,
            const vec2& point_ndc, const vec2& point_wc,
            const vec2& delta_ndc, double delta_x_ndc, double delta_y_ndc,
            const vec2& delta_wc,
            int button, bool control, bool shift
        );
 
        void mouse_up(
            RenderingContext* rendering_context,
            const vec2& point_ndc, const vec2& point_wc,
            int button, bool control, bool shift
        );
 
        void key_down(const std::string& value);
 
        void key_up(const std::string& value);
 
        void button_down(int value);
 
        void button_up(int value);
 
        void dropped_file(const std::string& value);
 
    public:
        void mouse_button_callback(int button, int action, int mods);
        void scroll_callback(double xoffset, double yoffset);
        void cursor_pos_callback(double xf, double yf);
        void drop_callback(int nb, const char** p);
        void char_callback(unsigned int c);
        void key_callback(int key, int scancode, int action, int mods);
 
    protected:
 
        void GL_initialize();
 
        void GL_terminate();
        void update_clipping_config();
 
    private:
        RenderingContext_var rendering_context_;
        index_t width_;
        index_t height_;
        index_t frame_buffer_width_;
        index_t frame_buffer_height_;
        std::string clipping_config_;
 
        index_t button_down_;
        bool control_is_down_;
        bool shift_is_down_;
        vec2 last_point_dc_;
        vec2 last_point_ndc_;
        vec2 last_point_wc_;
        Color background_color_;
        Color background_color_2_;
        mat4 viewing_matrix_;
        mat4 lighting_matrix_;
        std::string background_image_;
        GLUPContext* glup_context_;
        bool dirty_;
    };
 
    typedef SmartPointer<RenderArea> RenderArea_var;
 
}
 
#endif