Viewer.h

/*
 * Copyright 2019 Adobe. All rights reserved.
 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License. You may obtain a copy
 * of the License at http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under
 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
 * OF ANY KIND, either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
#pragma once
 
 
#include <lagrange/ui/Entity.h>
#include <lagrange/ui/api.h>
#include <lagrange/ui/default_components.h>
#include <lagrange/ui/default_keybinds.h>
#include <lagrange/ui/panels/ViewportPanel.h>
#include <lagrange/ui/types/Camera.h>
#include <lagrange/ui/types/Systems.h>
#include <lagrange/ui/types/Tools.h>
#include <lagrange/ui/utils/input.h>
#include <lagrange/ui/utils/layer.h>
#include <lagrange/ui/utils/uipanel.h>
 
#include <imgui.h>
#include <future>
#include <memory>
#include <mutex>
#include <queue>
#include <set>
#include <string>
 
struct GLFWwindow;
struct ImGuiContext;
 
namespace lagrange {
namespace ui {
 
 
class Renderer;

class LA_UI_API Viewer
{
public:
    /*
        IO functions
    */
    bool is_key_down(ImGuiKey key);
    bool is_key_pressed(ImGuiKey key);
    bool is_key_released(ImGuiKey key);
    bool is_mouse_down(ImGuiKey key);
    bool is_mouse_clicked(ImGuiKey key);
    bool is_mouse_released(ImGuiKey key);

    InputState& get_input() { return lagrange::ui::get_input(registry()); }

    const InputState& get_input() const { return lagrange::ui::get_input(registry()); }

    struct WindowOptions
    {
        std::string window_title = "";

        int pos_x = -1;
        int pos_y = -1;
        int width = 1024;
        int height = 768;
        bool window_fullscreen = false;
        bool fullscreen = false;
        bool vsync = true;
        int monitor_index = 0;

        int gl_version_major = 3;
        int gl_version_minor = 3;
        bool focus_on_show = true;

        bool show_default_ibl = true;
        size_t default_ibl_resolution = 256;

        bool show_topbar_menu = true;

        std::string imgui_ini_path = "";

        Color selection_color = Color(252.0f / 255.0f, 86.0f / 255.0f, 3.0f / 255.0f, 1.0f);

        bool use_srgb = true;
    };
 

    Viewer(const std::string& window_title, int window_width, int window_height);
 

    Viewer(int argc, char** argv);

    Viewer(const WindowOptions& window_options);
 
    virtual ~Viewer();
 
    operator ui::Registry&() { return registry(); }
 
    operator const ui::Registry&() const { return registry(); }

    bool should_close() const;

    bool run(const std::function<bool(Registry& r)>& main_loop);

    bool run(const std::function<void(void)>& main_loop = {});

    bool is_initialized() const;

    bool is_show_topbar_menu() const { return m_show_topbar_menu; }

    void set_show_topbar_menu(bool show_topbar_menu) { m_show_topbar_menu = show_topbar_menu; }

    double get_frame_elapsed_time() const;
 
    // Window width in pixels
    int get_width() const { return m_width; }
 
    // Window height in pixels
    int get_height() const { return m_height; }
 
    const std::string& get_imgui_config_path() const;

    float get_window_scaling() const;

    Keybinds& get_keybinds();

    const Keybinds& get_keybinds() const;

    Registry& registry() { return m_registry; }

    const Registry& registry() const { return m_registry; }

    const Systems& systems() const { return m_systems; }

    Systems& systems() { return m_systems; }

    std::future<void> run_on_main_thread(std::function<void(void)> fn);

    unsigned int get_main_thread_max_func_per_frame() const
    {
        return m_main_thread_max_func_per_frame;
    }

    void set_main_thread_max_func_per_frame(unsigned int limit)
    {
        m_main_thread_max_func_per_frame = limit;
    }
 
    static std::string get_config_folder();
 
protected:
    virtual void draw_menu();
 
private:
    void render_one_frame(const std::function<bool(Registry& r)>& main_loop);
 
    bool init_glfw(const WindowOptions& options);
    bool init_imgui();
    bool init_imgui_fonts();
 
 
    void resize(int window_width, int window_height);
    void move(int x, int y);
    void update_scale();
    void drop(int count, const char** paths);
 
    void process_input();
 
    void update_time();
 
    void start_imgui_frame();
 
    void end_imgui_frame();
 
    void make_current();
 
    void start_dockspace();
    void end_dockspace();
 
    void show_last_shader_error();
 
    WindowOptions m_initial_window_options;
 
    GLFWwindow* m_window;
    ImGuiContext* m_imgui_context;
 
 
    bool m_initialized = false;
 
    static bool m_instance_initialized;
 
    std::string m_imgui_ini_path;
 
    int m_width;
    int m_height;
 
    // DPI aware scaling
    float m_ui_scaling = 1.0f;
 
 
    std::string m_last_shader_error;
    std::string m_last_shader_error_desc;
 
    bool m_show_imgui_demo = false;
    bool m_show_imgui_style = false;
    bool m_show_topbar_menu = true;
 
    entt::registry m_registry;
    Systems m_systems;
 
    Entity m_main_viewport;
 
    // Functions that will be run on next frame on the main thread
    // Used for code interacting with OpenGL context
    std::mutex m_mutex;
    std::queue<std::pair<std::promise<void>, std::function<void(void)>>> m_main_thread_fn;
    std::atomic_uint m_main_thread_max_func_per_frame = std::numeric_limits<unsigned int>::max();
};
 
} // namespace ui
} // namespace lagrange