main.cpp

#include <windows.h>
#include "imgui.h"
#include "imgui_impl_dx9.h"
#include "imgui_impl_win32.h"
#include <d3d9.h>
#include "MemoryReader.h"
#include "OverlayGUI.h"
#include "GamePaused.h"
#include <memory>
#include "InputController.h"
#include <filesystem>
#include "resource.h"
#include "OverlayInitException.h"
#include <future>

using namespace std;

static LPDIRECT3D9              g_pD3D = nullptr;
static LPDIRECT3DDEVICE9        g_pd3dDevice = nullptr;
static D3DPRESENT_PARAMETERS    g_d3dpp = {};

bool CreateDeviceD3D(HWND hWnd);
void CleanupDeviceD3D();
void ResetDevice();

LRESULT WINAPI WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);

int main()
{
	// Create application window
	WNDCLASSEX wc = {sizeof(wc),CS_CLASSDC,WndProc,0L,0L,GetModuleHandle(nullptr),nullptr,nullptr,nullptr,nullptr,TEXT("HoMM3 Unit Helper")};
	wc.hIcon=LoadIcon(wc.hInstance, MAKEINTRESOURCE(IDI_ICON1));
	::RegisterClassEx(&wc);
	HWND appWindow = ::CreateWindow(wc.lpszClassName, wc.lpszClassName, WS_OVERLAPPEDWINDOW, 100, 100, 640, 340, nullptr, nullptr, wc.hInstance, nullptr);

	// Initialize Direct3D
	if (!CreateDeviceD3D(appWindow))
	{
		CleanupDeviceD3D();
		::UnregisterClass(wc.lpszClassName, wc.hInstance);
		return 1;
	}
	::ShowWindow(appWindow, SW_SHOWDEFAULT);
	::UpdateWindow(appWindow);

	// Setup Dear ImGui context
	ImGuiContext* mainContext=ImGui::CreateContext();
	ImGuiIO& io = ImGui::GetIO(); (void)io;
	io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;           // Enable Docking
	io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;         // Enable Multi-Viewport / Platform Windows
	io.ConfigViewportsNoTaskBarIcon = true;
	io.IniFilename = nullptr;

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

	// When viewports are enabled we tweak WindowRounding/WindowBg so platform windows can look identical to regular ones.
	ImGuiStyle& style = ImGui::GetStyle();
	if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
	{
		style.WindowRounding = 0.0f;
		style.Colors[ImGuiCol_WindowBg].w = 1.0f;
	}
	
	// Setup Platform/Renderer backends
	ImGui_ImplWin32_Init(appWindow);
	ImGui_ImplDX9_Init(g_pd3dDevice);

	// Our variables
	MemoryReader mr = MemoryReader();
	OverlayGUI overlay=OverlayGUI(mr);
	InputController inputController=InputController(mr,overlay);
	bool initOverlay = false;
	DWORD lastError = 0;
	const ImVec4 errColor = ImVec4(0.89f,0.259f,0.204f,1);
	const ImVec4 okColor = ImVec4(0.196f,0.8f,0.196f,1);
	ImGuiWindowFlags mainWindowFlags = ImGuiWindowFlags_NoTitleBar|ImGuiWindowFlags_MenuBar|ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoSavedSettings|ImGuiWindowFlags_NoMove;

	std::future<void> clickTask;
	// Main loop
	bool done = false;
	while (!done)
	{
		// Poll and handle messages (inputs, window resize, etc.)
		MSG msg;
		while (::PeekMessage(&msg, nullptr, 0U, 0U, PM_REMOVE))
		{
			::TranslateMessage(&msg);
			::DispatchMessage(&msg);
			if (msg.message == WM_QUIT)
				done = true;
			else if(msg.message == MH_PROCESS_CLICK)
			{
				clickTask=std::async(std::launch::async,[&inputController](){
					inputController.processClick();
				});
			}
		}
		if (done)
			break;

		// Start the Dear ImGui frame
		ImGui_ImplDX9_NewFrame();
		ImGui_ImplWin32_NewFrame();
		ImGui::NewFrame();

		// Fullscreen ImGui main window in a host window
		ImGui::SetNextWindowPos(ImGui::GetMainViewport()->WorkPos, ImGuiCond_Always);
		ImGui::SetNextWindowSize(ImGui::GetMainViewport()->WorkSize,ImGuiCond_Always);
		ImGui::Begin("Menu",nullptr,mainWindowFlags);
		if (ImGui::BeginMenuBar())
		{
			if (ImGui::BeginMenu("Options"))
			{
				//ImGui::Checkbox("Auto-attach on start",&autoAttach);
				ImGui::SliderFloat("Opacity",&overlay.getStyle().opacity,0.0f,1.0f);
				ImGui::EndMenu();
			}
			ImGui::EndMenuBar();
		}
		if (!initOverlay)
			ImGui::TextColored(errColor, "Not attached");
		else
		{
			ImGui::TextColored(okColor, "Succesfully attached");
			if (!mr.isGameStillRunning())
			{
				inputController.destroyLogic();
				initOverlay = false;
			}
		}
		if (ImGui::Button("Attach"))
		{
			try
			{
				if (initOverlay = inputController.setupLogic())
					lastError = 0;
				else
					lastError = GetLastError();
			}catch(OverlayInitException& e){
				lastError=e.getErrorCode();
			}
		}
		switch (lastError)
		{
		// No error, do nothing
		case 0:
			break;
		case ERROR_ACCESS_DENIED:
			ImGui::TextColored(errColor, "Attach failed: No privileges to attach.");
			ImGui::TextColored(errColor, "Restart game and launcher as regular user or run the helper as administrator.");
			break;
		case ERROR_NO_MORE_FILES:
			ImGui::TextColored(errColor, "Attach failed: Game process not found.");
			break;
		case ERROR_OVERLAY_INIT:
			ImGui::TextColored(errColor, "Overlay initialize failed: Game window not found.");
			break;
		case ERROR_OVERLAY_MOUSE_HOOK_INIT:
			ImGui::TextColored(errColor, "Overlay initialize failed: Can't setup mouse hook.");
			break;
		case ERROR_UNIT_DATA_FILE_NOT_FOUND:
			ImGui::TextColored(errColor, "Overlay initialize failed: Data file not found.");
			break;
		case ERROR_OVERLAY_ALREADY_INIT:
			ImGui::TextColored(errColor, "Overlay already initialized.");
			break;
		default:
			ImGui::TextColored(errColor, "Attach failed: Error: %i", lastError);
			break;
		}
		ImGui::End();
		if (initOverlay)
		{
			// Draw overlay only when the game window is focused
			if(mr.checkIsGameOnForeground())
			{
				if(mr.pollGamePause())
					overlay.setState(new GamePaused());
					if(clickTask.valid())
						clickTask.get();
				overlay.drawOverlay();
			}
		}

		// Rendering
		ImGui::EndFrame();
		g_pd3dDevice->SetRenderState(D3DRS_ZENABLE, FALSE);
		g_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
		g_pd3dDevice->SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE);
		D3DCOLOR clear_col_dx = D3DCOLOR_RGBA(0,0,0,255);
		g_pd3dDevice->Clear(0, nullptr, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, clear_col_dx, 1.0f, 0);
		if (g_pd3dDevice->BeginScene() >= 0)
		{
			ImGui::Render();
			ImGui_ImplDX9_RenderDrawData(ImGui::GetDrawData());
			g_pd3dDevice->EndScene();
		}

		// Update and Render additional Platform Windows
		if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
		{
			ImGui::UpdatePlatformWindows();
			ImGui::RenderPlatformWindowsDefault();
		}
		// Update changes to windows and styles
		if(initOverlay&&mr.isGameFocused())
		{
			overlay.updateChanges();
		}

		HRESULT result = g_pd3dDevice->Present(nullptr, nullptr, nullptr, nullptr);

		// Handle loss of D3D9 device
		if (result == D3DERR_DEVICELOST && g_pd3dDevice->TestCooperativeLevel() == D3DERR_DEVICENOTRESET)
			ResetDevice();
	}

	// Exit from GUI
	ImGui_ImplDX9_Shutdown();
	ImGui_ImplWin32_Shutdown();
	ImGui::DestroyContext();
	CleanupDeviceD3D();
	::DestroyWindow(appWindow);
	::UnregisterClass(wc.lpszClassName, wc.hInstance);
	return 0;
}

bool CreateDeviceD3D(HWND hWnd)
{
	if ((g_pD3D = Direct3DCreate9(D3D_SDK_VERSION)) == nullptr)
		return false;
	// Create the D3DDevice
	ZeroMemory(&g_d3dpp, sizeof(g_d3dpp));
	g_d3dpp.Windowed = TRUE;
	g_d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
	g_d3dpp.hDeviceWindow = hWnd;
	g_d3dpp.BackBufferFormat = D3DFMT_A8R8G8B8;// Need to use an explicit format with alpha if needing per-pixel alpha composition.
	g_d3dpp.EnableAutoDepthStencil = TRUE;
	g_d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
	g_d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_ONE;// Present with vsync
	if (g_pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, D3DCREATE_HARDWARE_VERTEXPROCESSING, &g_d3dpp, &g_pd3dDevice) < 0)
		return false;
	return true;
}

void CleanupDeviceD3D()
{
	if (g_pd3dDevice) { g_pd3dDevice->Release(); g_pd3dDevice = nullptr; }
	if (g_pD3D) { g_pD3D->Release(); g_pD3D = nullptr; }
}

void ResetDevice()
{
	ImGui_ImplDX9_InvalidateDeviceObjects();
	HRESULT hr = g_pd3dDevice->Reset(&g_d3dpp);
	if (hr == D3DERR_INVALIDCALL)
		IM_ASSERT(0);
	ImGui_ImplDX9_CreateDeviceObjects();
}

#ifndef WM_DPICHANGED
#define WM_DPICHANGED 0x02E0 // From Windows SDK 8.1+ headers
#endif

// Forward declare message handler from imgui_impl_win32.cpp
extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);

LRESULT WINAPI WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	if (ImGui_ImplWin32_WndProcHandler(hWnd, msg, wParam, lParam))
		return true;

	switch (msg)
	{
	case WM_SIZE:
		if (g_pd3dDevice != NULL && wParam != SIZE_MINIMIZED)
		{
			g_d3dpp.BackBufferWidth = LOWORD(lParam);
			g_d3dpp.BackBufferHeight = HIWORD(lParam);
			ResetDevice();
		}
		return 0;
	case WM_SYSCOMMAND:
		if ((wParam & 0xfff0) == SC_KEYMENU) // Disable ALT application menu
			return 0;
		break;
	case WM_DESTROY:
		::PostQuitMessage(0);
		return 0;
	case WM_DPICHANGED:
		if (ImGui::GetIO().ConfigFlags & ImGuiConfigFlags_DpiEnableScaleViewports)
		{
			const RECT* suggested_rect = (RECT*)lParam;
			::SetWindowPos(hWnd, nullptr, suggested_rect->left, suggested_rect->top, suggested_rect->right - suggested_rect->left, suggested_rect->bottom - suggested_rect->top, SWP_NOZORDER | SWP_NOACTIVATE);
		}
		break;
	}
	return ::DefWindowProc(hWnd, msg, wParam, lParam);
}