Magic_Game/src/kiwano-imgui/ImGuiModule.cpp

// Copyright (C) 2019 Nomango


#include <kiwano/core/Common.h>
#include <kiwano/event/Events.h>
#include <kiwano/platform/Input.h>
#include <kiwano/platform/Application.h>
#include <kiwano/render/Renderer.h>
#include <kiwano-imgui/ImGuiModule.h>
#include <kiwano-imgui/imgui_impl/imgui_impl.h>

namespace kiwano
{
namespace imgui
{
ImGuiModule::ImGuiModule()
{
}

void ImGuiModule::SetupModule()
{
    // Setup Dear ImGui context
    IMGUI_CHECKVERSION();
    ImGui::CreateContext();
    ImGuiIO& io = ImGui::GetIO();
    (void)io;

    // Setup Dear ImGui style
    ImGui::StyleColorsDark();

    window_ = Application::GetInstance().GetWindow();

    // Setup Platform/Renderer bindings
    io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors;  // We can honor GetMouseCursor() values (optional)
    io.BackendFlags |=
        ImGuiBackendFlags_HasSetMousePos;  // We can honor io.WantSetMousePos requests (optional, rarely used)
    io.BackendPlatformName = "imgui_impl_win32";
    io.ImeWindowHandle     = window_->GetHandle();

    // Keyboard mapping. ImGui will use those indices to peek into the io.KeysDown[] array that we will update during
    // the application lifetime.
    io.KeyMap[ImGuiKey_Tab]        = (int)KeyCode::Tab;
    io.KeyMap[ImGuiKey_LeftArrow]  = (int)KeyCode::Left;
    io.KeyMap[ImGuiKey_RightArrow] = (int)KeyCode::Right;
    io.KeyMap[ImGuiKey_UpArrow]    = (int)KeyCode::Up;
    io.KeyMap[ImGuiKey_DownArrow]  = (int)KeyCode::Down;
    io.KeyMap[ImGuiKey_Delete]     = (int)KeyCode::Delete;
    io.KeyMap[ImGuiKey_Backspace]  = (int)KeyCode::Back;
    io.KeyMap[ImGuiKey_Space]      = (int)KeyCode::Space;
    io.KeyMap[ImGuiKey_Enter]      = (int)KeyCode::Enter;
    io.KeyMap[ImGuiKey_Escape]     = (int)KeyCode::Esc;
    io.KeyMap[ImGuiKey_A]          = (int)KeyCode::A;
    io.KeyMap[ImGuiKey_C]          = (int)KeyCode::C;
    io.KeyMap[ImGuiKey_V]          = (int)KeyCode::V;
    io.KeyMap[ImGuiKey_X]          = (int)KeyCode::X;
    io.KeyMap[ImGuiKey_Y]          = (int)KeyCode::Y;
    io.KeyMap[ImGuiKey_Z]          = (int)KeyCode::Z;

    ImGui_Impl_Init();
}

void ImGuiModule::DestroyModule()
{
    ImGui_Impl_Shutdown();
    ImGui::DestroyContext();
}

void ImGuiModule::OnUpdate(UpdateModuleContext& ctx)
{
    ImGuiIO& io = ImGui::GetIO();

    // Setup time step
    io.DeltaTime = ctx.dt.Seconds();

    // Read keyboard modifiers inputs
    io.KeyCtrl  = Input::GetInstance().IsDown(KeyCode::Ctrl);
    io.KeyShift = Input::GetInstance().IsDown(KeyCode::Shift);
    io.KeyAlt   = Input::GetInstance().IsDown(KeyCode::Alt);
    io.KeySuper = Input::GetInstance().IsDown(KeyCode::Super);
    // io.KeysDown[], io.MousePos, io.MouseDown[], io.MouseWheel: filled by the HandleEvent function below.

    // Update OS mouse position
    UpdateMousePos();

    // Update OS mouse cursor with the cursor requested by imgui
    UpdateMouseCursor();

    ctx.Next();
}

void ImGuiModule::OnRender(RenderModuleContext& ctx)
{
    // Before render
    {
        ImGui_Impl_NewFrame();

        ImGuiIO& io = ImGui::GetIO();
        KGE_ASSERT(io.Fonts->IsBuilt() && "Font atlas not built!");

        // Setup display size (every frame to accommodate for window resizing)
        Size display_size = Renderer::GetInstance().GetOutputSize();
        io.DisplaySize    = ImVec2(display_size.x, display_size.y);

        ImGui::NewFrame();
    }

    ctx.Next();

    // After render
    {
        ImGui::Render();

        ImGui_Impl_RenderDrawData(ImGui::GetDrawData());
    }
}

void ImGuiModule::HandleEvent(EventModuleContext& ctx)
{
    if (ImGui::GetCurrentContext() != NULL)
    {
        Event* evt = ctx.evt;

        ImGuiIO& io = ImGui::GetIO();
        if (evt->IsType<MouseEvent>())
        {
            if (evt->IsType<MouseDownEvent>())
            {
                MouseButton button = dynamic_cast<MouseDownEvent*>(evt)->button;
                int         index  = 0;
                if (button == MouseButton::Left)
                    index = 0;
                else if (button == MouseButton::Right)
                    index = 1;
                else if (button == MouseButton::Middle)
                    index = 2;
                io.MouseDown[index] = true;
            }
            else if (evt->IsType<MouseUpEvent>())
            {
                MouseButton button = dynamic_cast<MouseUpEvent*>(evt)->button;
                int         index  = 0;
                if (button == MouseButton::Left)
                    index = 0;
                else if (button == MouseButton::Right)
                    index = 1;
                else if (button == MouseButton::Middle)
                    index = 2;
                io.MouseDown[index] = false;
            }
            else if (evt->IsType<MouseWheelEvent>())
            {
                float wheel = dynamic_cast<MouseWheelEvent*>(evt)->wheel;
                io.MouseWheel += wheel;
            }
        }
        else if (evt->IsType<KeyEvent>())
        {
            if (evt->IsType<KeyDownEvent>())
            {
                KeyCode key           = dynamic_cast<KeyDownEvent*>(evt)->code;
                io.KeysDown[(int)key] = true;
            }
            else if (evt->IsType<KeyUpEvent>())
            {
                KeyCode key           = dynamic_cast<KeyUpEvent*>(evt)->code;
                io.KeysDown[(int)key] = false;
            }
            else if (evt->IsType<KeyCharEvent>())
            {
                // You can also use ToAscii()+GetKeyboardState() to retrieve characters.
                char ch = dynamic_cast<KeyCharEvent*>(evt)->value;
                io.AddInputCharacter(static_cast<ImWchar>(ch));
            }
        }
    }

    ctx.Next();
}

void ImGuiModule::UpdateMousePos()
{
    ImGuiIO& io = ImGui::GetIO();

    // Set OS mouse position if requested (rarely used, only when ImGuiConfigFlags_NavEnableSetMousePos is enabled by
    // user)
    if (io.WantSetMousePos)
    {
        POINT pos = { (int)io.MousePos.x, (int)io.MousePos.y };
        ::ClientToScreen(window_->GetHandle(), &pos);
        ::SetCursorPos(pos.x, pos.y);
    }

    Point pos   = Input::GetInstance().GetMousePos();
    io.MousePos = ImVec2(pos.x, pos.y);
}

void ImGuiModule::UpdateMouseCursor()
{
    if (ImGui::GetIO().ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange)
        return;

    static ImGuiMouseCursor last_cursor = ImGuiMouseCursor_None;
    if (ImGui::GetMouseCursor() == last_cursor)
        return;

    last_cursor = ImGui::GetMouseCursor();

    CursorType cursor = CursorType::Arrow;
    switch (last_cursor)
    {
    case ImGuiMouseCursor_Arrow:
        cursor = CursorType::Arrow;
        break;
    case ImGuiMouseCursor_TextInput:
        cursor = CursorType::TextInput;
        break;
    case ImGuiMouseCursor_ResizeAll:
        cursor = CursorType::SizeAll;
        break;
    case ImGuiMouseCursor_ResizeEW:
        cursor = CursorType::SizeWE;
        break;
    case ImGuiMouseCursor_ResizeNS:
        cursor = CursorType::SizeNS;
        break;
    case ImGuiMouseCursor_ResizeNESW:
        cursor = CursorType::SizeNESW;
        break;
    case ImGuiMouseCursor_ResizeNWSE:
        cursor = CursorType::SizeNWSE;
        break;
    case ImGuiMouseCursor_Hand:
        cursor = CursorType::Hand;
        break;
    }

    window_->SetCursor(cursor);
}

}  // namespace imgui
}  // namespace kiwano