mirror of
https://github.com/hedge-dev/UnleashedRecomp.git
synced 2025-12-31 00:10:26 -06:00
365 lines
13 KiB
C++
365 lines
13 KiB
C++
#include "reddog_window.h"
|
|
|
|
#include <gpu/imgui/imgui_snapshot.h>
|
|
#include <gpu/video.h>
|
|
#include <ui/reddog/reddog_manager.h>
|
|
#include <ui/game_window.h>
|
|
#include <ui/imgui_utils.h>
|
|
|
|
#include <res/images/reddog/button_close_1.dds.h>
|
|
#include <res/images/reddog/button_close_2.dds.h>
|
|
#include <res/images/reddog/button_minimum_1.dds.h>
|
|
#include <res/images/reddog/button_minimum_2.dds.h>
|
|
#include <res/images/reddog/button_pin_1.dds.h>
|
|
#include <res/images/reddog/button_pin_2.dds.h>
|
|
#include <res/images/reddog/common_icon.dds.h>
|
|
#include <res/images/reddog/title_bar.dds.h>
|
|
|
|
constexpr float MIN_WINDOW_SIZE = 21.0f;
|
|
|
|
static std::unique_ptr<GuestTexture> g_upButtonClose1;
|
|
static std::unique_ptr<GuestTexture> g_upButtonClose2;
|
|
static std::unique_ptr<GuestTexture> g_upButtonMinimum1;
|
|
static std::unique_ptr<GuestTexture> g_upButtonMinimum2;
|
|
static std::unique_ptr<GuestTexture> g_upButtonPin1;
|
|
static std::unique_ptr<GuestTexture> g_upButtonPin2;
|
|
static std::unique_ptr<GuestTexture> g_upCommonIcon;
|
|
static std::unique_ptr<GuestTexture> g_upTitleBar;
|
|
static std::unique_ptr<GuestTexture> g_upWindowFrame;
|
|
|
|
ImFont* g_font;
|
|
float g_defaultFontScale;
|
|
|
|
ImGuiStyle g_defaultStyle;
|
|
|
|
static std::vector<Reddog::IWindow*>& Reddog::GetWindows()
|
|
{
|
|
static std::vector<Reddog::IWindow*> g_windows;
|
|
return g_windows;
|
|
}
|
|
|
|
void Reddog::InitWindowResources()
|
|
{
|
|
g_font = ImFontAtlasSnapshot::GetFont("micross.ttf");
|
|
g_defaultFontScale = g_font->Scale;
|
|
|
|
auto& style = ImGui::GetStyle();
|
|
g_defaultStyle = style;
|
|
|
|
g_upButtonClose1 = LoadTexture(g_button_close_1, sizeof(g_button_close_1));
|
|
g_upButtonClose2 = LoadTexture(g_button_close_2, sizeof(g_button_close_2));
|
|
g_upButtonMinimum1 = LoadTexture(g_button_minimum_1, sizeof(g_button_minimum_1));
|
|
g_upButtonMinimum2 = LoadTexture(g_button_minimum_2, sizeof(g_button_minimum_2));
|
|
g_upButtonPin1 = LoadTexture(g_button_pin_1, sizeof(g_button_pin_1));
|
|
g_upButtonPin2 = LoadTexture(g_button_pin_2, sizeof(g_button_pin_2));
|
|
g_upCommonIcon = LoadTexture(g_common_icon, sizeof(g_common_icon));
|
|
g_upTitleBar = LoadTexture(g_title_bar, sizeof(g_title_bar));
|
|
}
|
|
|
|
void Reddog::Window::BeginStyle()
|
|
{
|
|
g_font->Scale = ImGui::GetDefaultFont()->FontSize / g_font->FontSize;
|
|
ImGui::PushFont(g_font);
|
|
|
|
UpdateStyle();
|
|
}
|
|
|
|
void Reddog::Window::UpdateStyle()
|
|
{
|
|
auto& style = ImGui::GetStyle();
|
|
|
|
style.WindowMinSize = { 0, MIN_WINDOW_SIZE };
|
|
|
|
auto colBg = IsFocused
|
|
? ImU32ToImVec4(ActiveColour)
|
|
: ImU32ToImVec4(InactiveColour);
|
|
|
|
auto colBlack = ImVec4(0, 0, 0, 1);
|
|
auto colTrans = ImVec4(0, 0, 0, 0);
|
|
auto colWhite = ImVec4(1, 1, 1, 1);
|
|
|
|
style.Colors[ImGuiCol_Border] = colTrans;
|
|
style.Colors[ImGuiCol_Button] = colTrans;
|
|
style.Colors[ImGuiCol_ButtonActive] = ImVec4(0.8f, 0.788f, 0.741f, 1);
|
|
style.Colors[ImGuiCol_ButtonHovered] = ImVec4(0.722f, 0.714f, 0.667f, 1);
|
|
style.Colors[ImGuiCol_CheckMark] = colBlack;
|
|
style.Colors[ImGuiCol_ChildBg] = colBg;
|
|
style.Colors[ImGuiCol_FrameBg] = colBg;
|
|
style.Colors[ImGuiCol_PopupBg] = colBg;
|
|
style.Colors[ImGuiCol_ResizeGrip] = colTrans;
|
|
style.Colors[ImGuiCol_ResizeGripActive] = colTrans;
|
|
style.Colors[ImGuiCol_ResizeGripHovered] = colTrans;
|
|
style.Colors[ImGuiCol_ScrollbarBg] = ImVec4(0.6f, 0.6f, 0.6f, 1);
|
|
style.Colors[ImGuiCol_ScrollbarGrab] = ImVec4(1, 0.6f, 0, 1);
|
|
style.Colors[ImGuiCol_ScrollbarGrabHovered] = ImVec4(1, 0.6f, 0, 1);
|
|
style.Colors[ImGuiCol_ScrollbarGrabActive] = ImVec4(1, 0.6f, 0, 1);
|
|
style.Colors[ImGuiCol_SeparatorActive] = colTrans;
|
|
style.Colors[ImGuiCol_SeparatorHovered] = colTrans;
|
|
style.Colors[ImGuiCol_SliderGrab] = colWhite;
|
|
style.Colors[ImGuiCol_Tab] = ImVec4(0.467f, 0.467f, 0.467f, 1);
|
|
style.Colors[ImGuiCol_TabActive] = ImVec4(0.6f, 0.6f, 0.6f, 1);
|
|
style.Colors[ImGuiCol_TabHovered] = ImVec4(0.667f, 0.667f, 0.667f, 1);
|
|
style.Colors[ImGuiCol_Text] = colBlack;
|
|
style.Colors[ImGuiCol_WindowBg] = colBg;
|
|
}
|
|
|
|
void Reddog::Window::EndStyle()
|
|
{
|
|
ImGui::PopFont();
|
|
g_font->Scale = g_defaultFontScale;
|
|
|
|
ImGui::GetStyle() = g_defaultStyle;
|
|
}
|
|
|
|
void Reddog::Window::CreateWindowGrips()
|
|
{
|
|
if (!ImWindow || !IsFocused)
|
|
return;
|
|
|
|
auto& io = ImGui::GetIO();
|
|
|
|
auto windowPos = ImWindow->Pos;
|
|
auto windowSize = ImWindow->Size;
|
|
|
|
constexpr float resizeMargin = 5.0f;
|
|
|
|
ImRect grips[6] =
|
|
{
|
|
// Corners
|
|
ImRect(windowPos.x, windowPos.y + windowSize.y - resizeMargin, windowPos.x + resizeMargin, windowPos.y + windowSize.y), // Bottom left
|
|
ImRect(windowPos.x + windowSize.x - resizeMargin, windowPos.y + windowSize.y - resizeMargin, windowPos.x + windowSize.x, windowPos.y + windowSize.y), // Bottom right
|
|
|
|
// Edges
|
|
ImRect(windowPos.x + resizeMargin, windowPos.y, windowPos.x + windowSize.x - resizeMargin, windowPos.y + resizeMargin), // Top
|
|
ImRect(windowPos.x + resizeMargin, windowPos.y + windowSize.y - resizeMargin, windowPos.x + windowSize.x - resizeMargin, windowPos.y + windowSize.y), // Bottom
|
|
ImRect(windowPos.x, windowPos.y + resizeMargin, windowPos.x + resizeMargin, windowPos.y + windowSize.y - resizeMargin), // Left
|
|
ImRect(windowPos.x + windowSize.x - resizeMargin, windowPos.y + resizeMargin, windowPos.x + windowSize.x, windowPos.y + windowSize.y - resizeMargin) // Right
|
|
};
|
|
|
|
auto hoveredGrip = -1;
|
|
|
|
for (int i = 0; i < IM_ARRAYSIZE(grips); i++)
|
|
{
|
|
auto& grip = grips[i];
|
|
|
|
if (ImGui::IsMouseHoveringRect(grip.Min, grip.Max))
|
|
hoveredGrip = i;
|
|
}
|
|
|
|
if (hoveredGrip < 0)
|
|
{
|
|
GameWindow::SetCursor(ECursorType::DebugDefault);
|
|
}
|
|
else
|
|
{
|
|
if (hoveredGrip == 0)
|
|
{
|
|
GameWindow::SetCursor(ECursorType::DebugRightDiagonal);
|
|
}
|
|
else if (hoveredGrip == 1)
|
|
{
|
|
GameWindow::SetCursor(ECursorType::DebugLeftDiagonal);
|
|
}
|
|
else if (hoveredGrip == 2 || hoveredGrip == 3)
|
|
{
|
|
GameWindow::SetCursor(ECursorType::DebugVertical);
|
|
}
|
|
else
|
|
{
|
|
GameWindow::SetCursor(ECursorType::DebugHorizontal);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Reddog::Window::DrawFrame()
|
|
{
|
|
if (!ImWindow)
|
|
return;
|
|
|
|
if ((Flags & eWindowFlags_NoResize) == 0)
|
|
CreateWindowGrips();
|
|
|
|
UpdateStyle();
|
|
|
|
auto drawList = ImGui::GetWindowDrawList();
|
|
auto windowPos = ImWindow->Pos;
|
|
auto windowSize = ImWindow->Size;
|
|
auto isFocused = ImGui::IsWindowFocused();
|
|
auto hasTitleBar = (Flags & eWindowFlags_NoTitleBar) == 0;
|
|
|
|
float titleBarHeight = hasTitleBar ? 20.0f : 0.0f;
|
|
|
|
ImVec2 windowMin = { windowPos.x, windowPos.y + titleBarHeight };
|
|
ImVec2 windowMax = { windowPos.x + windowSize.x, windowPos.y + windowSize.y };
|
|
|
|
drawList->AddRectFilled(windowMin, windowMax, isFocused ? ActiveColour : InactiveColour);
|
|
drawList->AddLine(windowMin, { windowMax.x, windowMin.y }, IM_COL32(170, 170, 170, 255)); // Outer top line.
|
|
drawList->AddLine({ windowMin.x + 1, windowMin.y + 1 }, { windowMin.x + 1, windowMax.y }, IM_COL32(153, 153, 153, 255)); // Outer left line.
|
|
drawList->AddLine({ windowMin.x, windowMax.y - 2 }, { windowMax.x, windowMax.y - 2 }, IM_COL32(51, 51, 51, 255)); // Outer bottom line.
|
|
drawList->AddLine({ windowMax.x - 2, windowMin.y + 1 }, { windowMax.x - 2, windowMax.y }, IM_COL32(85, 85, 85, 255)); // Outer right line.
|
|
drawList->AddLine({ windowMin.x + 2, windowMin.y + 1 }, { windowMax.x - 2, windowMin.y + 1 }, IM_COL32(51, 51, 51, 255)); // Inner top line.
|
|
drawList->AddLine({ windowMin.x + 2, windowMin.y + 2 }, { windowMin.x + 2, windowMax.y - 2 }, IM_COL32(85, 85, 85, 255)); // Inner left line.
|
|
drawList->AddLine({ windowMin.x + 3, windowMax.y - 3 }, { windowMax.x - 2, windowMax.y - 3 }, IM_COL32(170, 170, 170, 255)); // Inner bottom line.
|
|
drawList->AddLine({ windowMax.x - 3, windowMin.y + 2 }, { windowMax.x - 3, windowMax.y - 3 }, IM_COL32(153, 153, 153, 255)); // Inner right line.
|
|
|
|
// Close window if unfocused whilst unpinned (yes it works like this in SU preview).
|
|
if (!IsPinned && !isFocused && m_pIsVisible)
|
|
*m_pIsVisible = !*m_pIsVisible;
|
|
|
|
if (hasTitleBar)
|
|
{
|
|
auto height = titleBarHeight;
|
|
auto left = PIXELS_TO_UV_COORDS(32, 32, 0, 0, 3, 32);
|
|
auto centre = PIXELS_TO_UV_COORDS(32, 32, 3, 0, 26, 32);
|
|
auto right = PIXELS_TO_UV_COORDS(32, 32, 29, 0, 3, 32);
|
|
|
|
auto col = isFocused
|
|
? IM_COL32(245, 245, 245, 255)
|
|
: IM_COL32(246, 226, 202, 255);
|
|
|
|
drawList->AddImage(g_upTitleBar.get(), { windowPos.x, windowPos.y }, { windowPos.x + 3, windowPos.y + height }, GET_UV_COORDS(left), col);
|
|
drawList->AddImage(g_upTitleBar.get(), { windowPos.x + 3, windowPos.y }, { windowPos.x + windowSize.x - 3, windowPos.y + height }, GET_UV_COORDS(centre), col);
|
|
drawList->AddImage(g_upTitleBar.get(), { windowPos.x + windowSize.x - 3, windowPos.y }, { windowPos.x + windowSize.x, windowPos.y + height }, GET_UV_COORDS(right), col);
|
|
|
|
auto cmnSize = 16.0f;
|
|
|
|
ImVec2 cmnIconMin = { windowPos.x + 9, windowPos.y + 2 };
|
|
ImVec2 cmnIconMax = { cmnIconMin.x + cmnSize, cmnIconMin.y + cmnSize };
|
|
|
|
drawList->AddImage(g_upCommonIcon.get(), cmnIconMin, cmnIconMax, { 0, 0 }, { 1, 1 }, IM_COL32(255, 255, 255, 255));
|
|
drawList->AddText({ cmnIconMax.x + 5, windowPos.y + 4 }, IM_COL32(255, 255, 255, 255), Name);
|
|
|
|
ImVec2 closeButtonMin = { windowPos.x + windowSize.x - cmnSize - 4, windowPos.y + 3 };
|
|
ImVec2 closeButtonMax = { closeButtonMin.x + cmnSize, closeButtonMin.y + cmnSize };
|
|
|
|
ImGui::SetCursorScreenPos(closeButtonMin);
|
|
ImGui::InvisibleButton("##CloseButton", { cmnSize, cmnSize });
|
|
bool isCloseButtonActive = ImGui::IsItemActive();
|
|
|
|
if (isCloseButtonActive)
|
|
{
|
|
drawList->AddImage(g_upButtonClose2.get(), closeButtonMin, closeButtonMax);
|
|
m_isCloseButtonPressed = true;
|
|
}
|
|
else
|
|
{
|
|
drawList->AddImage(g_upButtonClose1.get(), closeButtonMin, closeButtonMax);
|
|
|
|
if (m_isCloseButtonPressed && m_pIsVisible)
|
|
{
|
|
*m_pIsVisible = !*m_pIsVisible;
|
|
m_isCloseButtonPressed = false;
|
|
}
|
|
}
|
|
|
|
ImVec2 minimumButtonMin = { closeButtonMin.x - cmnSize - 4, windowPos.y + 3 };
|
|
ImVec2 minimumButtonMax = { minimumButtonMin.x + cmnSize, minimumButtonMin.y + cmnSize };
|
|
|
|
ImGui::SetCursorScreenPos(minimumButtonMin);
|
|
ImGui::InvisibleButton("##MinimumButton", { cmnSize, cmnSize });
|
|
bool isMinimumButtonActive = ImGui::IsItemActive();
|
|
|
|
if (isMinimumButtonActive)
|
|
{
|
|
drawList->AddImage(g_upButtonMinimum2.get(), minimumButtonMin, minimumButtonMax);
|
|
m_isMinimumButtonPressed = true;
|
|
}
|
|
else
|
|
{
|
|
drawList->AddImage(g_upButtonMinimum1.get(), minimumButtonMin, minimumButtonMax);
|
|
|
|
if (m_isMinimumButtonPressed)
|
|
{
|
|
IsMinimum = !IsMinimum;
|
|
|
|
if (IsMinimum)
|
|
{
|
|
m_preMinimumWindowSize = windowSize;
|
|
ImGui::SetWindowSize(ImWindow, { windowSize.x, MIN_WINDOW_SIZE });
|
|
}
|
|
else
|
|
{
|
|
ImGui::SetWindowSize(ImWindow, { windowSize.x, m_preMinimumWindowSize.y });
|
|
}
|
|
|
|
m_isMinimumButtonPressed = false;
|
|
}
|
|
}
|
|
|
|
ImVec2 pinButtonMin = { minimumButtonMin.x - cmnSize - 4, windowPos.y + 3 };
|
|
ImVec2 pinButtonMax = { pinButtonMin.x + cmnSize, pinButtonMin.y + cmnSize };
|
|
|
|
ImGui::SetCursorScreenPos(pinButtonMin);
|
|
ImGui::InvisibleButton("##PinButton", { cmnSize, cmnSize });
|
|
bool isPinButtonActive = ImGui::IsItemActive();
|
|
|
|
if (isPinButtonActive)
|
|
{
|
|
drawList->AddImage(g_upButtonPin2.get(), pinButtonMin, pinButtonMax);
|
|
m_isPinButtonPressed = true;
|
|
}
|
|
else
|
|
{
|
|
drawList->AddImage(g_upButtonPin1.get(), pinButtonMin, pinButtonMax);
|
|
|
|
if (m_isPinButtonPressed)
|
|
{
|
|
IsPinned = !IsPinned;
|
|
m_isPinButtonPressed = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Reddog::Window::SetVisible(bool isVisible)
|
|
{
|
|
IsVisible = m_isSetVisible = isVisible;
|
|
}
|
|
|
|
bool Reddog::Window::Begin(bool* pIsVisible)
|
|
{
|
|
if (pIsVisible)
|
|
{
|
|
m_pIsVisible = pIsVisible;
|
|
}
|
|
else
|
|
{
|
|
m_pIsVisible = &IsVisible;
|
|
}
|
|
|
|
BeginStyle();
|
|
|
|
ImGui::SetNextWindowSizeConstraints({ m_minWidth, m_minHeight }, { m_maxWidth, m_maxHeight });
|
|
|
|
auto flags = REDDOG_IMGUI_FLAGS;
|
|
|
|
if ((Flags & eWindowFlags_NoResize) != 0)
|
|
flags |= ImGuiWindowFlags_NoResize;
|
|
|
|
bool result = ImGui::Begin(Name, m_pIsVisible, flags);
|
|
|
|
if (result && *m_pIsVisible)
|
|
{
|
|
ImWindow = ImGui::GetCurrentWindow();
|
|
IsFocused = ImGui::IsWindowFocused();
|
|
|
|
if (m_isSetVisible)
|
|
{
|
|
ImGui::SetWindowFocus();
|
|
m_isSetVisible = false;
|
|
}
|
|
|
|
DrawFrame();
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void Reddog::Window::End()
|
|
{
|
|
ImGui::End();
|
|
EndStyle();
|
|
}
|