MadeOfJelly/MushMachine
2
2
Fork 0
mirror of https://github.com/MadeOfJelly/MushMachine.git synced 2025-06-19 19:26:36 +02:00
Code Issues Projects Releases Wiki Activity

reworked the general update strategy interface

Browse Source
This commit is contained in:
Green Sky
2021-04-28 19:38:25 +02:00
parent b8a5cd7cf4
commit efad254193
53 changed files with 756 additions and 889 deletions
Download Patch File Download Diff File Expand all files Collapse all files

142
framework/imgui/src/mm/services/engine_tools.cpp
View File

@ -1,12 +1,10 @@
#include "./engine_tools.hpp"
#include "mm/update_strategies/update_strategy.hpp"
#include <entt/config/version.h>
#include <mm/engine.hpp>
#include <entt/core/hashed_string.hpp>
#include <mm/update_strategies/default_strategy.hpp>
#include <mm/update_strategies/update_strategy.hpp>
#include <list>
@ -17,10 +15,13 @@ namespace MM::Services {
using UpdateStrategies::update_key_t;
template<typename NColFn, typename LColFn, typename TTFn>
static void renderUpdateStratGraph(const std::unordered_map<update_key_t, std::set<update_key_t>>& g, std::set<update_key_t>& a, NColFn&& node_color_fn, LColFn&& line_color_fn, TTFn&& tooltip_fn) {
//auto& g = us_default->getGraph(UpdateStrategies::update_phase_t::MAIN);
//auto& a = us_default->getActiveSet(UpdateStrategies::update_phase_t::MAIN);
static void renderUpdateStratGraph(
const std::unordered_map<update_key_t, std::set<update_key_t>>& g,
std::set<update_key_t>& a,
NColFn&& node_color_fn,
LColFn&& line_color_fn,
TTFn&& tooltip_fn
) {
using UpdateStrategies::update_key_t;
std::set<update_key_t> work_queue{a.begin(), a.end()};
@ -156,7 +157,7 @@ static void renderUpdateStratGraph(const std::unordered_map<update_key_t, std::s
}
}
bool ImGuiEngineTools::enable(Engine& engine) {
bool ImGuiEngineTools::enable(Engine& engine, std::vector<UpdateStrategies::TaskInfo>& task_array) {
auto& menu_bar = engine.getService<MM::Services::ImGuiMenuBar>();
// use underscore hack to make it last
@ -179,6 +180,13 @@ bool ImGuiEngineTools::enable(Engine& engine) {
ImGui::MenuItem("UpdateStrategy", NULL, &_show_update_stategy);
};
// add task
task_array.push_back(
UpdateStrategies::TaskInfo{"ImGuiEngineTools::render"}
.fn([this](Engine& e){ renderImGui(e); })
.succeed("ImGuiMenuBar::render")
);
return true;
}
@ -191,22 +199,6 @@ void ImGuiEngineTools::disable(Engine& engine) {
menu_bar.menu_tree["Engine"].erase("UpdateStrategy");
}
std::vector<UpdateStrategies::UpdateCreationInfo> ImGuiEngineTools::registerUpdates(void) {
using namespace entt::literals;
return {
{
"ImGuiEngineTools::render"_hs,
"ImGuiEngineTools::render",
[this](Engine& e){ renderImGui(e); },
UpdateStrategies::update_phase_t::MAIN,
true,
{
"ImGuiMenuBar::render"_hs
}
}
};
}
void ImGuiEngineTools::renderImGui(Engine& engine) {
if (_show_about) {
renderAbout(engine);
@ -250,7 +242,7 @@ void ImGuiEngineTools::renderServices(Engine& engine) {
ImGui::TableNextRow();
ImGui::TableNextColumn();
ImGui::Text("%d", it.first);
ImGui::Text("%u", it.first);
ImGui::TableNextColumn();
ImGui::Text("%s", it.second->second->name());
@ -284,10 +276,99 @@ void ImGuiEngineTools::renderUpdateStrategy(Engine& engine) {
auto us_name = us.name();
ImGui::Text("UpdateStrategy: '%s'", us_name);
ImGui::Separator();
auto* us_default = dynamic_cast<MM::UpdateStrategies::SingleThreadedDefault*>(&us);
if (us_default) {
// TODO: tabs? dropdown(combo)?
static const char* const phase_str[4] = {
"All",
"Pre",
"Main",
"Post",
};
static int curr_phase = 2;
ImGui::Combo("Phase", &curr_phase, phase_str, 4);
if (ImGui::BeginTabBar("tabs")) {
if (curr_phase != 0 && ImGui::BeginTabItem("Graph")) {
// BRUHHH this is needs to be cached
std::unordered_map<update_key_t, std::set<update_key_t>> graph;
std::unordered_map<update_key_t, UpdateStrategies::TaskInfo*> task_lut;
std::set<update_key_t> nodes;
// build lut
us.forEachTask([&graph, &nodes, &task_lut](UpdateStrategies::TaskInfo& task) -> bool {
if (task._phase != UpdateStrategies::update_phase_t(curr_phase-1)) {
return true; // skip, not our phase
}
graph[task._key] = task._dependencies;
task_lut[task._key] = &task;
nodes.emplace(task._key);
return true;
});
// also do dependents // ugh, 2*N
us.forEachTask([&graph](UpdateStrategies::TaskInfo& task) -> bool {
if (task._phase != UpdateStrategies::update_phase_t(curr_phase-1)) {
return true; // skip, not our phase
}
for (const auto it : task._dependents) {
graph[it].emplace(task._key);
}
return true;
});
// TODO: make sense of the colloring
renderUpdateStratGraph(graph, nodes,
[](const update_key_t key) -> ImVec4 {
return {0.9f, 1.f, 0.9f, 1.f};
},
[](const update_key_t from, const update_key_t to) -> ImVec4 {
return {0.9f, 1.f, 0.9f, 1.f};
},
[&task_lut](update_key_t key) {
ImGui::SetTooltip("%s\n[%u]", task_lut.at(key)->_name.c_str(), key);
}
);
ImGui::EndTabItem();
}
if (ImGui::BeginTabItem("List")) {
if (ImGui::BeginTable("table", curr_phase == 0 ? 3 : 2)) {
us.forEachTask([](UpdateStrategies::TaskInfo& task) -> bool {
if (
curr_phase == 0 ||
task._phase == UpdateStrategies::update_phase_t(curr_phase-1)
) {
ImGui::TableNextRow();
ImGui::TableNextColumn();
ImGui::Text("%u", task._key);
if (curr_phase == 0) {
ImGui::TableNextColumn();
ImGui::Text("%s", phase_str[task._phase + 1]);
}
ImGui::TableNextColumn();
ImGui::Text("%s", task._name.c_str());
}
return true;
});
ImGui::EndTable();
}
ImGui::EndTabItem();
}
ImGui::EndTabBar();
}
#if 0
auto& g = us_default->getGraph(UpdateStrategies::update_phase_t::MAIN);
auto& a = us_default->getActiveSet(UpdateStrategies::update_phase_t::MAIN);
std::set<update_key_t> nodes;
@ -305,7 +386,7 @@ void ImGuiEngineTools::renderUpdateStrategy(Engine& engine) {
ImGui::Text("%u", it);
ImGui::TableNextColumn();
ImGui::Text("%s", us_default->_tasks[it].name.c_str());
ImGui::Text("%s", us_default->_tasks.at(it)._name.c_str());
}
ImGui::EndTable();
}
@ -329,7 +410,7 @@ void ImGuiEngineTools::renderUpdateStrategy(Engine& engine) {
}
},
[us_default](update_key_t key) {
ImGui::SetTooltip("'%s'\n[%u]", us_default->_tasks[key].name.c_str(), key);
ImGui::SetTooltip("'%s'\n[%u]", us_default->_tasks.at(key)._name.c_str(), key);
});
ImGui::EndTabItem();
}
@ -337,6 +418,7 @@ void ImGuiEngineTools::renderUpdateStrategy(Engine& engine) {
ImGui::EndTabBar();
}
}
#endif
}
ImGui::End();
}

4
framework/imgui/src/mm/services/engine_tools.hpp
View File

@ -8,11 +8,9 @@ namespace MM::Services {
public:
const char* name(void) override { return "ImGuiEngineTools"; }
bool enable(Engine& engine) override;
bool enable(Engine& engine, std::vector<UpdateStrategies::TaskInfo>& task_array) override;
void disable(Engine& engine) override;
std::vector<UpdateStrategies::UpdateCreationInfo> registerUpdates(void) override;
private:
bool _show_about = false;
bool _show_services = false;

23
framework/imgui/src/mm/services/imgui_menu_bar.cpp
View File

@ -1,4 +1,5 @@
#include "./imgui_menu_bar.hpp"
#include "mm/services/service.hpp"
#include <mm/engine.hpp>
#include <entt/core/hashed_string.hpp>
@ -17,7 +18,7 @@
namespace MM::Services {
bool ImGuiMenuBar::enable(Engine& engine) {
bool ImGuiMenuBar::enable(Engine& engine, std::vector<UpdateStrategies::TaskInfo>& task_array) {
MM::Logger::initSectionLogger("ImGuiMenuBar");
auto* sdl_ss = engine.tryService<MM::Services::SDLService>();
@ -32,6 +33,12 @@ namespace MM::Services {
LOG_WARN("no SDLService, skipping toggle hotkey");
}
// add task
task_array.push_back(
UpdateStrategies::TaskInfo{"ImGuiMenuBar::render"}
.fn([this](Engine& e){ renderImGui(e); })
);
return true;
}
@ -43,17 +50,6 @@ namespace MM::Services {
}
}
std::vector<UpdateStrategies::UpdateCreationInfo> ImGuiMenuBar::registerUpdates(void) {
using namespace entt::literals;
return {
{
"ImGuiMenuBar::render"_hs,
"ImGuiMenuBar::render",
[this](Engine& e){ renderImGui(e); }
}
};
}
void ImGuiMenuBar::renderImGui(Engine& engine) {
if (show_menu_bar && ImGui::BeginMainMenuBar()) {
@ -80,7 +76,8 @@ namespace MM::Services {
}
ImGui::Text("| %.1fFPS", ImGui::GetIO().Framerate);
ImGui::Separator();
ImGui::Text("%.1fFPS", ImGui::GetIO().Framerate);
ImGui::EndMainMenuBar();
}
}

4
framework/imgui/src/mm/services/imgui_menu_bar.hpp
View File

@ -12,11 +12,9 @@ namespace MM::Services {
public:
const char* name(void) override { return "ImGuiMenuBar"; }
bool enable(Engine& engine) override;
bool enable(Engine& engine, std::vector<UpdateStrategies::TaskInfo>& task_array) override;
void disable(Engine& engine) override;
std::vector<UpdateStrategies::UpdateCreationInfo> registerUpdates(void) override;
public:
bool show_menu_bar = true;

26
framework/imgui/src/mm/services/imgui_s.cpp
View File

@ -1,4 +1,6 @@
#include "./imgui_s.hpp"
#include "mm/services/service.hpp"
#include "mm/update_strategies/update_strategy.hpp"
#include <imgui/imgui.h>
#include <imgui/backends/imgui_impl_sdl.h>
@ -25,7 +27,7 @@
namespace MM::Services {
bool ImGuiService::enable(Engine& engine) {
bool ImGuiService::enable(Engine& engine, std::vector<UpdateStrategies::TaskInfo>& task_array) {
IMGUI_CHECKVERSION();
ImGui::CreateContext();
@ -69,6 +71,14 @@ bool ImGuiService::enable(Engine& engine) {
[this](const SDL_Event& e) { return handle_sdl_event(e); }
);
// add task
task_array.push_back(
UpdateStrategies::TaskInfo{"ImGuiService::new_frame"}
.phase(UpdateStrategies::update_phase_t::PRE)
.fn([this](Engine& e) { this->imgui_new_frame(e); })
.succeed("SDLService::events")
);
return true;
}
@ -85,20 +95,6 @@ void ImGuiService::disable(Engine& engine) {
ImGui::DestroyContext();
}
std::vector<UpdateStrategies::UpdateCreationInfo> ImGuiService::registerUpdates(void) {
using namespace entt::literals;
return {
{
"ImGuiService::new_frame"_hs,
"ImGuiService::new_frame",
[this](Engine& e) { this->imgui_new_frame(e); },
UpdateStrategies::update_phase_t::PRE,
true,
{"SDLService::events"_hs}
}
};
}
void ImGuiService::imgui_new_frame(Engine& engine) {
ZoneScopedN("MM::Services::ImGuiService::imgui_new_frame");

4
framework/imgui/src/mm/services/imgui_s.hpp
View File

@ -14,13 +14,11 @@ namespace MM::Services {
// new frame needs to start AFTER the events have been processed (and obv bf rendt)
public:
bool enable(Engine& engine) override;
bool enable(Engine& engine, std::vector<UpdateStrategies::TaskInfo>& task_array) override;
void disable(Engine& engine) override;
const char* name(void) override { return "ImGuiService"; }
std::vector<UpdateStrategies::UpdateCreationInfo> registerUpdates(void) override;
private:
void imgui_new_frame(Engine& engine);

26
framework/imgui/src/mm/services/scene_tools.cpp
View File

@ -7,6 +7,7 @@
#include <mm/engine.hpp>
#include "./imgui_menu_bar.hpp"
#include "mm/components/time_delta.hpp"
#include "mm/services/service.hpp"
#include <imgui/imgui.h>
@ -36,7 +37,7 @@
namespace MM::Services {
bool ImGuiSceneToolsService::enable(Engine& engine) {
bool ImGuiSceneToolsService::enable(Engine& engine, std::vector<UpdateStrategies::TaskInfo>& task_array) {
if (!engine.tryService<MM::Services::SceneServiceInterface>()) {
LOGIGS("error: no SceneServiceInterface");
return false;
@ -82,6 +83,13 @@ namespace MM::Services {
ImGui::MenuItem("TimeDelta Context", NULL, &_show_time_delta_ctx, td_ptr);
};
// add task
task_array.push_back(
UpdateStrategies::TaskInfo{"ImGuiSceneToolsService::render"}
.fn([this](Engine& e){ renderImGui(e); })
.succeed("ImGuiMenuBar::render")
);
return true;
}
@ -94,22 +102,6 @@ namespace MM::Services {
menu_bar.menu_tree["Scene"].erase("TimeCtx");
}
std::vector<UpdateStrategies::UpdateCreationInfo> ImGuiSceneToolsService::registerUpdates(void) {
using namespace entt::literals;
return {
{
"ImGuiSceneToolsService::render"_hs,
"ImGuiSceneToolsService::render",
[this](Engine& e){ renderImGui(e); },
UpdateStrategies::update_phase_t::MAIN,
true,
{
"ImGuiMenuBar::render"_hs
}
}
};
}
void ImGuiSceneToolsService::renderImGui(Engine& engine) {
auto& scene = engine.tryService<MM::Services::SceneServiceInterface>()->getScene();

5
framework/imgui/src/mm/services/scene_tools.hpp
View File

@ -1,5 +1,6 @@
#pragma once
#include "mm/services/service.hpp"
#define MM_IEEE_ENTITY_WIDGET ::MM::ImGuiWidgets::Entity // evil
#define MM_IEEE_ASSERT(x)
#include <mm/imgui/widgets/entity.hpp>
@ -11,13 +12,11 @@ namespace MM::Services {
class ImGuiSceneToolsService : public Service {
public:
bool enable(Engine& engine) override;
bool enable(Engine& engine, std::vector<UpdateStrategies::TaskInfo>& task_array) override;
void disable(Engine& engine) override;
const char* name(void) override { return "ImGuiSceneToolsService"; }
std::vector<UpdateStrategies::UpdateCreationInfo> registerUpdates(void) override;
private:
bool _show_scene_metrics = false;
bool _show_entity_editor = false;

27
framework/imgui/src/mm/services/sound_tools.cpp
View File

@ -1,5 +1,5 @@
#include "./sound_tools.hpp"
#include "mm/imgui/sound_info.hpp"
#include <mm/imgui/sound_info.hpp>
#include <mm/engine.hpp>
#include <entt/core/hashed_string.hpp>
@ -13,7 +13,7 @@
namespace MM::Services {
bool ImGuiSoundTools::enable(Engine& engine) {
bool ImGuiSoundTools::enable(Engine& engine, std::vector<UpdateStrategies::TaskInfo>& task_array) {
auto& menu_bar = engine.getService<MM::Services::ImGuiMenuBar>();
//menu_bar.menu_tree["Engine"]["Stop Engine"] = [](Engine& e) {
@ -35,6 +35,13 @@ namespace MM::Services {
ImGui::MenuItem("Info", NULL, &_show_info);
};
// add task
task_array.push_back(
UpdateStrategies::TaskInfo{"ImGuiSoundTools::render"}
.fn([this](Engine& e){ renderImGui(e); })
.succeed("ImGuiMenuBar::render")
);
return true;
}
@ -45,22 +52,6 @@ namespace MM::Services {
menu_bar.menu_tree["Sound"].erase("Info");
}
std::vector<UpdateStrategies::UpdateCreationInfo> ImGuiSoundTools::registerUpdates(void) {
using namespace entt::literals;
return {
{
"ImGuiSoundTools::render"_hs,
"ImGuiSoundTools::render",
[this](Engine& e){ renderImGui(e); },
UpdateStrategies::update_phase_t::MAIN,
true,
{
"ImGuiMenuBar::render"_hs
}
}
};
}
void ImGuiSoundTools::renderImGui(Engine& engine) {
if (_show_info) {
MM::ImGuiSoundInfo(engine, &_show_info);

5
framework/imgui/src/mm/services/sound_tools.hpp
View File

@ -1,6 +1,7 @@
#pragma once
#include "./imgui_menu_bar.hpp"
#include "mm/services/service.hpp"
namespace MM::Services {
@ -8,11 +9,9 @@ namespace MM::Services {
public:
const char* name(void) override { return "ImGuiSoundTools"; }
bool enable(Engine& engine) override;
bool enable(Engine& engine, std::vector<UpdateStrategies::TaskInfo>& task_array) override;
void disable(Engine& engine) override;
std::vector<UpdateStrategies::UpdateCreationInfo> registerUpdates(void) override;
private:
bool _show_info = false;