simple_application.h

/*
 *  Copyright (c) 2000-2022 Inria
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright notice,
 *  this list of conditions and the following disclaimer in the documentation
 *  and/or other materials provided with the distribution.
 *  * Neither the name of the ALICE Project-Team nor the names of its
 *  contributors may be used to endorse or promote products derived from this
 *  software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 *
 *  Contact: Bruno Levy
 *
 *     https://www.inria.fr/fr/bruno-levy
 *
 *     Inria,
 *     Domaine de Voluceau,
 *     78150 Le Chesnay - Rocquencourt
 *     FRANCE
 *
 */
 
#ifndef H_GEOGRAM_GFX_GUI_SIMPLE_APPLICATION_H
#define H_GEOGRAM_GFX_GUI_SIMPLE_APPLICATION_H
 
#include <geogram_gfx/basic/common.h>
#include <geogram_gfx/gui/application.h>
#include <geogram_gfx/gui/status_bar.h>
#include <geogram_gfx/gui/console.h>
#include <geogram_gfx/gui/text_editor.h>
#include <geogram_gfx/gui/command.h>
#include <geogram_gfx/gui/arc_ball.h>
#include <geogram_gfx/full_screen_effects/full_screen_effect.h>
#include <geogram_gfx/imgui_ext/imgui_ext.h>
#include <geogram_gfx/imgui_ext/icon_font.h>
 
#include <map>
#include <functional>
 
struct lua_State;
 
namespace GEO {
 
    class GEOGRAM_GFX_API SimpleApplication : public Application {
    public:
 
        SimpleApplication(const std::string& name);
 
        ~SimpleApplication() override;
 
        void draw_gui() override;
 
        void draw_graphics() override;
 
        virtual bool save(const std::string& filename);
 
        virtual bool load(const std::string& filename);
 
        TextEditor& text_editor() {
            return text_editor_;
        }
 
        void show_text_editor() {
            text_editor_visible_ = true;
        }
 
        void hide_text_editor() {
            text_editor_visible_ = false;
        }
 
        void show_console() {
            console_visible_ = true;
        }
 
        void hide_console() {
            console_visible_ = false;
        }
 
        void home();
 
        void set_style(const std::string& style) override;
 
        void set_region_of_interest(
            double xmin, double ymin, double zmin,
            double xmax, double ymax, double zmax
        );
 
        void get_region_of_interest(
            double& xmin, double& ymin, double& zmin,
            double& xmax, double& ymax, double& zmax
        ) const;
 
        void zoom_in() {
            zoom_ *= 1.1;
        }
 
        void zoom_out() {
            zoom_ /= 1.1;
        }
 
        void set_clipping(bool x) {
            clipping_ = x;
        }
 
        void set_lighting(bool x) {
            lighting_ = x;
        }
 
        void set_background_color(const vec4f& color) {
            background_color_ = color;
        }
 
        virtual bool exec_command(const char* command);
 
        static SimpleApplication* instance() {
            return dynamic_cast<SimpleApplication*>(
                GEO::Application::instance()
            );
        }
 
        vec3 project(const vec3& p);
 
        vec3 unproject(const vec3& p);
 
        vec2 unproject_2d(const vec2& p);
 
 
        void drop_callback(int nb, const char** f) override;
 
        void run_key_func(const std::string& key) {
            auto it = key_funcs_.find(key);
            if(it != key_funcs_.end()) {
                it->second();
            }
        }
 
    protected:
        void add_key_func(
            const std::string& key, std::function<void()> cb,
            const char* help = nullptr
        );
 
        void add_key_toggle(
            const std::string& key, bool* p_val,
            const char* help = nullptr
        );
 
        void char_callback(unsigned int c) override;
 
        void key_callback(int key, int scancode, int action, int mods) override;
 
        void mouse_button_callback(
            int button, int action, int mods, int source
        ) override;
 
        void cursor_pos_callback(double x, double y, int source) override;
 
        void scroll_callback(double xoffset, double yoffset) override;
 
        virtual void draw_scene_begin();
 
        virtual void draw_scene();
 
        virtual void draw_scene_end();
 
        virtual void draw_viewer_properties_window();
 
        virtual void draw_viewer_properties();
 
        virtual void draw_object_properties_window();
 
        virtual void draw_object_properties();
 
 
        virtual void draw_command_window();
 
        virtual void draw_console();
 
 
        virtual void draw_menu_bar();
 
 
        virtual void draw_load_menu();
 
        virtual void draw_save_menu();
 
        virtual void draw_fileops_menu();
 
        virtual void draw_about();
 
        virtual void draw_help();
 
        virtual void draw_windows_menu();
 
        virtual void draw_application_menus();
 
        virtual void draw_application_icons();
 
 
        virtual void draw_command_line_editor();
 
 
        void post_draw() override;
 
        virtual bool can_load(const std::string& filename);
 
        virtual std::string supported_read_file_extensions();
 
        virtual std::string supported_write_file_extensions();
 
        void GL_initialize() override;
 
        void GL_terminate() override;
 
        void browse(const std::string& path, bool subdirs=false);
 
        void geogram_initialize(int argc, char** argv) override;
 
        void set_default_filename(const std::string& filename) {
            strcpy(filename_, filename.c_str());
        }
 
        void init_colormap(const std::string& name, const char** xpm_data);
 
        void init_colormaps();
 
        void ImGui_initialize() override;
 
        void set_2d() {
            three_D_ = false;
        }
 
        void set_3d() {
            three_D_ = true;
        }
 
        void set_default_layout();
 
        void resize(index_t w, index_t h, index_t fb_w, index_t fb_h) override;
 
        virtual const char* default_layout() const;
        virtual const char* default_layout_android_vertical() const;
        virtual const char* default_layout_android_horizontal() const;
 
        virtual void command_line_arg_changed(const std::string& argname);
 
        static void replay_latest_command();
 
        virtual void snapshot(
            Image* image,
            index_t x0=0, index_t y0=0, index_t width=0, index_t height=0,
            bool redraw = true
        );
 
        virtual void snapshot(std::string filename = "", bool verbose=false);
 
        void declare_args() override;
 
    protected:
        bool locked_; // avoid starting command when command is running
        bool lighting_;
        bool edit_light_;
        bool clipping_;
        GLUPclipMode clip_mode_;
        bool edit_clip_;
        bool fixed_clip_;
        GLenum effect_;
        vec4f background_color_;
 
        bool viewer_properties_visible_;
        bool object_properties_visible_;
        bool console_visible_;
        bool text_editor_visible_;
        bool use_text_editor_;
        bool command_line_editor_visible_;
 
        Box roi_;
        double roi_radius_;
        vec3    object_translation_;
        ArcBall object_rotation_;
        ArcBall light_rotation_;
        ArcBall clip_rotation_;
        vec3    clip_translation_;
        bool    three_D_;
        double  zoom_;
        double  zoom_down_; 
        bool props_pinned_;
 
        enum MouseOp {
            MOUSE_NOOP, MOUSE_ROTATE, MOUSE_TRANSLATE, MOUSE_ZOOM
        } mouse_op_;
 
        enum MouseTarget {
            MOUSE_NOTARGET, MOUSE_OBJECT, MOUSE_LIGHT, MOUSE_CLIP
        } mouse_target_;
 
        vec2 mouse_down_xy_; // in [-1,1] x [-1,1]
        vec2 mouse_xy_;      // in [-1,1] x [-1,1]
 
        // Current transform, for picking
        GLint viewport_[4];
        mat4 modelview_transpose_;
        mat4 project_transpose_;
 
        std::string path_;
        std::string current_file_;
        char filename_[geo_imgui_string_length]; // Buffer for file dialog.
        GLuint geogram_logo_texture_;
 
        Console_var console_;
        StatusBar_var status_bar_;
        TextEditor text_editor_;
 
        std::map< std::string, std::function<void()> > key_funcs_;
        std::map< std::string, std::string > key_funcs_help_;
 
        struct ColormapInfo {
            ColormapInfo() : texture(0) {
            }
            GLuint texture;
            std::string name;
        };
 
        vector<ColormapInfo> colormaps_;
        FullScreenEffectImpl_var full_screen_effect_;
 
        lua_State* lua_state_;
        bool lua_error_occured_;
    };
 
}
 
#endif