viewer.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_VIEWER_VIEWER_H
#define EASY3D_VIEWER_VIEWER_H
 
 
#include <string>
#include <vector>
#include <memory>
 
#include <easy3d/core/types.h>
 
 
struct GLFWwindow;
 
namespace easy3d {
 
    class Camera;
    class Model;
    class Drawable;
    class LinesDrawable2D;
    class TrianglesDrawable;
    class TextRenderer;
    class KeyFrameInterpolator;

    class Viewer
    {
    public:
        explicit Viewer(
            const std::string& title = "Easy3D Viewer",
            int samples = 4,
            int gl_major = 3,
            int gl_minor = 2,
            bool full_screen = false,
            bool resizable = true,
            int depth_bits = 24,
            int stencil_bits = 8,
            int width = 800,
            int height = 600
        );

        virtual ~Viewer();

        int run(bool see_all = true);

        virtual void exit();



        void set_title(const std::string &title);

        const std::string& title() const { return title_; }

        void resize(int w, int h);

        int width() const { return width_; }
        int height() const { return height_; }
        void viewer_size(int& w, int& h) const { w = width_; h = height_; }

        int framebuffer_width() const;
        int framebuffer_height() const;
        void framebuffer_size(int& w, int& h) const;

        void set_position(int xpos, int ypos);

        int  samples() const { return samples_; }

        float dpi_scaling() const { return dpi_scaling_; }

        void set_background_color(const vec4& color) { background_color_ = color; }

        const vec4& background_color() const { return background_color_; }

        Camera* camera() { return camera_.get(); }
        const Camera* camera() const { return camera_.get(); }



        virtual bool open();

        virtual bool save() const;



        virtual Model* add_model(const std::string& file_name, bool create_default_drawables = true);

        Model* add_model(std::shared_ptr<Model> model, bool create_default_drawables = true);
        Model* add_model(Model* model, bool create_default_drawables = true);

        virtual bool delete_model(Model* model);

        const std::vector< std::shared_ptr<Model> >& models() const { return models_; }

        Model* current_model() const;



        Drawable* add_drawable(std::shared_ptr<Drawable> drawable);
        Drawable* add_drawable(Drawable* drawable);

        bool delete_drawable(Drawable* drawable);

        const std::vector< std::shared_ptr<Drawable> >& drawables() const { return drawables_; }

        void clear_scene();



        void update() const;

        void fit_screen(const Model* model = nullptr);

        virtual bool snapshot() const;

        bool snapshot(const std::string& file_name, float scaling = 1.0f, int samples = 4, int back_ground = 1, bool expand = true) const;

        virtual vec3 point_under_pixel(int x, int y, bool &found) const;

        void set_usage(const std::string& manual = "default", const std::string& screen_hint = "");



        enum Key { // Do NOT modify the values!!!
            // the unknown key
            KEY_UNKNOWN = -1,
            // the number keys
            KEY_0 = 48, KEY_1 = 49, KEY_2 = 50, KEY_3 = 51, KEY_4 = 52, KEY_5 = 53, KEY_6 = 54, KEY_7 = 55,
            KEY_8 = 56, KEY_9 = 57,
            // the character keys
            KEY_A = 65, KEY_B = 66, KEY_C = 67, KEY_D = 68, KEY_E = 69, KEY_F = 70, KEY_G = 71, KEY_H = 72,
            KEY_I = 73, KEY_J = 74, KEY_K = 75, KEY_L = 76, KEY_M = 77, KEY_N = 78, KEY_O = 79, KEY_P = 80,
            KEY_Q = 81, KEY_R = 82, KEY_S = 83, KEY_T = 84, KEY_U = 85, KEY_V = 86, KEY_W = 87, KEY_X = 88,
            KEY_Y = 89, KEY_Z = 90,
            // the functional keys
            KEY_RIGHT = 262, KEY_LEFT = 263, KEY_DOWN = 264, KEY_UP = 265,
            KEY_F1 = 290,   KEY_F2 = 291,   KEY_F3 = 292,   KEY_F4 = 293,   KEY_F5 = 294,
            KEY_F6 = 295,   KEY_F7 = 296,   KEY_F8 = 297,   KEY_F9 = 298,
            // some printable keys
            KEY_SPACE = 32,
            KEY_COMMA = 44/* , */,  KEY_MINUS     = 45/* - */,  KEY_PERIOD = 46/* . */,
            KEY_SLASH = 47/* / */,  KEY_SEMICOLON = 59/* ; */,  KEY_EQUAL  = 61/* = */,
            KEY_LEFT_BRACKET = 91/* [ */,   KEY_BACKSLASH = 92/* \ */, KEY_RIGHT_BRACKET = 93/* ] */
        };

        enum Modifier { /* Do NOT modify the values!!! */
            MODIF_NONE = 0x0000, 
            MODIF_SHIFT = 0x0001, 
#ifdef __APPLE__    // To have the same shortcut behavior on macOS and other platforms (i.e., Windows and Linux)
            MODIF_CTRL = 0x0008,
#else
            MODIF_CTRL = 0x0002,
#endif
            MODIF_ALT = 0x0004
        };

        enum Button { // Do NOT modify the values!!!
            BUTTON_LEFT = 0,
            BUTTON_RIGHT = 1, 
            BUTTON_MIDDLE = 2
        };

        using Function = std::function<bool(Viewer* viewer, Model* model)>;

        void bind(const Function& func, Model* model, Key key, Modifier modifier = MODIF_NONE) {
            commands_[key][modifier] = std::make_pair(func, model);
        }




        std::function<bool(Viewer* viewer)> animation_func_;

        void set_animation(bool b);

        bool is_animating() const;
 
    protected:
 
        // rendering. Users can put their additional rendering function here by reimplementing it.
        virtual void draw() const;
 
        // OpenGL resources (e.g., shaders, textures, VAOs) must be created when 
        // there exists a valid rendering context. It is (usually) a bad idea to do 
        // this in a constructor because the OpenGL context may not have been 
        // created yet or the visible one is not *current*. This init() function is 
        // to ensure you have a valid rendering context. It will be called before 
        // the draw procedure. See also cleanup().
        // NOTE: Don't forget to call Viewer::init() at the beginning of your 
        //       inherited function.
        virtual void init();
 
        // To destroy OpenGL resources (e.g., shaders, textures, VAOs), there must exist a valid rendering context.
        // It is (usually) a bad idea to clean up OpenGL in a destructor because the OpenGL context may not exist
        // (e.g., destroyed already) or the visible one is not *current*. This cleanup() function is to ensure you
        // have a valid rendering context. See also init().
        // NOTE: Don't forget to call Viewer::cleanup() at the end of your inherited function.
        void cleanup();
 
        // This function will be called before the main draw procedure.
        virtual void pre_draw();
 
        // This function draws axes of the coordinate system, Easy3D logo, frame rate, etc. overlaid on the scene.
        // It will be called after the main draw procedure.
        virtual void post_draw();
 
        // External resize due to user interaction.
        // This function will be called after the window size being changed.
        // w/h: the new width and height of the viewer (not framebuffer, not viewport)
        virtual void post_resize(int w, int h) { (void)w, (void)h; }
 
        // Mouse button press event handler
        virtual bool mouse_press_event(int x, int y, int button, int modifiers);
        // Mouse button release event handler
        virtual bool mouse_release_event(int x, int y, int button, int modifiers);
        // Mouse drag (i.e., a mouse button was pressed) event handler
        virtual bool mouse_drag_event(int x, int y, int dx, int dy, int button, int modifiers);
        // Mouse free move (i.e., no mouse button was pressed) event handler
        virtual bool mouse_free_move_event(int x, int y, int dx, int dy, int modifiers);
        // Mouse scroll event handler
        virtual bool mouse_scroll_event(int x, int y, int dx, int dy);
 
        // Text input event handler: codepoint is native endian UTF-32 format
        // NOTE: This one reveals the actual character being sent (not just the physical key)
        virtual bool char_input_event(unsigned int codepoint);
        // Keyboard event handler.
        // NOTE: This function does not reveal the actual character.
        virtual bool key_press_event(int key, int modifiers);
        virtual bool key_release_event(int key, int modifiers);
 
        // Handle a file drop event
        virtual bool drop_event(const std::vector<std::string> & filenames);
 
        // Handle a focus change event
        virtual bool focus_event(bool focused);
 
    protected:
        GLFWwindow *create_window(const std::string &title,
                                  int samples,
                                  int gl_major,   // must >= 3
                                  int gl_minor,   // must >= 2
                                  bool full_screen,
                                  bool resizable,
                                  int depth_bits,
                                  int stencil_bits,
                                  int width,
                                  int height);
 
        void setup_callbacks(GLFWwindow*);
 
        /* Event handlers. Client code should not touch these */
        virtual bool callback_event_cursor_pos(double x, double y);
        virtual bool callback_event_mouse_button(int button, int action, int modifiers);
        virtual bool callback_event_keyboard(int key, int action, int mods);
        virtual bool callback_event_character(unsigned int codepoint);
        virtual bool callback_event_drop(int count, const char **filenames);
        virtual bool callback_event_scroll(double dx, double dy);
        virtual void callback_event_resize(int w, int h);
 
        void draw_corner_axes() const;
 
        void draw_face_labels(Model* model, TextRenderer* texter, int font_id, const vec3& color) const;
        void draw_vertex_labels(Model* model, TextRenderer* texter, int font_id, const vec3& color) const;
 
        void copy_view();
        void paste_view();
 
    protected:
        GLFWwindow* window_;
        bool        should_exit_;
        float       dpi_scaling_;
        int         width_;
        int         height_;
 
        std::string title_;
        std::unique_ptr<Camera> camera_;
 
        std::unique_ptr<KeyFrameInterpolator> kfi_;
        bool    is_animating_;
 
        std::string manual_;
        std::string hint_; // shown in the top-left corner of the screen
 
        int     samples_;   // the actual samples
 
        bool    full_screen_;
        vec4    background_color_;
 
        // enable/disable event processing
        bool    process_events_;
        char    framerate_[48];       // show the frame rate
 
        std::unique_ptr<TextRenderer> texter_;
        bool    show_easy3d_logo_;
 
        // mouse
        int     pressed_button_;    // for mouse drag
        int     modifiers_;         // for mouse drag
        bool    drag_active_;       // for mouse drag
        int     mouse_current_x_;   // for mouse button and scroll events
        int     mouse_current_y_;
        int     mouse_pressed_x_;   // last pressed position
        int     mouse_pressed_y_;
        int     pressed_key_;
 
        bool    show_pivot_point_;
        bool    show_frame_rate_;
 
        //----------------- viewer data -------------------
 
        // corner axes
        std::unique_ptr<TrianglesDrawable> drawable_axes_;
 
        // pivot cross
        std::unique_ptr<LinesDrawable2D> drawable_pivot_;
 
        // camera path
        bool    show_camera_path_;
 
        std::vector< std::shared_ptr<Model> > models_;
        int model_idx_;
 
        // drawables independent of any model
        std::vector< std::shared_ptr<Drawable> > drawables_;
 
        typedef std::pair<Function, Model*> FunctionModel;
        std::map<Key, std::map<Modifier, FunctionModel> >  commands_;
    };
 
}
 
 
#endif  // EASY3D_VIEWER_VIEWER_H