277 lines
9.9 KiB
C++
277 lines
9.9 KiB
C++
#include <utility>
|
|
|
|
#include "SDL2/SDL_keycode.h"
|
|
#include "editor_scenes.hpp"
|
|
#include "../../sdlpp/sdlpp.hpp"
|
|
#include "../../sdlpp/sdlpp_mouse.hpp"
|
|
#include "../global_vars.hpp"
|
|
#include "../objectids.hpp"
|
|
#include "../editor_visitor.hpp"
|
|
#include "../filesystem.hpp"
|
|
#include "../sprites.hpp"
|
|
|
|
bool __update_scenes_load_dialog = false;
|
|
bool __quit_scenes_load_dialog = false;
|
|
bool __started_load_dialog = false;
|
|
bool __pop_at_finish_load_dialog = false;
|
|
uint64_t __cur_button_index_load_dialog = -1;
|
|
uint64_t __cur_button_index_load_dialog_down = -1;
|
|
std::vector<std::shared_ptr<Button>> __buttons_load_dialog{};
|
|
std::shared_ptr<SDLPP::RectangleRender> __mouse_load_dialog{};
|
|
|
|
std::function<void(const std::string &)> __load_dialog_finalizer;
|
|
std::string __selected_level_load_dialog = "";
|
|
|
|
void __quitLoadDialog() {
|
|
__quit_scenes_load_dialog = true;
|
|
}
|
|
void __updateSelectedButton_LoadDialog(uint64_t new_index) {
|
|
if (new_index != __cur_button_index_load_dialog &&
|
|
new_index != (uint64_t)-1) {
|
|
__buttons_load_dialog[new_index]->setHighlight();
|
|
|
|
if (__cur_button_index_load_dialog != (uint64_t)-1) {
|
|
__buttons_load_dialog[__cur_button_index_load_dialog]
|
|
->unsetHighlight();
|
|
}
|
|
__cur_button_index_load_dialog = new_index;
|
|
}
|
|
}
|
|
|
|
void __quitCallback_LoadDialog(void * /*UNUSED*/, Button *btn) {
|
|
__selected_level_load_dialog = btn->getText();
|
|
__quitLoadDialog();
|
|
}
|
|
|
|
void __moveButtons(double movement) {
|
|
for (auto &button : __buttons_load_dialog) {
|
|
button->setPos(button->getPos() + SDLPP::Vec2D<double>(0, movement));
|
|
}
|
|
__update_scenes_load_dialog = true;
|
|
}
|
|
|
|
void __selectUpperButton() {
|
|
if (__cur_button_index_load_dialog > 0) {
|
|
__updateSelectedButton_LoadDialog(__cur_button_index_load_dialog - 1);
|
|
if (__buttons_load_dialog[__cur_button_index_load_dialog]
|
|
->getPos()
|
|
.getY() < 0.49) {
|
|
__moveButtons(0.25);
|
|
}
|
|
}
|
|
}
|
|
|
|
void __selectLowerButton() {
|
|
if (__cur_button_index_load_dialog < __buttons_load_dialog.size() - 1) {
|
|
__updateSelectedButton_LoadDialog(__cur_button_index_load_dialog + 1);
|
|
auto pos =
|
|
__buttons_load_dialog[__cur_button_index_load_dialog]->getPos();
|
|
if (__buttons_load_dialog[__cur_button_index_load_dialog]
|
|
->getPos()
|
|
.getY() > 0.99) {
|
|
__moveButtons(-0.25);
|
|
}
|
|
}
|
|
}
|
|
|
|
void __handleKeyUp_LoadDialog(SDL_Keycode key, SDLPP::Scene & /*UNUSED*/) {
|
|
switch (key) {
|
|
case SDLK_ESCAPE:
|
|
__selected_level_load_dialog = "";
|
|
__quitLoadDialog();
|
|
break;
|
|
case SDLK_RETURN:
|
|
__buttons_load_dialog[__cur_button_index_load_dialog]
|
|
->performFunction();
|
|
break;
|
|
case SDLK_UP:
|
|
case SDLK_w:
|
|
__selectUpperButton();
|
|
break;
|
|
case SDLK_DOWN:
|
|
case SDLK_s:
|
|
__selectLowerButton();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void addLevelButton(const std::string &path, const std::string &file,
|
|
double &start_height, const int initial_path_len,
|
|
std::shared_ptr<SDLPP::Renderer> &renderer,
|
|
ButtonConfig &button_theme) {
|
|
if (FSLib::isDirectory(path + FSLib::dir_divisor + file)) {
|
|
for (const auto &file_rec :
|
|
FSLib::Directory(path + FSLib::dir_divisor + file)) {
|
|
addLevelButton(path + FSLib::dir_divisor + file, file_rec,
|
|
start_height, initial_path_len, renderer,
|
|
button_theme);
|
|
}
|
|
} else {
|
|
__buttons_load_dialog.emplace_back(std::make_shared<Button>(
|
|
0.3, start_height, 0.4, 0.2, renderer,
|
|
(path + FSLib::dir_divisor + file).substr(initial_path_len),
|
|
button_theme, __quitCallback_LoadDialog, nullptr));
|
|
__buttons_load_dialog.back()->setAlignment(SDLPP::OBJ_CENTER,
|
|
SDLPP::OBJ_CENTER);
|
|
__buttons_load_dialog.back()->setPermanent();
|
|
__buttons_load_dialog.back()->setButtonIndex(
|
|
__buttons_load_dialog.size() - 1);
|
|
start_height += 0.25;
|
|
}
|
|
}
|
|
|
|
std::shared_ptr<SDLPP::Scene>
|
|
createSceneLoadDialog(std::shared_ptr<SDLPP::Renderer> &renderer,
|
|
const std::string &path, bool transparent_bg) {
|
|
auto scene = std::make_shared<SDLPP::Scene>(renderer);
|
|
auto bg = std::make_shared<SDLPP::RectangleRender>(0, 0, 10, 10, renderer,
|
|
transparent_bg ? "#000000BB" : MARIO_OVERWORLD_COLORKEY, true);
|
|
bg->setPermanent();
|
|
bg->setId(1);
|
|
scene->addObject(bg);
|
|
__mouse_load_dialog =
|
|
std::make_shared<SDLPP::RectangleRender>(0.01, 0.01, 0, 0, renderer);
|
|
__mouse_load_dialog->setMinWidth(1);
|
|
__mouse_load_dialog->setMinHeight(1);
|
|
__mouse_load_dialog->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
|
|
__mouse_load_dialog->setId(EDITOR_MOUSE_ID);
|
|
__mouse_load_dialog->setColiderColor("#00FF00");
|
|
__mouse_load_dialog->addCollision(SDLPP::RectColider({ 0, 0 }, { 1, 1 }));
|
|
scene->addObject(__mouse_load_dialog);
|
|
|
|
ButtonConfig default_button_theme{};
|
|
default_button_theme.bg_color = "#FFFFFF88";
|
|
default_button_theme.bg_color_highlight = "#FFFFFFBB";
|
|
default_button_theme.bg_color_disabled = "#AAAAAA88";
|
|
default_button_theme.font_color = "#000000";
|
|
default_button_theme.font_color_highlight = "#000000";
|
|
default_button_theme.font_color_disabled = "#555555";
|
|
default_button_theme.font_outline_color = "#FFFFFF88";
|
|
default_button_theme.font_outline_color_highlight = "#FFFFFFAA";
|
|
default_button_theme.font_outline_color_disabled = "#787878";
|
|
default_button_theme.outline = 0.1;
|
|
// buttons
|
|
double start_height = 0.5;
|
|
for (const auto &file : FSLib::Directory(path)) {
|
|
addLevelButton(path, file, start_height, path.length() + 1, renderer,
|
|
default_button_theme);
|
|
}
|
|
for (auto &button : __buttons_load_dialog) {
|
|
scene->addObject(button);
|
|
}
|
|
auto font_config = std::make_shared<SDLPP::FontConfiguration>(
|
|
g_text_config->getFont(), "#000000", "#FFFFFFAA", 0.05);
|
|
auto dialog_text = std::make_shared<SDLPP::TextRenderer>(
|
|
0.1, 0.15, 0.8, 0.3, renderer, "LEVELS", font_config,
|
|
SDLPP_TEXT_CENTER);
|
|
dialog_text->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
|
|
dialog_text->setPermanent();
|
|
scene->addObject(dialog_text);
|
|
return scene;
|
|
}
|
|
|
|
void __resetGlobals_LoadDialog() {
|
|
__update_scenes_load_dialog = false;
|
|
__quit_scenes_load_dialog = false;
|
|
__started_load_dialog = false;
|
|
__pop_at_finish_load_dialog = false;
|
|
__cur_button_index_load_dialog = -1;
|
|
__cur_button_index_load_dialog_down = -1;
|
|
__buttons_load_dialog.clear();
|
|
__mouse_load_dialog.reset();
|
|
__selected_level_load_dialog = "";
|
|
}
|
|
|
|
void __additionalRender_LoadDialog(std::shared_ptr<SDLPP::Scene> & /*UNUSED*/) {
|
|
if (__update_scenes_load_dialog) {
|
|
for (auto &_scene : game_scenes) {
|
|
_scene.scene->updateSizeAndPosition();
|
|
}
|
|
if (__started_load_dialog) {
|
|
__update_scenes_load_dialog = false;
|
|
} else {
|
|
__started_load_dialog = true;
|
|
}
|
|
}
|
|
if (__quit_scenes_load_dialog) {
|
|
__load_dialog_finalizer(__selected_level_load_dialog);
|
|
if(__pop_at_finish_load_dialog) {
|
|
game_scenes.pop_back();
|
|
}
|
|
__resetGlobals_LoadDialog();
|
|
}
|
|
}
|
|
|
|
void __getMousePositionFlags_LoadDialog(SDLPP::Scene &scene) {
|
|
auto mouse = scene.getObjects({ EDITOR_MOUSE_ID })[0];
|
|
// move mouse colider to mouse position
|
|
mouse->setPos(SDLPP::Mouse::getMousePositionDouble(
|
|
scene.getRenderer(), SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER));
|
|
|
|
MouseVisitor visitor;
|
|
scene.visitCollisions(*mouse, visitor);
|
|
__updateSelectedButton_LoadDialog(visitor.getCurButton());
|
|
//__cur_button_index_load_dialog = visitor.getCurButton();
|
|
}
|
|
|
|
void __pollEvents_LoadDialog(std::shared_ptr<SDLPP::Scene> &scene) {
|
|
SDL_Event event;
|
|
while (SDLPP::getSDLEvent(event)) {
|
|
switch (event.type) {
|
|
case SDL_QUIT:
|
|
__quitLoadDialog();
|
|
break;
|
|
case SDL_KEYUP:
|
|
__handleKeyUp_LoadDialog(event.key.keysym.sym, *scene);
|
|
break;
|
|
case SDL_WINDOWEVENT:
|
|
if (event.window.event == SDL_WINDOWEVENT_RESIZED) {
|
|
__update_scenes_load_dialog = true;
|
|
}
|
|
break;
|
|
case SDL_MOUSEMOTION:
|
|
__getMousePositionFlags_LoadDialog(*scene);
|
|
break;
|
|
case SDL_MOUSEBUTTONUP:
|
|
if (__cur_button_index_load_dialog_down ==
|
|
__cur_button_index_load_dialog &&
|
|
__cur_button_index_load_dialog != (uint64_t)-1) {
|
|
__buttons_load_dialog[__cur_button_index_load_dialog]
|
|
->performFunction();
|
|
}
|
|
break;
|
|
case SDL_MOUSEBUTTONDOWN:
|
|
// store current mouse flags in previous mouse flags
|
|
__cur_button_index_load_dialog_down =
|
|
__cur_button_index_load_dialog;
|
|
break;
|
|
case SDL_MOUSEWHEEL:
|
|
if (event.wheel.y > 0) {
|
|
__moveButtons(-0.02);
|
|
} else if (event.wheel.y < 0) {
|
|
__moveButtons(0.02);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
SceneStruct
|
|
createLoadScene(std::shared_ptr<SDLPP::Renderer> renderer,
|
|
const std::string &path,
|
|
std::function<void(const std::string &)> finalizer,
|
|
bool pop_at_finish, bool transparent_bg) {
|
|
__load_dialog_finalizer = std::move(finalizer);
|
|
__pop_at_finish_load_dialog = pop_at_finish;
|
|
SceneStruct ret{};
|
|
ret.scene = createSceneLoadDialog(renderer, path, transparent_bg);
|
|
ret.additionalRender = __additionalRender_LoadDialog;
|
|
ret.doInput = __pollEvents_LoadDialog;
|
|
__update_scenes_load_dialog = true;
|
|
__updateSelectedButton_LoadDialog(0);
|
|
return ret;
|
|
} |