454 lines
14 KiB
C++
454 lines
14 KiB
C++
// MassBuilderSaveTool
|
|
// Copyright (C) 2021-2022 Guillaume Jacquemin
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program 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 <https://www.gnu.org/licenses/>.
|
|
|
|
#include "SaveTool.h"
|
|
|
|
#include <Corrade/Containers/ScopeGuard.h>
|
|
#include <Corrade/Utility/Unicode.h>
|
|
|
|
#include <Magnum/GL/DebugOutput.h>
|
|
#include <Magnum/GL/DefaultFramebuffer.h>
|
|
#include <Magnum/GL/Extensions.h>
|
|
#include <Magnum/GL/Renderer.h>
|
|
|
|
#include <Magnum/ImGuiIntegration/Integration.h>
|
|
#include <Magnum/ImGuiIntegration/Context.hpp>
|
|
|
|
#include <curl/curl.h>
|
|
|
|
#include <shellapi.h>
|
|
#include <wtsapi32.h>
|
|
|
|
#include "../FontAwesome/IconsFontAwesome5.h"
|
|
|
|
using namespace Containers::Literals;
|
|
|
|
extern const ImVec2 center_pivot = {0.5f, 0.5f};
|
|
|
|
#ifdef SAVETOOL_DEBUG_BUILD
|
|
Utility::Tweakable tweak;
|
|
#endif
|
|
|
|
SaveTool::SaveTool(const Arguments& arguments):
|
|
Platform::Sdl2Application{arguments,
|
|
Configuration{}.setTitle("M.A.S.S. Builder Save Tool " SAVETOOL_VERSION " (\"" SAVETOOL_CODENAME "\")")
|
|
.setSize({960, 720})}
|
|
{
|
|
#ifdef SAVETOOL_DEBUG_BUILD
|
|
tweak.enable(""_s, "../../"_s);
|
|
#endif
|
|
|
|
GL::Renderer::enable(GL::Renderer::Feature::Blending);
|
|
GL::Renderer::enable(GL::Renderer::Feature::ScissorTest);
|
|
GL::Renderer::disable(GL::Renderer::Feature::FaceCulling);
|
|
GL::Renderer::disable(GL::Renderer::Feature::DepthTest);
|
|
GL::Renderer::setBlendFunction(GL::Renderer::BlendFunction::SourceAlpha,
|
|
GL::Renderer::BlendFunction::OneMinusSourceAlpha);
|
|
GL::Renderer::setBlendEquation(GL::Renderer::BlendEquation::Add,
|
|
GL::Renderer::BlendEquation::Add);
|
|
|
|
Utility::Debug{} << "Renderer initialisation successful.";
|
|
|
|
Utility::Debug{} << "===Configuring SDL2===";
|
|
|
|
{
|
|
Utility::Debug d{};
|
|
d << "Enabling clickthrough...";
|
|
|
|
if(SDL_VERSION_ATLEAST(2, 0, 5)) {
|
|
if(SDL_SetHintWithPriority(SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH, "1", SDL_HINT_OVERRIDE) == SDL_TRUE) {
|
|
d << "success!"_s;
|
|
} else {
|
|
d << "error: hint couldn't be set."_s;
|
|
}
|
|
} else {
|
|
d << "error: SDL2 is too old (version < 2.0.5)."_s;
|
|
}
|
|
}
|
|
|
|
if((_initEventId = SDL_RegisterEvents(3)) == UnsignedInt(-1)) {
|
|
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Error",
|
|
"SDL_RegisterEvents() failed in SaveTool::SaveTool(). Exiting...", window());
|
|
exit(EXIT_FAILURE);
|
|
return;
|
|
}
|
|
|
|
_updateEventId = _initEventId + 1;
|
|
_fileEventId = _initEventId + 2;
|
|
|
|
if(SDL_InitSubSystem(SDL_INIT_TIMER) != 0) {
|
|
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Error initialising the app", SDL_GetError(), window());
|
|
exit(EXIT_FAILURE);
|
|
return;
|
|
}
|
|
|
|
Utility::Debug{} << "SDL2 configuration successful.";
|
|
|
|
Utility::Debug{} << "===Initialising the Save Tool===";
|
|
|
|
initialiseGui();
|
|
|
|
if(!initialiseToolDirectories()) {
|
|
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Error initialising the app", _lastError.data(), window());
|
|
exit(EXIT_FAILURE);
|
|
return;
|
|
}
|
|
|
|
if(!findGameDataDirectory()) {
|
|
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Error initialising the app", _lastError.data(), window());
|
|
exit(EXIT_FAILURE);
|
|
return;
|
|
}
|
|
|
|
checkGameState();
|
|
_gameCheckTimerId = SDL_AddTimer(2000,
|
|
[](UnsignedInt interval, void* param)->UnsignedInt{
|
|
static_cast<SaveTool*>(param)->checkGameState();
|
|
return interval;
|
|
}, this);
|
|
if(_gameCheckTimerId == 0) {
|
|
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Error", SDL_GetError(), window());
|
|
exit(EXIT_FAILURE);
|
|
return;
|
|
}
|
|
|
|
initialiseConfiguration();
|
|
|
|
switch(_framelimit) {
|
|
case Framelimit::Vsync:
|
|
setSwapInterval(1);
|
|
break;
|
|
case Framelimit::HalfVsync:
|
|
setSwapInterval(2);
|
|
break;
|
|
case Framelimit::FpsCap:
|
|
setSwapInterval(0);
|
|
setMinimalLoopPeriod(1000/_fpsCap);
|
|
break;
|
|
}
|
|
|
|
curl_global_init(CURL_GLOBAL_DEFAULT);
|
|
if(_checkUpdatesOnStartup) {
|
|
_queue.addToast(Toast::Type::Default, "Checking for updates..."_s);
|
|
_updateThread = std::thread{[this]{ checkForUpdates(); }};
|
|
}
|
|
|
|
if(GL::Context::current().isExtensionSupported<GL::Extensions::KHR::debug>() &&
|
|
GL::Context::current().detectedDriver() == GL::Context::DetectedDriver::NVidia)
|
|
{
|
|
GL::DebugOutput::setEnabled(GL::DebugOutput::Source::Api, GL::DebugOutput::Type::Other, {131185}, false);
|
|
}
|
|
|
|
Utility::Debug{} << "Initialisation successful.";
|
|
Utility::Debug{} << "===Running main loop===";
|
|
|
|
if(_skipDisclaimer) {
|
|
_uiState = UiState::Initialising;
|
|
_initThread = std::thread{[this]{ initialiseManager(); }};
|
|
}
|
|
}
|
|
|
|
SaveTool::~SaveTool() {
|
|
Utility::Debug{} << "===Perfoming cleanup===";
|
|
|
|
Utility::Debug{} << "Shutting libcurl down...";
|
|
curl_global_cleanup();
|
|
|
|
SDL_RemoveTimer(_gameCheckTimerId);
|
|
|
|
Utility::Debug{} << "Saving the configuration...";
|
|
|
|
_conf.setValue("cheat_mode"_s, _cheatMode);
|
|
_conf.setValue("unsafe_mode"_s, _unsafeMode);
|
|
_conf.setValue("startup_update_check"_s, _checkUpdatesOnStartup);
|
|
_conf.setValue("skip_disclaimer"_s, _skipDisclaimer);
|
|
|
|
switch(_framelimit) {
|
|
case Framelimit::Vsync:
|
|
_conf.setValue("frame_limit"_s, "vsync"_s);
|
|
break;
|
|
case Framelimit::HalfVsync:
|
|
_conf.setValue("frame_limit"_s, "half_vsync"_s);
|
|
break;
|
|
case Framelimit::FpsCap:
|
|
_conf.setValue<UnsignedInt>("frame_limit"_s, _fpsCap);
|
|
break;
|
|
}
|
|
|
|
_conf.save();
|
|
|
|
Utility::Debug{} << "Exiting...";
|
|
}
|
|
|
|
void SaveTool::drawEvent() {
|
|
#ifdef SAVETOOL_DEBUG_BUILD
|
|
tweak.update();
|
|
#endif
|
|
|
|
GL::defaultFramebuffer.clear(GL::FramebufferClear::Color);
|
|
|
|
drawImGui();
|
|
|
|
swapBuffers();
|
|
redraw();
|
|
}
|
|
|
|
void SaveTool::viewportEvent(ViewportEvent& event) {
|
|
GL::defaultFramebuffer.setViewport({{}, event.framebufferSize()});
|
|
|
|
_imgui.relayout(event.windowSize());
|
|
}
|
|
|
|
void SaveTool::keyPressEvent(KeyEvent& event) {
|
|
if(_imgui.handleKeyPressEvent(event)) return;
|
|
}
|
|
|
|
void SaveTool::keyReleaseEvent(KeyEvent& event) {
|
|
if(_imgui.handleKeyReleaseEvent(event)) return;
|
|
}
|
|
|
|
void SaveTool::mousePressEvent(MouseEvent& event) {
|
|
if(_imgui.handleMousePressEvent(event)) return;
|
|
}
|
|
|
|
void SaveTool::mouseReleaseEvent(MouseEvent& event) {
|
|
if(_imgui.handleMouseReleaseEvent(event)) return;
|
|
}
|
|
|
|
void SaveTool::mouseMoveEvent(MouseMoveEvent& event) {
|
|
if(_imgui.handleMouseMoveEvent(event)) return;
|
|
}
|
|
|
|
void SaveTool::mouseScrollEvent(MouseScrollEvent& event) {
|
|
if(_imgui.handleMouseScrollEvent(event)) {
|
|
event.setAccepted();
|
|
return;
|
|
}
|
|
}
|
|
|
|
void SaveTool::textInputEvent(TextInputEvent& event) {
|
|
if(_imgui.handleTextInputEvent(event)) return;
|
|
}
|
|
|
|
void SaveTool::anyEvent(SDL_Event& event) {
|
|
if(event.type == _initEventId) {
|
|
initEvent(event);
|
|
}
|
|
else if(event.type == _updateEventId) {
|
|
updateCheckEvent(event);
|
|
}
|
|
else if(event.type == _fileEventId) {
|
|
fileUpdateEvent(event);
|
|
}
|
|
}
|
|
|
|
void SaveTool::drawImGui() {
|
|
_imgui.newFrame();
|
|
|
|
if(ImGui::GetIO().WantTextInput && !isTextInputActive()) {
|
|
startTextInput();
|
|
}
|
|
else if(!ImGui::GetIO().WantTextInput && isTextInputActive()) {
|
|
stopTextInput();
|
|
}
|
|
|
|
drawGui();
|
|
|
|
_imgui.updateApplicationCursor(*this);
|
|
|
|
_imgui.drawFrame();
|
|
}
|
|
|
|
void SaveTool::drawGui() {
|
|
drawMainMenu();
|
|
|
|
switch(_uiState) {
|
|
case UiState::Disclaimer:
|
|
drawDisclaimer();
|
|
break;
|
|
case UiState::Initialising:
|
|
drawInitialisation();
|
|
break;
|
|
case UiState::ProfileManager:
|
|
drawProfileManager();
|
|
break;
|
|
case UiState::MainManager:
|
|
drawManager();
|
|
break;
|
|
case UiState::MassViewer:
|
|
drawMassViewer();
|
|
break;
|
|
}
|
|
|
|
if(_aboutPopup) {
|
|
drawAbout();
|
|
}
|
|
|
|
#ifdef SAVETOOL_DEBUG_BUILD
|
|
if(_demoWindow) {
|
|
ImGui::ShowDemoWindow(&_demoWindow);
|
|
}
|
|
|
|
if(_styleEditor) {
|
|
ImGui::ShowStyleEditor(&ImGui::GetStyle());
|
|
}
|
|
|
|
if(_metricsWindow) {
|
|
ImGui::ShowMetricsWindow(&_metricsWindow);
|
|
}
|
|
#endif
|
|
|
|
_queue.draw(windowSize());
|
|
}
|
|
|
|
void SaveTool::drawDisclaimer() {
|
|
ImGui::SetNextWindowPos(ImVec2{Vector2{windowSize() / 2.0f}}, ImGuiCond_Always, center_pivot);
|
|
|
|
if(ImGui::Begin("Disclaimer##DisclaimerWindow", nullptr,
|
|
ImGuiWindowFlags_NoCollapse|ImGuiWindowFlags_NoMove|ImGuiWindowFlags_NoBringToFrontOnFocus|
|
|
ImGuiWindowFlags_NoResize|ImGuiWindowFlags_NoTitleBar|ImGuiWindowFlags_MenuBar))
|
|
{
|
|
if(ImGui::BeginMenuBar()) {
|
|
ImGui::TextUnformatted("Disclaimer");
|
|
ImGui::EndMenuBar();
|
|
}
|
|
|
|
ImGui::TextUnformatted("Before you start using the app, there are a few things you should know:");
|
|
|
|
ImGui::PushTextWrapPos(windowSize().x() * 0.67f);
|
|
|
|
ImGui::Bullet();
|
|
ImGui::SameLine();
|
|
ImGui::TextUnformatted("For this application to work properly, it is recommended to disable Steam Cloud syncing for the game. To disable it, right-click the game in your Steam library, click \"Properties\", go to the \"General\" tab, and uncheck \"Keep game saves in the Steam Cloud for M.A.S.S. Builder\".");
|
|
|
|
ImGui::Bullet();
|
|
ImGui::SameLine();
|
|
ImGui::TextUnformatted("The developer of this application (Guillaume Jacquemin) isn't associated with Vermillion Digital, and both parties cannot be held responsible for data loss or corruption this app might cause. PLEASE USE AT YOUR OWN RISK!");
|
|
|
|
ImGui::Bullet();
|
|
ImGui::SameLine();
|
|
ImGui::TextUnformatted("This application is released under the terms of the GNU General Public Licence version 3. Please see the COPYING file for more details, or the About screen if you somehow didn't get that file with your download of the program.");
|
|
|
|
ImGui::Bullet();
|
|
ImGui::SameLine();
|
|
ImGui::TextUnformatted("This version of the application was tested on M.A.S.S. Builder early access version " SUPPORTED_GAME_VERSION ". It may or may not work with other versions of the game.");
|
|
|
|
ImGui::PopTextWrapPos();
|
|
|
|
if(ImGui::BeginTable("##DisclaimerLayoutTable", 3)) {
|
|
ImGui::TableSetupColumn("##Empty1", ImGuiTableColumnFlags_WidthStretch);
|
|
ImGui::TableSetupColumn("##Button", ImGuiTableColumnFlags_WidthFixed);
|
|
ImGui::TableSetupColumn("##Empty2", ImGuiTableColumnFlags_WidthStretch);
|
|
|
|
ImGui::TableNextRow();
|
|
ImGui::TableSetColumnIndex(0);
|
|
ImGui::Dummy({0.0f, 5.0f});
|
|
ImGui::Dummy({4.0f, 0.0f});
|
|
ImGui::SameLine();
|
|
ImGui::Checkbox("Don't show next time", &_skipDisclaimer);
|
|
ImGui::TableSetColumnIndex(1);
|
|
ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, {24.0f, 12.0f});
|
|
if(ImGui::Button("I understand the risks")) {
|
|
_uiState = UiState::Initialising;
|
|
_initThread = std::thread{[this]{ initialiseManager(); }};
|
|
}
|
|
ImGui::PopStyleVar();
|
|
|
|
ImGui::EndTable();
|
|
}
|
|
}
|
|
ImGui::End();
|
|
}
|
|
|
|
void SaveTool::drawInitialisation() {
|
|
ImGui::SetNextWindowPos(ImVec2{Vector2{windowSize() / 2.0f}}, ImGuiCond_Always, center_pivot);
|
|
|
|
if(ImGui::BeginPopupModal("##InitPopup", nullptr,
|
|
ImGuiWindowFlags_AlwaysAutoResize|ImGuiWindowFlags_NoTitleBar))
|
|
{
|
|
ImGui::TextUnformatted("Initialising the manager. Please wait...");
|
|
ImGui::EndPopup();
|
|
}
|
|
|
|
ImGui::OpenPopup("##InitPopup");
|
|
}
|
|
|
|
void SaveTool::drawGameState() {
|
|
ImGui::TextUnformatted("Game state:");
|
|
ImGui::SameLine();
|
|
{
|
|
switch(_gameState) {
|
|
case GameState::Unknown:
|
|
ImGui::TextColored(ImColor{0xff00a5ff}, ICON_FA_CIRCLE);
|
|
drawTooltip("unknown");
|
|
break;
|
|
case GameState::NotRunning:
|
|
ImGui::TextColored(ImColor{0xff32cd32}, ICON_FA_CIRCLE);
|
|
drawTooltip("not running");
|
|
break;
|
|
case GameState::Running:
|
|
ImGui::TextColored(ImColor{0xff0000ff}, ICON_FA_CIRCLE);
|
|
drawTooltip("running");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void SaveTool::drawHelpMarker(Containers::StringView text, Float wrap_pos) {
|
|
ImGui::TextUnformatted(ICON_FA_QUESTION_CIRCLE);
|
|
drawTooltip(text, wrap_pos);
|
|
}
|
|
|
|
void SaveTool::drawTooltip(Containers::StringView text, Float wrap_pos) {
|
|
if(ImGui::IsItemHovered()){
|
|
ImGui::BeginTooltip();
|
|
if(wrap_pos > 0.0f) {
|
|
ImGui::PushTextWrapPos(wrap_pos);
|
|
}
|
|
ImGui::TextUnformatted(text.data());
|
|
if(wrap_pos > 0.0f) {
|
|
ImGui::PopTextWrapPos();
|
|
}
|
|
ImGui::EndTooltip();
|
|
}
|
|
}
|
|
|
|
void SaveTool::openUri(Containers::StringView uri) {
|
|
ShellExecuteW(nullptr, nullptr, Utility::Unicode::widen(uri.data()), nullptr, nullptr, SW_SHOWDEFAULT);
|
|
}
|
|
|
|
void SaveTool::checkGameState() {
|
|
WTS_PROCESS_INFOW* process_infos = nullptr;
|
|
unsigned long process_count = 0;
|
|
|
|
if(WTSEnumerateProcessesW(WTS_CURRENT_SERVER_HANDLE, 0, 1, &process_infos, &process_count)) {
|
|
Containers::ScopeGuard guard{process_infos, WTSFreeMemory};
|
|
|
|
for(unsigned long i = 0; i < process_count; ++i) {
|
|
if(std::wcscmp(process_infos[i].pProcessName, L"MASS_Builder-Win64-Shipping.exe") == 0) {
|
|
_gameState = GameState::Running;
|
|
break;
|
|
}
|
|
else {
|
|
_gameState = GameState::NotRunning;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
_gameState = GameState::Unknown;
|
|
}
|
|
}
|