zv0n/game
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Move map/tool controls to new button API
Some checks failed
continuous-integration/drone/push Build is failing
Details

Browse Source
This commit is contained in:
zv0n 2022-06-23 10:31:58 +02:00
parent 94d24e37fa
commit 194415500d
2 changed files with 284 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

323
mario/editor.cpp
View File

@ -1,6 +1,7 @@
#include "../sdlpp/sdlpp.hpp"
#include "gui/gui.hpp"
#include "sprites.hpp"
#include <memory>
#ifdef _WIN32
#include "../sdlpp/SDL2/SDL2_framerate.h"
#include <ctime>
@ -520,55 +521,115 @@ void getMousePositionFlags(SDLPP::Scene &scene) {
}
}
void mouseUpAction(uint64_t flags, SDLPP::Scene &scene) {
if (MouseVisitor::moveMapLeft(flags) && global_vars.map.cur_page != 0) {
global_vars.map.cur_page--;
scene.moveEverything(BLOCK_SIZE, 0);
struct moveStruct {
std::shared_ptr<SDLPP::Scene> scene;
std::shared_ptr<Button> other_button;
};
void toolMoveLeftUpdateButtons(Button *left, Button *right, int &cur_page, int &max_page, bool canAdd) {
if(cur_page == 0) {
left->disable(render_mutex);
}
if (MouseVisitor::moveMapRight(flags)) {
if (global_vars.map.cur_page == global_vars.map.max_page) {
// add column
global_vars.objects.resize(global_vars.objects.size() + 1);
global_vars.map.max_page++;
if(cur_page != max_page) {
if(canAdd) {
// TOOD global button config
right->changeText(">");
right->setFontColor("#000000", render_mutex);
right->setFontOutlineColor("#FFFFFF88", render_mutex);
right->setFontColorHighlight("#000000", render_mutex);
right->setFontOutlineColorHighlight("#FFFFFFAA", render_mutex);
} else {
right->enable(render_mutex);
}
global_vars.map.cur_page += 1;
scene.moveEverything(-BLOCK_SIZE, 0);
}
if (MouseVisitor::moveToolsLeft(flags) &&
global_vars.tool.cur_page_tools != 0) {
global_vars.tool.cur_page_tools--;
updateToolSelection(global_vars.tool.cur_page_tools + 1,
ToolType::BLOCK);
}
void toolMoveLeft(Button *left, Button *right, int &cur_page, int &max_page, bool canAdd) {
cur_page--;
toolMoveLeftUpdateButtons(left, right, cur_page, max_page, canAdd);
}
void toolMoveRightUpdateButtons(Button *left, Button *right, int &cur_page, int &max_page, bool canAdd) {
if(cur_page == max_page) {
if(canAdd) {
right->changeText("+");
right->setFontColor("#00FF00", render_mutex);
right->setFontOutlineColor("#000000", render_mutex);
right->setFontColorHighlight("#88FF88", render_mutex);
right->setFontOutlineColorHighlight("#444444", render_mutex);
} else {
right->disable(render_mutex);
}
}
if (MouseVisitor::moveToolsRight(flags) &&
global_vars.tool.cur_page_tools != global_vars.tool.max_page_tools) {
global_vars.tool.cur_page_tools++;
updateToolSelection(global_vars.tool.cur_page_tools - 1,
ToolType::BLOCK);
if(cur_page != 0) {
left->enable(render_mutex);
}
if (MouseVisitor::moveModsLeft(flags) &&
global_vars.tool.cur_page_mods != 0) {
global_vars.tool.cur_page_mods--;
updateToolSelection(global_vars.tool.cur_page_mods + 1, ToolType::MOD);
}
if (MouseVisitor::moveModsRight(flags) &&
global_vars.tool.cur_page_mods != global_vars.tool.max_page_mods) {
global_vars.tool.cur_page_mods++;
updateToolSelection(global_vars.tool.cur_page_mods - 1, ToolType::MOD);
}
if (MouseVisitor::moveCharactersLeft(flags) &&
global_vars.tool.cur_page_characters != 0) {
global_vars.tool.cur_page_characters--;
updateToolSelection(global_vars.tool.cur_page_characters + 1,
ToolType::CHARACTER);
}
if (MouseVisitor::moveCharactersRight(flags) &&
global_vars.tool.cur_page_characters !=
global_vars.tool.max_page_characters) {
global_vars.tool.cur_page_characters++;
updateToolSelection(global_vars.tool.cur_page_characters - 1,
ToolType::CHARACTER);
}
void toolMoveRight(Button *left, Button *right, int &cur_page, int &max_page, bool canAdd) {
cur_page += 1;
toolMoveRightUpdateButtons(left, right, cur_page, max_page, canAdd);
}
void moveMapLeft(void *input, Button *caller) {
auto actual_input = static_cast<moveStruct*>(input);
actual_input->scene->moveEverything(BLOCK_SIZE, 0);
toolMoveLeft(caller, actual_input->other_button.get(), global_vars.map.cur_page, global_vars.map.max_page, true);
}
void moveMapRight(void *input, Button *caller) {
auto actual_input = static_cast<moveStruct*>(input);
if (global_vars.map.cur_page == global_vars.map.max_page) { // add column
global_vars.objects.resize(global_vars.objects.size() + 1);
global_vars.map.max_page++;
}
toolMoveRight(actual_input->other_button.get(), caller, global_vars.map.cur_page, global_vars.map.max_page, true);
actual_input->scene->moveEverything(-BLOCK_SIZE, 0);
}
void moveToolsLeftButton(void *input, Button *caller) {
auto actual_input = static_cast<moveStruct*>(input);
toolMoveLeft(caller, actual_input->other_button.get(), global_vars.tool.cur_page_tools, global_vars.tool.max_page_tools, false);
updateToolSelection(global_vars.tool.cur_page_tools + 1,
ToolType::BLOCK);
}
void moveToolsRightButton(void *input, Button *caller) {
auto actual_input = static_cast<moveStruct*>(input);
toolMoveRight(actual_input->other_button.get(), caller, global_vars.tool.cur_page_tools, global_vars.tool.max_page_tools, false);
updateToolSelection(global_vars.tool.cur_page_tools - 1,
ToolType::BLOCK);
}
void moveModsLeft(void *input, Button *caller) {
auto actual_input = static_cast<moveStruct*>(input);
toolMoveLeft(caller, actual_input->other_button.get(), global_vars.tool.cur_page_mods, global_vars.tool.max_page_mods, false);
updateToolSelection(global_vars.tool.cur_page_tools + 1,
ToolType::MOD);
}
void moveModsRight(void *input, Button *caller) {
auto actual_input = static_cast<moveStruct*>(input);
toolMoveRight(actual_input->other_button.get(), caller, global_vars.tool.cur_page_mods, global_vars.tool.max_page_mods, false);
updateToolSelection(global_vars.tool.cur_page_tools - 1,
ToolType::MOD);
}
void moveCharsLeft(void *input, Button *caller) {
auto actual_input = static_cast<moveStruct*>(input);
toolMoveLeft(caller, actual_input->other_button.get(), global_vars.tool.cur_page_characters, global_vars.tool.max_page_characters, false);
updateToolSelection(global_vars.tool.cur_page_tools + 1,
ToolType::CHARACTER);
}
void moveCharsRight(void *input, Button *caller) {
auto actual_input = static_cast<moveStruct*>(input);
toolMoveRight(actual_input->other_button.get(), caller, global_vars.tool.cur_page_characters, global_vars.tool.max_page_characters, false);
updateToolSelection(global_vars.tool.cur_page_tools - 1,
ToolType::CHARACTER);
}
void mouseUpAction(uint64_t flags) {
if(MouseVisitor::button(flags)) {
global_vars.buttons[global_vars.mouse.cur_button_index]->performFunction();
}
@ -701,7 +762,7 @@ void pollEvents(SDLPP::Scene &scene) {
break;
case SDL_MOUSEBUTTONUP:
if (global_vars.mouse.cur_flags == global_vars.mouse.prev_flags) {
mouseUpAction(global_vars.mouse.cur_flags, scene);
mouseUpAction(global_vars.mouse.cur_flags);
}
if (global_vars.mouse.edit_box.getX() != 0) {
placeTool(scene);
@ -931,7 +992,7 @@ void populateWorldType(
scene->addObject(tool_text);
}
void checkArrowsEnabled(uint64_t cur_page, uint64_t max_page,
/*void checkArrowsEnabled(uint64_t cur_page, uint64_t max_page,
uint64_t left_flag, uint64_t right_flag,
std::shared_ptr<SDLPP::TextRenderer> &left_arrow,
std::shared_ptr<SDLPP::TextRenderer> &right_arrow,
@ -962,12 +1023,12 @@ void checkArrowsEnabled(uint64_t cur_page, uint64_t max_page,
right_arrow->changeText(">");
}
}
}
}*/
void testButtonFunc(void *input) {
void testButtonFunc(void *input, Button *caller) {
auto actual = static_cast<int*>(input);
std::cout << "NUM: " << *actual << std::endl;
global_vars.buttons[0]->disable(render_mutex);
caller->disable(render_mutex);
}
#ifdef _WIN32
@ -1025,12 +1086,49 @@ int main() {
// create grids and arrow controls
// map
auto arrows = createArrowControls(
/* auto arrows = createArrowControls(
0, (MAP_WIDTH + 1) * BLOCK_SIZE, 1 - MAP_HEIGHT * BLOCK_SIZE,
MAP_HEIGHT * BLOCK_SIZE, EDITOR_LEFT_MAP_ID, EDITOR_RIGHT_MAP_ID, scene,
font_config);
auto left_map_arrow = arrows.first;
auto right_map_arrow = arrows.second;
auto right_map_arrow = arrows.second;*/
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;
// left map arrow
moveStruct left_map_input{
.scene = scene,
.other_button = nullptr,
};
global_vars.buttons.emplace_back(std::make_shared<Button>(
0, 1 - MAP_HEIGHT * BLOCK_SIZE, BLOCK_SIZE, MAP_HEIGHT * BLOCK_SIZE,
renderer, "<", default_button_theme, moveMapLeft, &left_map_input));
global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
global_vars.buttons.back()->setPermanent();
global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
// right map arrow
moveStruct right_map_input{
.scene = scene,
.other_button = global_vars.buttons.back(),
};
global_vars.buttons.emplace_back(std::make_shared<Button>(
(MAP_WIDTH + 1) * BLOCK_SIZE, 1 - MAP_HEIGHT * BLOCK_SIZE, BLOCK_SIZE, MAP_HEIGHT * BLOCK_SIZE,
renderer, ">", default_button_theme, moveMapRight, &right_map_input));
global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
global_vars.buttons.back()->setPermanent();
global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
left_map_input.other_button = global_vars.buttons.back();
// ensure disabled/enabled properly
toolMoveRightUpdateButtons(right_map_input.other_button.get(), global_vars.buttons.back().get(), global_vars.map.cur_page, global_vars.map.max_page, true);
toolMoveLeftUpdateButtons(right_map_input.other_button.get(), global_vars.buttons.back().get(), global_vars.map.cur_page, global_vars.map.max_page, true);
createGrid(BLOCK_SIZE, 1 - MAP_HEIGHT * BLOCK_SIZE, MAP_WIDTH, MAP_HEIGHT,
scene);
// edit blocks on map
@ -1042,17 +1140,50 @@ int main() {
}
}
global_vars.tool.max_page_tools =
(possibleBlocks.size() - 1) / (2 * TOOLS_WIDTH);
global_vars.tool.max_page_mods =
(possibleMods.size() - 1) / (2 * MOD_WIDTH);
global_vars.tool.max_page_characters =
(possibleCharacters.size() - 1) / (2 * CHARACTER_WIDTH);
// tools
populateToolGrid(TOOLS_WIDTH, 2, (MAP_WIDTH - TOOLS_WIDTH) * BLOCK_SIZE,
1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, ToolType::BLOCK,
possibleBlocks, global_vars.tools, global_vars.tool_boxes,
scene, "TERRAIN", font_config);
arrows = createArrowControls(
/* arrows = createArrowControls(
(MAP_WIDTH - TOOLS_WIDTH - 1) * BLOCK_SIZE, MAP_WIDTH * BLOCK_SIZE,
1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, 2 * BLOCK_SIZE, EDITOR_LEFT_TOOL_ID,
EDITOR_RIGHT_TOOL_ID, scene, font_config);
auto left_tool_arrow = arrows.first;
auto right_tool_arrow = arrows.second;
auto right_tool_arrow = arrows.second;*/
// left tool arrow
moveStruct left_tool_input{
.scene = scene,
.other_button = nullptr,
};
global_vars.buttons.emplace_back(std::make_shared<Button>(
(MAP_WIDTH - TOOLS_WIDTH - 1) * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE,
renderer, "<", default_button_theme, moveToolsLeftButton, &left_tool_input));
global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
global_vars.buttons.back()->setPermanent();
global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
// right tool arrow
moveStruct right_tool_input{
.scene = scene,
.other_button = global_vars.buttons.back(),
};
global_vars.buttons.emplace_back(std::make_shared<Button>(
MAP_WIDTH * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE,
renderer, ">", default_button_theme, moveToolsRightButton, &right_tool_input));
global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
global_vars.buttons.back()->setPermanent();
global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
left_tool_input.other_button = global_vars.buttons.back();
// ensure disabled/enabled properly
toolMoveRightUpdateButtons(right_tool_input.other_button.get(), global_vars.buttons.back().get(), global_vars.tool.cur_page_tools, global_vars.tool.max_page_tools, false);
toolMoveLeftUpdateButtons(right_tool_input.other_button.get(), global_vars.buttons.back().get(), global_vars.tool.cur_page_tools, global_vars.tool.max_page_tools, false);
createGrid((MAP_WIDTH - TOOLS_WIDTH) * BLOCK_SIZE,
1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, TOOLS_WIDTH, 2, scene);
// mods
@ -1060,12 +1191,38 @@ int main() {
1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, ToolType::MOD,
possibleMods, global_vars.mods, global_vars.mod_boxes,
scene, "MODS", font_config);
arrows = createArrowControls(4 * BLOCK_SIZE, (MOD_WIDTH + 5) * BLOCK_SIZE,
/* arrows = createArrowControls(4 * BLOCK_SIZE, (MOD_WIDTH + 5) * BLOCK_SIZE,
1 - (MAP_HEIGHT + 3) * BLOCK_SIZE,
2 * BLOCK_SIZE, EDITOR_LEFT_MOD_ID,
EDITOR_RIGHT_MOD_ID, scene, font_config);
auto left_mod_arrow = arrows.first;
auto right_mod_arrow = arrows.second;
auto right_mod_arrow = arrows.second;*/
// left mod arrow
moveStruct left_mod_input{
.scene = scene,
.other_button = nullptr,
};
global_vars.buttons.emplace_back(std::make_shared<Button>(
4 * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE,
renderer, "<", default_button_theme, moveModsLeft, &left_mod_input));
global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
global_vars.buttons.back()->setPermanent();
global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
// right mod arrow
moveStruct right_mod_input{
.scene = scene,
.other_button = global_vars.buttons.back(),
};
global_vars.buttons.emplace_back(std::make_shared<Button>(
(MOD_WIDTH + 5) * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE,
renderer, ">", default_button_theme, moveModsRight, &right_mod_input));
global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
global_vars.buttons.back()->setPermanent();
global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
left_mod_input.other_button = global_vars.buttons.back();
// ensure disabled/enabled properly
toolMoveRightUpdateButtons(right_mod_input.other_button.get(), global_vars.buttons.back().get(), global_vars.tool.cur_page_mods, global_vars.tool.max_page_mods, false);
toolMoveLeftUpdateButtons(right_mod_input.other_button.get(), global_vars.buttons.back().get(), global_vars.tool.cur_page_mods, global_vars.tool.max_page_mods, false);
createGrid(5 * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, MOD_WIDTH, 2,
scene);
// characters
@ -1074,13 +1231,39 @@ int main() {
possibleCharacters, global_vars.characters,
global_vars.character_boxes, scene, "CHARACTERS",
font_config);
arrows = createArrowControls((MOD_WIDTH + 7) * BLOCK_SIZE,
/* arrows = createArrowControls((MOD_WIDTH + 7) * BLOCK_SIZE,
(MOD_WIDTH + 8 + CHARACTER_WIDTH) * BLOCK_SIZE,
1 - (MAP_HEIGHT + 3) * BLOCK_SIZE,
2 * BLOCK_SIZE, EDITOR_LEFT_CHARACTER_ID,
EDITOR_RIGHT_CHARACTER_ID, scene, font_config);
auto left_char_arrow = arrows.first;
auto right_char_arrow = arrows.second;
auto right_char_arrow = arrows.second;*/
// left character arrow
moveStruct left_character_input{
.scene = scene,
.other_button = nullptr,
};
global_vars.buttons.emplace_back(std::make_shared<Button>(
(MOD_WIDTH + 7) * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE,
renderer, "<", default_button_theme, moveCharsLeft, &left_character_input));
global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
global_vars.buttons.back()->setPermanent();
global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
// right character arrow
moveStruct right_character_input{
.scene = scene,
.other_button = global_vars.buttons.back(),
};
global_vars.buttons.emplace_back(std::make_shared<Button>(
(MOD_WIDTH + 8 + CHARACTER_WIDTH) * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE,
renderer, ">", default_button_theme, moveCharsRight, &right_character_input));
global_vars.buttons.back()->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
global_vars.buttons.back()->setPermanent();
global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
// ensure disabled/enabled properly
toolMoveRightUpdateButtons(right_character_input.other_button.get(), global_vars.buttons.back().get(), global_vars.tool.cur_page_characters, global_vars.tool.max_page_characters, false);
toolMoveLeftUpdateButtons(right_character_input.other_button.get(), global_vars.buttons.back().get(), global_vars.tool.cur_page_characters, global_vars.tool.max_page_characters, false);
left_character_input.other_button = global_vars.buttons.back();
createGrid((MOD_WIDTH + 8) * BLOCK_SIZE, 1 - (MAP_HEIGHT + 3) * BLOCK_SIZE,
CHARACTER_WIDTH, 2, scene);
@ -1093,13 +1276,6 @@ int main() {
global_vars.map.max_page = global_vars.objects.size() - MAP_WIDTH;
global_vars.tool.max_page_tools =
(possibleBlocks.size() - 1) / (2 * TOOLS_WIDTH);
global_vars.tool.max_page_mods =
(possibleMods.size() - 1) / (2 * MOD_WIDTH);
global_vars.tool.max_page_characters =
(possibleCharacters.size() - 1) / (2 * CHARACTER_WIDTH);
auto mouse =
std::make_shared<SDLPP::RectangleRender>(0.01, 0.01, 0, 0, renderer);
mouse->setMinWidth(1);
@ -1148,20 +1324,12 @@ int main() {
updateToolSelection(0, ToolType::CHARACTER);
setToolColor();
ButtonColors default_button_theme{};
default_button_theme.bg_color = "#FF0088";
default_button_theme.bg_color_highlight = "#FF00FF";
default_button_theme.bg_color_disabled = "#FFAAFF";
default_button_theme.font_color = "#FFFFFF";
default_button_theme.font_color_highlight = "#FFFFFF";
default_button_theme.font_color_disabled = "#BBBBBB";
default_button_theme.font_outline_color = "#000000";
default_button_theme.font_outline_color_highlight = "#444444";
default_button_theme.font_outline_color_disabled = "#888888";
global_vars.buttons.emplace_back(std::make_shared<Button>(0, 0, 0.2, 0.2, renderer, "CLICK ME", default_button_theme, testButtonFunc, &num));
global_vars.buttons.back()->setStatic();
global_vars.buttons.back()->setPermanent();
global_vars.buttons.back()->setButtonIndex(global_vars.buttons.size() - 1);
scene->addObject(global_vars.buttons.back());
for(auto &button : global_vars.buttons) {
scene->addObject(button);
}
auto base = SDL_GetTicks();
int frames = 0;
@ -1199,7 +1367,8 @@ int main() {
frames = 0;
base = SDL_GetTicks();
}
checkArrowsEnabled(global_vars.map.cur_page, global_vars.map.max_page,
// TODO maybe button update func instead of using mutex?
/* checkArrowsEnabled(global_vars.map.cur_page, global_vars.map.max_page,
MAP_LEFT_ENABLED_FLAG, MAP_RIGHT_ENABLED_FLAG,
left_map_arrow, right_map_arrow, font, true);
checkArrowsEnabled(global_vars.tool.cur_page_tools,
@ -1214,7 +1383,7 @@ int main() {
global_vars.tool.max_page_characters,
CHARACTER_LEFT_ENABLED_FLAG,
CHARACTER_RIGHT_ENABLED_FLAG, left_char_arrow,
right_char_arrow, font);
right_char_arrow, font);*/
if (getFlag(UPDATE_FLAG)) {
scene->updateSizeAndPosition();
unsetFlag(UPDATE_FLAG);

77
mario/gui/gui.hpp
View File

@ -8,9 +8,7 @@
#include <mutex>
#include <utility>
#define TEXT_OUTLINE 0.2
struct ButtonColors {
struct ButtonConfig {
std::string font_color;
std::string font_outline_color;
std::string bg_color;
@ -20,6 +18,7 @@ struct ButtonColors {
std::string font_color_disabled;
std::string font_outline_color_disabled;
std::string bg_color_disabled;
double outline;
};
class Button : public SDLPP::TextRenderer {
@ -27,73 +26,73 @@ public:
Button() = delete;
Button(double x, double y, double w, double h,
std::shared_ptr<SDLPP::Renderer> &r, const std::string &text,
const ButtonColors &colors,
std::function<void(void *)> click_fun, void *input)
: TextRenderer(x, y, w, h, r, g_text_config->getFont(), text, colors.font_color,
colors.font_outline_color, TEXT_OUTLINE),
const ButtonConfig &config,
std::function<void(void *, Button *)> click_fun, void *input)
: TextRenderer(x, y, w, h, r, g_text_config->getFont(), text, config.font_color,
config.font_outline_color, config.outline),
click_fun(std::move(click_fun)), func_input(input),
colors(colors) {
setColor(colors.bg_color);
config(config) {
setColor(config.bg_color);
setId(BUTTON_ID);
addCollision(SDLPP::RectColider(0, 0, 1, 1));
}
void setFontColor(const std::string &color, std::mutex &mutex) {
colors.font_color = color;
config.font_color = color;
if(!highlighted && !disabled) {
updateTextColor(colors.font_color, colors.font_outline_color, mutex);
updateTextColor(config.font_color, config.font_outline_color, mutex);
}
}
void setFontColorHighlight(const std::string &color, std::mutex &mutex) {
colors.font_color_highlight = color;
config.font_color_highlight = color;
if(highlighted && !disabled) {
updateTextColor(colors.font_color_highlight, colors.font_outline_color_highlight, mutex);
updateTextColor(config.font_color_highlight, config.font_outline_color_highlight, mutex);
}
}
void setFontColorDisabled(const std::string &color, std::mutex &mutex) {
colors.font_color_disabled = color;
config.font_color_disabled = color;
if(disabled) {
updateTextColor(colors.font_color_disabled, colors.font_outline_color_disabled, mutex);
updateTextColor(config.font_color_disabled, config.font_outline_color_disabled, mutex);
}
}
void setFontOutlineColor(const std::string &color, std::mutex &mutex) {
colors.font_outline_color = color;
config.font_outline_color = color;
if(!highlighted && !disabled) {
updateTextColor(colors.font_color, colors.font_outline_color, mutex);
updateTextColor(config.font_color, config.font_outline_color, mutex);
}
}
void setFontOutlineColorHighlight(const std::string &color, std::mutex &mutex) {
colors.font_outline_color_highlight = color;
config.font_outline_color_highlight = color;
if(highlighted && !disabled) {
updateTextColor(colors.font_color_highlight, colors.font_outline_color_highlight, mutex);
updateTextColor(config.font_color_highlight, config.font_outline_color_highlight, mutex);
}
}
void setFontOutlineColorDisabled(const std::string &color, std::mutex &mutex) {
colors.font_outline_color_disabled = color;
config.font_outline_color_disabled = color;
if(disabled) {
updateTextColor(colors.font_color_disabled, colors.font_outline_color_disabled, mutex);
updateTextColor(config.font_color_disabled, config.font_outline_color_disabled, mutex);
}
}
void setBackgroundColor(const std::string &color) {
colors.bg_color = color;
config.bg_color = color;
if(!highlighted && !disabled) {
setColor(color);
}
}
void setBackgroundColorHighlight(const std::string &color) {
colors.bg_color_highlight = color;
config.bg_color_highlight = color;
if(highlighted && !disabled) {
setColor(color);
}
}
void setBackgroundColorDisabled(const std::string &color) {
colors.bg_color_disabled = color;
config.bg_color_disabled = color;
if(disabled) {
setColor(color);
}
}
void performFunction() const {
void performFunction() {
if(!disabled) {
click_fun(func_input);
click_fun(func_input, this);
}
}
uint64_t getButtonIndex() const {
@ -104,43 +103,43 @@ public:
}
void setHighlight(std::mutex &mutex) {
if(!disabled) {
setColor(colors.bg_color_highlight);
updateTextColor(colors.font_color_highlight, colors.font_outline_color_highlight, mutex);
setColor(config.bg_color_highlight);
updateTextColor(config.font_color_highlight, config.font_outline_color_highlight, mutex);
}
highlighted = true;
}
void unsetHighlight(std::mutex &mutex) {
if(!disabled) {
setColor(colors.bg_color);
updateTextColor(colors.font_color, colors.font_outline_color, mutex);
setColor(config.bg_color);
updateTextColor(config.font_color, config.font_outline_color, mutex);
}
highlighted = false;
}
void disable(std::mutex &mutex) {
setColor(colors.bg_color_disabled);
updateTextColor(colors.font_color_disabled, colors.font_outline_color_disabled, mutex);
setColor(config.bg_color_disabled);
updateTextColor(config.font_color_disabled, config.font_outline_color_disabled, mutex);
disabled = true;
}
void enable(std::mutex &mutex) {
if(!highlighted) {
setColor(colors.bg_color);
updateTextColor(colors.font_color, colors.font_outline_color, mutex);
setColor(config.bg_color);
updateTextColor(config.font_color, config.font_outline_color, mutex);
} else {
setColor(colors.bg_color_highlight);
updateTextColor(colors.font_color_highlight, colors.font_outline_color_highlight, mutex);
setColor(config.bg_color_highlight);
updateTextColor(config.font_color_highlight, config.font_outline_color_highlight, mutex);
}
disabled = false;
}
private:
void updateTextColor(const std::string &font, const std::string &outline, std::mutex &mutex) {
std::lock_guard<std::mutex> textUpdate(mutex);
setTextColor(g_text_config->getFont(), font, outline, TEXT_OUTLINE);
setTextColor(g_text_config->getFont(), font, outline, config.outline);
}
std::function<void(void *)> click_fun;
std::function<void(void *, Button *)> click_fun;
void *func_input;
uint64_t _id{};
ButtonColors colors{};
ButtonConfig config{};
bool highlighted = false;
bool disabled = false;
};